openhermes 4.11.2 → 4.12.1

package/CONTEXT.md

@@ -1,12 +1,12 @@
 # OpenHermes — Shared Language
 
 ## Terms
-**OpenHermes** — OpenCode-native orchestration layer for this package.
-**Skill** — A `SKILL.md` loaded on demand through OpenCode's skill tool.
-**Command** — A slash command backed by package-local markdown in `harness/commands/`.
-**Agent** — A primary or subagent definition loaded through OpenCode config.
-**Instruction** — Markdown loaded through `AGENTS.md` or `opencode.json` instructions.
-**Bootstrap** — The first-message context injected by the OpenHermes plugin.
+**OpenHermes** — OpenCode-native orchestration layer for this package.
+**Skill** — A `SKILL.md` loaded on demand through OpenCode's skill tool.
+**Command** — A slash command backed by package-local command markdown; legacy compatibility loaders remain only where runtime-backed.
+**Agent** — A primary or subagent definition loaded through OpenCode config.
+**Instruction** — Markdown loaded through `AGENTS.md` or `opencode.json` instructions.
+**Bootstrap** — The first-message context injected by the OpenHermes plugin.
 
 ### Confidence Gate Terms
 **Confidence Gate** — Phase 0.5 protocol in the autopilot loop that evaluates signal strength before routing. Bounded to 1 conversational exchange max.

package/ETHOS.md

@@ -8,8 +8,8 @@ OpenCode-native loading over manual copying or hidden state.
 ## Small Surface
 Every file earns its keep. Prefer markdown when behavior is declarative.
 
-## Skills Over Glue
-Behavior lives in `SKILL.md`, `commands/*.md`, and `agents/*.md`.
+## Skills Over Glue
+Behavior lives in `SKILL.md`, command markdown, and agent markdown. Legacy command-doc compatibility loaders remain supported only where runtime-backed.
 
 ## Always Delegate — Never Execute
 OpenHermes orchestrates and reports. Sub-agents execute. OpenHermes never writes code, runs tests, or touches files directly.

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="v4.11.1"></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.3"></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>
@@ -44,7 +44,7 @@ OpenHermes v4.11 ships with a hardened internal architecture — 8 subsystems wo
 | **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. |
+| **Plan Location** | Resolves plan file paths per project with directory-per-project layout in `~/.local/share/openhermes/plans/`. |
 
 ---
 
@@ -72,14 +72,14 @@ The loop runs unsupervised because these never turn off:
 |---|---|
 | **Self-driving loop** | Type once. OpenHermes classifies, delegates, and routes — no pauses, no asking permission, no verbosity. |
 | **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`. |
+| **Auto-detected user skills** | Drop a skill in `~/.agents/skills/` or `~/.config/opencode/skills/`. OpenHermes finds it. Same name as a built-in? Your version wins. Survives `npm update`. |
 | **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/openhermes/plans/`. Survives `npm update`. |
-| **8 internal subsystems** | Compositor, hooks, memory, recovery, sync, sanity checks, background commands, test harness — all native Node.js / TypeScript. |
+| **8 internal subsystems** | Composer, recovery, memory, sync, hooks, plans, sanity, background — all native Node.js / TypeScript. |
 | **Zero npm dependency additions** | All new subsystems use native Node.js and TypeScript only. No new packages. |
 
-## 30 skills — three tiers
+## 30 skills — four tiers
 
 ### Tier 4 — Pipeline orchestrators
 Full multi-phase workflows:
@@ -143,17 +143,17 @@ openhermes-pkg/
 ├── harness/
 │   ├── agents/            # Agent manifests (OpenHermes primary)
 │   ├── codex/             # CHARTER, AUTOPILOT
-│   ├── commands/          # Slash commands
-│   ├── instructions/      # SHELL.md
+│   ├── instructions/      # SHELL.md
 │   ├── 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
+│   │   ├── plans/         # Plan file path resolution
 │   │   ├── sanity/        # Output degeneration detection
 │   │   └── background/    # Fire-and-forget command system
-│   └── skills/            # 30 skill SKILL.md files (CORE/DEEP format)
+│   └── skills/            # 30 skill SKILL.md files (CORE/DEEP format)
 ├── lib/                   # harness-resolver.ts
 └── test/
     └── harness/           # Test utilities (fixture, builders, mocks)

package/bootstrap.ts

@@ -1,24 +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 { compose } from "./harness/lib/composer/index.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,
-  planCheckHook,
+  HookRegistry,
+  HookResult,
+  nextRouteHook,
+  planCheckHook,
   shellDetectHook,
   confidenceGateHook,
   delegationDepthHook,
   resetDepthTracker,
   errorRecoveryHook,
-  memorySyncHook,
-  sanityCheckHook,
-  routeTrackingHook,
+  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"
 
@@ -29,18 +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", "openhermes", "plans")
-}
-
-function getProjectName(projectDir: string): string {
-  return path.basename(projectDir)
-}
-
-export { resolveHarnessRoot, setHarnessRootForTest, getHarnessDir, ensurePlanFile, findLatestPlanFile }
+export { resolveHarnessRoot, setHarnessRootForTest, getHarnessDir, ensurePlanFile, findLatestPlanFile, setPlanStorageDirForTest }
 
 function parseFrontmatter(raw: string | undefined): Record<string, string> {
   const frontmatter: Record<string, string> = {}
@@ -55,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]*)$/)
@@ -86,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
@@ -109,7 +106,7 @@ function commandDefinitions(dir: string): Record<string, CommandDef> {
   return commands
 }
 
-interface AgentDef {
+interface AgentDef {
   description: string
   mode: string
   prompt: string
@@ -140,47 +137,7 @@ function uniqueStrings(existing: string[] = [], additions: string[] = []): strin
 }
 
 
-function findLatestPlanFile(projectDir: string): string | null {
-  const projectName = getProjectName(projectDir)
-  const storage = planStorageDir()
-  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(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(projectDirPath, entry)
-        }
-      }
-    }
-  } catch {
-    return null
-  }
-  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 {
+function ensureDir(dir: string): void {
   try {
     if (!fs.existsSync(dir)) {
       fs.mkdirSync(dir, { recursive: true })
@@ -192,77 +149,15 @@ function ensureDir(dir: string): void {
   }
 }
 
-/**
- * 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 {
-    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[] {
+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
 }
@@ -333,27 +228,38 @@ export const BootstrapPlugin: Plugin = async (ctx) => {
   // Ensure plan storage exists
   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
+      const experimental = config.experimental as Record<string, unknown> | undefined;
+      const hooksConfig = (experimental?.hooks as
         | Record<string, boolean>
-        | undefined
+        | 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)
+        // 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 {
@@ -444,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
@@ -464,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") {
         resetDepthTracker()
+        resetSubagentFailures()
       }
     },
 
@@ -479,27 +386,26 @@ export const BootstrapPlugin: Plugin = async (ctx) => {
       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"
+        // 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 = {
+        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,
-          _maxDelegationDepth: 25,
-          _routeTrackingConfig: {
-            maxSkillRepeats: 5,
-            maxUnproductiveHops: 30,    // higher than max delegation depth (25) so depth guard fires first
-          },
-        }
+          _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: any
+        let preToolResult: { result: HookResult; modifiedContext?: HookContext }
         try {
           preToolResult = await reg.executePreTool(hookContext)
         } catch (err) {
@@ -515,7 +421,7 @@ export const BootstrapPlugin: Plugin = async (ctx) => {
           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). " +
+            ?? `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
@@ -546,7 +452,7 @@ export const BootstrapPlugin: Plugin = async (ctx) => {
         // 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
+        let routeResult: { result: HookResult; modifiedRoute?: string }
         try {
           routeResult = await reg.executeRoute(hookContext, agentName)
         } catch (err) {
@@ -556,18 +462,27 @@ export const BootstrapPlugin: Plugin = async (ctx) => {
           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) {
+        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
@@ -605,19 +520,21 @@ export const BootstrapPlugin: Plugin = async (ctx) => {
         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,
-        }
+        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 outputAny = output as Record<string, unknown> | undefined
+        const mutableOutput = (output ?? {}) as Record<string, unknown>
         let outputText = ""
         if (outputAny?.content) {
           const content = outputAny.content
@@ -640,12 +557,28 @@ export const BootstrapPlugin: Plugin = async (ctx) => {
           }
 
           // 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
+          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}`)