YeonGyu-Kim
370 lines
14 KiB
TypeScript
370 lines
14 KiB
TypeScript
import type { PluginInput } from "@opencode-ai/plugin"
|
|
import {
|
|
endTaskTimer,
|
|
getWorkForSession,
|
|
getPlanProgress,
|
|
getTaskSessionState,
|
|
readBoulderState,
|
|
resolveBoulderPlanPath,
|
|
resolveBoulderPlanPathForWork,
|
|
startTaskTimer,
|
|
upsertTaskSessionState,
|
|
} from "../../features/boulder-state"
|
|
import { existsSync, readFileSync } from "node:fs"
|
|
import { resolve } from "node:path"
|
|
import { log } from "../../shared/logger"
|
|
import { isCallerOrchestrator } from "../../shared/session-utils"
|
|
import { syncBackgroundLaunchSessionTracking } from "./background-launch-session-tracking"
|
|
import { collectGitDiffStats, formatFileChanges } from "../../shared/git-worktree"
|
|
import { shouldPauseForFinalWaveApproval } from "./final-wave-approval-gate"
|
|
import { HOOK_NAME } from "./hook-name"
|
|
import { DIRECT_WORK_REMINDER } from "./system-reminder-templates"
|
|
import { isOmoPath } from "./omo-path"
|
|
import { resolvePreferredSessionId, resolveTaskContext } from "./task-context"
|
|
import { extractSessionIdFromMetadata, extractSessionIdFromOutput, validateSubagentSessionId } from "./subagent-session-id"
|
|
import {
|
|
buildCompletionGate,
|
|
buildFinalWaveApprovalReminder,
|
|
buildOrchestratorReminder,
|
|
buildStandaloneVerificationReminder,
|
|
} from "./verification-reminders"
|
|
import { isWriteOrEditToolName } from "./write-edit-tool-policy"
|
|
import type { PendingTaskRef, SessionState } from "./types"
|
|
import type { ToolExecuteAfterInput, ToolExecuteAfterOutput } from "./types"
|
|
|
|
function isTrackedTaskChecked(planPath: string, taskKey: string): boolean {
|
|
if (!existsSync(planPath)) {
|
|
return false
|
|
}
|
|
|
|
const [section, label] = taskKey.split(":")
|
|
if (!section || !label) {
|
|
return false
|
|
}
|
|
|
|
const escapedLabel = label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
|
|
const matcher = section === "todo"
|
|
? new RegExp(`^\\s*[-*]\\s*\\[[xX]\\]\\s*${escapedLabel}\\.\\s+`, "m")
|
|
: section === "final-wave"
|
|
? new RegExp(`^\\s*[-*]\\s*\\[[xX]\\]\\s*${escapedLabel.toUpperCase()}\\.\\s+`, "m")
|
|
: null
|
|
if (!matcher) {
|
|
return false
|
|
}
|
|
|
|
try {
|
|
const content = readFileSync(planPath, "utf-8")
|
|
return matcher.test(content)
|
|
} catch {
|
|
return false
|
|
}
|
|
}
|
|
|
|
const TODO_HEADING_PATTERN = /^##\s+TODOs\b/i
|
|
const FINAL_VERIFICATION_HEADING_PATTERN = /^##\s+Final Verification Wave\b/i
|
|
const SECOND_LEVEL_HEADING_PATTERN = /^##\s+/
|
|
const CHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[[xX]\]\s*(.+)$/
|
|
const TODO_TASK_PATTERN = /^(\d+)\.\s+(.+)$/
|
|
const FINAL_WAVE_TASK_PATTERN = /^(F\d+)\.\s+(.+)$/i
|
|
|
|
function parseCheckedTopLevelTaskKeys(planContent: string): Set<string> {
|
|
const checkedKeys = new Set<string>()
|
|
const lines = planContent.split(/\r?\n/)
|
|
let section: "todo" | "final-wave" | "other" = "other"
|
|
|
|
for (const line of lines) {
|
|
if (SECOND_LEVEL_HEADING_PATTERN.test(line)) {
|
|
section = TODO_HEADING_PATTERN.test(line)
|
|
? "todo"
|
|
: FINAL_VERIFICATION_HEADING_PATTERN.test(line)
|
|
? "final-wave"
|
|
: "other"
|
|
continue
|
|
}
|
|
|
|
if (section !== "todo" && section !== "final-wave") {
|
|
continue
|
|
}
|
|
|
|
const checkedMatch = line.match(CHECKED_CHECKBOX_PATTERN)
|
|
if (!checkedMatch || checkedMatch[1].length > 0) {
|
|
continue
|
|
}
|
|
|
|
const taskBody = checkedMatch[2].trim()
|
|
if (section === "todo") {
|
|
const taskMatch = taskBody.match(TODO_TASK_PATTERN)
|
|
if (taskMatch?.[1]) {
|
|
checkedKeys.add(`todo:${taskMatch[1]}`)
|
|
}
|
|
continue
|
|
}
|
|
|
|
const taskMatch = taskBody.match(FINAL_WAVE_TASK_PATTERN)
|
|
if (taskMatch?.[1]) {
|
|
checkedKeys.add(`final-wave:${taskMatch[1].toLowerCase()}`)
|
|
}
|
|
}
|
|
|
|
return checkedKeys
|
|
}
|
|
|
|
function readCheckedTaskKeysFromPlan(planPath: string): Set<string> {
|
|
if (!existsSync(planPath)) {
|
|
return new Set<string>()
|
|
}
|
|
|
|
try {
|
|
return parseCheckedTopLevelTaskKeys(readFileSync(planPath, "utf-8"))
|
|
} catch {
|
|
return new Set<string>()
|
|
}
|
|
}
|
|
|
|
export function createToolExecuteAfterHandler(input: {
|
|
ctx: PluginInput
|
|
pendingFilePaths: Map<string, string>
|
|
pendingTaskRefs: Map<string, PendingTaskRef>
|
|
pendingPlanSnapshots?: Map<string, string>
|
|
autoCommit: boolean
|
|
getState: (sessionID: string) => SessionState
|
|
isCallerOrchestrator?: (sessionID: string | undefined) => Promise<boolean>
|
|
collectGitDiffStats?: typeof collectGitDiffStats
|
|
formatFileChanges?: typeof formatFileChanges
|
|
}): (toolInput: ToolExecuteAfterInput, toolOutput: ToolExecuteAfterOutput | undefined) => Promise<void> {
|
|
const { ctx, pendingFilePaths, pendingTaskRefs, pendingPlanSnapshots, autoCommit, getState } = input
|
|
const resolveIsCallerOrchestrator = input.isCallerOrchestrator ?? ((sessionID) => isCallerOrchestrator(sessionID, ctx.client))
|
|
const collectGitDiffStatsImpl = input.collectGitDiffStats ?? collectGitDiffStats
|
|
const formatFileChangesImpl = input.formatFileChanges ?? formatFileChanges
|
|
return async (toolInput, toolOutput): Promise<void> => {
|
|
// Guard against undefined output (e.g., from /review command - see issue #1035)
|
|
if (!toolOutput) {
|
|
return
|
|
}
|
|
|
|
if (!(await resolveIsCallerOrchestrator(toolInput.sessionID))) {
|
|
return
|
|
}
|
|
|
|
if (isWriteOrEditToolName(toolInput.tool)) {
|
|
let filePath = toolInput.callID ? pendingFilePaths.get(toolInput.callID) : undefined
|
|
const planSnapshot = toolInput.callID && pendingPlanSnapshots
|
|
? pendingPlanSnapshots.get(toolInput.callID)
|
|
: undefined
|
|
if (toolInput.callID) {
|
|
pendingFilePaths.delete(toolInput.callID)
|
|
pendingPlanSnapshots?.delete(toolInput.callID)
|
|
}
|
|
if (!filePath) {
|
|
filePath = toolOutput.metadata?.filePath as string | undefined
|
|
}
|
|
|
|
if (filePath && toolInput.sessionID) {
|
|
const sessionWork = getWorkForSession(ctx.directory, toolInput.sessionID)
|
|
if (sessionWork) {
|
|
const planPath = resolveBoulderPlanPathForWork(ctx.directory, sessionWork)
|
|
if (resolve(filePath) === resolve(planPath) && planSnapshot !== undefined) {
|
|
const beforeCheckedKeys = parseCheckedTopLevelTaskKeys(planSnapshot)
|
|
const afterCheckedKeys = readCheckedTaskKeysFromPlan(planPath)
|
|
for (const taskKey of afterCheckedKeys) {
|
|
if (!beforeCheckedKeys.has(taskKey)) {
|
|
endTaskTimer(ctx.directory, sessionWork.work_id, taskKey)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (filePath && !isOmoPath(filePath)) {
|
|
toolOutput.output = (toolOutput.output || "") + DIRECT_WORK_REMINDER
|
|
log(`[${HOOK_NAME}] Direct work reminder appended`, {
|
|
sessionID: toolInput.sessionID,
|
|
tool: toolInput.tool,
|
|
filePath,
|
|
})
|
|
}
|
|
return
|
|
}
|
|
|
|
const metadataSessionId = extractSessionIdFromMetadata(toolOutput.metadata)
|
|
const isPluginToolWithSession = toolInput.tool !== "task" && !!metadataSessionId
|
|
if (toolInput.tool !== "task" && !isPluginToolWithSession) {
|
|
return
|
|
}
|
|
|
|
const outputStr = toolOutput.output && typeof toolOutput.output === "string" ? toolOutput.output : ""
|
|
const pendingTaskRef = toolInput.callID ? pendingTaskRefs.get(toolInput.callID) : undefined
|
|
if (toolInput.callID) {
|
|
pendingTaskRefs.delete(toolInput.callID)
|
|
}
|
|
const boulderState = readBoulderState(ctx.directory)
|
|
const isBackgroundLaunch = outputStr.includes("Background task launched") || outputStr.includes("Background task continued")
|
|
|| outputStr.includes("Background delegate launched")
|
|
|| outputStr.includes("Background agent task launched")
|
|
if (isBackgroundLaunch) {
|
|
await syncBackgroundLaunchSessionTracking({
|
|
ctx,
|
|
boulderState,
|
|
toolInput,
|
|
toolOutput,
|
|
pendingTaskRef,
|
|
metadataSessionId,
|
|
})
|
|
return
|
|
}
|
|
|
|
if (toolOutput.output && typeof toolOutput.output === "string") {
|
|
const worktreePath = boulderState?.worktree_path?.trim()
|
|
const verificationDirectory = worktreePath ? worktreePath : ctx.directory
|
|
const gitStats = collectGitDiffStatsImpl(verificationDirectory)
|
|
const fileChanges = formatFileChangesImpl(gitStats)
|
|
const extractedSessionId = metadataSessionId ?? extractSessionIdFromOutput(toolOutput.output)
|
|
|
|
if (boulderState) {
|
|
const sessionWork = toolInput.sessionID
|
|
? getWorkForSession(ctx.directory, toolInput.sessionID)
|
|
: null
|
|
const planPath = sessionWork
|
|
? resolveBoulderPlanPathForWork(ctx.directory, sessionWork)
|
|
: resolveBoulderPlanPath(ctx.directory, boulderState)
|
|
const workScopedBoulderState = sessionWork
|
|
? {
|
|
...boulderState,
|
|
active_plan: sessionWork.active_plan,
|
|
plan_name: sessionWork.plan_name,
|
|
status: sessionWork.status,
|
|
started_at: sessionWork.started_at,
|
|
ended_at: sessionWork.ended_at,
|
|
elapsed_ms: sessionWork.elapsed_ms,
|
|
updated_at: sessionWork.updated_at,
|
|
session_ids: [...sessionWork.session_ids],
|
|
session_origins: sessionWork.session_origins ? { ...sessionWork.session_origins } : {},
|
|
agent: sessionWork.agent,
|
|
worktree_path: sessionWork.worktree_path,
|
|
task_sessions: sessionWork.task_sessions ? { ...sessionWork.task_sessions } : {},
|
|
}
|
|
: boulderState
|
|
const progress = getPlanProgress(planPath)
|
|
const {
|
|
currentTask,
|
|
shouldSkipTaskSessionUpdate,
|
|
shouldIgnoreCurrentSessionId,
|
|
} = resolveTaskContext(pendingTaskRef, planPath)
|
|
const trackedTaskSession = currentTask
|
|
? getTaskSessionState(ctx.directory, currentTask.key)
|
|
: null
|
|
const sessionState = toolInput.sessionID ? getState(toolInput.sessionID) : undefined
|
|
|
|
const lineageSessionIDs = sessionWork?.session_ids ?? boulderState.session_ids
|
|
const subagentSessionId = await validateSubagentSessionId({
|
|
client: ctx.client,
|
|
sessionID: extractedSessionId,
|
|
lineageSessionIDs,
|
|
})
|
|
|
|
if (currentTask && subagentSessionId && !shouldSkipTaskSessionUpdate) {
|
|
if (sessionWork) {
|
|
startTaskTimer(ctx.directory, sessionWork.work_id, {
|
|
taskKey: currentTask.key,
|
|
taskLabel: currentTask.label,
|
|
taskTitle: currentTask.title,
|
|
sessionId: subagentSessionId,
|
|
agent: typeof toolOutput.metadata?.agent === "string" ? toolOutput.metadata.agent : undefined,
|
|
category: typeof toolOutput.metadata?.category === "string" ? toolOutput.metadata.category : undefined,
|
|
})
|
|
if (isTrackedTaskChecked(planPath, currentTask.key)) {
|
|
endTaskTimer(ctx.directory, sessionWork.work_id, currentTask.key)
|
|
}
|
|
} else {
|
|
upsertTaskSessionState(ctx.directory, {
|
|
taskKey: currentTask.key,
|
|
taskLabel: currentTask.label,
|
|
taskTitle: currentTask.title,
|
|
sessionId: subagentSessionId,
|
|
agent: typeof toolOutput.metadata?.agent === "string" ? toolOutput.metadata.agent : undefined,
|
|
category: typeof toolOutput.metadata?.category === "string" ? toolOutput.metadata.category : undefined,
|
|
})
|
|
}
|
|
}
|
|
|
|
const preferredSessionId = resolvePreferredSessionId(
|
|
shouldIgnoreCurrentSessionId ? undefined : subagentSessionId,
|
|
trackedTaskSession?.session_id,
|
|
)
|
|
|
|
// Preserve original subagent response - critical for debugging failed tasks
|
|
const originalResponse = toolOutput.output
|
|
const shouldPauseForApproval = sessionState
|
|
? shouldPauseForFinalWaveApproval({
|
|
planPath,
|
|
taskOutput: originalResponse,
|
|
sessionState,
|
|
})
|
|
: false
|
|
|
|
if (sessionState) {
|
|
sessionState.waitingForFinalWaveApproval = shouldPauseForApproval
|
|
|
|
if (shouldPauseForApproval && sessionState.pendingRetryTimer) {
|
|
clearTimeout(sessionState.pendingRetryTimer)
|
|
sessionState.pendingRetryTimer = undefined
|
|
}
|
|
}
|
|
|
|
const leadReminder = shouldPauseForApproval
|
|
? buildFinalWaveApprovalReminder(workScopedBoulderState.plan_name, progress, preferredSessionId)
|
|
: buildCompletionGate(workScopedBoulderState.plan_name, preferredSessionId)
|
|
const followupReminder = shouldPauseForApproval
|
|
? null
|
|
: buildOrchestratorReminder(workScopedBoulderState.plan_name, progress, preferredSessionId, autoCommit, false)
|
|
|
|
toolOutput.output = `
|
|
<system-reminder>
|
|
${leadReminder}
|
|
</system-reminder>
|
|
|
|
## SUBAGENT WORK COMPLETED
|
|
|
|
${fileChanges}
|
|
|
|
---
|
|
|
|
**Subagent Response:**
|
|
|
|
${originalResponse}
|
|
|
|
${
|
|
followupReminder === null
|
|
? ""
|
|
: `<system-reminder>\n${followupReminder}\n</system-reminder>`
|
|
}`
|
|
log(`[${HOOK_NAME}] Output transformed for orchestrator mode (boulder)`, {
|
|
plan: workScopedBoulderState.plan_name,
|
|
progress: `${progress.completed}/${progress.total}`,
|
|
fileCount: gitStats.length,
|
|
preferredSessionId,
|
|
waitingForFinalWaveApproval: shouldPauseForApproval,
|
|
})
|
|
} else {
|
|
const lineageSessionIDs = toolInput.sessionID ? [toolInput.sessionID] : []
|
|
const subagentSessionId = await validateSubagentSessionId({
|
|
client: ctx.client,
|
|
sessionID: extractedSessionId,
|
|
lineageSessionIDs,
|
|
})
|
|
const preferredSessionId = pendingTaskRef?.kind === "skip"
|
|
? undefined
|
|
: subagentSessionId
|
|
toolOutput.output += `\n<system-reminder>\n${buildStandaloneVerificationReminder(
|
|
resolvePreferredSessionId(preferredSessionId),
|
|
)}\n</system-reminder>`
|
|
|
|
log(`[${HOOK_NAME}] Verification reminder appended for orchestrator`, {
|
|
sessionID: toolInput.sessionID,
|
|
fileCount: gitStats.length,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|