@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

package/src/hooks/guard/subagent-session-id.ts

@@ -1,54 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { log } from "../../shared/logger"
-import { isSessionInBoulderLineage } from "./boulder-session-lineage"
-import { HOOK_NAME } from "./hook-name"
-
-export function extractSessionIdFromMetadata(metadata: unknown): string | undefined {
-  if (metadata && typeof metadata === "object" && "sessionId" in metadata) {
-    const value = (metadata as Record<string, unknown>).sessionId
-    if (typeof value === "string" && value.startsWith("ses_")) {
-      return value
-    }
-  }
-  return undefined
-}
-
-export function extractSessionIdFromOutput(output: string): string | undefined {
-  const taskMetadataBlocks = [...output.matchAll(/<task_metadata>([\s\S]*?)<\/task_metadata>/gi)]
-  const lastTaskMetadataBlock = taskMetadataBlocks.at(-1)?.[1]
-  if (lastTaskMetadataBlock) {
-    const taskMetadataSessionMatch = lastTaskMetadataBlock.match(/session_id:\s*(ses_[a-zA-Z0-9_-]+)/i)
-    if (taskMetadataSessionMatch) {
-      return taskMetadataSessionMatch[1]
-    }
-  }
-
-  const explicitSessionMatches = [...output.matchAll(/Session ID:\s*(ses_[a-zA-Z0-9_-]+)/g)]
-  return explicitSessionMatches.at(-1)?.[1]
-}
-
-export async function validateSubagentSessionId(input: {
-  client: PluginInput["client"]
-  sessionID?: string
-  lineageSessionIDs: string[]
-}): Promise<string | undefined> {
-  if (!input.sessionID || input.lineageSessionIDs.length === 0) {
-    return undefined
-  }
-
-  const belongsToLineage = await isSessionInBoulderLineage({
-    client: input.client,
-    sessionID: input.sessionID,
-    boulderSessionIDs: input.lineageSessionIDs,
-  })
-
-  if (!belongsToLineage) {
-    log(`[${HOOK_NAME}] Ignoring extracted session id outside active lineage`, {
-      sessionID: input.sessionID,
-      lineageSessionIDs: input.lineageSessionIDs,
-    })
-    return undefined
-  }
-
-  return input.sessionID
-}

package/src/hooks/guard/system-reminder-templates.ts

@@ -1,249 +0,0 @@
-import { createSystemDirective, SystemDirectiveTypes } from "../../shared/system-directive"
-
-export const DIRECT_WORK_REMINDER = `
-
----
-
-${createSystemDirective(SystemDirectiveTypes.DELEGATION_REQUIRED)}
-
-You just performed direct file modifications outside \`.bob/\`.
-
-**You are an ORCHESTRATOR, not an IMPLEMENTER.**
-
-As an orchestrator, you should:
-- **DELEGATE** implementation work to subagents via \`task\`
-- **VERIFY** the work done by subagents
-- **COORDINATE** multiple tasks and ensure completion
-
-You should NOT:
-- Write code directly (except for \`.bob/\` files like plans and notepads)
-- Make direct file edits outside \`.bob/\`
-- Implement features yourself
-
-**If you need to make changes:**
-1. Use \`task\` to delegate to an appropriate subagent
-2. Provide clear instructions in the prompt
-3. Verify the subagent's work after completion
-
----
-`
-
-export const BOULDER_CONTINUATION_PROMPT = `${createSystemDirective(SystemDirectiveTypes.BOULDER_CONTINUATION)}
-
-You have an active work plan with incomplete tasks. Continue working.
-
-RULES:
-- **FIRST**: Read the plan file NOW. If the last completed task is still unchecked, mark it \`- [x]\` IMMEDIATELY before anything else
-- Proceed without asking for permission
-- Use the notepad at .bob/notepads/{PLAN_NAME}/ to record learnings
-- Do not stop until all tasks are complete
-- If blocked, document the blocker and move to the next task`
-
-export const VERIFICATION_REMINDER = `**THE SUBAGENT JUST CLAIMED THIS TASK IS DONE. THEY ARE PROBABLY LYING.**
-
-Subagents say "done" when code has errors, tests pass trivially, logic is wrong,
-or they quietly added features nobody asked for. This happens EVERY TIME.
-Assume the work is broken until YOU prove otherwise.
-
----
-
-**PHASE 1: READ THE CODE FIRST (before running anything)**
-
-Do NOT run tests yet. Read the code FIRST so you know what you're testing.
-
-1. \`Bash("git diff --stat -- ':!node_modules'")\` - see exactly which files changed. Any file outside expected scope = scope creep.
-2. \`Read\` EVERY changed file - no exceptions, no skimming.
-3. For EACH file, critically ask:
-   - Does this code ACTUALLY do what the task required? (Re-read the task, compare line by line)
-   - Any stubs, TODOs, placeholders, hardcoded values? (\`Grep\` for TODO, FIXME, HACK, xxx)
-   - Logic errors? Trace the happy path AND the error path in your head.
-   - Anti-patterns? (\`Grep\` for \`as any\`, \`@ts-ignore\`, empty catch, console.log in changed files)
-   - Scope creep? Did the subagent touch things or add features NOT in the task spec?
-4. Cross-check every claim:
-   - Said "Updated X" - READ X. Actually updated, or just superficially touched?
-   - Said "Added tests" - READ the tests. Do they test REAL behavior or just \`expect(true).toBe(true)\`?
-   - Said "Follows patterns" - OPEN a reference file. Does it ACTUALLY match?
-
-**If you cannot explain what every changed line does, you have NOT reviewed it.**
-
-**PHASE 2: RUN AUTOMATED CHECKS (targeted, then broad)**
-
-Now that you understand the code, verify mechanically:
-1. \`lsp_diagnostics\` on EACH changed file - ZERO new errors
-2. Run tests for changed modules FIRST, then full suite
-3. Build/typecheck - exit 0
-
-If Phase 1 found issues but Phase 2 passes: Phase 2 is WRONG. The code has bugs that tests don't cover. Fix the code.
-
-**PHASE 3: HANDS-ON QA - ACTUALLY RUN IT (MANDATORY for user-facing changes)**
-
-Tests and linters CANNOT catch: visual bugs, wrong CLI output, broken user flows, API response shape issues.
-
-**If this task produced anything a user would SEE or INTERACT with, you MUST launch it and verify yourself.**
-
-- **Frontend/UI**: \`/playwright\` skill - load the page, click through the flow, check console. Verify: page loads, interactions work, console clean, responsive.
-- **TUI/CLI**: \`interactive_bash\` - run the command, try good input, try bad input, try --help. Verify: command runs, output correct, error messages helpful, edge inputs handled.
-- **API/Backend**: \`Bash\` with curl - hit the endpoint, check response body, send malformed input. Verify: returns 200, body correct, error cases return proper errors.
-- **Config/Build**: Actually start the service or import the config. Verify: loads without error, backward compatible.
-
-This is NOT optional "if applicable". If the deliverable is user-facing and you did not run it, you are shipping untested work.
-
-**PHASE 4: GATE DECISION - Should you proceed to the next task?**
-
-Answer honestly:
-1. Can I explain what EVERY changed line does? (If no - back to Phase 1)
-2. Did I SEE it work with my own eyes? (If user-facing and no - back to Phase 3)
-3. Am I confident nothing existing is broken? (If no - run broader tests)
-
-ALL three must be YES. "Probably" = NO. "I think so" = NO. Investigate until CERTAIN.
-
-- **All 3 YES** - Proceed: mark task complete, move to next.
-- **Any NO** - Reject: resume session with \`session_id\`, fix the specific issue.
-- **Unsure** - Reject: "unsure" = "no". Investigate until you have a definitive answer.
-
-**DO NOT proceed to the next task until all 4 phases are complete and the gate passes.**`
-
-export const VERIFICATION_REMINDER_GEMINI = `**THE SUBAGENT HAS FINISHED. THEIR WORK IS EXTREMELY SUSPICIOUS.**
-
-The subagent CLAIMS this task is done. Based on thousands of executions, subagent claims are FALSE more often than true.
-They ROUTINELY:
-- Ship code with syntax errors they didn't bother to check
-- Create stub implementations with TODOs and call it "done"
-- Write tests that pass trivially (testing nothing meaningful)
-- Implement logic that does NOT match what was requested
-- Add features nobody asked for and call it "improvement"
-- Report "all tests pass" when they didn't run any tests
-
-**This is NOT a theoretical warning. This WILL happen on this task. Assume the work is BROKEN.**
-
-**YOU MUST VERIFY WITH ACTUAL TOOL CALLS. NOT REASONING. TOOL CALLS.**
-Thinking "it looks correct" is NOT verification. Running \`lsp_diagnostics\` IS.
-
----
-
-**PHASE 1: READ THE CODE FIRST (DO NOT SKIP - DO NOT RUN TESTS YET)**
-
-Read the code FIRST so you know what you're testing.
-
-1. \`Bash("git diff --stat -- ':!node_modules'")\` - see exactly which files changed.
-2. \`Read\` EVERY changed file - no exceptions, no skimming.
-3. For EACH file:
-   - Does this code ACTUALLY do what the task required? RE-READ the task spec.
-   - Any stubs, TODOs, placeholders? \`Grep\` for TODO, FIXME, HACK, xxx
-   - Anti-patterns? \`Grep\` for \`as any\`, \`@ts-ignore\`, empty catch
-   - Scope creep? Did the subagent add things NOT in the task spec?
-4. Cross-check EVERY claim against actual code.
-
-**If you cannot explain what every changed line does, GO BACK AND READ AGAIN.**
-
-**PHASE 2: RUN AUTOMATED CHECKS**
-
-1. \`lsp_diagnostics\` on EACH changed file - ZERO new errors. ACTUALLY RUN THIS.
-2. Run tests for changed modules, then full suite. ACTUALLY RUN THESE.
-3. Build/typecheck - exit 0.
-
-If Phase 1 found issues but Phase 2 passes: Phase 2 is WRONG. Fix the code.
-
-**PHASE 3: HANDS-ON QA (MANDATORY for user-facing changes)**
-
-- **Frontend/UI**: \`/playwright\`
-- **TUI/CLI**: \`interactive_bash\`
-- **API/Backend**: \`Bash\` with curl
-
-**If user-facing and you did not run it, you are shipping UNTESTED BROKEN work.**
-
-**PHASE 4: GATE DECISION**
-
-1. Can I explain what EVERY changed line does? (If no → Phase 1)
-2. Did I SEE it work via tool calls? (If user-facing and no → Phase 3)
-3. Am I confident nothing is broken? (If no → broader tests)
-
-ALL three must be YES. "Probably" = NO. "I think so" = NO.
-
-**DO NOT proceed to the next task until all 4 phases are complete.**`
-
-export const ORCHESTRATOR_DELEGATION_REQUIRED = `
-
----
-
-${createSystemDirective(SystemDirectiveTypes.DELEGATION_REQUIRED)}
-
-**STOP. YOU ARE VIOLATING ORCHESTRATOR PROTOCOL.**
-
-You (Guard) are attempting to directly modify a file outside \`.bob/\`.
-
-**Path attempted:** $FILE_PATH
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-**THIS IS FORBIDDEN** (except for VERIFICATION purposes)
-
-As an ORCHESTRATOR, you MUST:
-1. **DELEGATE** all implementation work via \`task\`
-2. **VERIFY** the work done by subagents (reading files is OK)
-3. **COORDINATE** - you orchestrate, you don't implement
-
-**ALLOWED direct file operations:**
-- Files inside \`.bob/\` (plans, notepads, drafts)
-- Reading files for verification
-- Running diagnostics/tests
-
-**FORBIDDEN direct file operations:**
-- Writing/editing source code
-- Creating new files outside \`.bob/\`
-- Any implementation work
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-**IF THIS IS FOR VERIFICATION:**
-Proceed if you are verifying subagent work by making a small fix.
-But for any substantial changes, USE \`task\`.
-
-**CORRECT APPROACH:**
-\`\`\`
-task(
-  category="...",
-  load_skills=[],
-  prompt="[specific single task with clear acceptance criteria]"
-)
-\`\`\`
-
-DELEGATE. DON'T IMPLEMENT.
-
----
-`
-
-export const SINGLE_TASK_DIRECTIVE = `
-
-${createSystemDirective(SystemDirectiveTypes.SINGLE_TASK_ONLY)}
-
-**STOP. READ THIS BEFORE PROCEEDING.**
-
-If you were given **multiple genuinely independent goals** (unrelated tasks, parallel workstreams, separate features), you MUST:
-1. **IMMEDIATELY REFUSE** this request
-2. **DEMAND** the orchestrator provide a single goal
-
-**What counts as multiple independent tasks (REFUSE):**
-- "Implement feature A. Also, add feature B."
-- "Fix bug X. Then refactor module Y. Also update the docs."
-- Multiple unrelated changes bundled into one request
-
-**What is a single task with sequential steps (PROCEED):**
-- A single goal broken into numbered steps (e.g., "Implement X by: 1. finding files, 2. adding logic, 3. writing tests")
-- Multi-step context where all steps serve ONE objective
-- Orchestrator-provided context explaining approach for a single deliverable
-
-**Your response if genuinely independent tasks are detected:**
-> "I refuse to proceed. You provided multiple independent tasks. Each task needs full attention.
-> 
-> PROVIDE EXACTLY ONE GOAL. One deliverable. One clear outcome.
-> 
-> Batching unrelated tasks causes: incomplete work, missed edge cases, broken tests, wasted context."
-
-**WARNING TO ORCHESTRATOR:**
-- Bundling unrelated tasks RUINS deliverables
-- Each independent goal needs FULL attention and PROPER verification
-- Batch delegation of separate concerns = sloppy work = rework = wasted tokens
-
-**REFUSE genuinely multi-task requests. ALLOW single-goal multi-step workflows.**
-`

package/src/hooks/guard/task-context.ts

@@ -1,45 +0,0 @@
-import { readCurrentTopLevelTask } from "../../features/boulder-state"
-import type { PendingTaskRef, TrackedTopLevelTaskRef } from "./types"
-
-export function resolvePreferredSessionId(currentSessionId?: string, trackedSessionId?: string): string {
-  return currentSessionId ?? trackedSessionId ?? "<session_id>"
-}
-
-export function resolveTaskContext(
-  pendingTaskRef: PendingTaskRef | undefined,
-  planPath: string,
-): {
-  currentTask: TrackedTopLevelTaskRef | null
-  shouldSkipTaskSessionUpdate: boolean
-  shouldIgnoreCurrentSessionId: boolean
-} {
-  if (!pendingTaskRef) {
-    return {
-      currentTask: readCurrentTopLevelTask(planPath),
-      shouldSkipTaskSessionUpdate: false,
-      shouldIgnoreCurrentSessionId: false,
-    }
-  }
-
-  if (pendingTaskRef.kind === "track") {
-    return {
-      currentTask: pendingTaskRef.task,
-      shouldSkipTaskSessionUpdate: false,
-      shouldIgnoreCurrentSessionId: false,
-    }
-  }
-
-  if (pendingTaskRef.reason === "explicit_resume") {
-    return {
-      currentTask: readCurrentTopLevelTask(planPath),
-      shouldSkipTaskSessionUpdate: true,
-      shouldIgnoreCurrentSessionId: true,
-    }
-  }
-
-  return {
-    currentTask: pendingTaskRef.task,
-    shouldSkipTaskSessionUpdate: true,
-    shouldIgnoreCurrentSessionId: true,
-  }
-}

package/src/hooks/guard/tool-execute-after.ts

@@ -1,209 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import {
-  appendSessionId,
-  getPlanProgress,
-  getTaskSessionState,
-  readBoulderState,
-  upsertTaskSessionState,
-} from "../../features/boulder-state"
-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 { isBobPath } from "./bob-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"
-
-export function createToolExecuteAfterHandler(input: {
-  ctx: PluginInput
-  pendingFilePaths: Map<string, string>
-  pendingTaskRefs: Map<string, PendingTaskRef>
-  autoCommit: boolean
-  getState: (sessionID: string) => SessionState
-}): (toolInput: ToolExecuteAfterInput, toolOutput: ToolExecuteAfterOutput) => Promise<void> {
-  const { ctx, pendingFilePaths, pendingTaskRefs, autoCommit, getState } = input
-  return async (toolInput, toolOutput): Promise<void> => {
-    // Guard against undefined output (e.g., from /review command - see issue #1035)
-    if (!toolOutput) {
-      return
-    }
-
-    if (!(await isCallerOrchestrator(toolInput.sessionID, ctx.client))) {
-      return
-    }
-
-    if (isWriteOrEditToolName(toolInput.tool)) {
-      let filePath = toolInput.callID ? pendingFilePaths.get(toolInput.callID) : undefined
-      if (toolInput.callID) {
-        pendingFilePaths.delete(toolInput.callID)
-      }
-      if (!filePath) {
-        filePath = toolOutput.metadata?.filePath as string | undefined
-      }
-      if (filePath && !isBobPath(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 = collectGitDiffStats(verificationDirectory)
-      const fileChanges = formatFileChanges(gitStats)
-      const extractedSessionId = metadataSessionId ?? extractSessionIdFromOutput(toolOutput.output)
-
-      if (boulderState) {
-        const progress = getPlanProgress(boulderState.active_plan)
-        const {
-          currentTask,
-          shouldSkipTaskSessionUpdate,
-          shouldIgnoreCurrentSessionId,
-        } = resolveTaskContext(pendingTaskRef, boulderState.active_plan)
-        const trackedTaskSession = currentTask
-          ? getTaskSessionState(ctx.directory, currentTask.key)
-          : null
-        const sessionState = toolInput.sessionID ? getState(toolInput.sessionID) : undefined
-
-        const lineageSessionIDs = boulderState.session_ids
-        const subagentSessionId = await validateSubagentSessionId({
-          client: ctx.client,
-          sessionID: extractedSessionId,
-          lineageSessionIDs,
-        })
-
-        if (currentTask && subagentSessionId && !shouldSkipTaskSessionUpdate) {
-          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: boulderState.active_plan,
-              taskOutput: originalResponse,
-              sessionState,
-            })
-          : false
-
-        if (sessionState) {
-          sessionState.waitingForFinalWaveApproval = shouldPauseForApproval
-
-          if (shouldPauseForApproval && sessionState.pendingRetryTimer) {
-            clearTimeout(sessionState.pendingRetryTimer)
-            sessionState.pendingRetryTimer = undefined
-          }
-        }
-
-        const leadReminder = shouldPauseForApproval
-          ? buildFinalWaveApprovalReminder(boulderState.plan_name, progress, preferredSessionId)
-          : buildCompletionGate(boulderState.plan_name, preferredSessionId)
-        const followupReminder = shouldPauseForApproval
-          ? null
-          : buildOrchestratorReminder(boulderState.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: boulderState.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,
-        })
-      }
-    }
-  }
-}

package/src/hooks/guard/tool-execute-before.ts

@@ -1,102 +0,0 @@
-import { log } from "../../shared/logger"
-import { SYSTEM_DIRECTIVE_PREFIX } from "../../shared/system-directive"
-import { isCallerOrchestrator } from "../../shared/session-utils"
-import type { PluginInput } from "@opencode-ai/plugin"
-import { readBoulderState, readCurrentTopLevelTask } from "../../features/boulder-state"
-import { HOOK_NAME } from "./hook-name"
-import { ORCHESTRATOR_DELEGATION_REQUIRED, SINGLE_TASK_DIRECTIVE } from "./system-reminder-templates"
-import { isBobPath } from "./bob-path"
-import type { PendingTaskRef, TrackedTopLevelTaskRef } from "./types"
-import { isWriteOrEditToolName } from "./write-edit-tool-policy"
-
-export function createToolExecuteBeforeHandler(input: {
-  ctx: PluginInput
-  pendingFilePaths: Map<string, string>
-  pendingTaskRefs: Map<string, PendingTaskRef>
-}): (
-  toolInput: { tool: string; sessionID?: string; callID?: string },
-  toolOutput: { args: Record<string, unknown>; message?: string }
-) => Promise<void> {
-  const { ctx, pendingFilePaths, pendingTaskRefs } = input
-
-  function trackTask(callID: string, task: TrackedTopLevelTaskRef): void {
-    pendingTaskRefs.set(callID, { kind: "track", task })
-  }
-
-  return async (toolInput, toolOutput): Promise<void> => {
-    if (!(await isCallerOrchestrator(toolInput.sessionID, ctx.client))) {
-      return
-    }
-
-    // Check Write/Edit tools for orchestrator - inject strong warning
-    // Warn-only policy: Guard guides orchestrators toward delegation but doesn't block, allowing flexibility for urgent fixes
-    if (isWriteOrEditToolName(toolInput.tool)) {
-      const filePath = (toolOutput.args.filePath ?? toolOutput.args.path ?? toolOutput.args.file) as string | undefined
-      if (filePath && !isBobPath(filePath)) {
-        // Store filePath for use in tool.execute.after
-        if (toolInput.callID) {
-          pendingFilePaths.set(toolInput.callID, filePath)
-        }
-        const warning = ORCHESTRATOR_DELEGATION_REQUIRED.replace("$FILE_PATH", filePath)
-        toolOutput.message = (toolOutput.message || "") + warning
-        log(`[${HOOK_NAME}] Injected delegation warning for direct file modification`, {
-          sessionID: toolInput.sessionID,
-          tool: toolInput.tool,
-          filePath,
-        })
-      }
-      return
-    }
-
-    // Check task - inject single-task directive
-    if (toolInput.tool === "task") {
-      if (toolInput.callID) {
-        const requestedSessionId = toolOutput.args.session_id as string | undefined
-        if (requestedSessionId) {
-          pendingTaskRefs.set(toolInput.callID, {
-            kind: "skip",
-            reason: "explicit_resume",
-          })
-        } else {
-          const boulderState = readBoulderState(ctx.directory)
-          const currentTask = boulderState
-            ? readCurrentTopLevelTask(boulderState.active_plan)
-            : null
-          if (currentTask) {
-            const task = {
-              key: currentTask.key,
-              label: currentTask.label,
-              title: currentTask.title,
-            }
-            const hasExistingClaim = [...pendingTaskRefs.values()].some((pendingTaskRef) => (
-              pendingTaskRef.kind === "track" && pendingTaskRef.task.key === task.key
-            ))
-
-            if (hasExistingClaim) {
-              pendingTaskRefs.set(toolInput.callID, {
-                kind: "skip",
-                reason: "ambiguous_task_key",
-                task,
-              })
-              log(`[${HOOK_NAME}] Skipping task session persistence for ambiguous task key`, {
-                sessionID: toolInput.sessionID,
-                callID: toolInput.callID,
-                taskKey: task.key,
-              })
-            } else {
-              trackTask(toolInput.callID, task)
-            }
-          }
-        }
-      }
-
-      const prompt = toolOutput.args.prompt as string | undefined
-      if (prompt && !prompt.includes(SYSTEM_DIRECTIVE_PREFIX)) {
-        toolOutput.args.prompt = `<system-reminder>${SINGLE_TASK_DIRECTIVE}</system-reminder>\n` + prompt
-        log(`[${HOOK_NAME}] Injected single-task directive to task`, {
-          sessionID: toolInput.sessionID,
-        })
-      }
-    }
-  }
-}

package/src/hooks/guard/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../../tsconfig.json",
-  "compilerOptions": {
-    "noEmit": true,
-    "types": ["bun-types"]
-  },
-  "include": ["./**/*.ts", "./**/*.d.ts"],
-  "exclude": []
-}