@cairnkeep/cli 2.19.1 → 2.20.0

package/opencode/plugins/memory-recall.ts

@@ -1,4 +1,6 @@
-import type { Plugin } from "@opencode-ai/plugin"
+import type { Plugin as V1Plugin } from "@opencode-ai/plugin"
+import type { Plugin as V2 } from "@opencode/plugin"
+import { spawn } from "node:child_process"
 import fs from "node:fs"
 import path from "node:path"
 
@@ -13,9 +15,12 @@ import path from "node:path"
 // The only confirmed mechanism is to `throw new Error(text)`, which the model
 // sees as the tool call's result and must retry — this blocks the first
 // attempt at a matched edit. A once-per-file-per-session guard prevents
-// re-throwing (and re-blocking) the same file forever (T-04-09).
+// re-throwing (and re-blocking) the same file forever (T-04-09). The same
+// throw-to-surface mechanism is used by the V2 `ctx.tool.hook
+// ("execute.before")` registration; the V2 hook fails the tool call with the
+// thrown message, which the model also sees as the call's result.
 //
-// Known OpenCode limitation (Pitfall 4, anomalyco/opencode#5894): this hook
+// Known OpenCode limitation (Pitfall 4, anomalyco/opencode#5894): the V1 hook
 // does not fire for tool calls issued by subagents spawned via the `task`
 // tool — subagent-issued edits silently bypass recall injection. Documented
 // scope limitation, not addressed by this phase.
@@ -27,6 +32,11 @@ import path from "node:path"
 //
 // Fail-open everywhere (D-03): a missing server binary, missing
 // .agentfs/.planning, or any unexpected error must never block an edit.
+//
+// V1/V2 dual entrypoint (2026-09-08): see memory-wakeup.ts's header — V2
+// (opencode2) requires the default-exported `{ id, setup }` definition
+// (server log ref err_128a87db); V1 >= 1.18.29 uses `server()` on the same
+// object.
 
 const SERVER_ENTRY = "@@INFRA_ROOT@@/mcp-memory-server/dist/index.js"
 const MIN_STEM_LENGTH = 4
@@ -43,22 +53,108 @@ function isContained(baseDir: string, candidate: string): boolean {
   return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel)
 }
 
-export const MemoryRecallPlugin: Plugin = async ({ $, directory }) => {
-  const surfaced = new Set<string>()
+// node's own child_process (never the plugin runtime's `$` — V2's context has
+// no BunShell at all, and `$` had a broken stdin writer under this V1 build
+// anyway; the OCP-06 defect note in memory-capture.ts applies).
+function runNode(entry: string, args: string[], timeoutMs = 3000): Promise<string> {
+  return new Promise((resolvePromise) => {
+    let stdout = ""
+    let settled = false
+    const finish = () => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      resolvePromise(stdout)
+    }
+    const child = spawn("node", [entry, ...args], {
+      stdio: ["ignore", "pipe", "ignore"],
+    })
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL")
+      } catch {
+        // best-effort kill only
+      }
+    }, timeoutMs)
+    child.stdout?.on("data", (chunk: Buffer) => {
+      stdout += chunk.toString("utf8")
+      if (stdout.length > 262144) {
+        stdout = ""
+        try {
+          child.kill("SIGKILL")
+        } catch {
+          // best-effort kill only
+        }
+      }
+    })
+    child.on("close", finish)
+    child.on("error", finish)
+  })
+}
+
+// Shared V1/V2 matching rules (OCP-02, D-10): `wakeupIndex` is the compact
+// AgentFS wakeup listing ("" when unavailable). Returns the bounded
+// surface-context text, or null when nothing specific matched (routine edits
+// proceed silently).
+function buildRecallContext(repo: string, base: string, stem: string, wakeupIndex: string): string | null {
+  const sections: string[] = []
+
+  // 1. AgentFS project memory: filter the compact wakeup index by stem.
+  if (wakeupIndex) {
+    const hitLines = wakeupIndex
+      .split("\n")
+      .filter((line) => line.toLowerCase().includes(stem.toLowerCase()))
+      .slice(0, MAX_MEMORY_HITS)
+    if (hitLines.length > 0) {
+      sections.push(`## Relevant project memory for ${base}`, "", hitLines.join("\n"))
+    }
+  }
 
-  return {
-    "tool.execute.before": async (input, output) => {
+  // 2. Wiki source pages (top level only) whose content mentions the
+  // stem. Reads are confined to wikiSourcesDir via isContained() —
+  // filePath (untrusted) only supplied the stem grep token above, it
+  // is never used to build a read path here.
+  const wikiSourcesDir = path.join(repo, ".planning", "wiki", "sources")
+  if (fs.existsSync(wikiSourcesDir)) {
+    const wikiHits: string[] = []
+    const entries = fs.readdirSync(wikiSourcesDir, { withFileTypes: true })
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".md")) continue
+      const pagePath = path.join(wikiSourcesDir, entry.name)
+      if (!isContained(wikiSourcesDir, pagePath)) continue
+      const content = fs.readFileSync(pagePath, "utf8")
+      if (!content.toLowerCase().includes(stem.toLowerCase())) continue
+      const teaserMatch = content.match(/^- \*\*.*$/m)
+      const teaser = teaserMatch ? teaserMatch[0].slice(0, 160) : ""
+      wikiHits.push(`- [${entry.name}] ${teaser}`)
+    }
+    if (wikiHits.length > 0) {
+      sections.push(`## Relevant wiki pages for ${base}`, "", wikiHits.join("\n"))
+    }
+  }
+
+  if (sections.length === 0) return null
+  return sections.join("\n\n").split("\n").slice(0, MAX_CONTEXT_LINES).join("\n")
+}
+
+export default {
+  id: "cairnkeep.memory-recall",
+
+  // V2 (opencode2) entrypoint.
+  async setup(ctx: V2.Context) {
+    const repo = ctx.location.directory
+    const surfaced = new Set<string>()
+
+    await ctx.tool.hook("execute.before", async (event) => {
       try {
-        if (input.tool !== "edit" && input.tool !== "write") return
+        if (event.tool !== "edit" && event.tool !== "write") return
 
-        const filePath: string | undefined = output.args?.filePath ?? output.args?.path
+        const args = event.input as { filePath?: string; path?: string } | undefined
+        const filePath = args?.filePath ?? args?.path
         if (!filePath) return
 
-        const repo = directory
-        const agentfsDb = path.join(repo, ".agentfs", "project.db")
-        const wikiSourcesDir = path.join(repo, ".planning", "wiki", "sources")
-        const hasAgentfs = fs.existsSync(agentfsDb)
-        const hasWiki = fs.existsSync(wikiSourcesDir)
+        const hasAgentfs = fs.existsSync(path.join(repo, ".agentfs", "project.db"))
+        const hasWiki = fs.existsSync(path.join(repo, ".planning", "wiki", "sources"))
         if (!hasAgentfs && !hasWiki) return
 
         const base = path.basename(filePath)
@@ -70,54 +166,18 @@ export const MemoryRecallPlugin: Plugin = async ({ $, directory }) => {
         // Once-per-file-per-session guard (T-04-09): after surfacing for
         // this file once in this session, let subsequent edits/retries of
         // the same file proceed unmodified — never re-block in a loop.
-        const dedupeKey = `${input.sessionID}:${filePath}`
+        const dedupeKey = `${event.sessionID}:${filePath}`
         if (surfaced.has(dedupeKey)) return
 
-        const sections: string[] = []
-
-        // 1. AgentFS project memory: filter the compact wakeup index by stem.
+        let wakeupIndex = ""
         if (hasAgentfs && fs.existsSync(SERVER_ENTRY)) {
-          const res = await $`node ${SERVER_ENTRY} wakeup`.quiet().nothrow()
-          const idx = String(res.stdout ?? "").trim()
-          if (idx) {
-            const hitLines = idx
-              .split("\n")
-              .filter((line) => line.toLowerCase().includes(stem.toLowerCase()))
-              .slice(0, MAX_MEMORY_HITS)
-            if (hitLines.length > 0) {
-              sections.push(`## Relevant project memory for ${base}`, "", hitLines.join("\n"))
-            }
-          }
+          wakeupIndex = (await runNode(SERVER_ENTRY, ["wakeup"])).trim()
         }
 
-        // 2. Wiki source pages (top level only) whose content mentions the
-        // stem. Reads are confined to wikiSourcesDir via isContained() —
-        // filePath (untrusted) only supplied the stem grep token above, it
-        // is never used to build a read path here.
-        if (hasWiki) {
-          const wikiHits: string[] = []
-          const entries = fs.readdirSync(wikiSourcesDir, { withFileTypes: true })
-          for (const entry of entries) {
-            if (!entry.isFile() || !entry.name.endsWith(".md")) continue
-            const pagePath = path.join(wikiSourcesDir, entry.name)
-            if (!isContained(wikiSourcesDir, pagePath)) continue
-            const content = fs.readFileSync(pagePath, "utf8")
-            if (!content.toLowerCase().includes(stem.toLowerCase())) continue
-            const teaserMatch = content.match(/^- \*\*.*$/m)
-            const teaser = teaserMatch ? teaserMatch[0].slice(0, 160) : ""
-            wikiHits.push(`- [${entry.name}] ${teaser}`)
-          }
-          if (wikiHits.length > 0) {
-            sections.push(`## Relevant wiki pages for ${base}`, "", wikiHits.join("\n"))
-          }
-        }
-
-        // Inject only when there is something specific (high-signal /
-        // low-noise) — routine edits with no match proceed silently.
-        if (sections.length === 0) return
+        const context = buildRecallContext(repo, base, stem, wakeupIndex)
+        if (!context) return
 
         surfaced.add(dedupeKey)
-        const context = sections.join("\n\n").split("\n").slice(0, MAX_CONTEXT_LINES).join("\n")
         throw new Error(`Memory recall (auto-injected for this file edit):\n\n${context}`)
       } catch (err) {
         // Re-throw our own intentional surface-context error (it carries the
@@ -127,6 +187,65 @@ export const MemoryRecallPlugin: Plugin = async ({ $, directory }) => {
           throw err
         }
       }
-    },
-  }
+    })
+  },
+
+  // V1 (opencode >= 1.18.29 documented object form) entrypoint — legacy
+  // implementation kept verbatim on its own API (`$` is V1's BunShell).
+  async server(input: Parameters<V1Plugin>[0]) {
+    const { $, directory } = input
+    const surfaced = new Set<string>()
+
+    return {
+      "tool.execute.before": async (
+        hookInput: { tool: string; sessionID: string },
+        hookOutput: { args?: { filePath?: string; path?: string } },
+      ) => {
+        try {
+          if (hookInput.tool !== "edit" && hookInput.tool !== "write") return
+
+          const filePath = hookOutput.args?.filePath ?? hookOutput.args?.path
+          if (!filePath) return
+
+          const repo = directory
+          const agentfsDb = path.join(repo, ".agentfs", "project.db")
+          const wikiSourcesDir = path.join(repo, ".planning", "wiki", "sources")
+          const hasAgentfs = fs.existsSync(agentfsDb)
+          const hasWiki = fs.existsSync(wikiSourcesDir)
+          if (!hasAgentfs && !hasWiki) return
+
+          const base = path.basename(filePath)
+          const stem = base.slice(0, base.length - path.extname(base).length)
+          // Low-noise rule (D-10): skip tiny/generic stems that would match
+          // too broadly and turn this into noise on routine edits.
+          if (stem.length < MIN_STEM_LENGTH) return
+
+          // Once-per-file-per-session guard (T-04-09): after surfacing for
+          // this file once in this session, let subsequent edits/retries of
+          // the same file proceed unmodified — never re-block in a loop.
+          const dedupeKey = `${hookInput.sessionID}:${filePath}`
+          if (surfaced.has(dedupeKey)) return
+
+          let wakeupIndex = ""
+          if (hasAgentfs && fs.existsSync(SERVER_ENTRY)) {
+            const res = await $`node ${SERVER_ENTRY} wakeup`.quiet().nothrow()
+            wakeupIndex = String(res.stdout ?? "").trim()
+          }
+
+          const context = buildRecallContext(repo, base, stem, wakeupIndex)
+          if (!context) return
+
+          surfaced.add(dedupeKey)
+          throw new Error(`Memory recall (auto-injected for this file edit):\n\n${context}`)
+        } catch (err) {
+          // Re-throw our own intentional surface-context error (it carries the
+          // "Memory recall" prefix); swallow everything else to fail open —
+          // a lookup failure must never block an edit (D-03).
+          if (err instanceof Error && err.message.startsWith("Memory recall (auto-injected")) {
+            throw err
+          }
+        }
+      },
+    }
+  },
 }

package/opencode/plugins/memory-wakeup.ts

@@ -1,4 +1,5 @@
-import type { Plugin } from "@opencode-ai/plugin"
+import type { Plugin as V1Plugin } from "@opencode-ai/plugin"
+import type { Plugin as V2 } from "@opencode/plugin"
 import { spawn } from "node:child_process"
 import fs from "node:fs"
 import path from "node:path"
@@ -18,10 +19,21 @@ import path from "node:path"
 // Fail-open everywhere (D-03): a missing server binary, missing
 // .agentfs/.planning, or a failed subcommand must never wedge an OpenCode
 // session.
+//
+// V1/V2 dual entrypoint (2026-09-08): opencode2 (V2) schema-decodes the
+// module `default` export as a definition with `id` + `setup`/`effect` — the
+// old named `export const MemoryWakeupPlugin: Plugin` shape fails V2 loading
+// with `SchemaError(Missing key at ["default"])` (server log ref
+// err_128a87db). V1 >= 1.18.29 (installed on deep and fast) accepts the same
+// default-export object and calls `server()` for the legacy hooks. Each side
+// stays on its own API; V2 ignores `server()` and never translates V1 hooks.
 
 const SERVER_ENTRY = "@@INFRA_ROOT@@/mcp-memory-server/dist/index.js"
 const ARTIFACT_ENTRY = "@@INFRA_ROOT@@/mcp-memory-server/dist/artifact-cli.js"
 
+const WAKEUP_NOTICE =
+  "Session-start context (auto-surfaced by the memory-wakeup plugin — use it; do not ask the user to recall anything it contains):"
+
 function compactionCaptureEnabled(): boolean {
   return /^(1|true|yes|on)$/i.test(process.env.CAIRN_COMPACTION_CAPTURE ?? "")
 }
@@ -62,93 +74,155 @@ function runNode(entry: string, args: string[], timeoutMs = 3000): Promise<strin
   })
 }
 
-export const MemoryWakeupPlugin: Plugin = async ({ $, directory }) => {
-  return {
-    // No per-session dedupe: this hook fires more than once per session
-    // (including OpenCode's internal title-generation call, which happens
-    // before the first real agent turn and shares the same sessionID). A
-    // "surface once per session" Set keyed on sessionID would mark the
-    // session surfaced on that throwaway title-gen call and silently skip
-    // every real turn afterward — the OCP-05 acceptance gate never sees the
-    // injected context. `output.system` is a fresh array per call, so
-    // re-pushing on every invocation is both correct and required.
-    "experimental.chat.system.transform": async (input, output) => {
-      try {
-        const repo = directory
-        const agentfsDb = path.join(repo, ".agentfs", "project.db")
-        const wikiIndex = path.join(repo, ".planning", "wiki", "index.md")
-        const hasAgentfs = fs.existsSync(agentfsDb)
-        const hasWiki = fs.existsSync(wikiIndex)
-        const compactionEnabled = compactionCaptureEnabled()
-        if (!hasAgentfs && !hasWiki && !compactionEnabled) return
+// Shared V1/V2 surfacing rules (OCP-05, D-04) — one source of truth for the
+// sections so both runtimes inject byte-identical context.
+// `agentfsMemory === null` means "no AgentFS store present" (section omitted);
+// a string means the store exists, even when the wakeup call returned "".
+function collectSections(repo: string, agentfsMemory: string | null): string[] {
+  const sections: string[] = []
 
-        const sections: string[] = []
+  if (agentfsMemory !== null) {
+    sections.push("## Project memory (AgentFS)")
+    if (agentfsMemory) sections.push(agentfsMemory)
+  }
 
-        if (hasAgentfs) {
-          const res = await $`node ${SERVER_ENTRY} wakeup`.quiet().nothrow()
-          const memory = String(res.stdout ?? "").trim()
-          sections.push("## Project memory (AgentFS)")
-          if (memory) sections.push(memory)
-        }
+  const wikiIndex = path.join(repo, ".planning", "wiki", "index.md")
+  if (fs.existsSync(wikiIndex)) {
+    const wiki = fs.readFileSync(wikiIndex, "utf8").trim()
+    sections.push("## Wiki index")
+    if (wiki) sections.push(wiki)
+  }
 
-        if (hasWiki) {
-          const wiki = fs.readFileSync(wikiIndex, "utf8").trim()
-          sections.push("## Wiki index")
-          if (wiki) sections.push(wiki)
-        }
+  // Surface open HARD wiki contradictions so the agent (and user) see
+  // them at session start without anyone having to remember to scan the
+  // register. Hard entries cannot both be correct and must be resolved
+  // before dependent work.
+  const contradictionsPath = path.join(repo, ".planning", "wiki", "CONTRADICTIONS.md")
+  if (fs.existsSync(contradictionsPath)) {
+    const raw = fs.readFileSync(contradictionsPath, "utf8")
+    const start = raw.indexOf("<!-- wiki:contradictions:open:start -->")
+    const end = raw.indexOf("<!-- wiki:contradictions:open:end -->")
+    if (start !== -1 && end !== -1 && end > start) {
+      const region = raw.slice(start, end)
+      const hardLines = region
+        .split("\n")
+        .filter((line) => /severity:\s*hard/i.test(line))
+      if (hardLines.length > 0) {
+        sections.push("## Open HARD contradictions — resolve before dependent work")
+        sections.push(hardLines.join("\n"))
+      }
+    }
+  }
 
-        // Surface open HARD wiki contradictions so the agent (and user) see
-        // them at session start without anyone having to remember to scan the
-        // register. Hard entries cannot both be correct and must be resolved
-        // before dependent work.
-        const contradictionsPath = path.join(repo, ".planning", "wiki", "CONTRADICTIONS.md")
-        if (fs.existsSync(contradictionsPath)) {
-          const raw = fs.readFileSync(contradictionsPath, "utf8")
-          const start = raw.indexOf("<!-- wiki:contradictions:open:start -->")
-          const end = raw.indexOf("<!-- wiki:contradictions:open:end -->")
-          if (start !== -1 && end !== -1 && end > start) {
-            const region = raw.slice(start, end)
-            const hardLines = region
-              .split("\n")
-              .filter((line) => /severity:\s*hard/i.test(line))
-            if (hardLines.length > 0) {
-              sections.push("## Open HARD contradictions — resolve before dependent work")
-              sections.push(hardLines.join("\n"))
-            }
-          }
-        }
+  // Surface staged memory candidates captured by the session-end
+  // capture plugin. These are extracted automatically from the last
+  // session but NOT yet written to AgentFS — /memory-review is the
+  // accept gate.
+  const stagingDir = path.join(repo, ".planning", "memory-staging")
+  if (fs.existsSync(stagingDir)) {
+    const staged = fs.readdirSync(stagingDir).filter((f) => f.endsWith(".json"))
+    if (staged.length > 0) {
+      sections.push(`## Staged memory candidates (${staged.length} session(s)) — UNREVIEWED`)
+      sections.push("Run /memory-review to accept (→ AgentFS) or discard these before doing other work.")
+    }
+  }
 
-        // Surface staged memory candidates captured by the session-end
-        // capture plugin. These are extracted automatically from the last
-        // session but NOT yet written to AgentFS — /memory-review is the
-        // accept gate.
-        const stagingDir = path.join(repo, ".planning", "memory-staging")
-        if (fs.existsSync(stagingDir)) {
-          const staged = fs.readdirSync(stagingDir).filter((f) => f.endsWith(".json"))
-          if (staged.length > 0) {
-            sections.push(`## Staged memory candidates (${staged.length} session(s)) — UNREVIEWED`)
-            sections.push("Run /memory-review to accept (→ AgentFS) or discard these before doing other work.")
-          }
-        }
+  return sections
+}
 
+export default {
+  id: "cairnkeep.memory-wakeup",
+
+  // V2 (opencode2) entrypoint. `session.hook("context")` fires per model
+  // dispatch for this location's sessions — NOT for title requests, but it
+  // does run again for tool continuations, compaction and transient generate
+  // calls. `event.system` is a fresh SystemPart array per call, so
+  // re-pushing on every invocation is both correct and required (a
+  // per-session dedupe Set would key on the throwaway title-gen call under
+  // V1 and silently skip real turns — the original OCP-05 pitfall).
+  async setup(ctx: V2.Context) {
+    const repo = ctx.location.directory
+    await ctx.session.hook("context", async (event) => {
+      try {
+        const hasAgentfs = fs.existsSync(path.join(repo, ".agentfs", "project.db"))
+        const hasWiki = fs.existsSync(path.join(repo, ".planning", "wiki", "index.md"))
+        const compactionEnabled = compactionCaptureEnabled()
+        if (!hasAgentfs && !hasWiki && !compactionEnabled) return
+
+        // No `$` BunShell in the V2 context — use node's own child_process
+        // (same helper the V1 compaction path already relies on).
+        let agentfsMemory: string | null = null
+        if (hasAgentfs) agentfsMemory = (await runNode(SERVER_ENTRY, ["wakeup"])).trim()
+
+        const sections = collectSections(repo, agentfsMemory)
         if (sections.length > 0) {
-          output.system.push(
-            "Session-start context (auto-surfaced by the memory-wakeup plugin — use it; do not ask the user to recall anything it contains):",
-          )
-          output.system.push(sections.join("\n\n"))
+          event.system.push({ type: "text", text: WAKEUP_NOTICE })
+          event.system.push({ type: "text", text: sections.join("\n\n") })
         }
 
         if (compactionEnabled && fs.existsSync(ARTIFACT_ENTRY)) {
           const args = ["recover", repo]
-          if (typeof input.sessionID === "string" && input.sessionID) {
-            args.push("--session-ref", `opencode:${input.sessionID}`)
+          const sessionID = (event as { sessionID?: unknown }).sessionID
+          if (typeof sessionID === "string" && sessionID) {
+            args.push("--session-ref", `opencode:${sessionID}`)
           }
           const recovery = (await runNode(ARTIFACT_ENTRY, args, 3000)).trim()
-          if (recovery) output.system.push(recovery)
+          if (recovery) event.system.push({ type: "text", text: recovery })
         }
       } catch {
         // Fail open — never block a session because context surfacing failed.
       }
-    },
-  }
+    })
+  },
+
+  // V1 (opencode >= 1.18.29 documented object form) entrypoint — legacy
+  // implementation kept verbatim on its own API (`$` is V1's BunShell).
+  async server(input: Parameters<V1Plugin>[0]) {
+    const { $, directory } = input
+    return {
+      // No per-session dedupe: this hook fires more than once per session
+      // (including OpenCode's internal title-generation call, which happens
+      // before the first real agent turn and shares the same sessionID). A
+      // "surface once per session" Set keyed on sessionID would mark the
+      // session surfaced on that throwaway title-gen call and silently skip
+      // every real turn afterward — the OCP-05 acceptance gate never sees the
+      // injected context. `output.system` is a fresh array per call, so
+      // re-pushing on every invocation is both correct and required.
+      "experimental.chat.system.transform": async (
+        hookInput: { sessionID?: unknown },
+        output: { system: string[] },
+      ) => {
+        try {
+          const repo = directory
+          const hasAgentfs = fs.existsSync(path.join(repo, ".agentfs", "project.db"))
+          const hasWiki = fs.existsSync(path.join(repo, ".planning", "wiki", "index.md"))
+          const compactionEnabled = compactionCaptureEnabled()
+          if (!hasAgentfs && !hasWiki && !compactionEnabled) return
+
+          let agentfsMemory: string | null = null
+          if (hasAgentfs) {
+            const res = await $`node ${SERVER_ENTRY} wakeup`.quiet().nothrow()
+            agentfsMemory = String(res.stdout ?? "").trim()
+          }
+
+          const sections = collectSections(repo, agentfsMemory)
+          if (sections.length > 0) {
+            output.system.push(WAKEUP_NOTICE)
+            output.system.push(sections.join("\n\n"))
+          }
+
+          if (compactionEnabled && fs.existsSync(ARTIFACT_ENTRY)) {
+            const args = ["recover", repo]
+            if (typeof hookInput.sessionID === "string" && hookInput.sessionID) {
+              args.push("--session-ref", `opencode:${hookInput.sessionID}`)
+            }
+            const recovery = (await runNode(ARTIFACT_ENTRY, args, 3000)).trim()
+            if (recovery) output.system.push(recovery)
+          }
+        } catch {
+          // Fail open — never block a session because context surfacing failed.
+        }
+      },
+    }
+  },
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cairnkeep/cli",
-    "version": "2.19.1",
+    "version": "2.20.0",
     "description": "A durable, harness-agnostic memory + context layer for coding agents and MCP clients.",
     "license": "Apache-2.0",
     "type": "module",