@orquentra/codebuddy 2.9.0 → 2.14.0

package/dist/{chunk-J4T6HHI4.js → chunk-L6BRYZ6G.js}

@@ -4,10 +4,30 @@ import {
   MODE_LABELS,
   sharedRulesReaders,
   supportedModes
-} from "./chunk-W7GAXL6C.js";
+} from "./chunk-V7PT6ER5.js";
+import {
+  runLeanHook
+} from "./chunk-LRQNPYCK.js";
+import {
+  appendHostEvents,
+  extractEditedPaths,
+  isUnfinished,
+  latestUnfinished,
+  readCheckpoint,
+  renderCheckpointNow,
+  runCaptureHook,
+  runCheckpointHook,
+  runContextHook,
+  runResetHook,
+  runResumeHook,
+  runStageHook
+} from "./chunk-XSNW6Y3X.js";
+import {
+  hookRoot
+} from "./chunk-TGFTKWOR.js";
 import {
   indexRepository
-} from "./chunk-ITQO632W.js";
+} from "./chunk-YNSTIMCF.js";
 import {
   resolveNamespaceFrom
 } from "./chunk-KNR2P2UY.js";
@@ -17,18 +37,318 @@ import {
 
 // src/clients/install.ts
 import { access as access2 } from "fs/promises";
-import { join as join9, resolve as resolve7 } from "path";
+import { join as join10, resolve as resolve7 } from "path";
+
+// src/hooks/codex.ts
+import { join as join2 } from "path";
+
+// src/hooks/bridge.ts
+async function runBridgeHook(input, emit) {
+  await runCheckpointHook(input);
+  const root = hookRoot(input.cwd);
+  const session = input.session_id ?? "default";
+  const recovery = input.bridge_recovery;
+  const checkpoint = recovery === "resume" ? await latestUnfinished(root, session) : recovery ? await readCheckpoint(root, session) : null;
+  const task = checkpoint && (recovery === "compact" || isUnfinished(checkpoint)) && (recovery !== "current" || checkpoint.editedPaths.length || checkpoint.findings.length || checkpoint.nextAction || checkpoint.verification.length) ? await renderCheckpointNow(
+    root,
+    checkpoint,
+    recovery === "resume" ? `unfinished, from session ${checkpoint.session}` : "current task"
+  ) : "";
+  let sent = false;
+  const output = async (block2) => {
+    await emit?.([block2, task].filter(Boolean).join("\n"));
+    sent = true;
+  };
+  const block = input.injection === "lean" ? await runLeanHook(input, output) : await runContextHook(input, output);
+  if (!sent && task) await emit?.(task);
+  return [block, task].filter(Boolean).join("\n");
+}
+
+// src/hooks/settings.ts
+import { mkdir, readFile } from "fs/promises";
+import { dirname, join, resolve } from "path";
+var HOOK_COMMAND_PREFIX = "codebuddy hooks";
+var TOOL_GUARD_DEF = {
+  event: "PreToolUse",
+  matcher: "Read|Grep|Bash",
+  command: `${HOOK_COMMAND_PREFIX} pretool`
+};
+var CAPTURE_DEFS = [
+  {
+    event: "PostToolUse",
+    matcher: "Edit|Write|MultiEdit",
+    command: `${HOOK_COMMAND_PREFIX} stage`
+  },
+  { event: "Stop", command: `${HOOK_COMMAND_PREFIX} capture` },
+  // Journal the transcript before compaction summarizes it.
+  { event: "PreCompact", command: `${HOOK_COMMAND_PREFIX} checkpoint` },
+  // A new or resumed session sees another session's unfinished task, if any.
+  { event: "SessionStart", matcher: "startup|resume", command: `${HOOK_COMMAND_PREFIX} resume` }
+];
+var [STAGE_DEF, TURN_END_DEF, CHECKPOINT_DEF, RESUME_DEF] = CAPTURE_DEFS;
+var RESET_DEF = {
+  event: "SessionStart",
+  matcher: "compact|clear",
+  command: `${HOOK_COMMAND_PREFIX} reset`
+};
+var INJECTION_DEFS = {
+  full: { event: "UserPromptSubmit", command: `${HOOK_COMMAND_PREFIX} context` },
+  /** Lean: prompt pointers only. */
+  lean: { event: "UserPromptSubmit", command: `${HOOK_COMMAND_PREFIX} lean` }
+};
+function hookDefs(variant, capture) {
+  return [INJECTION_DEFS[variant], RESET_DEF, ...capture ? CAPTURE_DEFS : [], TOOL_GUARD_DEF];
+}
+var defaultCapture = (variant) => variant === "full";
+function claudeSettingsPath(repositoryRoot = process.cwd()) {
+  return join(resolve(repositoryRoot), ".claude", "settings.json");
+}
+function upsertHooks(settings, variant = "full", capture = defaultCapture(variant)) {
+  const defs = hookDefs(variant, capture);
+  const wanted = new Set(defs.map((def) => def.command));
+  const next = { ...settings, hooks: { ...settings.hooks ?? {} } };
+  const hooks = next.hooks;
+  let changed = false;
+  for (const event of Object.keys(hooks)) {
+    const groups = [];
+    for (const group of hooks[event] ?? []) {
+      const kept = (group.hooks ?? []).filter(
+        (hook) => !hook.command?.startsWith(HOOK_COMMAND_PREFIX) || wanted.has(hook.command)
+      );
+      if (kept.length !== (group.hooks ?? []).length) changed = true;
+      if (kept.length > 0) groups.push({ ...group, hooks: kept });
+    }
+    if (groups.length > 0) hooks[event] = groups;
+    else delete hooks[event];
+  }
+  for (const def of defs) {
+    const groups = [...hooks[def.event] ?? []];
+    const existingIndex = groups.findIndex(
+      (group) => group.hooks?.some((hook) => hook.command === def.command)
+    );
+    if (existingIndex === -1) {
+      groups.push({
+        ...def.matcher ? { matcher: def.matcher } : {},
+        hooks: [{ type: "command", command: def.command }]
+      });
+      changed = true;
+    } else {
+      const existing = groups[existingIndex];
+      if (existing && (def.matcher ?? void 0) !== (existing.matcher ?? void 0)) {
+        const { matcher: _oldMatcher, ...rest } = existing;
+        groups[existingIndex] = def.matcher ? { ...rest, matcher: def.matcher } : rest;
+        changed = true;
+      }
+    }
+    hooks[def.event] = groups;
+  }
+  return { settings: next, changed };
+}
+function removeHooks(settings) {
+  if (!settings.hooks) return { settings, changed: false };
+  const next = { ...settings, hooks: { ...settings.hooks } };
+  const hooks = next.hooks;
+  let changed = false;
+  for (const event of Object.keys(hooks)) {
+    const keptGroups = [];
+    for (const group of hooks[event] ?? []) {
+      const keptHooks = (group.hooks ?? []).filter(
+        (hook) => !hook.command?.startsWith(HOOK_COMMAND_PREFIX)
+      );
+      if (keptHooks.length !== (group.hooks ?? []).length) changed = true;
+      if (keptHooks.length === 0) continue;
+      keptGroups.push({ ...group, hooks: keptHooks });
+    }
+    if (keptGroups.length === 0) delete hooks[event];
+    else hooks[event] = keptGroups;
+  }
+  return { settings: next, changed };
+}
+function hooksInstalled(settings) {
+  const hooks = settings.hooks ?? {};
+  return Object.values(hooks).some(
+    (groups) => groups.some((group) => group.hooks?.some((h) => h.command?.startsWith(HOOK_COMMAND_PREFIX)))
+  );
+}
+function hooksVariant(settings) {
+  if (!hooksInstalled(settings)) return null;
+  const leanCommand = `${HOOK_COMMAND_PREFIX} lean`;
+  const lean = Object.values(settings.hooks ?? {}).some(
+    (groups) => groups.some((group) => group.hooks?.some((hook) => hook.command === leanCommand))
+  );
+  return lean ? "lean" : "full";
+}
+function hookCapabilities(settings) {
+  const commands = new Set(
+    Object.values(settings.hooks ?? {}).flatMap(
+      (groups) => groups.flatMap((group) => (group.hooks ?? []).map((hook) => hook.command))
+    )
+  );
+  const has = (def) => commands.has(def.command);
+  return {
+    injection: has(INJECTION_DEFS.lean) ? "lean" : has(INJECTION_DEFS.full) ? "full" : null,
+    capture: has(STAGE_DEF) && has(TURN_END_DEF),
+    recovery: has(CHECKPOINT_DEF) && has(RESUME_DEF),
+    reset: has(RESET_DEF),
+    guard: has(TOOL_GUARD_DEF)
+  };
+}
+async function readSettings(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return {};
+    throw error;
+  }
+}
+async function writeSettings(path, settings) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeAtomic(path, `${JSON.stringify(settings, null, 2)}
+`, { mode: 420 });
+}
+
+// src/hooks/codex.ts
+var PREFIX = "codebuddy hooks codex";
+var owned = (command) => command === PREFIX || command.startsWith(`${PREFIX} `);
+var codexHooksPath = (root) => join2(root, ".codex", "hooks.json");
+async function setCodexHooks(root, enabled, variant = "full", capture = defaultCapture(variant)) {
+  const path = codexHooksPath(root);
+  const before = await readSettings(path);
+  const hooks = {};
+  const next = { ...before, hooks };
+  for (const [event, groups] of Object.entries(before.hooks ?? {})) {
+    const kept = groups.flatMap((group) => {
+      const hooks2 = group.hooks.filter((hook) => !owned(hook.command));
+      return hooks2.length ? [{ ...group, hooks: hooks2 }] : [];
+    });
+    if (kept.length) hooks[event] = kept;
+  }
+  if (enabled) {
+    const command = `${PREFIX} --injection ${variant}${capture ? " --capture" : ""}`;
+    for (const [event, matcher] of [
+      ["UserPromptSubmit", void 0],
+      ...capture ? [
+        ["PostToolUse", "Bash|apply_patch|Edit|Write"],
+        ["Stop", void 0],
+        ["PreCompact", void 0],
+        ["Interrupt", void 0]
+      ] : [],
+      ["SessionStart", "startup|resume|fork|compact|clear"]
+    ]) {
+      const handler = {
+        type: "command",
+        command,
+        timeout: event === "Interrupt" ? 3 : 20
+      };
+      hooks[event] ??= [];
+      hooks[event].push({ ...matcher ? { matcher } : {}, hooks: [handler] });
+    }
+  }
+  if (!Object.keys(next.hooks ?? {}).length) delete next.hooks;
+  if (JSON.stringify(before) === JSON.stringify(next)) return false;
+  await writeSettings(path, next);
+  return true;
+}
+async function codexHookCapabilities(root) {
+  const settings = await readSettings(codexHooksPath(root));
+  const commands = (event) => (settings.hooks?.[event] ?? []).flatMap((group) => group.hooks.map((hook) => hook.command)).filter(owned);
+  const prompt = commands("UserPromptSubmit")[0];
+  const capture = commands("Stop").length > 0;
+  return {
+    injection: prompt ? prompt.includes("--injection lean") ? "lean" : "full" : null,
+    capture,
+    recovery: capture && commands("PreCompact").length > 0,
+    reset: commands("SessionStart").length > 0,
+    guard: false
+  };
+}
+function toolOutcome(value) {
+  if (value && typeof value === "object") {
+    const item = value;
+    if (typeof item.exit_code === "number") return item.exit_code === 0;
+    if (typeof item.is_error === "boolean") return !item.is_error;
+  }
+  return void 0;
+}
+async function runCodexHook(input, variant, capture) {
+  const root = hookRoot(input.cwd);
+  const session = input.session_id ?? "default";
+  const turn = input.turn_id ?? input.session_id ?? "default";
+  const event = input.hook_event_name;
+  let context = "";
+  const base = { cwd: root, session_id: session };
+  if (event === "UserPromptSubmit") {
+    const journal_events = capture && input.prompt ? [{ id: `${turn}:prompt`, kind: "user", text: input.prompt }] : [];
+    context = await runBridgeHook({
+      ...base,
+      ...input.prompt ? { prompt: input.prompt } : {},
+      injection: variant,
+      journal_events
+    });
+  } else if (event === "PostToolUse" && capture) {
+    const id = input.tool_use_id ?? `${turn}:${JSON.stringify(input.tool_input)}`;
+    const events = [];
+    if (input.tool_name === "Bash" && typeof input.tool_input?.command === "string") {
+      events.push({ id, kind: "command", ref: id, text: input.tool_input.command });
+      const ok = toolOutcome(input.tool_response);
+      events.push({
+        id: `${id}:result`,
+        kind: "result",
+        ref: id,
+        ...ok !== void 0 ? { ok } : {}
+      });
+      await appendHostEvents(root, session, events);
+    } else {
+      if (toolOutcome(input.tool_response) === false) return {};
+      const tool_input = input.tool_name === "apply_patch" ? { patch: input.tool_input?.command } : input.tool_input;
+      extractEditedPaths(tool_input).forEach((path, index) => {
+        events.push({ id: `${id}:${index}`, kind: "edit", path });
+      });
+      await runStageHook({
+        ...base,
+        ...tool_input ? { tool_input } : {},
+        journal_events: events
+      });
+    }
+  } else if (event === "Stop" && capture) {
+    const checkpoint = await readCheckpoint(root, session);
+    await runCaptureHook({
+      ...base,
+      ...input.last_assistant_message ? { last_assistant_message: input.last_assistant_message } : {},
+      user_prompts: checkpoint?.constraints ?? [],
+      shell_commands: checkpoint?.verification.map((run) => ({
+        command: run.command,
+        exit_code: run.ok === null ? null : run.ok ? 0 : 1
+      })) ?? [],
+      journal_events: input.last_assistant_message ? [{ id: `${turn}:assistant`, kind: "assistant", text: input.last_assistant_message }] : []
+    });
+  } else if (event === "SessionStart") {
+    if (input.source === "compact" || input.source === "clear") {
+      context = await runResetHook({
+        ...base,
+        ...variant === "full" ? { hook_event_name: "SessionStart" } : {},
+        source: capture ? input.source : "clear"
+      });
+      if (variant === "lean" && capture && input.source === "compact") {
+        const checkpoint = await readCheckpoint(root, session);
+        if (checkpoint?.goal)
+          context = await renderCheckpointNow(root, checkpoint, "before compaction");
+      }
+    } else if (capture) context = await runResumeHook(base);
+  }
+  return context ? { hookSpecificOutput: { hookEventName: event, additionalContext: context } } : {};
+}
 
 // src/hooks/hermes-plugin.ts
-import { readFile as readFile2 } from "fs/promises";
-import { dirname as dirname2, join, resolve } from "path";
+import { readFile as readFile3 } from "fs/promises";
+import { dirname as dirname3, join as join3, resolve as resolve2 } from "path";
 
 // src/hooks/managed-plugin.ts
-import { mkdir, readFile, rm, rmdir } from "fs/promises";
-import { dirname } from "path";
+import { mkdir as mkdir2, readFile as readFile2, rm, rmdir } from "fs/promises";
+import { dirname as dirname2 } from "path";
 async function read(path) {
   try {
-    return await readFile(path, "utf8");
+    return await readFile2(path, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw error;
@@ -55,7 +375,7 @@ async function setManagedPlugin(plugin3, enabled) {
   let changed = false;
   for (const [i, file] of plugin3.files.entries()) {
     if (enabled && current[i] !== file.content) {
-      await mkdir(dirname(file.path), { recursive: true });
+      await mkdir2(dirname2(file.path), { recursive: true });
       await writeAtomic(file.path, file.content, { mode: 420 });
       changed = true;
     } else if (!enabled && current[i] != null) {
@@ -108,9 +428,14 @@ var HERMES_HOOK_FN = `def _hook(command, payload):
 
 
 `;
-function renderHermesPlugin(variant) {
-  return variant === "lean" ? `${HERMES_PLUGIN_MARKER} v1 lean
-# Generated by "codebuddy clients install hermes --mode lean"; removed by
+function renderHermesPlugin(variant, capture = defaultCapture(variant)) {
+  const command = variant === "lean" ? "lean" : "context";
+  const mode = variant === "lean" ? "lean" : "hooks";
+  const captureMarker = capture === defaultCapture(variant) ? "" : `
+# codebuddy-capture: ${capture ? "on" : "off"}`;
+  const marker = `${HERMES_PLUGIN_MARKER} v1${variant === "lean" ? " lean" : ""}${captureMarker}${capture ? "\n# codebuddy-recovery: v1" : ""}`;
+  return !capture ? `${marker}
+# Generated by "codebuddy clients install hermes --mode ${mode}"; removed by
 # "codebuddy clients uninstall hermes". Local edits are overwritten.
 """CodeBuddy lean bridge: forwards each prompt to "codebuddy hooks lean"."""
 
@@ -120,7 +445,7 @@ from pathlib import Path
 
 # <root>/.hermes/plugins/codebuddy/__init__.py
 ROOT = str(Path(__file__).absolute().parents[3])
-TIMEOUT_S = {"lean": 2}
+TIMEOUT_S = {"${command}": ${variant === "lean" ? 2 : 20}}
 
 
 ${HERMES_HOOK_FN}def _pre_llm_call(session_id="", user_message="", **_):
@@ -132,14 +457,14 @@ ${HERMES_HOOK_FN}def _pre_llm_call(session_id="", user_message="", **_):
         "ephemeral_context": True,
         "prompt": user_message,
     }
-    block = _hook("lean", payload).strip()
+    block = _hook("${command}", payload).strip()
     return {"context": block} if block else None
 
 
 def register(ctx):
     ctx.register_hook("pre_llm_call", _pre_llm_call)
-` : `${HERMES_PLUGIN_MARKER} v1
-# Generated by "codebuddy clients install hermes --mode hooks"; removed by
+` : `${marker}
+# Generated by "codebuddy clients install hermes --mode ${mode}"; removed by
 # "codebuddy clients uninstall hermes". Local edits are overwritten.
 """CodeBuddy lifecycle bridge: forwards Hermes hooks to "codebuddy hooks <command>"."""
 
@@ -151,7 +476,7 @@ from pathlib import Path
 # <root>/.hermes/plugins/codebuddy/__init__.py
 ROOT = str(Path(__file__).absolute().parents[3])
 EDIT_TOOLS = {"write_file", "patch"}
-TIMEOUT_S = {"context": 20, "stage": 10, "capture": 60}
+TIMEOUT_S = {"bridge": 20, "checkpoint": 10, "stage": 10, "capture": 60}
 _lock = threading.Lock()
 _turns = {}
 
@@ -160,20 +485,23 @@ ${HERMES_HOOK_FN}def _turn(turn_id, session_id):
     # Compression can rotate the session id mid-turn; a turn keeps its first id.
     with _lock:
         return _turns.setdefault(
-            turn_id or session_id, {"session": session_id, "text": "", "commands": []}
+            turn_id or session_id, {"session": session_id, "text": "", "commands": [], "prompt": ""}
         )
 
 
-def _pre_llm_call(session_id="", turn_id="", user_message="", **_):
-    _turn(turn_id, session_id)
-    payload = {"session_id": session_id, "hook_event_name": "pre_llm_call", "ephemeral_context": True}
+def _pre_llm_call(session_id="", turn_id="", user_message="", is_first_turn=False, **_):
+    turn = _turn(turn_id, session_id)
+    payload = {"session_id": turn["session"], "hook_event_name": "pre_llm_call", "ephemeral_context": True,
+               "injection": "${variant}", "bridge_recovery": "resume" if is_first_turn else "current"}
     if isinstance(user_message, str) and user_message.strip():
         payload["prompt"] = user_message
-    block = _hook("context", payload).strip()
+        turn["prompt"] = user_message
+        payload["journal_events"] = [{"id": (turn_id or session_id) + ":prompt", "kind": "user", "text": user_message}]
+    block = _hook("bridge", payload).strip()
     return {"context": block} if block else None
 
 
-def _post_tool_call(tool_name="", args=None, result=None, session_id="", turn_id="", **_):
+def _post_tool_call(tool_name="", args=None, result=None, session_id="", turn_id="", tool_call_id="", **_):
     turn = _turn(turn_id, session_id)
     args = args if isinstance(args, dict) else {}
     if tool_name in EDIT_TOOLS:
@@ -184,6 +512,7 @@ def _post_tool_call(tool_name="", args=None, result=None, session_id="", turn_id
             "hook_event_name": "post_tool_call",
             "tool_name": tool_name,
             "tool_input": tool_input,
+            "journal_event_id": tool_call_id or turn_id + ":" + json.dumps(tool_input, sort_keys=True),
         })
     elif tool_name == "terminal" and isinstance(args.get("command"), str):
         exit_code = None
@@ -196,18 +525,29 @@ def _post_tool_call(tool_name="", args=None, result=None, session_id="", turn_id
             "command": args["command"],
             "exit_code": exit_code if type(exit_code) is int else None,
         })
+        ref = tool_call_id or turn_id + ":" + args["command"]
+        outcome = {"id": ref + ":result", "kind": "result", "ref": ref}
+        if type(exit_code) is int:
+            outcome["ok"] = exit_code == 0
+        _hook("checkpoint", {"session_id": turn["session"], "journal_events": [
+            {"id": ref, "kind": "command", "ref": ref, "text": args["command"]}, outcome]})
 
 
 def _post_llm_call(session_id="", turn_id="", assistant_response="", **_):
     if isinstance(assistant_response, str) and assistant_response.strip():
-        _turn(turn_id, session_id)["text"] = assistant_response
+        turn = _turn(turn_id, session_id)
+        turn["text"] = assistant_response
+        _hook("checkpoint", {"session_id": turn["session"], "journal_events": [
+            {"id": (turn_id or session_id) + ":text:" + assistant_response, "kind": "assistant", "text": assistant_response}]})
 
 
 def _on_session_end(session_id="", turn_id="", **_):
     with _lock:
         turn = _turns.pop(turn_id or session_id, None)
-    turn = turn or {"session": session_id, "text": "", "commands": []}
+    turn = turn or {"session": session_id, "text": "", "commands": [], "prompt": ""}
     payload = {"session_id": turn["session"], "hook_event_name": "on_session_end"}
+    if turn.get("prompt"):
+        payload["user_prompts"] = [turn["prompt"]]
     if turn["text"]:
         payload["last_assistant_message"] = turn["text"]
     if turn["commands"]:
@@ -224,37 +564,49 @@ def register(ctx):
 }
 var HERMES_PLUGIN_SOURCE = renderHermesPlugin("full");
 function hermesPluginDir(repositoryRoot) {
-  return join(resolve(repositoryRoot), ".hermes", "plugins", "codebuddy");
+  return join3(resolve2(repositoryRoot), ".hermes", "plugins", "codebuddy");
 }
-function plugin(repositoryRoot, variant = "full") {
+function plugin(repositoryRoot, variant = "full", capture = defaultCapture(variant)) {
   const dir = hermesPluginDir(repositoryRoot);
   return {
     marker: HERMES_PLUGIN_MARKER,
     files: [
       {
-        path: join(dir, "plugin.yaml"),
-        content: variant === "lean" ? HERMES_LEAN_MANIFEST : HERMES_PLUGIN_MANIFEST
+        path: join3(dir, "plugin.yaml"),
+        content: capture ? HERMES_PLUGIN_MANIFEST : HERMES_LEAN_MANIFEST
       },
-      { path: join(dir, "__init__.py"), content: renderHermesPlugin(variant) }
+      { path: join3(dir, "__init__.py"), content: renderHermesPlugin(variant, capture) }
     ],
-    dirs: [dir, dirname2(dir), dirname2(dirname2(dir))]
+    dirs: [dir, dirname3(dir), dirname3(dirname3(dir))]
   };
 }
 function hermesPluginInstalled(repositoryRoot) {
   return managedPluginInstalled(plugin(repositoryRoot));
 }
-function setHermesPlugin(repositoryRoot, enabled, variant = "full") {
-  return setManagedPlugin(plugin(repositoryRoot, variant), enabled);
+function setHermesPlugin(repositoryRoot, enabled, variant = "full", capture = defaultCapture(variant)) {
+  return setManagedPlugin(plugin(repositoryRoot, variant, capture), enabled);
+}
+async function hermesPluginCapabilities(root) {
+  const injection = await hermesPluginVariant(root);
+  const source = injection ? await readFile3(join3(hermesPluginDir(root), "__init__.py"), "utf8") : "";
+  const explicit = source.match(/^# codebuddy-capture: (on|off)$/m)?.[1];
+  return {
+    injection,
+    capture: explicit ? explicit === "on" : injection === "full",
+    recovery: (explicit ? explicit === "on" : injection === "full") && source.includes("codebuddy-recovery: v1"),
+    reset: injection !== null,
+    guard: false
+  };
 }
 async function hermesPluginVariant(repositoryRoot) {
   if (!await hermesPluginInstalled(repositoryRoot)) return null;
-  const source = await readFile2(join(hermesPluginDir(repositoryRoot), "__init__.py"), "utf8");
+  const source = await readFile3(join3(hermesPluginDir(repositoryRoot), "__init__.py"), "utf8");
   return source.startsWith(`${HERMES_PLUGIN_MARKER} v1 lean`) ? "lean" : "full";
 }
 
 // src/hooks/opencode-plugin.ts
-import { readFile as readFile3 } from "fs/promises";
-import { dirname as dirname3, join as join2, resolve as resolve2 } from "path";
+import { readFile as readFile4 } from "fs/promises";
+import { dirname as dirname4, join as join4, resolve as resolve3 } from "path";
 var OPENCODE_PLUGIN_MARKER = "// codebuddy-managed: opencode-plugin";
 var OPENCODE_RUNTIME = `const ID_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 let lastMs = 0;
@@ -309,13 +661,18 @@ function partId() {
 }
 
 `;
-function renderOpencodePlugin(variant) {
-  return variant === "lean" ? `${OPENCODE_PLUGIN_MARKER} v1 lean
-// Generated by \`codebuddy clients install opencode --mode lean\`; removed by
+function renderOpencodePlugin(variant, capture = defaultCapture(variant)) {
+  const command = variant === "lean" ? "lean" : "context";
+  const mode = variant === "lean" ? "lean" : "hooks";
+  const captureMarker = capture === defaultCapture(variant) ? "" : `
+// codebuddy-capture: ${capture ? "on" : "off"}`;
+  const marker = `${OPENCODE_PLUGIN_MARKER} v1${variant === "lean" ? " lean" : ""}${captureMarker}${capture ? "\n// codebuddy-recovery: v1" : ""}`;
+  return !capture ? `${marker}
+// Generated by \`codebuddy clients install opencode --mode ${mode}\`; removed by
 // \`codebuddy clients uninstall opencode\`. Local edits are overwritten.
 import { spawn } from "node:child_process";
 
-const TIMEOUT_MS = { lean: 2000, reset: 10000 };
+const TIMEOUT_MS = { ${command}: ${variant === "lean" ? 2e3 : 2e4}, reset: 10000 };
 ${OPENCODE_RUNTIME}/** @type {import("@opencode-ai/plugin").Plugin} */
 export const CodeBuddyPlugin = async ({ directory }) => {
   const base = (sessionID, event) => ({ session_id: sessionID, cwd: directory, hook_event_name: event });
@@ -327,7 +684,7 @@ export const CodeBuddyPlugin = async ({ directory }) => {
         .join("\\n")
         .trim();
       if (!prompt) return;
-      const block = (await hook("lean", { ...base(input.sessionID, "chat.message"), prompt })).trim();
+      const block = (await hook("${command}", { ...base(input.sessionID, "chat.message"), prompt })).trim();
       if (!block) return;
       output.parts.push({
         id: partId(),
@@ -345,19 +702,21 @@ export const CodeBuddyPlugin = async ({ directory }) => {
     },
   };
 };
-` : `${OPENCODE_PLUGIN_MARKER} v1
-// Generated by \`codebuddy clients install opencode --mode hooks\`; removed by
+` : `${marker}
+// Generated by \`codebuddy clients install opencode --mode ${mode}\`; removed by
 // \`codebuddy clients uninstall opencode\`. Local edits are overwritten.
 import { spawn } from "node:child_process";
 
 const EDIT_TOOLS = new Set(["edit", "write", "patch", "apply_patch"]);
-const TIMEOUT_MS = { context: 20000, stage: 10000, capture: 60000, reset: 10000 };
+const TIMEOUT_MS = { bridge: 20000, checkpoint: 10000, stage: 10000, capture: 60000, reset: 10000 };
 ${OPENCODE_RUNTIME}/** @type {import("@opencode-ai/plugin").Plugin} */
 export const CodeBuddyPlugin = async ({ directory }) => {
   /** @type {Map<string, { text: string, commands: Array<{ command: string, exit_code: number | null }> }>} */
   const turns = new Map();
+  const sessions = new Set();
+  const compacted = new Set();
   const turn = (sessionID) => {
-    if (!turns.has(sessionID)) turns.set(sessionID, { text: "", commands: [] });
+    if (!turns.has(sessionID)) turns.set(sessionID, { text: "", commands: [], prompt: "" });
     return turns.get(sessionID);
   };
   const base = (sessionID, event) => ({ session_id: sessionID, cwd: directory, hook_event_name: event });
@@ -369,9 +728,16 @@ export const CodeBuddyPlugin = async ({ directory }) => {
         .flatMap((part) => (part.type === "text" && !part.synthetic ? [part.text] : []))
         .join("\\n")
         .trim();
+      turn(input.sessionID).prompt = prompt;
       const block = (
-        await hook("context", { ...base(input.sessionID, "chat.message"), ...(prompt ? { prompt } : {}) })
+        await hook("bridge", {
+          ...base(input.sessionID, "chat.message"), ...(prompt ? { prompt } : {}),
+          injection: "${variant}",
+          journal_events: prompt ? [{ id: output.message.id, kind: "user", text: prompt }] : [],
+          ...(compacted.has(input.sessionID) ? { bridge_recovery: "compact" } : !sessions.has(input.sessionID) ? { bridge_recovery: "resume" } : {}),
+        })
       ).trim();
+      if (block) { sessions.add(input.sessionID); compacted.delete(input.sessionID); }
       if (!block) return;
       output.parts.push({
         id: partId(),
@@ -388,6 +754,7 @@ export const CodeBuddyPlugin = async ({ directory }) => {
           ...base(input.sessionID, "tool.execute.after"),
           tool_name: input.tool,
           tool_input: input.args,
+          journal_event_id: input.callID,
         });
       } else if (input.tool === "bash" && typeof input.args?.command === "string") {
         const exit = output.metadata?.exit;
@@ -395,10 +762,23 @@ export const CodeBuddyPlugin = async ({ directory }) => {
           command: input.args.command,
           exit_code: typeof exit === "number" ? exit : null,
         });
+        await hook("checkpoint", {
+          ...base(input.sessionID, "tool.execute.after"),
+          journal_events: [
+            { id: input.callID, kind: "command", ref: input.callID, text: input.args.command },
+            { id: input.callID + ":result", kind: "result", ref: input.callID, ...(typeof exit === "number" ? { ok: exit === 0 } : {}) },
+          ],
+        });
       }
     },
     "experimental.text.complete": async (input, output) => {
-      if (output.text.trim()) turn(input.sessionID).text = output.text;
+      if (output.text.trim()) {
+        turn(input.sessionID).text = output.text;
+        await hook("checkpoint", {
+          ...base(input.sessionID, "experimental.text.complete"),
+          journal_events: [{ id: (input.messageID || input.sessionID) + ":text:" + output.text, kind: "assistant", text: output.text }],
+        });
+      }
     },
     event: async ({ event }) => {
       if (event.type === "session.idle") {
@@ -407,10 +787,12 @@ export const CodeBuddyPlugin = async ({ directory }) => {
         turns.delete(sessionID);
         await hook("capture", {
           ...base(sessionID, "session.idle"),
+          ...(current?.prompt ? { user_prompts: [current.prompt] } : {}),
           ...(current?.text ? { last_assistant_message: current.text } : {}),
           ...(current?.commands.length ? { shell_commands: current.commands.slice(-20) } : {}),
         });
       } else if (event.type === "session.compacted") {
+        compacted.add(event.properties.sessionID);
         await hook("reset", { ...base(event.properties.sessionID, "session.compacted"), source: "compact" });
       }
     },
@@ -420,179 +802,105 @@ export const CodeBuddyPlugin = async ({ directory }) => {
 }
 var OPENCODE_PLUGIN_SOURCE = renderOpencodePlugin("full");
 function opencodePluginPath(repositoryRoot) {
-  return join2(resolve2(repositoryRoot), ".opencode", "plugins", "codebuddy.js");
+  return join4(resolve3(repositoryRoot), ".opencode", "plugins", "codebuddy.js");
 }
-function plugin2(repositoryRoot, variant = "full") {
+function plugin2(repositoryRoot, variant = "full", capture = defaultCapture(variant)) {
   const path = opencodePluginPath(repositoryRoot);
   return {
     marker: OPENCODE_PLUGIN_MARKER,
-    files: [{ path, content: renderOpencodePlugin(variant) }],
-    dirs: [dirname3(path), dirname3(dirname3(path))]
+    files: [{ path, content: renderOpencodePlugin(variant, capture) }],
+    dirs: [dirname4(path), dirname4(dirname4(path))]
   };
 }
 function opencodePluginInstalled(repositoryRoot) {
   return managedPluginInstalled(plugin2(repositoryRoot));
 }
-function setOpencodePlugin(repositoryRoot, enabled, variant = "full") {
-  return setManagedPlugin(plugin2(repositoryRoot, variant), enabled);
+function setOpencodePlugin(repositoryRoot, enabled, variant = "full", capture = defaultCapture(variant)) {
+  return setManagedPlugin(plugin2(repositoryRoot, variant, capture), enabled);
+}
+async function opencodePluginCapabilities(root) {
+  const injection = await opencodePluginVariant(root);
+  const source = injection ? await readFile4(opencodePluginPath(root), "utf8") : "";
+  const explicit = source.match(/^\/\/ codebuddy-capture: (on|off)$/m)?.[1];
+  return {
+    injection,
+    capture: explicit ? explicit === "on" : injection === "full",
+    recovery: (explicit ? explicit === "on" : injection === "full") && source.includes("codebuddy-recovery: v1"),
+    reset: injection !== null,
+    guard: false
+  };
 }
 async function opencodePluginVariant(repositoryRoot) {
   if (!await opencodePluginInstalled(repositoryRoot)) return null;
-  const source = await readFile3(opencodePluginPath(repositoryRoot), "utf8");
+  const source = await readFile4(opencodePluginPath(repositoryRoot), "utf8");
   return source.startsWith(`${OPENCODE_PLUGIN_MARKER} v1 lean`) ? "lean" : "full";
 }
 
-// src/hooks/settings.ts
-import { mkdir as mkdir2, readFile as readFile4 } from "fs/promises";
-import { dirname as dirname4, join as join3, resolve as resolve3 } from "path";
-var HOOK_COMMAND_PREFIX = "codebuddy hooks";
-var TOOL_GUARD_DEF = {
-  event: "PreToolUse",
-  matcher: "Read|Grep|Bash",
-  command: `${HOOK_COMMAND_PREFIX} pretool`
-};
-var HOOK_DEFS = [
-  { event: "UserPromptSubmit", command: `${HOOK_COMMAND_PREFIX} context` },
-  {
-    event: "PostToolUse",
-    matcher: "Edit|Write|MultiEdit",
-    command: `${HOOK_COMMAND_PREFIX} stage`
-  },
-  { event: "Stop", command: `${HOOK_COMMAND_PREFIX} capture` },
-  // After compaction or /clear the model no longer holds earlier context, so
-  // capsules the session ledger marked as sent must be sent again.
-  { event: "SessionStart", matcher: "compact|clear", command: `${HOOK_COMMAND_PREFIX} reset` },
-  TOOL_GUARD_DEF
-];
-var LEAN_HOOK_DEFS = [
-  { event: "UserPromptSubmit", command: `${HOOK_COMMAND_PREFIX} lean` },
-  { event: "SessionStart", matcher: "compact|clear", command: `${HOOK_COMMAND_PREFIX} reset` },
-  TOOL_GUARD_DEF
-];
-function claudeSettingsPath(repositoryRoot = process.cwd()) {
-  return join3(resolve3(repositoryRoot), ".claude", "settings.json");
-}
-function upsertHooks(settings, variant = "full") {
-  const defs = variant === "lean" ? LEAN_HOOK_DEFS : HOOK_DEFS;
-  const wanted = new Set(defs.map((def) => def.command));
-  const next = { ...settings, hooks: { ...settings.hooks ?? {} } };
-  const hooks = next.hooks;
-  let changed = false;
-  for (const event of Object.keys(hooks)) {
-    const groups = [];
-    for (const group of hooks[event] ?? []) {
-      const kept = (group.hooks ?? []).filter(
-        (hook) => !hook.command?.startsWith(HOOK_COMMAND_PREFIX) || wanted.has(hook.command)
-      );
-      if (kept.length !== (group.hooks ?? []).length) changed = true;
-      if (kept.length > 0) groups.push({ ...group, hooks: kept });
-    }
-    if (groups.length > 0) hooks[event] = groups;
-    else delete hooks[event];
-  }
-  for (const def of defs) {
-    const groups = [...hooks[def.event] ?? []];
-    const existingIndex = groups.findIndex(
-      (group) => group.hooks?.some((hook) => hook.command === def.command)
-    );
-    if (existingIndex === -1) {
-      groups.push({
-        ...def.matcher ? { matcher: def.matcher } : {},
-        hooks: [{ type: "command", command: def.command }]
-      });
-      changed = true;
-    } else {
-      const existing = groups[existingIndex];
-      if (existing && (def.matcher ?? void 0) !== (existing.matcher ?? void 0)) {
-        const { matcher: _oldMatcher, ...rest } = existing;
-        groups[existingIndex] = def.matcher ? { ...rest, matcher: def.matcher } : rest;
-        changed = true;
-      }
-    }
-    hooks[def.event] = groups;
-  }
-  return { settings: next, changed };
-}
-function removeHooks(settings) {
-  if (!settings.hooks) return { settings, changed: false };
-  const next = { ...settings, hooks: { ...settings.hooks } };
-  const hooks = next.hooks;
-  let changed = false;
-  for (const event of Object.keys(hooks)) {
-    const keptGroups = [];
-    for (const group of hooks[event] ?? []) {
-      const keptHooks = (group.hooks ?? []).filter(
-        (hook) => !hook.command?.startsWith(HOOK_COMMAND_PREFIX)
-      );
-      if (keptHooks.length !== (group.hooks ?? []).length) changed = true;
-      if (keptHooks.length === 0) continue;
-      keptGroups.push({ ...group, hooks: keptHooks });
-    }
-    if (keptGroups.length === 0) delete hooks[event];
-    else hooks[event] = keptGroups;
-  }
-  return { settings: next, changed };
-}
-function hooksInstalled(settings) {
-  const hooks = settings.hooks ?? {};
-  return Object.values(hooks).some(
-    (groups) => groups.some((group) => group.hooks?.some((h) => h.command?.startsWith(HOOK_COMMAND_PREFIX)))
-  );
-}
-function hooksVariant(settings) {
-  if (!hooksInstalled(settings)) return null;
-  const leanCommand = `${HOOK_COMMAND_PREFIX} lean`;
-  const lean = Object.values(settings.hooks ?? {}).some(
-    (groups) => groups.some((group) => group.hooks?.some((hook) => hook.command === leanCommand))
-  );
-  return lean ? "lean" : "full";
-}
-async function readSettings(path) {
-  try {
-    return JSON.parse(await readFile4(path, "utf8"));
-  } catch (error) {
-    if (error.code === "ENOENT") return {};
-    throw error;
-  }
-}
-async function writeSettings(path, settings) {
-  await mkdir2(dirname4(path), { recursive: true });
-  await writeAtomic(path, `${JSON.stringify(settings, null, 2)}
-`, { mode: 420 });
-}
-
 // src/hooks/install.ts
 var SURFACES = {
   "claude-settings": {
     path: claudeSettingsPath,
     installed: async (root) => hooksInstalled(await readSettings(claudeSettingsPath(root))),
     variant: async (root) => hooksVariant(await readSettings(claudeSettingsPath(root))),
-    set: async (root, enabled, variant) => {
+    set: async (root, enabled, variant, capture) => {
       const path = claudeSettingsPath(root);
       const current = await readSettings(path);
-      const { settings, changed } = enabled ? upsertHooks(current, variant) : removeHooks(current);
+      const { settings, changed } = enabled ? upsertHooks(current, variant, capture) : removeHooks(current);
       if (changed) await writeSettings(path, settings);
       return changed;
-    }
+    },
+    capabilities: async (root) => hookCapabilities(await readSettings(claudeSettingsPath(root)))
+  },
+  "codex-hooks": {
+    path: codexHooksPath,
+    installed: async (root) => (await codexHookCapabilities(root)).injection !== null,
+    variant: async (root) => (await codexHookCapabilities(root)).injection,
+    set: setCodexHooks,
+    capabilities: codexHookCapabilities
   },
   "opencode-plugin": {
     path: opencodePluginPath,
     installed: opencodePluginInstalled,
     variant: opencodePluginVariant,
-    set: setOpencodePlugin
+    set: setOpencodePlugin,
+    capabilities: opencodePluginCapabilities
   },
   "hermes-plugin": {
     path: hermesPluginDir,
     installed: hermesPluginInstalled,
     variant: hermesPluginVariant,
-    set: setHermesPlugin
+    set: setHermesPlugin,
+    capabilities: hermesPluginCapabilities
   }
 };
-async function setClientHooks(root, client, enabled, variant = "full") {
+async function setClientHooks(root, client, enabled, variant = "full", capture = defaultCapture(variant)) {
+  const surface = CLIENT_ADAPTERS[client].hooks;
+  if (!surface) return null;
+  const { path, set, capabilities } = SURFACES[surface];
+  if (enabled && !capabilities && capture !== defaultCapture(variant)) {
+    throw new Error(
+      `${CLIENT_ADAPTERS[client].name} hooks cannot set capture separately: ${variant} hooks ${defaultCapture(variant) ? "always" : "never"} capture.`
+    );
+  }
+  return { target: path(root), changed: await set(root, enabled, variant, capture) };
+}
+function supportsCaptureOption(client) {
+  const surface = CLIENT_ADAPTERS[client].hooks;
+  return surface !== void 0 && SURFACES[surface].capabilities !== void 0;
+}
+async function clientHookCapabilities(root, client) {
   const surface = CLIENT_ADAPTERS[client].hooks;
   if (!surface) return null;
-  const { path, set } = SURFACES[surface];
-  return { target: path(root), changed: await set(root, enabled, variant) };
+  const { capabilities, variant } = SURFACES[surface];
+  if (capabilities) return capabilities(root);
+  const installed = await variant(root);
+  return {
+    injection: installed,
+    capture: installed ? defaultCapture(installed) : false,
+    recovery: false,
+    reset: installed !== null,
+    guard: false
+  };
 }
 async function clientHooksVariant(root, client) {
   const surface = CLIENT_ADAPTERS[client].hooks;
@@ -618,9 +926,9 @@ async function rulesFileHooked(root, client) {
 
 // src/integrations/project-mcp.ts
 import { access, mkdir as mkdir3, readFile as readFile5, rm as rm2 } from "fs/promises";
-import { dirname as dirname5, join as join4, resolve as resolve4 } from "path";
+import { dirname as dirname5, join as join5, resolve as resolve4 } from "path";
 async function writeProjectMcpConfig(options) {
-  const path = join4(options.repositoryRoot, ".mcp.json");
+  const path = join5(options.repositoryRoot, ".mcp.json");
   const current = await readProjectMcpConfig(path);
   current.mcpServers ??= {};
   current.mcpServers[`codebuddy-${options.namespace}`] = codebuddyMcpServer(
@@ -652,12 +960,12 @@ function codebuddyMcpServer(repositoryRoot, namespace) {
     env: {
       CODEBUDDY_PROJECT_ROOT: repositoryRoot,
       CODEBUDDY_NAMESPACE: namespace,
-      CODEBUDDY_TOOL_PROFILE: "core"
+      CODEBUDDY_TOOL_PROFILE: "lean"
     }
   };
 }
 async function projectMcpPath(root, file, format) {
-  const path = join4(root, file);
+  const path = join5(root, file);
   if (format !== "opencode" || await exists(path)) return path;
   return await exists(`${path}c`) ? `${path}c` : path;
 }
@@ -737,120 +1045,25 @@ async function readProjectMcpConfig(path) {
 
 // src/templates/install.ts
 import { readFile as readFile6, rm as rm3 } from "fs/promises";
-import { join as join5, resolve as resolve5 } from "path";
+import { join as join6, resolve as resolve5 } from "path";
 
 // src/templates/workflow.ts
 var WORKFLOW_CLIENTS = CLIENT_IDS;
-var INTRO = [
-  "You have CodeBuddy available as a local, MCP-backed project-context engine.",
-  "Use it to work like a careful senior engineer, not to dump broad context.",
-  ""
-];
-var START_AGENT = [
-  "## At the start of a substantive coding turn",
-  "",
-  "1. When project context is needed, call `context_pack` with the user's task and a token budget (start",
-  "   with 4000). It automatically finds relevant files and returns bounded symbols,",
-  "   plan, policy, incidents, risks, architecture neighbours, and team facts.",
-  "   Reuse evidence already present. For a clearly identified small edit, read the",
-  "   needed source directly; fetch context for unknown dependencies or project constraints.",
-  "   Read missing function bodies before editing. If safety evidence was omitted,",
-  "   narrow the targets or increase the budget before proceeding.",
-  "2. Use `context_bootstrap` only when you need broad project orientation beyond",
-  "   the task pack. Use `context_before_edit` when you already have exact paths",
-  "   or a plan and need a narrower follow-up.",
-  "3. Prior work from earlier chats arrives as `handoffs` with freshness",
-  "   (`changedSince`, `missing`); re-check those files before relying on it.",
-  "4. On repeated context calls in one conversation, pass a stable `sessionId` and",
-  "   the previous response's `delivery.deliveryId` as `ack`. Unchanged sections",
-  "   are then omitted and listed in `delivery.unchanged`. If earlier output is no",
-  "   longer in your context (e.g. after compaction), pass `full: true`.",
-  ""
-];
-var START_HOOKS = [
-  "## At the start of a substantive coding turn",
-  "",
-  "CodeBuddy hooks inject a `CodeBuddy project context (auto-recalled)` block into",
-  "each prompt: project, plan, policies, facts, incidents, handoffs, current",
-  "changes, and risk. Agents without CodeBuddy hooks (no such block in the prompt)",
-  "follow the agent-driven flow: `context_pack` first, `context_after_turn` last.",
-  "",
-  "1. Start from the injected block; do not call `context_bootstrap` for orientation",
-  "   it already covers. Its `task files` are CodeBuddy's best match; when it names",
-  "   none, call `context_pack` with the task before searching the repository yourself.",
-  "2. Read ranges, not whole files: `Read` with offset/limit, or `sed -n 'A,Bp'`.",
-  "   Large files read whole (`Read` without a range, `cat`, `less`) are denied with an",
-  "   outline of their symbols and line ranges; read the range you need from it.",
-  "3. Call `context_pack` (or `context_before_edit` with exact paths) when the",
-  "   task needs symbols, neighbours, or file-level evidence the block lacks. Pass the",
-  "   block's `session` value as `sessionId` and the previous `delivery.deliveryId`",
-  "   as `ack` so unchanged sections are not resent.",
-  "4. Prior work from earlier chats arrives as handoffs with freshness; re-check",
-  "   those files before relying on it.",
-  ""
+var HOOKS_RULES = [
+  "- The prompt's `CodeBuddy` block names likely files and line ranges: read those ranges",
+  "  first (ranged `Read` or `sed -n`); search only if they do not fit.",
+  "- Call `context_pack` only when it names no files. Hooks inject and capture: never call",
+  "  `context_bootstrap` or `context_after_turn`.",
+  "- `recall` answers project-convention questions."
 ];
-var MIDDLE = [
-  "## While implementing",
-  "",
-  "- Prefer the smallest sufficient set of edits; preserve existing behavior.",
-  "- Honor risk warnings and policy rules for the files you touch; call out risk",
-  "  before editing sensitive areas.",
-  "- Do not re-request broad context if the task pack already suffices.",
-  "",
-  "## Before finalizing",
-  "",
-  "- Consider calling `code_suggestions` (with `paths`, `planId`, or `useGit`) for",
-  "  read-only, evidence-backed quality findings; resolve high-severity ones.",
-  "- Run the smallest relevant verification (tests, lint, typecheck) and fix",
-  "  failures before presenting completion.",
-  ""
-];
-var AFTER_AGENT = [
-  "## After a meaningful turn",
-  "",
-  "- Call `context_after_turn` with a concise `summary`, the `changedFiles`, and a",
-  "  `planId` if one is active, plus `verification` (commands run and results)",
-  "  so the turn's worklog handoff records it. CodeBuddy auto-saves confident facts, decisions,",
-  "  and incidents, queues uncertain or sensitive items for review, and drops",
-  "  chatter. Never paste secrets, tokens, or credentials into the summary.",
-  ""
-];
-var AFTER_HOOKS = [
-  "## After a meaningful turn",
-  "",
-  "- Do not call `context_after_turn`: the turn-end hook captures the turn once, from",
-  "  the real change set and the verification commands you ran. A second capture",
-  "  would record a divergent worklog entry.",
-  "- Never paste secrets, tokens, or credentials into your final message; it is the",
-  "  capture summary.",
-  ""
-];
-var TAIL = [
-  "## If a tool or service is unavailable (degraded mode)",
-  "",
-  "- A CodeBuddy MCP tool errors or is missing: proceed using the repository",
-  "  itself as the source of truth; do not block on it.",
-  "- Postgres is unreachable: the file-based tools (context, plan, risk, map,",
-  "  suggest) still work; recall and embeddings may be degraded \u2014 say so instead",
-  "  of inventing remembered facts.",
-  "- Retrieval returns no context: read the relevant files directly rather than",
-  "  guessing; the working tree is authoritative.",
-  "",
-  "## Never",
-  "",
-  "- Invent behavior the codebase does not support.",
-  "- Ignore failing tests or lint.",
-  "- Make speculative, wide changes without evidence.",
-  "- Save low-confidence project memory as a durable fact."
+var AGENT_RULES = [
+  "- In unfamiliar code, call `context_pack` once with the task; read its line ranges first.",
+  "- `recall` answers project-convention questions; `remember` durable facts (never secrets).",
+  "- After changing code, call `context_after_turn` (summary, changed files) if listed."
 ];
+var TAIL = "- CodeBuddy unavailable (degraded mode): use the repository directly.";
 function renderBody(mode) {
-  return [
-    ...INTRO,
-    ...mode === "hooks" ? START_HOOKS : START_AGENT,
-    ...MIDDLE,
-    ...mode === "hooks" ? AFTER_HOOKS : AFTER_AGENT,
-    ...TAIL
-  ].join("\n");
+  return [...mode === "hooks" ? HOOKS_RULES : AGENT_RULES, TAIL].join("\n");
 }
 function rulesReaders(file) {
   return CLIENT_IDS.filter((id) => CLIENT_ADAPTERS[id].rulesFile === file).map((id) => CLIENT_ADAPTERS[id].name).join(", ");
@@ -860,9 +1073,7 @@ function renderWorkflowTemplate(client, mode = "agent") {
   return [
     `# CodeBuddy workflow (${rulesReaders(file)})`,
     "",
-    "This section is managed by CodeBuddy (`codebuddy clients install <client> --mode <mode>`)",
-    `and lives in \`${file}\`. Edit outside the managed markers to customize.`,
-    `Automation mode: \`${mode}\` (${MODE_LABELS[mode]}).`,
+    `Managed by CodeBuddy; edit outside the markers. Automation mode: \`${mode}\`.`,
     "",
     renderBody(mode)
   ].join("\n");
@@ -888,7 +1099,7 @@ ${END_MARKER}
 }
 async function installWorkflowRules(options) {
   const projectRoot = resolve5(options.projectRoot ?? process.cwd());
-  const path = options.targetPath ?? join5(projectRoot, defaultRulesFile(options.client));
+  const path = options.targetPath ?? join6(projectRoot, defaultRulesFile(options.client));
   const existing = await readIfPresent(path);
   const mode = options.mode ?? await defaultRulesMode(options.client, projectRoot);
   if (options.onlyIfManaged && (existing === null || !hasManagedBlock(existing))) {
@@ -954,21 +1165,21 @@ async function readIfPresent(path) {
 import { existsSync as existsSync2 } from "fs";
 import { mkdir as mkdir5, readFile as readFile8 } from "fs/promises";
 import { homedir } from "os";
-import { dirname as dirname7, join as join7 } from "path";
+import { dirname as dirname7, join as join8 } from "path";
 
 // src/cli/commands/claude-desktop.ts
 import { existsSync } from "fs";
 import { mkdir as mkdir4, readFile as readFile7 } from "fs/promises";
-import { dirname as dirname6, join as join6, resolve as resolve6 } from "path";
+import { dirname as dirname6, join as join7, resolve as resolve6 } from "path";
 import { fileURLToPath } from "url";
 function claudeDesktopConfigPath(home = process.env.HOME ?? "") {
   if (process.platform === "darwin") {
-    return join6(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    return join7(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
   }
   if (process.platform === "win32") {
-    return join6(process.env.APPDATA ?? home, "Claude", "claude_desktop_config.json");
+    return join7(process.env.APPDATA ?? home, "Claude", "claude_desktop_config.json");
   }
-  return join6(home, ".config", "Claude", "claude_desktop_config.json");
+  return join7(home, ".config", "Claude", "claude_desktop_config.json");
 }
 async function readClaudeConfig(path) {
   if (!existsSync(path)) return {};
@@ -1051,7 +1262,7 @@ async function listClaudeEntries() {
 
 // src/cli/commands/codex.ts
 function codexConfigPath(home = homedir()) {
-  return join7(home, ".codex", "config.toml");
+  return join8(home, ".codex", "config.toml");
 }
 async function readCodexConfig(path) {
   if (!existsSync2(path)) return "";
@@ -1163,11 +1374,11 @@ function escapeRegExp(value) {
 // src/integrations/hermes-config.ts
 import { mkdir as mkdir6, readFile as readFile9 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname8, join as join8 } from "path";
+import { dirname as dirname8, join as join9 } from "path";
 import { isDeepStrictEqual } from "util";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 function hermesConfigPath(home = homedir2()) {
-  return join8(process.env.HERMES_HOME ?? join8(home, ".hermes"), "config.yaml");
+  return join9(process.env.HERMES_HOME ?? join9(home, ".hermes"), "config.yaml");
 }
 async function readRaw(path) {
   try {
@@ -1273,7 +1484,7 @@ async function setGlobalMcp(target, options) {
     namespace,
     projectRoot: root,
     serverName: name,
-    toolProfile: "core"
+    toolProfile: "lean"
   });
   return result.created ? "created" : result.changed ? "updated" : "unchanged";
 }
@@ -1290,10 +1501,16 @@ async function installClient(options) {
       `${adapter.name} does not support ${MODE_LABELS[options.mode]} mode: ${adapter.gap ?? "no lifecycle hooks"}.`
     );
   }
-  return apply(options, options.mode, options.mode !== "lean");
+  const variant = options.mode === "lean" ? "lean" : "full";
+  if (options.capture !== void 0 && options.capture !== defaultCapture(variant) && !supportsCaptureOption(options.client)) {
+    throw new Error(
+      `${adapter.name} hooks cannot set capture separately: ${variant} hooks ${defaultCapture(variant) ? "always" : "never"} capture.`
+    );
+  }
+  return apply(options, options.mode, options.mode !== "lean", options.capture);
 }
 async function ensureIndex(root) {
-  const target = join9(root, ".codebuddy", "cache", "index.json");
+  const target = join10(root, ".codebuddy", "cache", "index.json");
   const existed = await access2(target).then(
     () => true,
     () => false
@@ -1304,7 +1521,7 @@ async function ensureIndex(root) {
 async function uninstallClient(options) {
   return apply(options, "mcp-only", false);
 }
-async function apply(options, mode, keepMcp) {
+async function apply(options, mode, keepMcp, capture) {
   const root = resolve7(options.projectRoot ?? process.cwd());
   const adapter = CLIENT_ADAPTERS[options.client];
   const steps = [];
@@ -1314,7 +1531,7 @@ async function apply(options, mode, keepMcp) {
   const shared = sharedRulesReaders(options.client);
   const liveSiblings = mode === "mcp-only" || mode === "lean" ? await installedWithMcp(root, shared, namespace) : [];
   if (liveSiblings.length > 0) {
-    const path = join9(root, adapter.rulesFile);
+    const path = join10(root, adapter.rulesFile);
     steps.push({ surface: "rules", target: path, action: "kept" });
     notes.push(
       `Kept the CodeBuddy block in ${adapter.rulesFile}: still used by ${liveSiblings.map((id) => CLIENT_ADAPTERS[id].name).join(", ")}.`
@@ -1343,7 +1560,8 @@ async function apply(options, mode, keepMcp) {
     root,
     mode === "hooks" || mode === "lean",
     options.client,
-    mode === "lean" ? "lean" : "full"
+    mode === "lean" ? "lean" : "full",
+    capture
   );
   if (hooks) steps.push(hooks);
   if (mode === "lean") steps.push(await ensureIndex(root));
@@ -1385,8 +1603,8 @@ async function installedWithMcp(root, clients, namespace) {
   }
   return live;
 }
-async function setHooks(root, enabled, client = "claude", variant = "full") {
-  const result = await setClientHooks(root, client, enabled, variant);
+async function setHooks(root, enabled, client = "claude", variant = "full", capture) {
+  const result = await setClientHooks(root, client, enabled, variant, capture);
   if (!result) return null;
   const action = result.changed ? enabled ? "installed" : "removed" : "unchanged";
   return { surface: "hooks", target: result.target, action };
@@ -1394,7 +1612,7 @@ async function setHooks(root, enabled, client = "claude", variant = "full") {
 async function detectClient(client, projectRoot = process.cwd(), namespace) {
   const root = resolve7(projectRoot);
   const adapter = CLIENT_ADAPTERS[client];
-  const rulesMode = await readManagedMode(join9(root, adapter.rulesFile));
+  const rulesMode = await readManagedMode(join10(root, adapter.rulesFile));
   const hooks = await clientHooksInstalled(root, client);
   const name = `codebuddy-${namespace ?? await resolveNamespaceFrom(root)}`;
   const mcp = "file" in adapter.mcp ? await hasMcpServer(
@@ -1413,13 +1631,16 @@ async function detectClient(client, projectRoot = process.cwd(), namespace) {
       `${adapter.rulesFile} is hook-driven but hooks are not installed: turns are not captured.`
     );
   }
-  const effectiveRules = hooks === null && rulesMode === "hooks" ? "agent" : rulesMode;
+  const effectiveRules = hooks !== true && rulesMode === "hooks" ? "agent" : rulesMode;
   const mode = hooks ? await clientHooksVariant(root, client) === "lean" ? "lean" : "hooks" : effectiveRules ?? (mcp ? "mcp-only" : "none");
   return { client, mode, rulesMode, hooks, mcp, warnings };
 }
 
 export {
+  runBridgeHook,
+  runCodexHook,
   hermesPluginInstalled,
+  clientHookCapabilities,
   clientHooksInstalled,
   writeProjectMcpConfig,
   WORKFLOW_CLIENTS,
@@ -1441,4 +1662,4 @@ export {
   setHooks,
   detectClient
 };
-//# sourceMappingURL=chunk-J4T6HHI4.js.map
+//# sourceMappingURL=chunk-L6BRYZ6G.js.map