openhermes 4.9.2 → 4.12.1

package/bootstrap.ts

@@ -1,8 +1,32 @@
-import path from "node:path"
-import fs from "node:fs"
-import os from "node:os"
-import type { Plugin } from "@opencode-ai/plugin"
-import { getHarnessDir, setHarnessRootForTest, resolveHarnessRoot } from "./lib/harness-resolver.ts"
+import path from "node:path"
+import fs from "node:fs"
+import os from "node:os"
+import type { Plugin } from "@opencode-ai/plugin"
+import { getHarnessDir, setHarnessRootForTest, resolveHarnessRoot } from "./lib/harness-resolver.ts"
+import { compose } from "./harness/lib/composer/index.ts"
+import { ensurePlanFile, findLatestPlanFile, planStorageDir, setPlanStorageDirForTest, resolvePlanAccess } from "./harness/lib/plans/plan-location.ts"
+import { clearRuntimeRouteDecision, consumeRouteGuidance, getRuntimeRouteDecision, rememberRuntimeRouteDecision } from "./harness/lib/routing/index.ts"
+
+// Hook system — pluggable lifecycle hooks with topological sort
+import {
+  HookRegistry,
+  HookResult,
+  nextRouteHook,
+  planCheckHook,
+  shellDetectHook,
+  confidenceGateHook,
+  delegationDepthHook,
+  resetDepthTracker,
+  errorRecoveryHook,
+  memorySyncHook,
+  sanityCheckHook,
+  dynamicRouteHook,
+  routeTrackingHook,
+  subagentFailureHook,
+  resetSubagentFailures,
+  DEFAULT_GUARD_CONFIG,
+} from "./harness/lib/hooks/index.ts"
+import type { HookContext } from "./harness/lib/hooks/index.ts"
 
 const OPENHERMES_AGENT = "OpenHermes"
 
@@ -13,19 +37,7 @@ const USER_SKILL_DIRS: ReadonlyArray<string> = [
   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")
-}
-
-function getProjectName(projectDir: string): string {
-  return path.basename(projectDir)
-}
-
-
-export { resolveHarnessRoot, setHarnessRootForTest, getHarnessDir, ensurePlanFile }
+export { resolveHarnessRoot, setHarnessRootForTest, getHarnessDir, ensurePlanFile, findLatestPlanFile, setPlanStorageDirForTest }
 
 function parseFrontmatter(raw: string | undefined): Record<string, string> {
   const frontmatter: Record<string, string> = {}
@@ -40,12 +52,12 @@ function parseFrontmatter(raw: string | undefined): Record<string, string> {
   return frontmatter
 }
 
-interface MarkdownDocument {
-  frontmatter: Record<string, string>
-  body: string
-}
-
-function readMarkdownDocument(filePath: string): MarkdownDocument | null {
+interface MarkdownDocument {
+  frontmatter: Record<string, string>
+  body: string
+}
+
+function readMarkdownDocument(filePath: string): MarkdownDocument | null {
   if (!fs.existsSync(filePath)) return null
   const source = fs.readFileSync(filePath, "utf8")
   const match = source.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/)
@@ -71,7 +83,7 @@ function readMarkdownDirectory(dir: string): DirEntry[] {
     .filter((e): e is DirEntry => e !== null)
 }
 
-interface CommandDef {
+interface CommandDef {
   description: string
   template: string
   agent?: string
@@ -94,7 +106,7 @@ function commandDefinitions(dir: string): Record<string, CommandDef> {
   return commands
 }
 
-interface AgentDef {
+interface AgentDef {
   description: string
   mode: string
   prompt: string
@@ -125,119 +137,27 @@ function uniqueStrings(existing: string[] = [], additions: string[] = []): strin
 }
 
 
-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$`)
-  let latest: string | null = null
-  let highest = -1
+function ensureDir(dir: string): void {
   try {
-    for (const entry of fs.readdirSync(storage)) {
-      const m = entry.match(pattern)
-      if (m) {
-        const n = parseInt(m[1], 10)
-        if (n > highest) {
-          highest = n
-          latest = path.join(storage, entry)
-        }
-      }
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true })
     }
-  } catch {
-    return null
+  } 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
   }
-  return latest
-}
-
-function readPlanFromFile(filePath: string): string | null {
-  if (!fs.existsSync(filePath)) return null
-  const source = fs.readFileSync(filePath, "utf8")
-  const status = source.match(/^Status:\s*(.+)$/m)?.[1]?.trim()
-  const objective = source.match(/^Objective:\s*(.+)$/m)?.[1]?.trim()
-  if (!status && !objective) return null
-  const parts = [status ? `status=${status}` : null, objective ? `objective=${objective}` : null].filter(Boolean)
-  return `Active plan: ${parts.join(" | ")}`
 }
 
-function readPlanSummary(projectDir: string): string | null {
-  const planFile = findLatestPlanFile(projectDir)
-  if (!planFile) return null
-  return readPlanFromFile(planFile)
-}
-
-function ensureDir(dir: string): void {
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true })
-  }
-}
-
-/**
- * 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()
-  ensureDir(storage)
-
-  // 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 planId = `${projectName}-plan-${String(nextSeq).padStart(3, "0")}`
-  const planPath = path.join(storage, `${planId}.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")
-
-  fs.writeFileSync(planPath, content, "utf8")
-  return planPath
-}
-
-export function buildCompactionContext(projectDir: string): string[] {
+export function buildCompactionContext(projectDir: string): string[] {
   const context = [
     "OpenHermes: native-first, verify before claim, always delegate, concise over verbose.",
     "Preserve domain terms: skill, command, agent, bootstrap, compaction.",
     "Preserve blockers, current task, and next steps; do not invent durable state.",
   ]
 
-  const planSummary = readPlanSummary(projectDir)
-  if (planSummary) context.push(planSummary)
+  const planSummary = resolvePlanAccess(projectDir)?.summary
+  if (planSummary) context.push(planSummary)
 
   return context
 }
@@ -277,6 +197,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) => {
@@ -298,17 +219,54 @@ export const BootstrapPlugin: Plugin = async (ctx) => {
   // Auto-detect and wire user skills from ~/.agents/skills and ~/.config/opencode/skills
   const userSkillPaths: string[] = []
   for (const userDir of USER_SKILL_DIRS) {
-    ensureDir(userDir)
+    try { ensureDir(userDir) } catch {}
     userSkillPaths.push(userDir)
     await logToOC("info", `wired user skills from ${userDir}`)
   }
 
   const compactionContext = buildCompactionContext(ctx.directory)
   // 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 experimental = config.experimental as Record<string, unknown> | undefined;
+      const hooksConfig = (experimental?.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)
+        reg.registerRoute(nextRouteHook)
+        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?.dynamic_route ?? true) reg.registerPostTool(dynamicRouteHook)
+        if (hooksConfig?.route_tracking ?? true) {
+          reg.registerRoute(routeTrackingHook)
+        } else {
+          reg.unregister("route-tracking")
+        }
+        if (hooksConfig?.subagent_failure ?? true) reg.registerPostTool(subagentFailureHook)
+
+        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]
@@ -325,10 +283,17 @@ export const BootstrapPlugin: Plugin = async (ctx) => {
       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
@@ -336,18 +301,18 @@ export const BootstrapPlugin: Plugin = async (ctx) => {
         "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-manifest": { 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-planner": { 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-security": { 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-review": { 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-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" } },
       }
 
@@ -385,11 +350,11 @@ export const BootstrapPlugin: Plugin = async (ctx) => {
             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",
-            },
-          },
-        },
+            external_directory: {         // CAN read/write plan files outside worktree
+              "~/.local/share/openhermes/plans/**": "allow",
+            },
+          },
+        },
       }
 
       config.default_agent = OPENHERMES_AGENT
@@ -405,9 +370,10 @@ export const BootstrapPlugin: Plugin = async (ctx) => {
       // 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
+      // Reset delegation depth and subagent failures on session start/error
       if (typed.type === "session.created" || typed.type === "session.error") {
-        delegationDepths.delete(`delegation:${ctx.directory}`)
+        resetDepthTracker()
+        resetSubagentFailures()
       }
     },
 
@@ -415,22 +381,208 @@ export const BootstrapPlugin: Plugin = async (ctx) => {
       output.context.push(...compactionContext)
     },
 
-    // Mechanical delegation loop guard — prevents runaway agent nesting
+    // Hook-enabled tool execution — delegates to HookRegistry for lifecycle hooks
     "tool.execute.before": async (input, output) => {
       if (input.tool === "task") {
-        // Track delegation depth per project (one session per project at a time)
-        const depthKey = `delegation:${ctx.directory}`
-        const currentDepth = (delegationDepths.get(depthKey) ?? 0) + 1
-        delegationDepths.set(depthKey, currentDepth)
+        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"
+        const pendingNextRoute = getRuntimeRouteDecision(ctx.directory) ?? undefined
+
+        // Build hook context from input and current session state
+        const hookContext: 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,
+          _guardConfig: DEFAULT_GUARD_CONFIG,
+          _nextRoute: pendingNextRoute,
+          _routingSkillsDir: skillsDir,
+        }
+
+        // Run all registered PreToolUse hooks (plan check, shell detect, delegation depth)
+        let preToolResult: { result: HookResult; modifiedContext?: HookContext }
+        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 (currentDepth >= 10) {
+        if (preToolResult.result === HookResult.STOP) {
+          // Depth exceeded or other stop condition
           const errOutput = output as { args: unknown; isError?: boolean; content?: unknown[] }
           errOutput.isError = true
-          errOutput.content = [{
-            type: "text",
-            text: "LOOP GUARD: Delegation depth exceeded (max 10). " +
-                  "Surface to orchestrator with findings and stop delegating."
-          }]
+          const message = (preToolResult.modifiedContext?._depthError as string)
+            ?? `LOOP GUARD: Delegation depth exceeded (max ${DEFAULT_GUARD_CONFIG.maxDelegationDepth}). ` +
+               "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: { result: HookResult; modifiedRoute?: string }
+        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 optiReport = hookContext._optiRoute
+            ? JSON.stringify(hookContext._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.modifiedRoute) {
+          const concreteRoute = routeResult.modifiedRoute.split("?")[0] ?? routeResult.modifiedRoute
+          if (concreteRoute && concreteRoute !== agentName) {
+            inputAny.agent = concreteRoute
+          }
+          if (pendingNextRoute?.selected && concreteRoute === pendingNextRoute.selected) {
+            clearRuntimeRouteDecision(ctx.directory)
+          }
+        }
+
+        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: HookContext = {
+          sessionId: ctx.directory,
+          agent: agentName,
+          directory: ctx.directory,
+          sessions: new Map(),
+          _confidenceLevel: typeof inputAny.confidence === "string" ? inputAny.confidence : undefined,
+          _confidenceExchanges: 0,
+          _guardConfig: DEFAULT_GUARD_CONFIG,
+          _routingSkillsDir: skillsDir,
+        }
+ 
+        // 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
+        const mutableOutput = (output ?? {}) as Record<string, unknown>
+        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")
+          }
+
+          const routedOutput = consumeRouteGuidance(postToolResult.modifiedOutput ?? outputText)
+          const finalOutput = routedOutput.output
+          const runtimeNextRoute = rememberRuntimeRouteDecision(ctx.directory, finalOutput)
+
+          if (finalOutput !== outputText) {
+            if (typeof outputAny?.content === "string") {
+              mutableOutput.content = finalOutput
+            } else {
+              mutableOutput.content = [{ type: "text", text: finalOutput }]
+            }
+          }
+
+          if (runtimeNextRoute) {
+            mutableOutput._nextRoute = runtimeNextRoute
+          }
+
+          // 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
         }
       }
     },
@@ -438,5 +590,3 @@ export const BootstrapPlugin: Plugin = async (ctx) => {
   }
 }
 
-// Module-level delegation depth tracker — reset per project session
-const delegationDepths = new Map<string, number>()

package/harness/agents/oh-planner.md

@@ -26,7 +26,7 @@ Always know before you go.
 
 # oh-planner
 
-ALL-arounder planner. Merges brainstorm, architecture analysis, strategy, and plan review into one skill. Produces plan files in canonical storage (`~/.local/share/opencode/openhermes/plans/`).
+ALL-arounder planner. Merges brainstorm, architecture analysis, strategy, and plan review into one skill. Produces plan files in canonical storage (`~/.local/share/openhermes/plans/`).
 
 Load the relevant section based on entry mode: