openhermes 4.3.0 → 4.11.2

package/bootstrap.ts

@@ -1,35 +1,46 @@
 import path from "node:path"
 import fs from "node:fs"
 import os from "node:os"
-import { fileURLToPath } from "node:url"
 import type { Plugin } from "@opencode-ai/plugin"
-import { createLogger } from "./lib/logger.ts"
 import { getHarnessDir, setHarnessRootForTest, resolveHarnessRoot } from "./lib/harness-resolver.ts"
+import { compose } from "./harness/lib/composer/index.ts"
+
+// Hook system — pluggable lifecycle hooks with topological sort
+import {
+  HookRegistry,
+  HookResult,
+  planCheckHook,
+  shellDetectHook,
+  confidenceGateHook,
+  delegationDepthHook,
+  resetDepthTracker,
+  errorRecoveryHook,
+  memorySyncHook,
+  sanityCheckHook,
+  routeTrackingHook,
+} from "./harness/lib/hooks/index.ts"
 
-const log = createLogger("bootstrap")
-const sessionLog = createLogger("session")
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-const BOOTSTRAP_MARKER = "OPENHERMES_BOOTSTRAP"
 const OPENHERMES_AGENT = "OpenHermes"
 
+// User skill directories — auto-discovered on every session, survive npm updates
+const USER_SKILL_DIRS: ReadonlyArray<string> = [
+  path.join(os.homedir(), ".agents", "skills"),
+  path.join(os.homedir(), ".config", "opencode", "skills"),
+  path.join(os.homedir(), ".claude", "skills"),      // Claude Code backward compat
+]
+
 // Canonical storage under OpenCode's data directory — survives npm updates
 let _planStorageOverride: string | undefined
 export function setPlanStorageDirForTest(dir: string | undefined): void { _planStorageOverride = dir }
 function planStorageDir(): string {
-  return _planStorageOverride ?? path.join(os.homedir(), ".local", "share", "opencode", "openhermes", "plans")
+  return _planStorageOverride ?? path.join(os.homedir(), ".local", "share", "openhermes", "plans")
 }
 
 function getProjectName(projectDir: string): string {
   return path.basename(projectDir)
 }
 
-// User skill directories — auto-scanned on every session, survive npm updates
-const USER_SKILL_DIRS: ReadonlyArray<string> = [
-  path.join(os.homedir(), ".agents", "skills"),
-  path.join(os.homedir(), ".config", "opencode", "skills"),
-]
-
-export { resolveHarnessRoot, setHarnessRootForTest, getHarnessDir }
+export { resolveHarnessRoot, setHarnessRootForTest, getHarnessDir, ensurePlanFile, findLatestPlanFile }
 
 function parseFrontmatter(raw: string | undefined): Record<string, string> {
   const frontmatter: Record<string, string> = {}
@@ -128,29 +139,22 @@ function uniqueStrings(existing: string[] = [], additions: string[] = []): strin
   return merged
 }
 
-function readText(filePath: string): string {
-  return fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : ""
-}
-
-function regexEscape(s: string): string {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-}
 
 function findLatestPlanFile(projectDir: string): string | null {
   const projectName = getProjectName(projectDir)
   const storage = planStorageDir()
-  if (!fs.existsSync(storage)) return null
-  const pattern = new RegExp(`^${regexEscape(projectName)}-plan-(\\d{3})\\.md$`)
+  const projectDirPath = path.join(storage, projectName)
+  if (!fs.existsSync(projectDirPath)) return null
   let latest: string | null = null
   let highest = -1
   try {
-    for (const entry of fs.readdirSync(storage)) {
-      const m = entry.match(pattern)
+    for (const entry of fs.readdirSync(projectDirPath)) {
+      const m = entry.match(/^plan-(\d{3})\.md$/)
       if (m) {
         const n = parseInt(m[1], 10)
         if (n > highest) {
           highest = n
-          latest = path.join(storage, entry)
+          latest = path.join(projectDirPath, entry)
         }
       }
     }
@@ -177,20 +181,77 @@ function readPlanSummary(projectDir: string): string | null {
 }
 
 function ensureDir(dir: string): void {
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true })
+  try {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true })
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    console.error(`[openhermes] Failed to create directory ${dir}: ${msg}`)
+    // Don't throw — let the plan system degrade gracefully
   }
 }
 
-function countSkills(dir: string): number {
+/**
+ * Ensure a plan file exists for the project.
+ * Creates a skeleton plan if none exists or if the latest is complete/abandoned.
+ * Reuses an existing active or in-progress plan.
+ * Returns the path to the plan file.
+ */
+function ensurePlanFile(projectDir: string): string {
+  const projectName = getProjectName(projectDir)
+  const storage = planStorageDir()
+  const projectDirPath = path.join(storage, projectName)
+  ensureDir(projectDirPath)
+
+  // Reuse active or in-progress plan
+  const latest = findLatestPlanFile(projectDir)
+  if (latest) {
+    const content = fs.readFileSync(latest, "utf8")
+    const status = content.match(/^Status:\s*(.+)$/m)?.[1]?.trim()
+    if (status === "active" || status === "in-progress") {
+      return latest
+    }
+  }
+
+  // Determine next sequence number
+  let nextSeq = 1
+  if (latest) {
+    const m = path.basename(latest).match(/^plan-(\d{3})\.md$/)
+    if (m) nextSeq = parseInt(m[1], 10) + 1
+  }
+
+  const seq = String(nextSeq).padStart(3, "0")
+  const planId = `${projectName}/plan-${seq}.md`
+  const planPath = path.join(projectDirPath, `plan-${seq}.md`)
+  const now = new Date().toISOString().replace("T", " ").slice(0, 16)
+
+  const content = [
+    `# PLAN: ${projectName}`,
+    "",
+    `Plan ID: ${planId}`,
+    `Project: ${projectName}`,
+    `Status: active`,
+    `Created: ${now}`,
+    `Updated: ${now}`,
+    `Project Path: ${projectDir}`,
+    `Plan Path: ${planPath}`,
+    `Objective: (pending classification)`,
+    "",
+    "## Tasks",
+    "",
+    "- [ ] (discoverable — pending classification)",
+    "",
+  ].join("\n")
+
   try {
-    return fs.readdirSync(dir).filter(e => {
-      const full = path.join(dir, e)
-      return fs.statSync(full).isDirectory() && fs.existsSync(path.join(full, "SKILL.md"))
-    }).length
-  } catch {
-    return 0
+    fs.writeFileSync(planPath, content, "utf8")
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    console.error(`[openhermes] Failed to write plan file ${planPath}: ${msg}`)
+    // Don't throw — let the plan system degrade gracefully
   }
+  return planPath
 }
 
 export function buildCompactionContext(projectDir: string): string[] {
@@ -232,83 +293,8 @@ export function formatSessionEvent(event: SessionLifecycleEvent): { level: "info
   }
 }
 
-function parseRouteYaml(raw: string): { pass: string; fail: string; blocker: string } {
-  const def: { pass: string; fail: string; blocker: string } = { pass: "surface", fail: "surface", blocker: "surface" }
-  const m = raw.match(/route:\n((?:  [^\n]*\n?)*)/)
-  if (!m) return def
-  const block = m[1]
-
-  const kv = (key: string): string | undefined => {
-    // Single-line:  pass: oh-builder  (horizontal whitespace only, no newlines)
-    const s = block.match(new RegExp(`  ${key}:[ \\t]*(\\S.*)`))
-    if (s) return s[1].trim()
-    // Multi-line array:  pass:\n    - oh-builder\n    - oh-gauntlet
-    const a = block.match(new RegExp(`  ${key}:\\n((?:    - .+\\n?)*)`))
-    if (a) {
-      const items = a[1].match(/    - (.+)/g)?.map(i => i.replace(/    - /, "").trim()) ?? []
-      return items.length > 0 ? `[${items.join(", ")}]` : undefined
-    }
-    return undefined
-  }
 
-  const p = kv("pass")
-  const f = kv("fail")
-  const b = kv("blocker")
-  if (p) def.pass = p
-  if (f) def.fail = f
-  if (b) def.blocker = b
-  return def
-}
 
-function buildRoutingInventory(skillDirs: string[]): string {
-  const rows: string[] = []
-  for (const dir of skillDirs) {
-    let entries: string[] = []
-    try { entries = fs.readdirSync(dir).filter(e => fs.statSync(path.join(dir, e)).isDirectory()) } catch { continue }
-    for (const name of entries.sort()) {
-      const skPath = path.join(dir, name, "SKILL.md")
-      if (!fs.existsSync(skPath)) continue
-      const raw = fs.readFileSync(skPath, "utf8").replace(/\r\n/g, "\n")
-      const fm = raw.match(/^---\n([\s\S]*?)\n---/)
-      if (!fm) continue
-      const route = parseRouteYaml(fm[1])
-      rows.push(`| **${name}** | ${route.pass} | ${route.fail} | ${route.blocker} |`)
-    }
-  }
-  if (rows.length === 0) return ""
-  const header = "## Dynamic Routing Inventory\n\nAll skills and their routes:\n\n| Skill | pass | fail | blocker |\n|---|---|---|---|\n"
-  return header + rows.join("\n")
-}
-
-function buildBootstrapContent(hDir: string, extraDirs: string[] = []): string {
-  const parts = [
-    `<${BOOTSTRAP_MARKER}>`,
-    `You are OpenHermes.`,
-    `OpenHermes is OpenCode-native: load skills on demand, always delegate, never execute tasks directly, and keep the surface small.`,
-    `Durable state is removed for now. Do not invent a persistence layer unless the user explicitly asks for one later.`,
-  ]
-
-  const autopilot = readText(path.join(hDir, "codex", "AUTOPILOT.md"))
-  const constitution = readText(path.join(hDir, "codex", "CONSTITUTION.md"))
-  const runtime = readText(path.join(hDir, "instructions", "RUNTIME.md"))
-  const context = readText(path.join(__dirname, "CONTEXT.md"))
-  const ethos = readText(path.join(__dirname, "ETHOS.md"))
-
-  if (autopilot) parts.push(`<AUTOPILOT>\n${autopilot}\n</AUTOPILOT>`)
-  if (constitution) parts.push(`<CONSTITUTION>\n${constitution}\n</CONSTITUTION>`)
-  if (runtime) parts.push(`<RUNTIME>\n${runtime}\n</RUNTIME>`)
-  if (context) parts.push(`<CONTEXT>\n${context}\n</CONTEXT>`)
-  if (ethos) parts.push(`<ETHOS>\n${ethos}\n</ETHOS>`)
-
-  // Dynamic routing inventory: built-in skills + user skills
-  const allSkillDirs = [path.join(hDir, "skills"), ...extraDirs.filter(Boolean)]
-  const inventory = buildRoutingInventory(allSkillDirs)
-  if (inventory) parts.push(inventory)
-
-  parts.push(`</${BOOTSTRAP_MARKER}>`)
-
-  return parts.join("\n\n")
-}
 
 interface OpenHermesConfig {
   skills?: { paths?: string[] }
@@ -316,6 +302,7 @@ interface OpenHermesConfig {
   agent?: Record<string, unknown>
   instructions?: string[]
   default_agent?: string
+  [key: string]: unknown  // allow additional SDK properties (experimental, etc.)
 }
 
 export const BootstrapPlugin: Plugin = async (ctx) => {
@@ -323,56 +310,143 @@ export const BootstrapPlugin: Plugin = async (ctx) => {
   const skillsDir = path.join(hDir, "skills")
   const commandsDir = path.join(hDir, "commands")
   const agentsDir = path.join(hDir, "agents")
+  const client = ctx.client  // SDK client for structured logging
+
+  // Safe logging — uses OpenCode SDK when available, falls back to stdout for tests
+  async function logToOC(level: "info" | "warn" | "error" | "debug", message: string): Promise<void> {
+    if (client?.app?.log) {
+      await client.app.log({ body: { service: "openhermes", level, message } })
+    } else {
+      console.log(`[openhermes] [${level.toUpperCase()}] ${message}`)
+    }
+  }
+
   // Auto-detect and wire user skills from ~/.agents/skills and ~/.config/opencode/skills
-  // (Must happen before bootstrapContent is built so routing inventory includes user skills)
   const userSkillPaths: string[] = []
   for (const userDir of USER_SKILL_DIRS) {
-    ensureDir(userDir)
-    const count = countSkills(userDir)
-    if (count > 0) {
-      userSkillPaths.push(userDir)
-      log.info(`found ${count} user skill(s) in ${userDir}`)
-    }
+    try { ensureDir(userDir) } catch {}
+    userSkillPaths.push(userDir)
+    await logToOC("info", `wired user skills from ${userDir}`)
   }
 
-  const bootstrapContent = buildBootstrapContent(hDir, userSkillPaths)
   const compactionContext = buildCompactionContext(ctx.directory)
-  const builtInCount = countSkills(skillsDir)
-  const userCount = userSkillPaths.reduce((sum, d) => sum + countSkills(d), 0)
-
   // Ensure plan storage exists
-  ensureDir(planStorageDir())
+  try { ensureDir(planStorageDir()) } catch {}
 
   return {
     config: async (config: OpenHermesConfig) => {
+      // ── 1. Hooks System ─────────────────────────────────────────────────
+      // Read experimental.hooks config from the raw config object
+      const hooksConfig = (config.experimental as Record<string, unknown> | undefined)?.hooks as
+        | Record<string, boolean>
+        | undefined
+      const hooksEnabled = (hooksConfig?.enabled ?? true) as boolean
+
+      if (hooksEnabled) {
+        const reg = HookRegistry.getInstance()
+
+        // Check individual hook flags (default: true if not specified)
+        if (hooksConfig?.plan_check ?? true) reg.registerPreTool(planCheckHook)
+        if (hooksConfig?.shell_detect ?? true) reg.registerPreTool(shellDetectHook)
+        if (hooksConfig?.delegation_depth ?? true) reg.registerPreTool(delegationDepthHook)
+        if (hooksConfig?.confidence_gate ?? true) reg.registerRoute(confidenceGateHook)
+        if (hooksConfig?.error_recovery ?? true) reg.registerPostTool(errorRecoveryHook)
+        if (hooksConfig?.memory_sync ?? true) reg.registerPostTool(memorySyncHook)
+        if (hooksConfig?.sanity_check ?? true) reg.registerPostTool(sanityCheckHook)
+        if (hooksConfig?.route_tracking ?? true) reg.registerRoute(routeTrackingHook)
+
+        await logToOC("info", `hooks: ${reg.getPreToolHooks().length + reg.getPostToolHooks().length + reg.getRouteHooks().length} registered`)
+      } else {
+        await logToOC("info", "hooks: disabled via config")
+      }
+
+      // ── 2. Skills ──────────────────────────────────────────────────────
       config.skills = config.skills || {}
       // Built-in paths first, user paths last → user skills override built-in on name conflict
       const allPaths = [skillsDir, ...userSkillPaths]
       config.skills.paths = uniqueStrings(config.skills.paths || [], allPaths)
 
-      log.info(`skills: ${builtInCount} built-in + ${userCount} user (${allPaths.length} path(s))`)
+      await logToOC("info", `skills: ${allPaths.length} path(s)`)
+
+      // Register harness docs as native OpenCode instructions — no prompt-embedding needed
+      config.instructions = uniqueStrings(config.instructions ?? [], [
+        path.join(hDir, "codex"),
+        path.join(hDir, "instructions"),
+      ])
 
       config.command = { ...(config.command ?? {}), ...commandDefinitions(commandsDir) }
 
       const loadedAgents = agentDefinitions(agentsDir)
-      const openHermesAgent = loadedAgents[OPENHERMES_AGENT] ?? {
-        description: "OpenHermes primary orchestrator",
-        mode: "primary",
-        prompt: "You are OpenHermes.",
+      // Use composer for the OpenHermes agent prompt — assemble from fragments
+      let openHermesPrompt: string
+      try {
+        openHermesPrompt = compose()
+      } catch {
+        openHermesPrompt = loadedAgents[OPENHERMES_AGENT]?.prompt ?? "You are OpenHermes."
+      }
+      const openHermesAgent = {
+        description: loadedAgents[OPENHERMES_AGENT]?.description ?? "OpenHermes primary orchestrator",
+        mode: loadedAgents[OPENHERMES_AGENT]?.mode ?? "primary",
+        prompt: openHermesPrompt,
+      }
+
+      // Subagent permissions — tier-4 and tier-3 get execution access but cannot spawn orchestrators
+      const SUBAGENT_PERMISSIONS: Record<string, Record<string, unknown>> = {
+        "oh-builder": { bash: { "*": "allow" }, edit: "allow", read: "allow", glob: "allow", grep: "allow", task: { "oh-*": "deny" } },
+        "oh-browser": { bash: { "*": "allow" }, edit: "allow", read: "allow", glob: "allow", grep: "allow", task: { "oh-*": "deny" } },
+        "oh-facade": { bash: { "*": "allow" }, edit: "allow", read: "allow", glob: "allow", grep: "allow", task: { "oh-*": "deny" } },
+        "oh-fusion": { bash: { "*": "allow" }, edit: "allow", read: "allow", glob: "allow", grep: "allow", task: { "oh-*": "deny" } },
+        "oh-gauntlet": { bash: { "*": "allow" }, edit: "allow", read: "allow", glob: "allow", grep: "allow", task: { "oh-*": "deny" } },
+        "oh-grill": { bash: { "*": "allow" }, edit: "allow", read: "allow", glob: "allow", grep: "allow", task: { "oh-*": "deny" } },
+        "oh-investigate": { bash: { "*": "allow" }, edit: "allow", read: "allow", glob: "allow", grep: "allow", task: { "oh-*": "deny" } },
+        "oh-manifest": { bash: { "*": "allow" }, edit: "allow", read: "allow", glob: "allow", grep: "allow", task: { "oh-*": "deny" } },
+        "oh-plan-review": { bash: { "*": "allow" }, edit: "allow", read: "allow", glob: "allow", grep: "allow", task: { "oh-*": "deny" } },
+        "oh-planner": { bash: { "*": "allow" }, edit: "allow", read: "allow", glob: "allow", grep: "allow", task: { "oh-*": "deny" } },
+        "oh-refactor": { bash: { "*": "allow" }, edit: "allow", read: "allow", glob: "allow", grep: "allow", task: { "oh-*": "deny" } },
+        "oh-retro": { bash: { "*": "allow" }, edit: "allow", read: "allow", glob: "allow", grep: "allow", task: { "oh-*": "deny" } },
+        "oh-review": { bash: { "*": "allow" }, edit: "allow", read: "allow", glob: "allow", grep: "allow", task: { "oh-*": "deny" } },
+        "oh-security": { bash: { "*": "allow" }, edit: "allow", read: "allow", glob: "allow", grep: "allow", task: { "oh-*": "deny" } },
+        "oh-ship": { bash: { "*": "allow" }, edit: "allow", read: "allow", glob: "allow", grep: "allow", task: { "oh-*": "deny" } },
+        "oh-skill-craft": { bash: { "*": "allow" }, edit: "allow", read: "allow", glob: "allow", grep: "allow", task: { "oh-*": "deny" } },
       }
 
       config.agent = {
         ...(config.agent ?? {}),
         ...loadedAgents,
+        // Apply permissions + hidden flag to subagents
+        ...Object.fromEntries(
+          Object.entries(loadedAgents)
+            .filter(([name]) => name !== OPENHERMES_AGENT)
+            .map(([name, agentDef]) => [
+              name,
+              {
+                ...agentDef,
+                permission: SUBAGENT_PERMISSIONS[name] ?? { bash: { "*": "deny" }, edit: "deny", read: "allow" },
+                // Hide routing-internal subagents from @-menu
+                // Only agents with existing .md files can be hidden — names without files are no-ops
+                ...(["oh-planner", "oh-grill", "oh-skill-craft"].includes(name) ? { hidden: true } : {}),
+              },
+            ])
+        ),
         [OPENHERMES_AGENT]: {
           ...openHermesAgent,
           description: openHermesAgent.description || "OpenHermes primary orchestrator",
           mode: "primary",
+          steps: 15,                     // Max agentic iterations — prevents runaway loops
           permission: {
-            bash: { "*": "allow" },
-            edit: "allow",
-            read: "allow",
-            task: { "*": "allow" },
+            bash: { "*": "deny" },       // CANNOT execute commands
+            edit: "deny",                // CANNOT write/edit files
+            read: "allow",               // CAN read for classification
+            glob: "allow",               // CAN search for files
+            grep: "allow",               // CAN search content
+            task: { "*": "allow" },      // MUST delegate via subagents
+            skill: "allow",              // CAN load skill instructions
+            webfetch: "allow",           // CAN fetch docs for context
+            question: "allow",           // CAN ask user questions
+            websearch: "allow",          // CAN search web for research context
+            external_directory: {         // CAN read/write plan files outside worktree
+              "~/.local/share/opencode/openhermes/**": "allow",
+            },
           },
         },
       }
@@ -381,25 +455,205 @@ export const BootstrapPlugin: Plugin = async (ctx) => {
     },
 
     event: async ({ event }) => {
-      const record = formatSessionEvent(event as SessionLifecycleEvent)
+      const typed = event as SessionLifecycleEvent
+      const record = formatSessionEvent(typed)
       if (!record) return
-      sessionLog[record.level](record.message)
+      await logToOC(record.level, record.message)
+
+      // NOTE: Plan files are NOT auto-created here. The LLM agent
+      // creates plans on demand (see Task Flow step 1 in agent prompt).
+      // Auto-creation produced ghost skeletons like plan-004.
+
+      // Reset delegation depth on session start/error
+      if (typed.type === "session.created" || typed.type === "session.error") {
+        resetDepthTracker()
+      }
     },
 
     "experimental.session.compacting": async (_input, output) => {
       output.context.push(...compactionContext)
     },
 
-    "experimental.chat.messages.transform": async (_input: unknown, output: { messages?: Array<{ info?: { role?: string }; parts?: Array<{ text?: string; type?: string }> }> }) => {
-      try {
-        if (!output.messages?.length) return
-        const firstUser = output.messages.find(m => m?.info?.role === "user")
-        if (!firstUser?.parts?.length) return
-        if (firstUser.parts.some(p => p.text?.includes(BOOTSTRAP_MARKER))) return
-        firstUser.parts.unshift({ type: "text", text: bootstrapContent })
-      } catch (err: unknown) {
-        log.error("transform error:", (err as Error)?.message)
+    // Hook-enabled tool execution — delegates to HookRegistry for lifecycle hooks
+    "tool.execute.before": async (input, output) => {
+      if (input.tool === "task") {
+        const reg = HookRegistry.getInstance()
+
+        // Access optional fields from input (SDK may include these at runtime)
+        const inputAny = input as Record<string, unknown>
+        const agentName = typeof inputAny.agent === "string" ? inputAny.agent : "unknown"
+
+        // Build hook context from input and current session state
+        const hookContext = {
+          sessionId: ctx.directory,           // project directory as session key
+          agent: agentName,
+          directory: ctx.directory,
+          sessions: new Map(),
+          _confidenceLevel: typeof inputAny.confidence === "string" ? inputAny.confidence : undefined,
+          _confidenceExchanges: 0,
+          _maxDelegationDepth: 25,
+          _routeTrackingConfig: {
+            maxSkillRepeats: 5,
+            maxUnproductiveHops: 30,    // higher than max delegation depth (25) so depth guard fires first
+          },
+        }
+
+        // Run all registered PreToolUse hooks (plan check, shell detect, delegation depth)
+        let preToolResult: any
+        try {
+          preToolResult = await reg.executePreTool(hookContext)
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err)
+          const errOutput = output as { args: unknown; isError?: boolean; content?: unknown[] }
+          errOutput.isError = true
+          errOutput.content = [{ type: "text", text: `Hook error (PreTool): ${msg}` }]
+          return
+        }
+
+        if (preToolResult.result === HookResult.STOP) {
+          // Depth exceeded or other stop condition
+          const errOutput = output as { args: unknown; isError?: boolean; content?: unknown[] }
+          errOutput.isError = true
+          const message = (preToolResult.modifiedContext?._depthError as string)
+            ?? "LOOP GUARD: Delegation depth exceeded (max 25). " +
+               "Surface to orchestrator with findings and stop delegating."
+          errOutput.content = [{ type: "text", text: message }]
+          return
+        }
+
+        // Handle INJECT from PreTool hooks (e.g. plan check wants a plan first)
+        if (preToolResult.result === HookResult.INJECT) {
+          const planInstruction = preToolResult.modifiedContext?._planCheckInstruction as string | undefined
+          if (planInstruction) {
+            // Plan check hook returned INJECT — inject "create plan" instruction
+            const inputAny = input as Record<string, unknown>
+            const existingPrompt = (inputAny.description as string) || (inputAny.prompt as string) || ""
+            if (inputAny.description) {
+              inputAny.description = `${planInstruction}\n\n${existingPrompt}`
+            } else if (inputAny.prompt) {
+              inputAny.prompt = `${planInstruction}\n\n${existingPrompt}`
+            } else {
+              inputAny.description = planInstruction
+            }
+            await logToOC("info", `Plan check: injected plan creation instruction into task for "${agentName}"`)
+          } else {
+            // Generic INJECT — hooks modified task context
+            await logToOC("debug", `PreTool INJECT: hooks modified task context for "${agentName}"`)
+          }
+          // Continue execution — INJECT is not a stop signal
+        }
+
+        // Run all registered RouteHooks — the agent/skill being delegated to IS the route
+        // This fires confidence-gate (inject confirm/question on MEDIUM/LOW confidence)
+        // and route-tracking (guard against infinite routing loops)
+        let routeResult: any
+        try {
+          routeResult = await reg.executeRoute(hookContext, agentName)
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err)
+          await logToOC("error", `Hook error (Route): ${msg}`)
+          // Route failed — don't change routing decision, just log
+          routeResult = { result: HookResult.CONTINUE }
+        }
+
+        if (routeResult.result === HookResult.STOP) {
+          // Loop guard triggered by route-tracking hook
+          const errOutput = output as { args: unknown; isError?: boolean; content?: unknown[] }
+          errOutput.isError = true
+          const ctxAny = hookContext as Record<string, unknown>
+          const optiReport = ctxAny._optiRoute
+            ? JSON.stringify(ctxAny._optiRoute, null, 2)
+            : "Route guard: Excessive or unproductive routing detected."
+          errOutput.content = [{ type: "text", text: `ROUTE GUARD: ${optiReport}\n\nSurface to orchestrator with findings and stop delegating.` }]
+        }
+
+        if (routeResult.result === HookResult.INJECT && routeResult.modifiedRoute) {
+          // Confidence gate wants to inject a confirmation/pause into routing.
+          // Parse the modifiedRoute for markers and inject into task description/prompt.
+          const modifiedRoute: string = routeResult.modifiedRoute
+          const inputAny = input as Record<string, unknown>
+          const existingPrompt = (inputAny.description as string) || (inputAny.prompt as string) || ""
+          let gateMsg: string | undefined
+
+          if (modifiedRoute.includes("?echo=confirm")) {
+            gateMsg = "[CONFIDENCE: MEDIUM] Review your plan and confirm it before executing."
+          } else if (modifiedRoute.includes("?question=pause")) {
+            gateMsg = "[CONFIDENCE: LOW] Pause and ask the user for approval before proceeding."
+          }
+
+          if (gateMsg) {
+            if (inputAny.description) {
+              inputAny.description = `${gateMsg}\n${existingPrompt}`
+            } else if (inputAny.prompt) {
+              inputAny.prompt = `${gateMsg}\n${existingPrompt}`
+            } else {
+              inputAny.description = gateMsg
+            }
+            await logToOC("info", `Confidence gate: injected instruction into task to "${agentName}": ${gateMsg}`)
+          }
+        }
       }
     },
+
+    // Hook-enabled post-execution — runs PostToolUse hooks
+    "tool.execute.after": async (input, output) => {
+      if (input.tool === "task") {
+        const reg = HookRegistry.getInstance()
+
+        // Access optional fields from input
+        const inputAny = input as Record<string, unknown>
+        const agentName = typeof inputAny.agent === "string" ? inputAny.agent : "unknown"
+
+        // Build hook context from input and current session state
+        const hookContext = {
+          sessionId: ctx.directory,
+          agent: agentName,
+          directory: ctx.directory,
+          sessions: new Map(),
+          _confidenceLevel: typeof inputAny.confidence === "string" ? inputAny.confidence : undefined,
+          _confidenceExchanges: 0,
+          _maxDelegationDepth: 25,
+        }
+ 
+        // Extract output text from tool result
+        // output.content may be array of content blocks, or a string, or undefined
+        const outputAny = output as Record<string, unknown> | undefined
+        let outputText = ""
+        if (outputAny?.content) {
+          const content = outputAny.content
+          if (typeof content === "string") {
+            outputText = content
+          } else if (Array.isArray(content)) {
+            outputText = content
+              .map((c: Record<string, unknown>) => (typeof c.text === "string" ? c.text : ""))
+              .join("\n")
+          }
+        }
+
+        // Run all registered PostToolUse hooks
+        try {
+          const postToolResult = await reg.executePostTool(hookContext, outputText)
+
+          // Surface recovery instructions from errorRecoveryHook and/or sanityCheckHook
+          if (postToolResult.recovery) {
+            await logToOC("warn", `PostTool recovery instruction:\n${postToolResult.recovery}`)
+          }
+
+          // Log when hooks signal issues (INJECT = anomaly/error detected by a hook)
+          if (postToolResult.result === HookResult.INJECT) {
+            await logToOC("warn", "PostTool INJECT: hooks detected issues in tool output")
+          }
+
+          // memorySyncHook catches its own errors (best-effort sync),
+          // so memory sync failures are already handled gracefully inside the hook
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err)
+          await logToOC("error", `Hook error (PostTool): ${msg}`)
+          // Non-fatal — tool already executed
+        }
+      }
+    },
+
   }
 }
+