openhermes 4.9.2 → 4.11.2

package/CONTEXT.md

@@ -24,4 +24,4 @@
 - OpenHermes is the default primary Agent.
 
 ## Flagged Ambiguities
-- Durable state is deferred for now and not a domain term for this pass.
+- Durable state resolved — 4-Tier Memory subsystem (System/Project/Mission/Task) now provides structured persistence with importance-driven retention.

package/README.md

@@ -5,7 +5,7 @@
 </p>
 
 <p align="center">
-  <a href="https://www.npmjs.com/package/openhermes"><img src="https://img.shields.io/npm/v/openhermes?style=for-the-badge&label=version&color=FFD700" alt="npm version"></a>
+  <a href="https://www.npmjs.com/package/openhermes"><img src="https://img.shields.io/npm/v/openhermes?style=for-the-badge&label=version&color=FFD700" alt="v4.11.1"></a>
   <a href="https://github.com/nathwn12/openhermes/blob/master/LICENSE"><img src="https://img.shields.io/badge/license-MIT-green?style=for-the-badge" alt="License: MIT"></a>
   <a href="https://opencode.ai"><img src="https://img.shields.io/badge/runs%20on-OpenCode-6366f1?style=for-the-badge" alt="Runs on OpenCode"></a>
   <a href="https://github.com/nathwn12/openhermes"><img src="https://img.shields.io/badge/⭐%20star%20on-GitHub-181717?style=for-the-badge" alt="Star on GitHub"></a>
@@ -31,27 +31,20 @@ To install from `dev` (latest features, may be unstable):
 
 ---
 
-## One sentence. Nine steps.
+## One sentence. One engine.
 
-Add the plugin. Restart. Type:
+OpenHermes v4.11 ships with a hardened internal architecture — 8 subsystems working together to make every session faster, more reliable, and fully autonomous:
 
-> *"Plan a CLI tool for managing dotfiles."*
-
-You see output. Behind the scenes, this runs:
-
-| # | What fires | What it does |
-|---|---|---|
-| **1** | `AUTOPILOT.md` decision matrix | Multi-step, vague → `PLANNING NEEDED` |
-| **2** | `oh-planner` | Brainstorm mode: architecture, user flow, risks |
-| **3** | `oh-planner` → `oh-grill` | Plan passes → stress-test it |
-| **4** | `oh-grill` → `oh-planner` (revise) | Gaps found → planner revises |
-| **5** | `oh-planner` → `oh-manifest` | Plan solid → enter build loop |
-| **6** | `oh-planner` → `oh-builder` → `oh-gauntlet` | Implement → test → review → loop |
-| **7** | `oh-gauntlet` → `oh-ship` | Tests pass → PR pipeline |
-| **8** | `oh-ship` → `oh-retro` | Shipped → retrospective |
-| **9** | `oh-retro` → `oh-planner` | Ready for the next cycle |
-
-One sentence. Nine automated steps. Each skill loaded on demand, executed in isolation, routed to the next specialist. **Auto-classify, delegate, route, repeat.** That's the entire model.
+| Subsystem | What it does |
+|-----------|-------------|
+| **Prompt Composer** | 9 modular fragments joined at runtime → byte-identical. Add a fragment, never edit the composition code. |
+| **Auto-Recovery** | 9 error categories with typed actions — retry with backoff, compact on overflow, escalate on unknowns. Self-healing. |
+| **4-Tier Memory** | System → Project → Mission → Task. Importance-scored, budget-enforced, plan-file-persisted. Context that survives hops. |
+| **Hook Registry** | Pluggable pre-tool, post-tool, route, and session hooks with topological sort. 8 built-in hooks, zero routing boilerplate. |
+| **MVCC Sync** | Atomic writes, version counters, conflict detection. Multiple sub-agents writing the same plan file — no data loss. |
+| **Sanity Checker** | 8 output degeneration detectors — repetition, gibberish, low diversity — with automatic escalation and recovery injection. |
+| **Background Cmd** | Fire-and-forget process spawning with timeout, status polling, and auto-cleanup. Non-blocking long-running tasks. |
+| **Test Harness** | Disposable temp dirs (Symbol.asyncDispose), factory builders, restore-capable mocks. Professional-grade test utilities. |
 
 ---
 
@@ -78,15 +71,15 @@ The loop runs unsupervised because these never turn off:
 | Capability | Why it matters |
 |---|---|
 | **Self-driving loop** | Type once. OpenHermes classifies, delegates, and routes — no pauses, no asking permission, no verbosity. |
-| **31 specialist skills** | Planning → building → testing → browser → security → review → shipping → retro. Every dev cycle phase. |
+| **30 specialist skills** | Planning → building → testing → browser → security → review → shipping → retro. Every dev cycle phase. |
 | **Auto-detected user skills** | Drop a skill in `~/.agents/skills/`. OpenHermes finds it. Same name as a built-in? Your version wins. Survives `npm update`. |
-| **`/oh-doctor`** | Verify plugin load, skill discovery, command registration, config safety. |
-| **`/oh-log`** | Session log — routing hops, skill loads, compaction events. |
 | **Shared operating model** | CHARTER + AUTOPILOT + CONTEXT + ETHOS injected every session. Every interaction grounded in the same rules. |
 | **CORE/DEEP skill format** | Every skill is a two-file system: CORE (SKILL.md) handles 80% of passes in one read. DEEP.md loads on demand for hard cases. |
-| **Plan file storage** | `~/.local/share/opencode/openhermes/plans/`. Survives `npm update`. |
+| **Plan file storage** | `~/.local/share/openhermes/plans/`. Survives `npm update`. |
+| **8 internal subsystems** | Compositor, hooks, memory, recovery, sync, sanity checks, background commands, test harness — all native Node.js / TypeScript. |
+| **Zero npm dependency additions** | All new subsystems use native Node.js and TypeScript only. No new packages. |
 
-## 31 skills — three tiers
+## 30 skills — three tiers
 
 ### Tier 4 — Pipeline orchestrators
 Full multi-phase workflows:
@@ -132,7 +125,6 @@ Single-purpose, one thing well:
 | **oh-issue** | Break a plan/spec/PRD into independently-grabbable issues |
 | **oh-prd** | Conversation → PRD → GitHub issue |
 | **oh-freeze** | Restrict file edits to a specific directory |
-| **oh-learn** | Extract, evolve, promote session learnings as instincts |
 | **oh-guard** | Safety confirmation — warn before destructive operations |
 | **oh-skills-link** | Verify OpenCode discovers the skill directory |
 | **oh-skills-list** | List all available `oh-*` skills |
@@ -148,17 +140,26 @@ openhermes-pkg/
 ├── ETHOS.md               # Operating principles
 ├── bootstrap.ts           # Plugin entry — registers everything
 ├── index.ts               # Package entrypoint
-├── lib/                   # harness-resolver.ts
 ├── harness/
 │   ├── agents/            # Agent manifests (OpenHermes primary)
 │   ├── codex/             # CHARTER, AUTOPILOT
-│   ├── commands/          # Slash commands (/oh-doctor, /oh-log)
+│   ├── commands/          # Slash commands
 │   ├── instructions/      # SHELL.md
-│   └── skills/            # 31 skill SKILL.md files (CORE/DEEP format)
+│   ├── lib/               # Internal subsystems
+│   │   ├── composer/      # Prompt fragment composition
+│   │   ├── recovery/      # Auto-recovery with error patterns
+│   │   ├── memory/        # 4-tier hierarchical memory
+│   │   ├── sync/          # MVCC plan synchronization
+│   │   ├── hooks/         # Pluggable hook registry
+│   │   ├── sanity/        # Output degeneration detection
+│   │   └── background/    # Fire-and-forget command system
+│   └── skills/            # 30 skill SKILL.md files (CORE/DEEP format)
+├── lib/                   # harness-resolver.ts
 └── test/
+    └── harness/           # Test utilities (fixture, builders, mocks)
 ```
 
-Plan files: `~/.local/share/opencode/openhermes/plans/<project>-plan-<nnn>.md`
+Plan files: `~/.local/share/openhermes/plans/<project>/plan-<nnn>.md`
 
 ---
 
@@ -166,7 +167,7 @@ Plan files: `~/.local/share/opencode/openhermes/plans/<project>-plan-<nnn>.md`
 
 1. Add the plugin line to `opencode.json`
 2. Restart or reload OpenCode
-3. Run `/oh-doctor` to verify everything loaded
+3. Verify the plugin loaded in the startup log
 4. Type *any* prompt — "plan a feature", "investigate this bug", "refactor this module"
 
 The first time you see OpenHermes auto-route to a specialist skill without you asking — you'll feel the loop.

package/bootstrap.ts

@@ -3,6 +3,22 @@ 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"
+
+// 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 OPENHERMES_AGENT = "OpenHermes"
 
@@ -17,15 +33,14 @@ const USER_SKILL_DIRS: ReadonlyArray<string> = [
 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)
 }
 
-
-export { resolveHarnessRoot, setHarnessRootForTest, getHarnessDir, ensurePlanFile }
+export { resolveHarnessRoot, setHarnessRootForTest, getHarnessDir, ensurePlanFile, findLatestPlanFile }
 
 function parseFrontmatter(raw: string | undefined): Record<string, string> {
   const frontmatter: Record<string, string> = {}
@@ -125,25 +140,21 @@ 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$`)
+  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)
         }
       }
     }
@@ -170,8 +181,14 @@ 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
   }
 }
 
@@ -184,7 +201,8 @@ function ensureDir(dir: string): void {
 function ensurePlanFile(projectDir: string): string {
   const projectName = getProjectName(projectDir)
   const storage = planStorageDir()
-  ensureDir(storage)
+  const projectDirPath = path.join(storage, projectName)
+  ensureDir(projectDirPath)
 
   // Reuse active or in-progress plan
   const latest = findLatestPlanFile(projectDir)
@@ -199,12 +217,13 @@ function ensurePlanFile(projectDir: string): string {
   // Determine next sequence number
   let nextSeq = 1
   if (latest) {
-    const m = path.basename(latest).match(/-plan-(\d{3})\.md$/)
+    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 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 = [
@@ -225,7 +244,13 @@ function ensurePlanFile(projectDir: string): string {
     "",
   ].join("\n")
 
-  fs.writeFileSync(planPath, content, "utf8")
+  try {
+    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
 }
 
@@ -277,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) => {
@@ -298,17 +324,43 @@ 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 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]
@@ -325,10 +377,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 +395,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" } },
       }
 
@@ -407,7 +466,7 @@ export const BootstrapPlugin: Plugin = async (ctx) => {
 
       // Reset delegation depth on session start/error
       if (typed.type === "session.created" || typed.type === "session.error") {
-        delegationDepths.delete(`delegation:${ctx.directory}`)
+        resetDepthTracker()
       }
     },
 
@@ -415,22 +474,182 @@ 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"
+
+        // 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 (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 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
         }
       }
     },
@@ -438,5 +657,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: