@orquentra/codebuddy 2.9.0 → 2.15.0

package/dist/{chunk-F4BJ3DXW.js → chunk-KQCP3ZYH.js}

@@ -1,48 +1,52 @@
+import {
+  recordTrace
+} from "./chunk-YN7TEIUH.js";
 import {
   SessionCapsuleLedger,
   detectTestCommand,
   estimateTokens,
   findCoveringTest
-} from "./chunk-GKNYMNFM.js";
-import {
-  recordTrace
-} from "./chunk-YN7TEIUH.js";
+} from "./chunk-7IPSDDO5.js";
 import {
   hookRoot
 } from "./chunk-TGFTKWOR.js";
+import {
+  skipPromptRetrieval
+} from "./chunk-GQKWUHMA.js";
 import {
   MEMORY_CLASSES,
   memoryCandidateSchema
 } from "./chunk-DFV2SK6C.js";
 import {
-  INCIDENT_SEVERITIES,
-  MemoryFileStore,
-  admitsLexically,
-  isEligibleMemory,
-  lexicalTerms,
-  termOverlap
-} from "./chunk-SRA4MDVG.js";
-import {
-  generateEntityId
-} from "./chunk-CAEPHLHC.js";
-import {
+  NON_SOURCE_PATH,
   TASK_PATH_LIMIT,
+  TEST_PATH,
   countTerms,
   discoverTaskPaths,
+  hashContent,
   identifierTokens,
+  loadFreshIndex,
   loadProjectArchitectureMap,
   namedSegments,
   readBoundedSource,
   syncFileVectors,
   taskTerms
-} from "./chunk-TLWGZVPC.js";
-import {
-  loadFreshIndex
-} from "./chunk-ITQO632W.js";
+} from "./chunk-UR3DF74I.js";
 import {
   extractSymbolTable,
   supportsSymbols
 } from "./chunk-Y7D7PUBE.js";
+import {
+  INCIDENT_SEVERITIES,
+  MemoryFileStore,
+  admitsLexically,
+  isEligibleMemory,
+  lexicalTerms,
+  termOverlap
+} from "./chunk-YMXFSHXT.js";
+import {
+  generateEntityId
+} from "./chunk-EMWGLKPR.js";
 import {
   REDACTED_LINE,
   claimText,
@@ -54,30 +58,31 @@ import {
   scanFields,
   scanSensitive
 } from "./chunk-AL6VBTNA.js";
-import {
-  DEFAULT_RERANK_MODELS
-} from "./chunk-HPOR6YXA.js";
 import {
   loadPlanPolicy,
   loadRuntimeConfig,
   readConfigFile
-} from "./chunk-KNR2P2UY.js";
+} from "./chunk-M75SN4D4.js";
 import {
   assertNoSymlinkBetween,
   composeMarkdown,
   parseFrontMatter,
   writeAtomic
 } from "./chunk-CG5B3LYG.js";
+import {
+  DEFAULT_RERANK_MODELS,
+  LOCAL_EMBEDDING_MODEL
+} from "./chunk-HPOR6YXA.js";
 
 // src/hooks/runtime.ts
-import { mkdir as mkdir5, readFile as readFile7, rm as rm4, stat as stat4, writeFile } from "fs/promises";
-import { basename, dirname as dirname5, isAbsolute, join as join7, relative as relative5, resolve as resolve9, sep as sep5 } from "path";
-import pTimeout2 from "p-timeout";
+import { mkdir as mkdir7, readFile as readFile10, rm as rm5, stat as stat4, writeFile } from "fs/promises";
+import { basename, dirname as dirname6, isAbsolute as isAbsolute2, join as join9, relative as relative6, resolve as resolve10, sep as sep6 } from "path";
+import pTimeout3 from "p-timeout";
 
 // src/context/engine.ts
-import { execFile } from "child_process";
-import { join as join4, resolve as resolve5 } from "path";
-import { promisify } from "util";
+import { execFile as execFile2 } from "child_process";
+import { join as join4, resolve as resolve6 } from "path";
+import { promisify as promisify2 } from "util";
 
 // src/core/plan-file-store.ts
 import { mkdir, open, readdir, readFile, rm, stat } from "fs/promises";
@@ -308,7 +313,7 @@ function formatIssues(error) {
   });
 }
 function delay(ms) {
-  return new Promise((resolve10) => setTimeout(resolve10, ms));
+  return new Promise((resolve11) => setTimeout(resolve11, ms));
 }
 async function releaseOwnedLock(lockPath) {
   try {
@@ -543,7 +548,7 @@ async function gitLogForPath(repositoryRoot, path, range) {
   }).filter((record) => record.sha.length > 0);
 }
 function runGit(cwd, args) {
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve11, reject) => {
     const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
@@ -554,7 +559,7 @@ function runGit(cwd, args) {
       stderr += String(chunk);
     });
     child.on("error", reject);
-    child.on("close", (code) => resolve10({ code: code ?? 0, stdout, stderr }));
+    child.on("close", (code) => resolve11({ code: code ?? 0, stdout, stderr }));
   });
 }
 
@@ -692,13 +697,13 @@ function escapeRegExp(value) {
 // src/risk/service.ts
 async function assessRisk(input) {
   const repositoryRoot = resolve3(input.repositoryRoot ?? process.cwd());
-  const paths = await resolveRiskPaths({
+  const paths2 = await resolveRiskPaths({
     repositoryRoot,
     ...input.planId !== void 0 ? { planId: input.planId } : {},
     ...input.paths !== void 0 ? { paths: input.paths } : {},
     ...input.useGit !== void 0 ? { useGit: input.useGit } : {}
   });
-  if (paths.length === 0) {
+  if (paths2.length === 0) {
     return {
       items: [],
       stats: { pathsConsidered: 0, itemsProduced: 0, signalsRun: 0, perSignal: [] }
@@ -718,7 +723,7 @@ async function assessRisk(input) {
     ]
   ];
   const assessment = await new RiskAssessor(signals).assess({
-    paths,
+    paths: paths2,
     repositoryRoot,
     namespace: input.namespace
   });
@@ -728,30 +733,30 @@ async function assessRisk(input) {
   };
 }
 async function resolveRiskPaths(input) {
-  const paths = /* @__PURE__ */ new Set();
+  const paths2 = /* @__PURE__ */ new Set();
   for (const path of input.paths ?? []) {
     if (!path.trim()) continue;
     const contained = containedRelativePath(input.repositoryRoot, path);
-    if (contained) paths.add(contained);
+    if (contained) paths2.add(contained);
   }
   if (input.planId) {
     const plan = await new PlanFileStore(input.repositoryRoot).readPlan(input.planId);
-    for (const file of plan.filesToTouch) {
-      const contained = containedRelativePath(input.repositoryRoot, file.path);
-      if (contained) paths.add(contained);
+    for (const file2 of plan.filesToTouch) {
+      const contained = containedRelativePath(input.repositoryRoot, file2.path);
+      if (contained) paths2.add(contained);
     }
   }
-  if (input.useGit !== false && (input.useGit || paths.size === 0)) {
+  if (input.useGit !== false && (input.useGit || paths2.size === 0)) {
     for (const path of await changedGitPaths(input.repositoryRoot)) {
       const contained = containedRelativePath(input.repositoryRoot, path);
-      if (contained) paths.add(contained);
+      if (contained) paths2.add(contained);
     }
   }
   const realRoot = await realpath2(input.repositoryRoot).catch(() => resolve3(input.repositoryRoot));
   const inside = await Promise.all(
-    [...paths].map((path) => realPathInside(realRoot, resolve3(input.repositoryRoot, path)))
+    [...paths2].map((path) => realPathInside(realRoot, resolve3(input.repositoryRoot, path)))
   );
-  const resolved = [...paths].filter((_, index) => inside[index]).sort();
+  const resolved = [...paths2].filter((_, index) => inside[index]).sort();
   return resolved.length > MAX_RESOLVED_PATHS ? resolved.slice(0, MAX_RESOLVED_PATHS) : resolved;
 }
 var MAX_RESOLVED_PATHS = 200;
@@ -999,10 +1004,64 @@ var PlanLifecycle = class {
 
 // src/worklog/store.ts
 import { createHash } from "crypto";
-import { mkdir as mkdir2, readdir as readdir2, readFile as readFile4, stat as stat2 } from "fs/promises";
-import { dirname as dirname3, join as join3, relative as relative3, resolve as resolve4, sep as sep3 } from "path";
+import { mkdir as mkdir2, readdir as readdir2, readFile as readFile5 } from "fs/promises";
+import { dirname as dirname3, join as join3, resolve as resolve5 } from "path";
 import { parse as parseYaml3, stringify as stringifyYaml2 } from "yaml";
 import { z as z3 } from "zod";
+
+// src/core/freshness.ts
+import { execFile } from "child_process";
+import { readFile as readFile4 } from "fs/promises";
+import { relative as relative3, resolve as resolve4, sep as sep3 } from "path";
+import { promisify } from "util";
+async function hashFile(root, path) {
+  const absolute = resolve4(root, path);
+  const rel = relative3(resolve4(root), absolute);
+  if (rel === ".." || rel.startsWith(`..${sep3}`)) return null;
+  try {
+    return hashContent(await readFile4(absolute, "utf8")).slice(0, 16);
+  } catch {
+    return null;
+  }
+}
+async function fileHashes(root, paths2) {
+  const entries = await Promise.all(
+    paths2.map(async (path) => [path, await hashFile(root, path)])
+  );
+  return Object.fromEntries(entries);
+}
+async function compareFreshness(root, paths2, recorded) {
+  const result = { current: [], changed: [], missing: [], unknown: [] };
+  for (const path of paths2) {
+    const now = await hashFile(root, path);
+    const then = recorded?.[path];
+    if (now === null) result.missing.push(path);
+    else if (then === void 0) result.unknown.push(path);
+    else if (then === now) result.current.push(path);
+    else result.changed.push(path);
+  }
+  return result;
+}
+var run = promisify(execFile);
+async function repoIdentity(root) {
+  const git = async (...args) => {
+    try {
+      const { stdout } = await run("git", args, { cwd: root, timeout: 2e3 });
+      return stdout.trim() || null;
+    } catch {
+      return null;
+    }
+  };
+  const [worktree, gitDir, branch, head] = await Promise.all([
+    git("rev-parse", "--show-toplevel"),
+    git("rev-parse", "--absolute-git-dir"),
+    git("rev-parse", "--abbrev-ref", "HEAD"),
+    git("rev-parse", "HEAD")
+  ]);
+  return { worktree, gitDir, branch, head };
+}
+
+// src/worklog/store.ts
 var LIMITS = {
   summaryChars: 600,
   files: 50,
@@ -1023,13 +1082,16 @@ var entrySchema = z3.object({
   verification: z3.array(z3.string()).default([]),
   savedMemory: z3.array(z3.string()).default([]),
   queuedForReview: z3.array(z3.string()).default([]),
-  fingerprint: z3.string().regex(/^[a-f0-9]{64}$/)
+  fingerprint: z3.string().regex(/^[a-f0-9]{64}$/),
+  /** Content hash per file when recorded (absent in entries written before 2.10). */
+  fileHashes: z3.record(z3.string(), z3.string().nullable()).optional(),
+  branch: z3.string().nullable().optional()
 });
 var WorklogStore = class {
   repositoryRoot;
   directory;
   constructor(repositoryRoot = process.cwd()) {
-    this.repositoryRoot = resolve4(repositoryRoot);
+    this.repositoryRoot = resolve5(repositoryRoot);
     this.directory = join3(this.repositoryRoot, ".codebuddy", "worklog");
   }
   /**
@@ -1051,6 +1113,10 @@ var WorklogStore = class {
     ).digest("hex");
     const existing = (await this.list()).find((entry) => entry.fingerprint === fingerprint);
     if (existing) return existing.id;
+    const [hashes, identity] = await Promise.all([
+      fileHashes(this.repositoryRoot, files),
+      repoIdentity(this.repositoryRoot)
+    ]);
     const id = generateEntityId("wlg", now.getTime());
     const path = this.entryPath(id);
     await assertNoSymlinkBetween(this.repositoryRoot, dirname3(path));
@@ -1068,7 +1134,9 @@ var WorklogStore = class {
       verification,
       savedMemory: input.savedMemory ?? [],
       queuedForReview: input.queuedForReview ?? [],
-      fingerprint
+      fingerprint,
+      fileHashes: hashes,
+      branch: identity.branch
     });
     await writeAtomic(path, composeMarkdown(frontMatter, summary));
     return id;
@@ -1076,7 +1144,7 @@ var WorklogStore = class {
   async read(id) {
     const path = this.entryPath(id);
     await assertNoSymlinkBetween(this.repositoryRoot, path);
-    const parsed = parseFrontMatter(await readFile4(path, "utf8"));
+    const parsed = parseFrontMatter(await readFile5(path, "utf8"));
     return {
       ...entrySchema.parse(parseYaml3(parsed.frontMatter)),
       summary: parsed.content.trim(),
@@ -1116,11 +1184,11 @@ var WorklogStore = class {
     const now = input.now ?? /* @__PURE__ */ new Date();
     const limit = input.limit ?? 3;
     const entries = await this.list(input.namespace);
-    const paths = new Set((input.paths ?? []).map(normalizePath3));
+    const paths2 = new Set((input.paths ?? []).map(normalizePath3));
     const taskWords = words(input.task ?? "");
-    const targeted = paths.size > 0 || taskWords.size > 0;
+    const targeted = paths2.size > 0 || taskWords.size > 0;
     const ranked = entries.map((entry, recency) => {
-      const fileHits = entry.files.filter((file) => paths.has(file));
+      const fileHits = entry.files.filter((file2) => paths2.has(file2));
       const summaryWords = words(entry.summary);
       const wordHits = [...taskWords].filter((word) => summaryWords.has(word));
       const score = fileHits.length * 3 + Math.min(wordHits.length, 5);
@@ -1151,20 +1219,12 @@ var WorklogStore = class {
     );
   }
   async freshness(entry) {
-    const createdAt = Date.parse(entry.createdAt);
-    const changedSince = [];
-    const missing = [];
-    for (const file of entry.files) {
-      const absolute = resolve4(this.repositoryRoot, file);
-      const rel = relative3(this.repositoryRoot, absolute);
-      if (rel.startsWith(`..${sep3}`) || rel === "..") continue;
-      try {
-        if ((await stat2(absolute)).mtimeMs > createdAt) changedSince.push(file);
-      } catch {
-        missing.push(file);
-      }
-    }
-    return { changedSince, missing };
+    const { changed, missing, unknown } = await compareFreshness(
+      this.repositoryRoot,
+      entry.files,
+      entry.fileHashes
+    );
+    return { changedSince: changed, missing, unknown };
   }
   entryPath(id) {
     if (!/^wlg_[a-z0-9]+$/.test(id)) throw new Error(`Invalid worklog id: ${id}`);
@@ -1206,6 +1266,7 @@ function enforceContextBudget(input) {
     ["facts", 40],
     ["rules", 45],
     ["symbols", 50],
+    ["reuse", 75],
     ["policyRules", 90],
     ["incidents", 80]
   ]) {
@@ -1269,6 +1330,7 @@ function enforceContextBudget(input) {
     if (account(output) <= output.tokens.budget) continue;
     remove();
     if (candidate.essential) output.tokens.essentialOmitted++;
+    if (candidate.section === "reuse") continue;
     const smaller = candidate.essential ? compactSafety(candidate.value) : compact(candidate.value, 100);
     insert(smaller);
     if (account(output) <= output.tokens.budget) continue;
@@ -1339,9 +1401,9 @@ var LIMITS2 = {
 var DEFAULT_TOKEN_BUDGET = 4e3;
 var MAX_DIFF_FILES = 8;
 var MAX_DIFF_CHARS_PER_FILE = 2400;
-var execFileAsync = promisify(execFile);
+var execFileAsync = promisify2(execFile2);
 async function buildBootstrapContext(input) {
-  const repositoryRoot = resolve5(input.repositoryRoot ?? process.cwd());
+  const repositoryRoot = resolve6(input.repositoryRoot ?? process.cwd());
   const namespace = input.namespace;
   const planStore = new PlanFileStore(repositoryRoot);
   const memoryStore = new MemoryFileStore(repositoryRoot);
@@ -1400,7 +1462,7 @@ async function buildBootstrapContext(input) {
   return enforceContextBudget({ ...assembled, tokens });
 }
 async function buildBeforeEditContext(input) {
-  const repositoryRoot = resolve5(input.repositoryRoot ?? process.cwd());
+  const repositoryRoot = resolve6(input.repositoryRoot ?? process.cwd());
   const namespace = input.namespace;
   const hasExplicitTargets = (input.paths?.length ?? 0) > 0 || input.planId !== void 0;
   const fresh = await loadFreshIndex(repositoryRoot);
@@ -1412,7 +1474,7 @@ async function buildBeforeEditContext(input) {
     ...hasExplicitTargets ? { useGit: false } : input.useGit !== void 0 ? { useGit: input.useGit } : {}
   });
   const mapPromise = loadProjectArchitectureMap(repositoryRoot, manifest);
-  const discovery = !hasExplicitTargets && input.task ? await discoverTaskPaths(repositoryRoot, input.task, manifest, mapPromise) : { paths: [], hits: [], explain: [] };
+  const discovery = !hasExplicitTargets && input.task ? await discoverTaskPaths(repositoryRoot, input.task, manifest, mapPromise) : { paths: [], hits: [], explain: [], confidence: void 0 };
   const taskPaths = discovery.paths;
   const askedTask = Boolean(input.task?.trim());
   const targetPaths = hasExplicitTargets ? resolvedPaths : taskPaths.length > 0 ? taskPaths : askedTask && input.useGit !== true ? [] : resolvedPaths;
@@ -1482,7 +1544,7 @@ async function buildBeforeEditContext(input) {
     knownSecrets
   );
   if (symbols.length > 0) {
-    const spans = symbols.reduce((total, file) => total + (file.spans?.length ?? 0), 0);
+    const spans = symbols.reduce((total, file2) => total + (file2.spans?.length ?? 0), 0);
     explain.push(
       `symbols: signatures for ${symbols.length} target file(s) (in place of full source)` + (spans > 0 ? `; ${spans} task-ranked span(s) read from current source` : "")
     );
@@ -1530,11 +1592,15 @@ async function buildBeforeEditContext(input) {
     tests,
     testCommand,
     diffs,
-    explain
+    explain,
+    ...discovery.confidence && !hasExplicitTargets ? { confidence: discovery.confidence } : {},
+    // A plain abstention: no guessed files, and the agent is told to search itself.
+    ...askedTask && !hasExplicitTargets && targetPaths.length === 0 ? { note: NO_MATCH_NOTE } : {}
   };
   const tokens = buildTokenStats(assembled, input.tokenBudget);
   return enforceContextBudget({ ...assembled, tokens });
 }
+var NO_MATCH_NOTE = "No confident file match for this task; search the repository normally (grep/glob) instead of relying on CodeBuddy targets.";
 async function recallHandoffs(repositoryRoot, input) {
   try {
     return await new WorklogStore(repositoryRoot).recall(input);
@@ -1556,7 +1622,7 @@ function summarizePlan(plan) {
     title: plan.title,
     status: plan.status,
     brief: plan.brief,
-    filesToTouch: plan.filesToTouch.map((file) => file.path),
+    filesToTouch: plan.filesToTouch.map((file2) => file2.path),
     risks: plan.risks
   };
 }
@@ -1596,9 +1662,9 @@ function summarizePolicyRules(rules) {
     weight: rule.weight
   }));
 }
-function summarizeMatchingPolicyRules(rules, paths) {
+function summarizeMatchingPolicyRules(rules, paths2) {
   const matching = rules.filter(
-    (rule) => paths.some((path) => matchesPolicyGlob(path, rule.pattern))
+    (rule) => paths2.some((path) => matchesPolicyGlob(path, rule.pattern))
   );
   return summarizePolicyRules(matching);
 }
@@ -1620,9 +1686,9 @@ function summarizeArchitecture(map) {
   }).slice(0, LIMITS2.hotspots);
   return { moduleCount: map.modules.length, edgeCount: map.edges.length, hotspots };
 }
-function computeNeighbours(map, paths) {
+function computeNeighbours(map, paths2) {
   const result = [];
-  for (const path of paths.slice(0, LIMITS2.neighbourPaths)) {
+  for (const path of paths2.slice(0, LIMITS2.neighbourPaths)) {
     const dependsOn = [
       ...new Set(map.edges.filter((edge) => edge.from === path).map((edge) => edge.to))
     ].slice(0, LIMITS2.neighbourEdges);
@@ -1744,8 +1810,8 @@ function headInSignature(lines, symbol) {
   const line = (lines[symbol.startLine - 1] ?? "").trim();
   return !head.endsWith("\u2026") && line.startsWith(head) && /^[\s{=>(]*$/.test(line.slice(head.length));
 }
-async function readGitDiffs(repositoryRoot, paths, knownSecrets = []) {
-  if (paths.length === 0) return [];
+async function readGitDiffs(repositoryRoot, paths2, knownSecrets = []) {
+  if (paths2.length === 0) return [];
   const sections = [];
   try {
     const { stdout } = await execFileAsync(
@@ -1758,7 +1824,7 @@ async function readGitDiffs(repositoryRoot, paths, knownSecrets = []) {
         "--no-ext-diff",
         "--unified=3",
         "--",
-        ...paths
+        ...paths2
       ],
       { cwd: repositoryRoot, maxBuffer: 2e6 }
     );
@@ -1773,9 +1839,9 @@ async function readGitDiffs(repositoryRoot, paths, knownSecrets = []) {
         "--no-ext-diff",
         "--unified=3",
         "--",
-        ...paths
+        ...paths2
       ],
-      ["-c", "core.quotePath=false", "diff", "--no-ext-diff", "--unified=3", "--", ...paths]
+      ["-c", "core.quotePath=false", "diff", "--no-ext-diff", "--unified=3", "--", ...paths2]
     ]) {
       try {
         const { stdout } = await execFileAsync("git", args, {
@@ -1789,7 +1855,7 @@ async function readGitDiffs(repositoryRoot, paths, knownSecrets = []) {
   }
   const parsed = parseGitDiff(sections.join("\n"), knownSecrets);
   const known = new Set(parsed.map((diff) => diff.path));
-  const untracked = await listUntrackedPaths(repositoryRoot, paths);
+  const untracked = await listUntrackedPaths(repositoryRoot, paths2);
   for (const path of untracked) {
     if (known.has(path)) continue;
     const patch = isCredentialPath(path) ? withheldPatch(path) : await buildUntrackedPatch(repositoryRoot, path, knownSecrets);
@@ -1850,11 +1916,11 @@ function parseGitDiff(diff, knownSecrets = []) {
     ] : [];
   });
 }
-async function listUntrackedPaths(repositoryRoot, paths) {
+async function listUntrackedPaths(repositoryRoot, paths2) {
   try {
     const { stdout } = await execFileAsync(
       "git",
-      ["ls-files", "-z", "--others", "--exclude-standard", "--", ...paths],
+      ["ls-files", "-z", "--others", "--exclude-standard", "--", ...paths2],
       { cwd: repositoryRoot, maxBuffer: 1e6 }
     );
     return stdout.split("\0").filter(Boolean);
@@ -2045,9 +2111,831 @@ function truncate(value, max) {
   return trimmed.length <= max ? trimmed : `${trimmed.slice(0, max - 1)}\u2026`;
 }
 
-// src/memory-extract/engine.ts
+// src/context/reuse-vectors.ts
+import { mkdir as mkdir3, readFile as readFile6 } from "fs/promises";
+import { dirname as dirname4, join as join5 } from "path";
+import pTimeout from "p-timeout";
+var MODEL = `${LOCAL_EMBEDDING_MODEL.id}@${LOCAL_EMBEDDING_MODEL.revision}:${LOCAL_EMBEDDING_MODEL.schema}`;
+var file = (root) => join5(root, ".codebuddy", "cache", "reuse-vectors.json");
+var kinds = /* @__PURE__ */ new Set(["function", "class", "method", "const"]);
+var valid = (vector) => Array.isArray(vector) && vector.length === LOCAL_EMBEDDING_MODEL.dimensions && vector.every(Number.isFinite) && vector.some((value) => value !== 0);
+async function embedLocal(texts) {
+  const { LocalModelProvider } = await import("./local-ST4WMRCG.js");
+  return (await new LocalModelProvider().embed({ input: texts })).vectors;
+}
+async function load(root) {
+  try {
+    const cache = JSON.parse(await readFile6(file(root), "utf8"));
+    if (cache.version === 1 && cache.model === MODEL && Array.isArray(cache.entries))
+      return {
+        ...cache,
+        entries: cache.entries.filter(
+          (entry) => typeof entry.path === "string" && typeof entry.name === "string" && valid(entry.vector)
+        )
+      };
+  } catch {
+  }
+  return { version: 1, model: MODEL, entries: [] };
+}
+async function refreshReuseVectors(root, manifest, deadlineAt, embed = embedLocal) {
+  const cache = await load(root);
+  const cached = new Map(cache.entries.map((entry) => [`${entry.path}\0${entry.name}`, entry]));
+  const entries = [];
+  const pending = [];
+  for (const entry of Object.values(manifest.entries)) {
+    if (NON_SOURCE_PATH.test(entry.path) || TEST_PATH.test(entry.path)) continue;
+    const symbols = (entry.symbolTable ?? []).filter(
+      (symbol) => symbol.exported && kinds.has(symbol.kind)
+    );
+    if (!symbols.length) continue;
+    const source = await readBoundedSource(root, entry.path);
+    if (source === null) continue;
+    const lines = source.split("\n");
+    for (const symbol of symbols) {
+      const old = cached.get(`${entry.path}\0${symbol.name}`);
+      const existing = old?.hash === entry.hash ? old : void 0;
+      if (existing) {
+        entries.push(existing);
+        continue;
+      }
+      pending.push({
+        path: entry.path,
+        name: symbol.name,
+        hash: entry.hash,
+        text: `${entry.path}
+${symbol.signature}
+${lines.slice(Math.max(0, symbol.startLine - 4), symbol.endLine).join("\n")}`.slice(
+          0,
+          2e3
+        )
+      });
+    }
+  }
+  let embedded = 0;
+  for (let start = 0; start < pending.length && Date.now() < deadlineAt; start += 16) {
+    const batch = pending.slice(start, start + 16);
+    const vectors = await embed(batch.map((item) => item.text));
+    if (vectors.length !== batch.length || vectors.some((vector) => !valid(vector)))
+      throw new Error("Invalid reuse embedding batch");
+    batch.forEach(({ text: _text, ...entry }, index) => {
+      entries.push({ ...entry, vector: vectors[index] });
+    });
+    embedded += batch.length;
+  }
+  await mkdir3(dirname4(file(root)), { recursive: true });
+  await writeAtomic(file(root), JSON.stringify({ version: 1, model: MODEL, entries }), {
+    mode: 384
+  });
+  return { embedded, pending: pending.length - embedded };
+}
+async function syncReuseVectors(root, budgetMs) {
+  if (budgetMs <= 0 || process.env.CODEBUDDY_SEMANTIC === "0") return null;
+  try {
+    const { manifest } = await loadFreshIndex(root);
+    return await refreshReuseVectors(root, manifest, Date.now() + budgetMs);
+  } catch {
+    return null;
+  }
+}
+async function rankSemanticReuse(root, task, manifest, embed = embedLocal) {
+  if (process.env.CODEBUDDY_SEMANTIC === "0") return [];
+  const cache = await load(root);
+  const eligible = cache.entries.filter(
+    (entry) => manifest.entries[entry.path]?.hash === entry.hash
+  );
+  if (!eligible.length) return [];
+  try {
+    const vectors = await pTimeout(embed([task]), { milliseconds: 2e3 });
+    const query = vectors[0];
+    if (!query || !valid(query)) return [];
+    const norm = Math.sqrt(query.reduce((sum, value) => sum + value * value, 0));
+    return eligible.map((entry) => {
+      const denominator = norm * Math.sqrt(entry.vector.reduce((sum, value) => sum + value * value, 0));
+      return {
+        path: entry.path,
+        name: entry.name,
+        score: entry.vector.reduce((sum, value, index) => sum + value * (query[index] ?? 0), 0) / denominator
+      };
+    }).sort((left, right) => right.score - left.score || left.path.localeCompare(right.path));
+  } catch {
+    return [];
+  }
+}
+
+// src/journal/journal.ts
 import { createHash as createHash2 } from "crypto";
-import { resolve as resolve7 } from "path";
+import {
+  appendFile,
+  chmod,
+  mkdir as mkdir4,
+  open as open2,
+  readdir as readdir3,
+  readFile as readFile7,
+  realpath as realpath3,
+  rm as rm2,
+  stat as stat2
+} from "fs/promises";
+import { homedir } from "os";
+import { isAbsolute, join as join6, relative as relative4, sep as sep4 } from "path";
+var JOURNAL_VERSION = 1;
+var JOURNAL_LIMITS = {
+  eventChars: 1e3,
+  journalBytes: 1e6,
+  /** Largest transcript delta read per ingest; the rest is read by the next one. */
+  chunkBytes: 4e6,
+  maxAgeDays: 30,
+  findings: 5,
+  findingChars: 300,
+  verification: 5,
+  constraints: 5,
+  editedPaths: 100
+};
+function journalDir(root) {
+  return join6(root, ".codebuddy", "cache", "journal");
+}
+function safeSession(session) {
+  const clean2 = session.replace(/[^A-Za-z0-9_.-]/g, "_");
+  if (clean2 === session && clean2.length <= 120 && clean2 !== "." && clean2 !== ".." && clean2 !== "")
+    return clean2;
+  const name = clean2.slice(0, 100);
+  return `${name.replace(/^\.+$/, "session") || "session"}-${createHash2("sha256").update(session).digest("hex").slice(0, 16)}`;
+}
+var paths = (root, session) => {
+  const base = join6(journalDir(root), safeSession(session));
+  return {
+    journal: `${base}.jsonl`,
+    cursor: `${base}.cursor.json`,
+    checkpoint: `${base}.checkpoint.json`,
+    lock: `${base}.lock`
+  };
+};
+var VERIFICATION_SEGMENT = /^\s*(?:\w+=\S*\s+)*(?:npm|pnpm|yarn|bun|npx|cargo|go|make|mvn|gradle|\.\/gradlew|tsc|vitest|jest|pytest|python3? -m pytest|ruff|mypy|eslint|biome)\b.*\b(?:test|tests|lint|typecheck|tsc|build|check|vet|clippy|vitest|jest|pytest|ruff|mypy|eslint|biome)\b/;
+function isVerificationCommand(command) {
+  return command.split(/&&|\|\||;/).some((segment) => VERIFICATION_SEGMENT.test(segment));
+}
+var TAGGED_BLOCK = /<([a-z][\w-]*)[^>]*>[\s\S]*?<\/\1>/gi;
+var EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+var clip2 = (text, max) => text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+function clean(text) {
+  const trimmed = text.replace(TAGGED_BLOCK, " ").replace(/\s+/g, " ").trim();
+  return trimmed ? clip2(redactSensitive(trimmed), JOURNAL_LIMITS.eventChars) : null;
+}
+function eventsFromLine(line, offset) {
+  let entry;
+  try {
+    entry = JSON.parse(line);
+  } catch {
+    return [];
+  }
+  const message = entry.message ?? {};
+  const at = typeof entry.timestamp === "string" ? entry.timestamp : (/* @__PURE__ */ new Date(0)).toISOString();
+  const lineId = typeof entry.uuid === "string" ? entry.uuid : createHash2("sha1").update(line).digest("hex").slice(0, 16);
+  const blocks = typeof message.content === "string" ? [{ type: "text", text: message.content }] : Array.isArray(message.content) ? message.content : [];
+  const events = [];
+  blocks.forEach((block, index) => {
+    const id = `${lineId}:${index}`;
+    if (message.role === "user") {
+      if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
+        events.push({
+          id,
+          at,
+          kind: "result",
+          ref: block.tool_use_id,
+          ok: block.is_error !== true,
+          offset
+        });
+      } else if (block.type === "text" && entry.isMeta !== true) {
+        const text = clean(String(block.text ?? ""));
+        if (text) events.push({ id, at, kind: "user", text, offset });
+      }
+      return;
+    }
+    if (message.role !== "assistant") return;
+    if (block.type === "text") {
+      const text = clean(String(block.text ?? ""));
+      if (text) events.push({ id, at, kind: "assistant", text, offset });
+      return;
+    }
+    if (block.type !== "tool_use") return;
+    const input = block.input ?? {};
+    const name = String(block.name ?? "");
+    const path = input.file_path ?? input.notebook_path;
+    if (EDIT_TOOLS.has(name) && typeof path === "string") {
+      events.push({ id, at, kind: "edit", path: clip2(path, 500), offset });
+    } else if (name === "Bash" && typeof input.command === "string") {
+      const text = clean(input.command);
+      if (text) {
+        events.push({
+          id,
+          at,
+          kind: "command",
+          text,
+          ...typeof block.id === "string" ? { ref: block.id } : {},
+          offset
+        });
+      }
+    }
+  });
+  return events;
+}
+async function readJournal(root, session) {
+  let raw;
+  try {
+    raw = await readFile7(paths(root, session).journal, "utf8");
+  } catch {
+    return [];
+  }
+  const events = [];
+  for (const line of raw.split("\n")) {
+    if (!line) continue;
+    try {
+      const event = JSON.parse(line);
+      if (event.v === JOURNAL_VERSION && typeof event.id === "string") events.push(event);
+    } catch {
+    }
+  }
+  return events;
+}
+async function readCursor(path) {
+  try {
+    const cursor = JSON.parse(await readFile7(path, "utf8"));
+    return validCursor(cursor) ? cursor : null;
+  } catch {
+    return null;
+  }
+}
+function validCursor(cursor) {
+  return cursor !== null && typeof cursor === "object" && cursor.v === JOURNAL_VERSION && typeof cursor.transcript === "string" && typeof cursor.head === "string" && Number.isSafeInteger(cursor.offset) && cursor.offset >= 0 && Number.isSafeInteger(cursor.seq) && cursor.seq >= 0 && (cursor.headBytes === void 0 || Number.isInteger(cursor.headBytes) && cursor.headBytes >= 0 && cursor.headBytes <= 256);
+}
+async function headHash(path, length = 256) {
+  const handle = await open2(path, "r");
+  try {
+    const buffer = Buffer.alloc(length);
+    const { bytesRead } = await handle.read(buffer, 0, length, 0);
+    return createHash2("sha1").update(buffer.subarray(0, bytesRead)).digest("hex");
+  } finally {
+    await handle.close();
+  }
+}
+async function withLock(lock, run2, waitMs = 0) {
+  const deadline = Date.now() + waitMs;
+  for (; ; ) {
+    try {
+      await mkdir4(lock);
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      const age = Date.now() - await stat2(lock).then(
+        (value) => value.mtimeMs,
+        () => Date.now()
+      );
+      if (age >= 6e4) {
+        await rm2(lock, { recursive: true, force: true });
+        continue;
+      }
+      if (Date.now() >= deadline) return null;
+      await new Promise((resolve11) => setTimeout(resolve11, 10));
+    }
+  }
+  try {
+    return await run2();
+  } finally {
+    await rm2(lock, { recursive: true, force: true });
+  }
+}
+async function ingestTranscript(root, session, transcript, now = /* @__PURE__ */ new Date(), parse = eventsFromLine) {
+  const files = paths(root, session);
+  await mkdir4(journalDir(root), { recursive: true, mode: 448 });
+  return withLock(files.lock, async () => {
+    const size = (await stat2(transcript)).size;
+    const previous = await readCheckpoint(root, session);
+    const storedCursor = await readCursor(files.cursor);
+    const cursor = storedCursor ?? (previous?.sourceCursor && validCursor(previous.sourceCursor) ? previous.sourceCursor : null);
+    const headBytes = Math.min(size, 256);
+    const head = size > 0 ? await headHash(transcript, headBytes) : "";
+    const priorHead = cursor?.headBytes !== void 0 ? cursor.headBytes === 0 ? "" : await headHash(transcript, Math.min(size, cursor.headBytes)) : head;
+    const rotated = cursor !== null && (cursor.transcript !== transcript || cursor.offset > size || cursor.head !== priorHead);
+    let offset = cursor && !rotated ? cursor.offset : 0;
+    if (cursor && previous && !rotated && cursor.offset === size && (previous.evidence?.toSeq ?? 0) === cursor.seq) {
+      if (!storedCursor)
+        await writeAtomic(files.cursor, `${JSON.stringify(cursor)}
+`, { mode: 384 });
+      return { added: 0, offset: cursor.offset, rotated: false, checkpoint: previous };
+    }
+    const existing = await readJournal(root, session);
+    const appended = [];
+    const seen = new Set(existing.map((event) => event.id));
+    let seq = Math.max(existing.at(-1)?.seq ?? 0, cursor?.seq ?? 0, previous?.evidence?.toSeq ?? 0);
+    let added = 0;
+    const handle = await open2(transcript, "r");
+    try {
+      while (offset < size) {
+        const length = Math.min(size - offset, JOURNAL_LIMITS.chunkBytes);
+        const buffer = Buffer.alloc(length);
+        const { bytesRead } = await handle.read(buffer, 0, length, offset);
+        const end = buffer.subarray(0, bytesRead).lastIndexOf(10);
+        if (end === -1) {
+          let scan = offset + bytesRead;
+          let boundary = -1;
+          while (scan < size) {
+            const chunk = Buffer.alloc(Math.min(size - scan, JOURNAL_LIMITS.chunkBytes));
+            const read = await handle.read(chunk, 0, chunk.length, scan);
+            if (read.bytesRead === 0) break;
+            const newline = chunk.subarray(0, read.bytesRead).indexOf(10);
+            if (newline !== -1) {
+              boundary = scan + newline;
+              break;
+            }
+            scan += read.bytesRead;
+          }
+          if (boundary === -1) break;
+          const id = `gap:${createHash2("sha256").update(`${transcript}:${offset}:${boundary}`).digest("hex").slice(0, 24)}`;
+          if (!seen.has(id)) {
+            const gap = {
+              v: JOURNAL_VERSION,
+              seq: ++seq,
+              id,
+              at: now.toISOString(),
+              kind: "gap",
+              offset
+            };
+            const torn = !await endsWithNewline(files.journal);
+            await appendFile(files.journal, `${torn ? "\n" : ""}${JSON.stringify(gap)}
+`, {
+              mode: 384
+            });
+            await chmod(files.journal, 384);
+            seen.add(id);
+            appended.push(gap);
+            added++;
+          }
+          offset = boundary + 1;
+          continue;
+        }
+        const lines = [];
+        let lineStart = 0;
+        for (const line of buffer.subarray(0, end).toString("utf8").split("\n")) {
+          const lineOffset = offset + lineStart;
+          lineStart += Buffer.byteLength(line) + 1;
+          for (const event of parse(line, lineOffset)) {
+            if (seen.has(event.id)) continue;
+            seen.add(event.id);
+            const saved = { ...event, v: JOURNAL_VERSION, seq: ++seq };
+            appended.push(saved);
+            lines.push(JSON.stringify(saved));
+          }
+        }
+        if (lines.length > 0) {
+          const torn = !await endsWithNewline(files.journal);
+          await appendFile(files.journal, `${torn ? "\n" : ""}${lines.join("\n")}
+`, {
+            mode: 384
+          });
+          await chmod(files.journal, 384);
+        }
+        added += lines.length;
+        offset += end + 1;
+      }
+    } finally {
+      await handle.close();
+    }
+    const next = { v: JOURNAL_VERSION, transcript, offset, head, headBytes, seq };
+    await writeAtomic(files.cursor, `${JSON.stringify(next)}
+`, { mode: 384 });
+    const events = [...existing, ...appended];
+    const fresh = previous ? events.filter((event) => event.seq > (previous.evidence?.toSeq ?? 0)) : events;
+    if (previous && fresh.length === 0) {
+      await enforceRetention(files.journal);
+      return { added, offset, rotated, checkpoint: previous };
+    }
+    const checkpoint = await persistCheckpoint(root, session, fresh, previous, now, {
+      sourceCursor: next
+    });
+    await enforceRetention(files.journal);
+    void pruneOldJournals(root, now).catch(() => void 0);
+    return { added, offset, rotated, checkpoint };
+  });
+}
+async function persistCheckpoint(root, session, fresh, previous, now, metadata = {}) {
+  const derived = deriveCheckpoint(session, fresh, now, previous ?? void 0);
+  const editedPaths = [...new Set(derived.editedPaths.map((path) => repoRelative(root, path)))];
+  const sameTask = previous && derived.evidence?.fromSeq === previous.evidence?.fromSeq;
+  const newlyEdited = fresh.filter((event) => event.kind === "edit" && event.path).map((event) => repoRelative(root, event.path));
+  const hashes = {
+    ...sameTask ? previous.fileHashes : {},
+    ...await fileHashes(root, sameTask ? newlyEdited : editedPaths)
+  };
+  const checkpoint = {
+    ...derived,
+    editedPaths,
+    identity: sameTask && previous.identity || await repoIdentity(root),
+    fileHashes: Object.fromEntries(editedPaths.map((path) => [path, hashes[path] ?? null])),
+    ...metadata
+  };
+  await writeAtomic(paths(root, session).checkpoint, `${JSON.stringify(checkpoint, null, 2)}
+`, {
+    mode: 384
+  });
+  return checkpoint;
+}
+async function appendHostEvents(root, session, input, now = /* @__PURE__ */ new Date()) {
+  if (!input.length) return null;
+  const files = paths(root, session);
+  await mkdir4(journalDir(root), { recursive: true, mode: 448 });
+  return withLock(
+    files.lock,
+    async () => {
+      const previous = await readCheckpoint(root, session);
+      const existing = await readJournal(root, session);
+      const pending = previous ? existing.filter((event) => event.seq > (previous.evidence?.toSeq ?? 0)) : existing;
+      const seen = /* @__PURE__ */ new Set([
+        ...existing.map((event) => event.id),
+        ...previous?.recentHostEventIds ?? []
+      ]);
+      let seq = Math.max(existing.at(-1)?.seq ?? 0, previous?.evidence?.toSeq ?? 0);
+      const fresh = [];
+      for (const candidate of input.slice(0, 100)) {
+        if (!candidate || typeof candidate.id !== "string" || !candidate.id || !["user", "assistant", "edit", "command", "result"].includes(candidate.kind))
+          continue;
+        const id = `host:${createHash2("sha256").update(candidate.id).digest("hex").slice(0, 32)}`;
+        if (seen.has(id)) continue;
+        const text = typeof candidate.text === "string" ? clean(candidate.text) : null;
+        const path = typeof candidate.path === "string" ? clean(candidate.path) : null;
+        if ((candidate.kind === "user" || candidate.kind === "assistant" || candidate.kind === "command") && !text)
+          continue;
+        if (candidate.kind === "edit" && !path) continue;
+        if (candidate.kind === "result" && typeof candidate.ref !== "string") continue;
+        fresh.push({
+          v: JOURNAL_VERSION,
+          seq: ++seq,
+          id,
+          at: now.toISOString(),
+          kind: candidate.kind,
+          offset: -1,
+          ...text ? { text } : {},
+          ...path ? { path: clip2(path, 500) } : {},
+          ...typeof candidate.ref === "string" ? { ref: clip2(candidate.ref, 500) } : {},
+          ...typeof candidate.ok === "boolean" ? { ok: candidate.ok } : {}
+        });
+        seen.add(id);
+      }
+      if (!fresh.length && !pending.length && previous) return { added: 0, checkpoint: previous };
+      if (fresh.length) {
+        const torn = !await endsWithNewline(files.journal);
+        await appendFile(
+          files.journal,
+          `${torn ? "\n" : ""}${fresh.map((event) => JSON.stringify(event)).join("\n")}
+`,
+          { mode: 384 }
+        );
+        await chmod(files.journal, 384);
+      }
+      const checkpoint = await persistCheckpoint(
+        root,
+        session,
+        [...pending, ...fresh],
+        previous,
+        now,
+        {
+          recentHostEventIds: [
+            .../* @__PURE__ */ new Set([
+              ...previous?.recentHostEventIds ?? [],
+              ...fresh.map((event) => event.id)
+            ])
+          ].slice(-256)
+        }
+      );
+      await enforceRetention(files.journal);
+      void pruneOldJournals(root, now).catch(() => void 0);
+      return { added: fresh.length, checkpoint };
+    },
+    2e3
+  );
+}
+async function endsWithNewline(path) {
+  try {
+    const handle = await open2(path, "r");
+    try {
+      const { size } = await handle.stat();
+      if (size === 0) return true;
+      const byte = Buffer.alloc(1);
+      await handle.read(byte, 0, 1, size - 1);
+      return byte[0] === 10;
+    } finally {
+      await handle.close();
+    }
+  } catch {
+    return true;
+  }
+}
+function repoRelative(root, path) {
+  if (!isAbsolute(path)) return path;
+  const rel = relative4(root, path);
+  return rel && rel !== ".." && !rel.startsWith(`..${sep4}`) && !isAbsolute(rel) ? rel : path;
+}
+async function enforceRetention(journal) {
+  const size = await stat2(journal).then(
+    (s) => s.size,
+    () => 0
+  );
+  if (size <= JOURNAL_LIMITS.journalBytes) return;
+  const lines = (await readFile7(journal, "utf8")).split("\n").filter(Boolean);
+  let bytes = 0;
+  let cut = lines.length;
+  const budget = Math.floor(JOURNAL_LIMITS.journalBytes / 2);
+  while (cut > 0) {
+    const length = Buffer.byteLength(lines[cut - 1]) + 1;
+    if (bytes + length > budget) break;
+    bytes += length;
+    cut--;
+  }
+  const kept = lines.slice(cut);
+  await writeAtomic(journal, `${kept.join("\n")}
+`, { mode: 384 });
+}
+async function pruneOldJournals(root, now) {
+  const cutoff = now.getTime() - JOURNAL_LIMITS.maxAgeDays * 864e5;
+  let removed = 0;
+  for (const name of await readdir3(journalDir(root)).catch(() => [])) {
+    const path = join6(journalDir(root), name);
+    if (await stat2(path).then(
+      (s) => s.mtimeMs,
+      () => now.getTime()
+    ) < cutoff) {
+      await rm2(path, { recursive: true, force: true });
+      removed++;
+    }
+  }
+  return removed;
+}
+async function journalLag(root) {
+  const names = await readdir3(journalDir(root)).catch(() => []);
+  return Promise.all(
+    names.filter((name) => name.endsWith(".cursor.json")).map(async (name) => {
+      const cursor = await readCursor(join6(journalDir(root), name));
+      const size = cursor ? await stat2(cursor.transcript).then(
+        (s) => s.size,
+        () => null
+      ) : null;
+      return {
+        session: name.replace(/\.cursor\.json$/, ""),
+        // null: the transcript is gone, so nothing more can be journaled.
+        behindBytes: cursor && size !== null ? Math.max(0, size - cursor.offset) : null
+      };
+    })
+  );
+}
+async function forgetJournal(root, session) {
+  if (session === void 0) {
+    await rm2(journalDir(root), { recursive: true, force: true });
+    return;
+  }
+  const files = paths(root, session);
+  await Promise.all(
+    [files.journal, files.cursor, files.checkpoint].map((path) => rm2(path, { force: true }))
+  );
+}
+async function readCheckpoint(root, session) {
+  try {
+    const checkpoint = JSON.parse(
+      await readFile7(paths(root, session).checkpoint, "utf8")
+    );
+    return validCheckpoint(checkpoint) && checkpoint.session === session ? checkpoint : null;
+  } catch {
+    return null;
+  }
+}
+function validCheckpoint(value) {
+  return value !== null && typeof value === "object" && value.v === JOURNAL_VERSION && typeof value.session === "string" && typeof value.updatedAt === "string" && Number.isFinite(Date.parse(value.updatedAt)) && (value.goal === null || typeof value.goal === "string") && [value.constraints, value.editedPaths, value.findings, value.failedApproaches].every(
+    (items) => Array.isArray(items) && items.every((item) => typeof item === "string")
+  ) && Array.isArray(value.verification) && value.verification.every(
+    (run2) => run2 !== null && typeof run2 === "object" && typeof run2.command === "string" && (run2.ok === null || typeof run2.ok === "boolean") && typeof run2.stale === "boolean"
+  ) && (value.nextAction === null || typeof value.nextAction === "string");
+}
+async function listJournals(root) {
+  const names = await readdir3(journalDir(root)).catch(() => []);
+  const sessions = await Promise.all(
+    names.filter((name) => name.endsWith(".checkpoint.json")).map(async (name) => {
+      try {
+        const checkpoint = JSON.parse(
+          await readFile7(join6(journalDir(root), name), "utf8")
+        );
+        return validCheckpoint(checkpoint) ? { session: checkpoint.session, updatedAt: checkpoint.updatedAt } : null;
+      } catch {
+        return null;
+      }
+    })
+  );
+  return sessions.filter((item) => item !== null).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+function eventsFromCodexLine(line, offset) {
+  let entry;
+  try {
+    entry = JSON.parse(line);
+  } catch {
+    return [];
+  }
+  const payload = entry.payload ?? {};
+  if (entry.type !== "response_item") return [];
+  const at = typeof entry.timestamp === "string" ? entry.timestamp : (/* @__PURE__ */ new Date(0)).toISOString();
+  const base = typeof payload.id === "string" ? payload.id : createHash2("sha1").update(line).digest("hex").slice(0, 16);
+  if (payload.type === "message" && (payload.role === "user" || payload.role === "assistant")) {
+    const kind = payload.role === "user" ? "user" : "assistant";
+    return (payload.content ?? []).flatMap((item, index) => {
+      if (item.type !== "input_text" && item.type !== "output_text") return [];
+      const text = clean(String(item.text ?? ""));
+      return text ? [{ id: `${base}:${index}`, at, kind, text, offset }] : [];
+    });
+  }
+  if (payload.type === "custom_tool_call" && payload.name === "apply_patch") {
+    const patch = String(payload.input ?? "");
+    const files = [...patch.matchAll(/^\*\*\* (?:Add|Update|Delete) File: (.+)$/gm)];
+    return files.map((match, index) => ({
+      id: `${base}:${index}`,
+      at,
+      kind: "edit",
+      path: clip2((match[1] ?? "").trim(), 500),
+      offset
+    }));
+  }
+  return [];
+}
+async function firstLine(path) {
+  const handle = await open2(path, "r");
+  try {
+    const buffer = Buffer.alloc(2e6);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    const end = buffer.subarray(0, bytesRead).indexOf(10);
+    return buffer.subarray(0, end === -1 ? bytesRead : end).toString("utf8");
+  } finally {
+    await handle.close();
+  }
+}
+async function findCodexRollouts(root, codexHome = join6(homedir(), ".codex"), limit = 300) {
+  const want = await realpath3(root).catch(() => root);
+  const files = [];
+  const walk = async (dir, depth) => {
+    for (const name of await readdir3(dir).catch(() => [])) {
+      const path = join6(dir, name);
+      if (depth < 3) await walk(path, depth + 1);
+      else if (name.startsWith("rollout-") && name.endsWith(".jsonl")) {
+        files.push({
+          path,
+          mtime: await stat2(path).then(
+            (s) => s.mtimeMs,
+            () => 0
+          )
+        });
+      }
+    }
+  };
+  await walk(join6(codexHome, "sessions"), 0);
+  const found = [];
+  for (const { path } of files.sort((a, b) => b.mtime - a.mtime).slice(0, limit)) {
+    try {
+      const meta = JSON.parse(await firstLine(path));
+      if (meta.type !== "session_meta" || !meta.payload?.cwd || !meta.payload.id) continue;
+      const cwd = await realpath3(meta.payload.cwd).catch(() => meta.payload?.cwd);
+      if (cwd === want) found.push({ path, id: meta.payload.id });
+    } catch {
+    }
+  }
+  return found;
+}
+function importCodexRollout(root, rollout, now = /* @__PURE__ */ new Date()) {
+  return ingestTranscript(root, `codex-${rollout.id}`, rollout.path, now, eventsFromCodexLine);
+}
+function renderCheckpoint(checkpoint, label, annotate = {}) {
+  const mark = (path) => annotate.missing?.includes(path) ? `${path} (missing now)` : annotate.changed?.includes(path) ? `${path} (changed since)` : path;
+  const lines = [
+    `## CodeBuddy task checkpoint (${label}, ${checkpoint.updatedAt.slice(0, 16)}Z)`,
+    checkpoint.omittedTranscriptLines ? `coverage: ${checkpoint.omittedTranscriptLines} oversized transcript line(s) omitted; consult the original transcript` : "",
+    annotate.identity ?? "",
+    checkpoint.goal ? `goal: ${clip2(checkpoint.goal, 300)}` : "",
+    checkpoint.constraints.length > 0 ? `constraints: ${checkpoint.constraints.join(" ")}` : "",
+    checkpoint.editedPaths.length > 0 ? `edited: ${checkpoint.editedPaths.slice(-8).map(mark).join(", ")}` : "",
+    checkpoint.verification.length > 0 ? `checks: ${checkpoint.verification.map(
+      (run2) => `${run2.command} (${run2.ok === null ? "no result" : run2.ok ? "passed" : "failed"}${run2.stale ? annotate.sourceChanged ? ", stale: source changed" : ", stale: edited after" : ""})`
+    ).join("; ")}` : "",
+    checkpoint.findings.length > 0 ? `findings: ${checkpoint.findings.slice(-3).join(" | ")}` : "",
+    checkpoint.nextAction ? `next: ${checkpoint.nextAction}` : ""
+  ];
+  return clip2(lines.filter(Boolean).join("\n"), 1500);
+}
+async function renderCheckpointNow(root, checkpoint, label) {
+  const freshness = await compareFreshness(root, checkpoint.editedPaths, checkpoint.fileHashes);
+  const now = await repoIdentity(root);
+  const then = checkpoint.identity;
+  const moved = then && (then.branch !== now.branch || then.gitDir !== now.gitDir) ? `recorded on ${then.branch ?? "no branch"}${then.head ? ` at ${then.head.slice(0, 7)}` : ""}${then.gitDir !== now.gitDir ? ` in ${then.worktree ?? "another checkout"}` : ""}; now on ${now.branch ?? "no branch"}` : void 0;
+  const sourceChanged = freshness.changed.length > 0 || freshness.missing.length > 0;
+  const rendered = sourceChanged ? {
+    ...checkpoint,
+    verification: checkpoint.verification.map((run2) => ({ ...run2, stale: true }))
+  } : checkpoint;
+  return renderCheckpoint(rendered, label, {
+    changed: freshness.changed,
+    missing: freshness.missing,
+    sourceChanged,
+    ...moved ? { identity: moved } : {}
+  });
+}
+function isUnfinished(checkpoint) {
+  if (!checkpoint.goal) return false;
+  return checkpoint.nextAction !== null || [...new Map(checkpoint.verification.map((run2) => [run2.command, run2])).values()].some(
+    (run2) => run2.ok !== true || run2.stale
+  ) || checkpoint.editedPaths.length > 0 && checkpoint.verification.length === 0 || !checkpoint.lastAssistant && checkpoint.verification.length === 0;
+}
+async function latestUnfinished(root, excludeSession, now = /* @__PURE__ */ new Date(), maxAgeDays = 3) {
+  const cutoff = now.getTime() - maxAgeDays * 864e5;
+  for (const { session, updatedAt } of await listJournals(root)) {
+    if (session === excludeSession || Date.parse(updatedAt) < cutoff) continue;
+    const checkpoint = await readCheckpoint(root, session);
+    if (checkpoint && isUnfinished(checkpoint)) return checkpoint;
+  }
+  return null;
+}
+var CONSTRAINT = /\b(must|never|don't|do not|always|only|without|keep|avoid)\b/i;
+var NEXT_STEP = /\b(next|remaining|todo|still need|then I(?:'ll| will)|will now)\b/i;
+function isFollowUp(text) {
+  return text.split(/\s+/).filter(Boolean).length <= 6 && taskTerms(text).length <= 3;
+}
+function deriveCheckpoint(session, events, now = /* @__PURE__ */ new Date(), previous) {
+  let goal = previous?.goal ?? null;
+  let constraints = [...previous?.constraints ?? []];
+  let editedPaths = [...previous?.editedPaths ?? []];
+  let runs = (previous?.verification ?? []).map((run2, index) => ({
+    ...run2,
+    ref: previous?.verificationRefs?.[index] ?? null
+  }));
+  let findings = [...previous?.findings ?? []];
+  let lastAssistant = previous?.lastAssistant ?? "";
+  let nextAction = previous?.nextAction ?? null;
+  let fromSeq = previous?.evidence?.fromSeq ?? events[0]?.seq ?? 0;
+  let omittedTranscriptLines = previous?.omittedTranscriptLines ?? 0;
+  const continuation = /^(?:also|and|please also|following up|continue|keep|do not|don't|instead of|for (?:this|that)|what about|why|how|can you|could you)\b/i;
+  const switchTask = /^(?:new task\s*:|switch (?:tasks?|to)\b|now (?:refactor|implement|build|create|fix|migrate|port)\b)/i;
+  const bareFollowUp = /^(?:continue|go on|yes|ok(?:ay)?|thanks|run (?:the )?(?:tests?|checks?)(?: again)?)[.!]?$/i;
+  for (const event of events) {
+    if (event.kind === "user" && event.text) {
+      const completed = runs.length > 0 && [...new Map(runs.map((run2) => [run2.command, run2])).values()].every(
+        (run2) => run2.ok === true && !run2.stale
+      ) && !nextAction;
+      const start = !goal ? !bareFollowUp.test(event.text) : switchTask.test(event.text) || completed && !continuation.test(event.text) && !isFollowUp(event.text);
+      if (start) {
+        goal = event.text;
+        constraints = [];
+        editedPaths = [];
+        runs = [];
+        findings = [];
+        lastAssistant = "";
+        nextAction = null;
+        fromSeq = event.seq;
+      }
+      constraints.push(
+        ...event.text.split(/(?<=[.!?])\s+/).filter((sentence) => CONSTRAINT.test(sentence)).map((sentence) => clip2(sentence, 200))
+      );
+      constraints = [...new Set(constraints)].slice(-JOURNAL_LIMITS.constraints);
+    } else if (event.kind === "edit" && event.path) {
+      editedPaths = [.../* @__PURE__ */ new Set([...editedPaths, event.path])].slice(-JOURNAL_LIMITS.editedPaths);
+      for (const run2 of runs) run2.stale = true;
+    } else if (event.kind === "command" && event.text && isVerificationCommand(event.text)) {
+      runs.push({ command: clip2(event.text, 160), ok: null, stale: false, ref: event.ref ?? null });
+      runs = runs.slice(-JOURNAL_LIMITS.verification);
+    } else if (event.kind === "result" && event.ref) {
+      for (const run2 of runs) if (run2.ref === event.ref) run2.ok = event.ok ?? null;
+    } else if (event.kind === "assistant" && event.text) {
+      if (lastAssistant) findings.push(clip2(lastAssistant, JOURNAL_LIMITS.findingChars));
+      findings = findings.slice(-JOURNAL_LIMITS.findings);
+      lastAssistant = event.text;
+      const next = lastAssistant.split(/(?<=[.!?])\s+/).find((sentence) => NEXT_STEP.test(sentence));
+      nextAction = next ? clip2(next, 200) : null;
+    } else if (event.kind === "gap") {
+      omittedTranscriptLines++;
+    }
+  }
+  return {
+    v: JOURNAL_VERSION,
+    session,
+    updatedAt: now.toISOString(),
+    goal,
+    constraints,
+    editedPaths,
+    verification: runs.map(({ ref: _ref, ...run2 }) => run2),
+    verificationRefs: runs.map((run2) => run2.ref),
+    failedApproaches: [
+      ...new Set(runs.filter((run2) => run2.ok === false).map((run2) => `${run2.command}: failed`))
+    ].slice(-JOURNAL_LIMITS.verification),
+    findings,
+    lastAssistant,
+    ...omittedTranscriptLines ? { omittedTranscriptLines } : {},
+    nextAction,
+    evidence: events.length > 0 ? { fromSeq, toSeq: events.at(-1)?.seq ?? 0 } : previous?.evidence ?? null
+  };
+}
+
+// src/memory-extract/engine.ts
+import { createHash as createHash3 } from "crypto";
+import { resolve as resolve8 } from "path";
 
 // src/memory-extract/deterministic.ts
 var EXPLICIT_RESOLUTION = /\b(?:fixed|resolved|closed)\b.*\bfact_[a-z0-9]+\b/i;
@@ -2290,8 +3178,8 @@ function matchResolution(fixText, pathCandidates, unresolved) {
 }
 
 // src/memory-extract/review-store.ts
-import { mkdir as mkdir3, readdir as readdir3, readFile as readFile5, rename, rm as rm2 } from "fs/promises";
-import { dirname as dirname4, join as join5, relative as relative4, resolve as resolve6, sep as sep4 } from "path";
+import { mkdir as mkdir5, readdir as readdir4, readFile as readFile8, rename, rm as rm3 } from "fs/promises";
+import { dirname as dirname5, join as join7, relative as relative5, resolve as resolve7, sep as sep5 } from "path";
 import { parse as parseYaml4, stringify as stringifyYaml3 } from "yaml";
 import { z as z5 } from "zod";
 var reviewSchema = z5.object({
@@ -2326,15 +3214,15 @@ var ReviewStore = class {
   reviewDirectory;
   archiveDirectory;
   constructor(repositoryRoot = process.cwd()) {
-    this.repositoryRoot = resolve6(repositoryRoot);
-    this.reviewDirectory = join5(this.repositoryRoot, ".codebuddy", "memory", "review");
-    this.archiveDirectory = join5(this.repositoryRoot, ".codebuddy", "memory", "review-archive");
+    this.repositoryRoot = resolve7(repositoryRoot);
+    this.reviewDirectory = join7(this.repositoryRoot, ".codebuddy", "memory", "review");
+    this.archiveDirectory = join7(this.repositoryRoot, ".codebuddy", "memory", "review-archive");
   }
   async write(raw) {
     const input = redactPersisted(raw);
     const path = this.itemPath(input.id);
     await this.prepareDirectory();
-    await assertNoSymlinkBetween(this.repositoryRoot, dirname4(path));
+    await assertNoSymlinkBetween(this.repositoryRoot, dirname5(path));
     const frontMatter = stringifyYaml3({
       schemaVersion: 1,
       id: input.id,
@@ -2363,7 +3251,7 @@ var ReviewStore = class {
   async read(id) {
     const path = this.itemPath(id);
     await assertNoSymlinkBetween(this.repositoryRoot, path);
-    const parsed = parseFrontMatter(await readFile5(path, "utf8"));
+    const parsed = parseFrontMatter(await readFile8(path, "utf8"));
     return {
       ...reviewSchema.parse(parseYaml4(parsed.frontMatter)),
       content: parsed.content.trim(),
@@ -2373,7 +3261,7 @@ var ReviewStore = class {
   async list() {
     try {
       await this.prepareDirectory();
-      const entries = await readdir3(this.reviewDirectory, { withFileTypes: true });
+      const entries = await readdir4(this.reviewDirectory, { withFileTypes: true });
       const items = [];
       for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
         if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
@@ -2390,7 +3278,7 @@ var ReviewStore = class {
     }
   }
   async delete(id) {
-    await rm2(this.itemPath(id), { force: true });
+    await rm3(this.itemPath(id), { force: true });
   }
   async archiveExpired(options = {}) {
     const cutoff = (options.now ?? /* @__PURE__ */ new Date()).getTime() - (options.olderThanDays ?? 30) * 24 * 60 * 60 * 1e3;
@@ -2412,25 +3300,25 @@ var ReviewStore = class {
     return overflow;
   }
   async archive(item) {
-    await mkdir3(this.archiveDirectory, { recursive: true, mode: 448 });
+    await mkdir5(this.archiveDirectory, { recursive: true, mode: 448 });
     await assertNoSymlinkBetween(this.repositoryRoot, this.archiveDirectory);
-    await rename(item.path, join5(this.archiveDirectory, `${item.id}.md`));
+    await rename(item.path, join7(this.archiveDirectory, `${item.id}.md`));
   }
   itemPath(id) {
     if (!/^rev_[a-z0-9]+$/.test(id)) throw new Error(`Invalid review id: ${id}`);
-    return this.safePath(join5(this.reviewDirectory, `${id}.md`));
+    return this.safePath(join7(this.reviewDirectory, `${id}.md`));
   }
   safePath(path) {
-    const absolute = resolve6(path);
-    const relativePath = relative4(this.repositoryRoot, absolute);
-    if (relativePath === ".." || relativePath.startsWith(`..${sep4}`) || relativePath === "") {
+    const absolute = resolve7(path);
+    const relativePath = relative5(this.repositoryRoot, absolute);
+    if (relativePath === ".." || relativePath.startsWith(`..${sep5}`) || relativePath === "") {
       throw new Error(`Review path escapes repository root: ${path}`);
     }
     return absolute;
   }
   async prepareDirectory() {
-    await assertNoSymlinkBetween(this.repositoryRoot, dirname4(this.reviewDirectory));
-    await mkdir3(this.reviewDirectory, { recursive: true, mode: 448 });
+    await assertNoSymlinkBetween(this.repositoryRoot, dirname5(this.reviewDirectory));
+    await mkdir5(this.reviewDirectory, { recursive: true, mode: 448 });
   }
 };
 
@@ -2517,7 +3405,7 @@ var AUTO_SAVE_THRESHOLD = 0.7;
 var STATED_CONFIDENCE = 0.9;
 var POLICY_CONFIDENCE = 0.6;
 async function captureAfterTurn(input, options = {}) {
-  const repositoryRoot = resolve7(options.repositoryRoot ?? process.cwd());
+  const repositoryRoot = resolve8(options.repositoryRoot ?? process.cwd());
   const now = options.now ?? (() => /* @__PURE__ */ new Date());
   const memoryStore = new MemoryFileStore(repositoryRoot);
   const reviewStore = new ReviewStore(repositoryRoot);
@@ -2881,10 +3769,10 @@ function candidateFingerprint(namespace, raw) {
     content: candidate.content.trim().replace(/\s+/g, " ").toLowerCase(),
     paths: [...new Set(candidate.paths.map((path) => path.replace(/\\/g, "/")))].sort()
   });
-  return createHash2("sha256").update(canonical).digest("hex");
+  return createHash3("sha256").update(canonical).digest("hex");
 }
 async function approveReviewItem(id, options = {}) {
-  const repositoryRoot = resolve7(options.repositoryRoot ?? process.cwd());
+  const repositoryRoot = resolve8(options.repositoryRoot ?? process.cwd());
   const now = options.now ?? (() => /* @__PURE__ */ new Date());
   const reviewStore = new ReviewStore(repositoryRoot);
   const memoryStore = new MemoryFileStore(repositoryRoot);
@@ -2931,17 +3819,17 @@ async function approveReviewItem(id, options = {}) {
 }
 
 // src/hooks/semantic.ts
-import pTimeout from "p-timeout";
+import pTimeout2 from "p-timeout";
 var CONNECT_BUDGET_MS = 2500;
 var SEARCH_BUDGET_MS = 3e3;
 var RERANK_BUDGET_MS = 2e3;
 async function configuredReranker(repositoryRoot) {
   if (process.env.CODEBUDDY_RERANK === "0") return void 0;
-  const file = await readConfigFile(repositoryRoot);
-  const provider = file.rerank?.provider ?? "off";
+  const file2 = await readConfigFile(repositoryRoot);
+  const provider = file2.rerank?.provider ?? "off";
   if (provider === "off") return void 0;
-  const model = file.rerank?.model ?? DEFAULT_RERANK_MODELS[provider].id;
-  const bounded = (scores) => pTimeout(scores, { milliseconds: RERANK_BUDGET_MS });
+  const model = file2.rerank?.model ?? DEFAULT_RERANK_MODELS[provider].id;
+  const bounded = (scores) => pTimeout2(scores, { milliseconds: RERANK_BUDGET_MS });
   if (provider === "local") {
     const revision = model === DEFAULT_RERANK_MODELS.local.id ? DEFAULT_RERANK_MODELS.local.revision : void 0;
     return async (task, documents) => {
@@ -2951,7 +3839,7 @@ async function configuredReranker(repositoryRoot) {
       );
     };
   }
-  const apiKey = provider === "openrouter" ? process.env.OPENROUTER_API_KEY : process.env.HF_TOKEN ?? file.provider?.apiKey;
+  const apiKey = provider === "openrouter" ? process.env.OPENROUTER_API_KEY : process.env.HF_TOKEN ?? file2.provider?.apiKey;
   if (!apiKey) return void 0;
   const { rerankHuggingFace, rerankOpenRouter } = await import("./cloud-LXZUR3U2.js");
   const call = provider === "openrouter" ? rerankOpenRouter : rerankHuggingFace;
@@ -2962,14 +3850,14 @@ async function openHookSemantics(repositoryRoot) {
   const connect = async () => {
     const config = await loadRuntimeConfig(repositoryRoot, { requireDatabase: false });
     if (!config.postgresUrl) return null;
-    const { createRuntime } = await import("./operations-OG4ISWIM.js");
+    const { createRuntime } = await import("./operations-STR7S5UO.js");
     const opening = createRuntime(config, {
       repositoryRoot,
       startWorker: false,
       connectTimeoutSeconds: 2
     });
     try {
-      return await pTimeout(opening, { milliseconds: CONNECT_BUDGET_MS });
+      return await pTimeout2(opening, { milliseconds: CONNECT_BUDGET_MS });
     } catch {
       void opening.then((handle) => handle.close()).catch(() => void 0);
       return null;
@@ -2997,22 +3885,22 @@ async function openHookSemantics(repositoryRoot) {
 }
 
 // src/hooks/staging.ts
-import { mkdir as mkdir4, readFile as readFile6, rename as rename2, rm as rm3, stat as stat3 } from "fs/promises";
-import { join as join6, resolve as resolve8 } from "path";
+import { mkdir as mkdir6, readdir as readdir5, readFile as readFile9, rename as rename2, rm as rm4, stat as stat3 } from "fs/promises";
+import { join as join8, resolve as resolve9 } from "path";
 var STAGING_LOCK_STALE_MS = 1e4;
 var HookStagingStore = class {
   directory;
   operations = Promise.resolve();
   constructor(repositoryRoot = process.cwd()) {
-    this.directory = join6(resolve8(repositoryRoot), ".codebuddy", "cache", "hooks");
+    this.directory = join8(resolve9(repositoryRoot), ".codebuddy", "cache", "hooks");
   }
-  async add(sessionId, paths) {
+  async add(sessionId, paths2) {
     await this.serialize(async () => {
-      const clean = paths.map(normalize2).filter(Boolean);
-      if (clean.length === 0) return;
-      await mkdir4(this.directory, { recursive: true, mode: 448 });
+      const clean2 = paths2.map(normalize2).filter(Boolean);
+      if (clean2.length === 0) return;
+      await mkdir6(this.directory, { recursive: true, mode: 448 });
       await this.withFileLock(sessionId, async () => {
-        const merged = [.../* @__PURE__ */ new Set([...await this.read(sessionId), ...clean])].sort();
+        const merged = [.../* @__PURE__ */ new Set([...await this.read(sessionId), ...clean2])].sort();
         await writeAtomic(
           this.filePath(sessionId),
           `${JSON.stringify({ paths: merged }, null, 2)}
@@ -3021,9 +3909,18 @@ var HookStagingStore = class {
       });
     });
   }
+  /** Sessions with edits staged but not yet captured by a turn end. */
+  async pending() {
+    const names = await readdir5(this.directory).catch(() => []);
+    const sessions = names.filter((name) => name.endsWith(".json")).map((name) => name.slice(0, -5));
+    const counts = await Promise.all(
+      sessions.map(async (session) => ({ session, paths: (await this.read(session)).length }))
+    );
+    return counts.filter((entry) => entry.paths > 0);
+  }
   async read(sessionId) {
     try {
-      const parsed = JSON.parse(await readFile6(this.filePath(sessionId), "utf8"));
+      const parsed = JSON.parse(await readFile9(this.filePath(sessionId), "utf8"));
       return Array.isArray(parsed?.paths) ? parsed.paths.filter((p) => typeof p === "string") : [];
     } catch {
       return [];
@@ -3032,7 +3929,7 @@ var HookStagingStore = class {
   /** Return the staged paths and clear them. */
   async drain(sessionId) {
     return this.serialize(async () => {
-      await mkdir4(this.directory, { recursive: true, mode: 448 });
+      await mkdir6(this.directory, { recursive: true, mode: 448 });
       return this.withFileLock(sessionId, async () => {
         const path = this.filePath(sessionId);
         const draining = `${path}.${process.pid}.${Date.now()}.drain`;
@@ -3043,27 +3940,27 @@ var HookStagingStore = class {
           throw error;
         }
         try {
-          const parsed = JSON.parse(await readFile6(draining, "utf8"));
+          const parsed = JSON.parse(await readFile9(draining, "utf8"));
           return Array.isArray(parsed?.paths) ? parsed.paths.filter((item) => typeof item === "string") : [];
         } finally {
-          await rm3(draining, { force: true });
+          await rm4(draining, { force: true });
         }
       });
     });
   }
   /** Claim a batch without consuming edits staged while capture runs. */
   async claim(sessionId) {
-    await mkdir4(this.directory, { recursive: true, mode: 448 });
+    await mkdir6(this.directory, { recursive: true, mode: 448 });
     const captureLock = `${this.filePath(sessionId)}.capture-lock`;
     for (let attempt = 0; ; attempt++) {
       try {
-        await mkdir4(captureLock);
+        await mkdir6(captureLock);
         break;
       } catch (error) {
         if (error.code !== "EEXIST") throw error;
         const age = Date.now() - (await stat3(captureLock).catch(() => ({ mtimeMs: Date.now() }))).mtimeMs;
         if (age > 6e4) {
-          await rm3(captureLock, { recursive: true, force: true });
+          await rm4(captureLock, { recursive: true, force: true });
           continue;
         }
         if (attempt >= 200) return null;
@@ -3074,34 +3971,34 @@ var HookStagingStore = class {
       return await this.withFileLock(sessionId, async () => {
         const claimed = this.claimPath(sessionId);
         try {
-          return parsePaths(await readFile6(claimed, "utf8"));
+          return parsePaths(await readFile9(claimed, "utf8"));
         } catch (error) {
           if (error.code !== "ENOENT") throw error;
         }
         try {
           await rename2(this.filePath(sessionId), claimed);
-          return parsePaths(await readFile6(claimed, "utf8"));
+          return parsePaths(await readFile9(claimed, "utf8"));
         } catch (error) {
           if (error.code === "ENOENT") return [];
           throw error;
         }
       });
     } catch (error) {
-      await rm3(captureLock, { recursive: true, force: true });
+      await rm4(captureLock, { recursive: true, force: true });
       throw error;
     }
   }
   /** Acknowledge only the claimed batch; later edits remain staged. */
   async acknowledge(sessionId) {
     await this.withFileLock(sessionId, async () => {
-      await rm3(this.claimPath(sessionId), { force: true });
+      await rm4(this.claimPath(sessionId), { force: true });
     });
-    await rm3(`${this.filePath(sessionId)}.capture-lock`, { recursive: true, force: true });
+    await rm4(`${this.filePath(sessionId)}.capture-lock`, { recursive: true, force: true });
   }
   /** Restore the claimed batch for retry, merging edits that arrived during capture. */
   async rollback(sessionId) {
     await this.withFileLock(sessionId, async () => {
-      const claimed = await readFile6(this.claimPath(sessionId), "utf8").then(parsePaths).catch(() => []);
+      const claimed = await readFile9(this.claimPath(sessionId), "utf8").then(parsePaths).catch(() => []);
       const merged = [.../* @__PURE__ */ new Set([...claimed, ...await this.read(sessionId)])].sort();
       if (merged.length > 0)
         await writeAtomic(
@@ -3109,9 +4006,9 @@ var HookStagingStore = class {
           `${JSON.stringify({ paths: merged }, null, 2)}
 `
         );
-      await rm3(this.claimPath(sessionId), { force: true });
+      await rm4(this.claimPath(sessionId), { force: true });
     });
-    await rm3(`${this.filePath(sessionId)}.capture-lock`, { recursive: true, force: true });
+    await rm4(`${this.filePath(sessionId)}.capture-lock`, { recursive: true, force: true });
   }
   claimPath(sessionId) {
     return `${this.filePath(sessionId)}.claimed`;
@@ -3120,7 +4017,7 @@ var HookStagingStore = class {
     const lock = `${this.filePath(sessionId)}.lock`;
     for (let attempt = 0; ; attempt++) {
       try {
-        await mkdir4(lock);
+        await mkdir6(lock);
         break;
       } catch (error) {
         if (error.code !== "EEXIST" || attempt >= 200) throw error;
@@ -3129,7 +4026,7 @@ var HookStagingStore = class {
           () => 0
         );
         if (age > STAGING_LOCK_STALE_MS) {
-          await rm3(lock, { recursive: true, force: true });
+          await rm4(lock, { recursive: true, force: true });
           continue;
         }
         await new Promise((resolveWait) => setTimeout(resolveWait, 10));
@@ -3138,7 +4035,7 @@ var HookStagingStore = class {
     try {
       return await operation();
     } finally {
-      await rm3(lock, { recursive: true, force: true });
+      await rm4(lock, { recursive: true, force: true });
     }
   }
   async serialize(operation) {
@@ -3156,7 +4053,7 @@ var HookStagingStore = class {
   }
   filePath(sessionId) {
     const safe = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_") || "default";
-    return join6(this.directory, `${safe}.json`);
+    return join8(this.directory, `${safe}.json`);
   }
 };
 function normalize2(path) {
@@ -3169,39 +4066,44 @@ function parsePaths(raw) {
 
 // src/hooks/runtime.ts
 var CONTEXT_BLOCK_MAX_CHARS = 1800;
+var STANDALONE_FREE = /* @__PURE__ */ new Set(["session", "test-command"]);
 var HOOK_TASK_FILES = 2;
 var PROMPT_FACTS = 3;
+var HOOK_SPANS_PER_FILE = 2;
 var CONTEXT_HOOK_BUDGET_MS = 15e3;
 async function resolveNamespace(repositoryRoot) {
   if (process.env.CODEBUDDY_NAMESPACE) return process.env.CODEBUDDY_NAMESPACE;
-  const file = await readConfigFile(repositoryRoot);
-  return file.namespace ?? basename(repositoryRoot);
+  const file2 = await readConfigFile(repositoryRoot);
+  return file2.namespace ?? basename(repositoryRoot);
 }
 async function runContextHook(input, emit, budgetMs = CONTEXT_HOOK_BUDGET_MS) {
+  if (skipPromptRetrieval(input.prompt)) return "";
   const started = Date.now();
   const repositoryRoot = hookRoot(input.cwd);
   const namespace = await resolveNamespace(repositoryRoot);
   const bootstrap = await buildBootstrapContext({ repositoryRoot, namespace });
-  let beforeEdit = null;
-  const semantics = input.prompt ? await openHookSemantics(repositoryRoot) : null;
-  try {
-    beforeEdit = await buildBeforeEditContext({
-      repositoryRoot,
-      namespace,
-      // Git changes are the targets only without a prompt; a prompt that
-      // matches no file gets none (an explicit useGit would force them back).
-      ...input.prompt ? { task: input.prompt } : {},
-      ...semantics?.semanticRanker ? { semanticRanker: semantics.semanticRanker } : {},
-      ...semantics?.reranker ? { reranker: semantics.reranker } : {}
-    });
-  } catch {
-    beforeEdit = null;
-  } finally {
-    await semantics?.close();
-  }
   const ledger = new SessionCapsuleLedger(repositoryRoot);
   const sessionId = input.session_id ?? "default";
   if (input.ephemeral_context) await ledger.reset(sessionId);
+  const followUp = input.prompt !== void 0 && input.session_id !== void 0 && isFollowUpPrompt(input.prompt) && await ledger.delivered(sessionId);
+  let beforeEdit = null;
+  const semantics = input.prompt && !followUp ? await openHookSemantics(repositoryRoot) : null;
+  if (!followUp)
+    try {
+      beforeEdit = await buildBeforeEditContext({
+        repositoryRoot,
+        namespace,
+        // Git changes are the targets only without a prompt; a prompt that
+        // matches no file gets none (an explicit useGit would force them back).
+        ...input.prompt ? { task: input.prompt } : {},
+        ...semantics?.semanticRanker ? { semanticRanker: semantics.semanticRanker } : {},
+        ...semantics?.reranker ? { reranker: semantics.reranker } : {}
+      });
+    } catch {
+      beforeEdit = null;
+    } finally {
+      await semantics?.close();
+    }
   const { text, emitted } = await renderContextBlock(
     bootstrap,
     beforeEdit,
@@ -3219,6 +4121,10 @@ async function runContextHook(input, emit, budgetMs = CONTEXT_HOOK_BUDGET_MS) {
   await ledger.markSent(sessionId, emitted);
   return text;
 }
+function isFollowUpPrompt(prompt) {
+  const words2 = prompt.trim().split(/\s+/).filter(Boolean);
+  return words2.length <= 6 && taskTerms(prompt).length <= 3;
+}
 function recallTrace(input, beforeEdit, emitted, text, started, late) {
   const shown = new Set(
     emitted.filter((c) => c.key.startsWith("fact:")).map((c) => c.key.slice(5))
@@ -3234,29 +4140,47 @@ function recallTrace(input, beforeEdit, emitted, text, started, late) {
     tokensOut: estimateTokens(text),
     ...input.session_id ? { session: input.session_id } : {},
     detail: {
-      prompt: clip2(prompt, 120),
+      prompt: clip3(prompt, 120),
       facts: facts.map((fact) => fact.summary.slice(0, 100)),
       dense: facts.filter((fact) => fact.reason.includes("semantic")).length,
       lexical: facts.filter((fact) => /task term|target path/.test(fact.reason)).length,
       files: (beforeEdit?.targetPaths ?? []).slice(0, 3),
       sections: emitted.length,
-      ...text.trim() ? { block: clip2(redactSensitive(text.trim()), 2e3) } : {},
+      ...text.trim() ? { block: clip3(redactSensitive(text.trim()), 2e3) } : {},
       ...late ? { dropped: "built after the hook budget" } : {}
     }
   };
 }
-function clip2(text, max) {
+function clip3(text, max) {
   return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
 }
 async function runStageHook(input) {
   const repositoryRoot = hookRoot(input.cwd);
-  const paths = extractEditedPaths(input.tool_input).map((path) => toRepoRelative(repositoryRoot, path)).filter((path) => path !== null);
-  await new HookStagingStore(repositoryRoot).add(input.session_id ?? "default", paths);
-  return paths;
+  const paths2 = extractEditedPaths(input.tool_input).map((path) => toRepoRelative(repositoryRoot, path)).filter((path) => path !== null);
+  await new HookStagingStore(repositoryRoot).add(input.session_id ?? "default", paths2);
+  if (input.journal_event_id)
+    await appendHostEvents(
+      repositoryRoot,
+      input.session_id ?? "default",
+      paths2.map((path, index) => ({
+        id: `${input.journal_event_id}:${index}`,
+        kind: "edit",
+        path
+      }))
+    );
+  if (input.journal_events?.length) await runCheckpointHook(input).catch(() => null);
+  if (input.transcript_path) {
+    await ingestTranscript(
+      repositoryRoot,
+      input.session_id ?? "default",
+      input.transcript_path
+    ).catch(() => null);
+  }
+  return paths2;
 }
 async function llmMemoryOptions(repositoryRoot) {
   try {
-    return await (await import("./memory-TGHVTBME.js")).llmCaptureOptions(repositoryRoot);
+    return await (await import("./memory-PFFVMTCH.js")).llmCaptureOptions(repositoryRoot);
   } catch {
     return {};
   }
@@ -3268,15 +4192,20 @@ async function runCaptureHook(input) {
   const repositoryRoot = hookRoot(input.cwd);
   const staging = new HookStagingStore(repositoryRoot);
   const sessionId = input.session_id ?? "default";
+  if (input.journal_events?.length) await runCheckpointHook(input).catch(() => null);
+  if (input.transcript_path) {
+    await ingestTranscript(repositoryRoot, sessionId, input.transcript_path).catch(() => null);
+  }
   const claimed = await staging.claim(sessionId);
   if (claimed === null) return { changedFiles: [], result: null };
   const changedFiles = claimed;
   try {
-    const prompts = input.transcript_path ? await turnUserPrompts(input.transcript_path) : [];
+    const transcript = input.transcript_path ? await readCaptureTurn(input.transcript_path) : null;
+    const prompts = transcript?.prompts ?? input.user_prompts ?? [];
     const { rules, revocations, policies } = extractUserRules(prompts);
     let investigation = false;
     if (changedFiles.length === 0) {
-      const assistant = input.transcript_path ? await lastAssistantMessage(input.transcript_path) : input.last_assistant_message?.trim() ?? "";
+      const assistant = transcript?.assistant ?? input.last_assistant_message?.trim() ?? "";
       investigation = assistant.length >= INVESTIGATION_MIN_CHARS && NAMES_CODE.test(assistant);
       if (!investigation && rules.length === 0 && revocations.length === 0 && policies.length === 0) {
         await staging.acknowledge(sessionId);
@@ -3285,11 +4214,11 @@ async function runCaptureHook(input) {
     }
     const namespace = await resolveNamespace(repositoryRoot);
     const summary = await deriveSummary(
-      input.transcript_path,
+      void 0,
       changedFiles,
-      input.last_assistant_message
+      transcript?.assistant ?? input.last_assistant_message
     );
-    const verification = input.transcript_path ? await turnVerification(input.transcript_path) : verificationLines(
+    const verification = transcript ? transcript.verification : verificationLines(
       (input.shell_commands ?? []).map(({ command, exit_code }) => ({
         command,
         ok: typeof exit_code === "number" ? exit_code === 0 : void 0
@@ -3339,26 +4268,26 @@ var SYNC_BUDGET_MS = 5 * 6e4;
 async function runSyncHook(repositoryRoot, options = {}) {
   const config = await loadRuntimeConfig(repositoryRoot, { requireDatabase: false });
   if (!config.postgresUrl) return null;
-  const lock = join7(repositoryRoot, ".codebuddy", "cache", "sync.lock");
-  const dirty = join7(repositoryRoot, ".codebuddy", "cache", "sync.dirty");
-  await mkdir5(dirname5(lock), { recursive: true });
+  const lock = join9(repositoryRoot, ".codebuddy", "cache", "sync.lock");
+  const dirty = join9(repositoryRoot, ".codebuddy", "cache", "sync.dirty");
+  await mkdir7(dirname6(lock), { recursive: true });
   if (!await takeLock(lock)) {
     await writeFile(dirty, "").catch(() => void 0);
     return null;
   }
-  const { createRuntime } = await import("./operations-OG4ISWIM.js");
+  const { createRuntime } = await import("./operations-STR7S5UO.js");
   const runtime = await createRuntime(config, { repositoryRoot }).catch(async (error) => {
-    await rm4(lock, { recursive: true, force: true });
+    await rm5(lock, { recursive: true, force: true });
     throw error;
   });
   try {
     let result;
     let round = 0;
     do {
-      await rm4(dirty, { force: true });
+      await rm5(dirty, { force: true });
       const started = Date.now();
       const reindex = await runtime.memory.reindexMemory(options.respace ? {} : { respace: false });
-      const drained = await pTimeout2(runtime.memory.getWorker().drain(), {
+      const drained = await pTimeout3(runtime.memory.getWorker().drain(), {
         milliseconds: SYNC_BUDGET_MS
       }).then(
         () => true,
@@ -3384,7 +4313,9 @@ async function runSyncHook(repositoryRoot, options = {}) {
     ));
     if (config.provider.type === "local") {
       const started = Date.now();
+      const vectorStarted = Date.now();
       const vectors = await syncFileVectors(repositoryRoot, SYNC_BUDGET_MS);
+      await syncReuseVectors(repositoryRoot, SYNC_BUDGET_MS - (Date.now() - vectorStarted));
       if (vectors) {
         await recordTrace(repositoryRoot, {
           kind: "sync",
@@ -3398,13 +4329,13 @@ async function runSyncHook(repositoryRoot, options = {}) {
     return result;
   } finally {
     await runtime.close();
-    await rm4(lock, { recursive: true, force: true });
+    await rm5(lock, { recursive: true, force: true });
   }
 }
 var SYNC_LOCK_STALE_MS = SYNC_BUDGET_MS + 6e4;
 async function takeLock(path) {
   try {
-    await mkdir5(path);
+    await mkdir7(path);
     return true;
   } catch {
     const age = await stat4(path).then(
@@ -3412,8 +4343,8 @@ async function takeLock(path) {
       () => 0
     );
     if (age < SYNC_LOCK_STALE_MS) return false;
-    await rm4(path, { recursive: true, force: true });
-    return mkdir5(path).then(
+    await rm5(path, { recursive: true, force: true });
+    return mkdir7(path).then(
       () => true,
       () => false
     );
@@ -3427,22 +4358,56 @@ async function runResetHook(input, emit) {
   if (input.hook_event_name !== "SessionStart") return "";
   const namespace = await resolveNamespace(repositoryRoot);
   const bootstrap = await buildBootstrapContext({ repositoryRoot, namespace });
-  const { text, emitted } = await renderContextBlock(
+  const { text: block, emitted } = await renderContextBlock(
     bootstrap,
     null,
     ledger,
     sessionId,
     input.session_id !== void 0
   );
+  let task = "";
+  if (input.source === "compact") {
+    if (input.transcript_path) {
+      await ingestTranscript(repositoryRoot, sessionId, input.transcript_path).catch(() => null);
+    }
+    const checkpoint = await readCheckpoint(repositoryRoot, sessionId).catch(() => null);
+    if (checkpoint?.goal) {
+      task = await renderCheckpointNow(
+        repositoryRoot,
+        checkpoint,
+        "this session, before compaction"
+      );
+    }
+  }
+  const text = [block, task].filter(Boolean).join("\n");
   if (text.trim()) await emit?.(text);
   await ledger.markSent(sessionId, emitted);
   return text;
 }
+async function runCheckpointHook(input) {
+  const repositoryRoot = hookRoot(input.cwd);
+  if (input.transcript_path)
+    await ingestTranscript(repositoryRoot, input.session_id ?? "default", input.transcript_path);
+  if (input.journal_events?.length)
+    await appendHostEvents(repositoryRoot, input.session_id ?? "default", input.journal_events);
+}
+async function runResumeHook(input, emit) {
+  const repositoryRoot = hookRoot(input.cwd);
+  const checkpoint = await latestUnfinished(repositoryRoot, input.session_id);
+  if (!checkpoint) return "";
+  const text = await renderCheckpointNow(
+    repositoryRoot,
+    checkpoint,
+    `unfinished, from session ${checkpoint.session}`
+  );
+  await emit?.(text);
+  return text;
+}
 function extractEditedPaths(toolInput) {
   if (!toolInput) return [];
-  const paths = [];
+  const paths2 = [];
   const push = (value) => {
-    if (typeof value === "string" && value.trim()) paths.push(value);
+    if (typeof value === "string" && value.trim()) paths2.push(value);
   };
   push(toolInput.file_path);
   push(toolInput.filePath);
@@ -3460,12 +4425,12 @@ function extractEditedPaths(toolInput) {
       if (edit && typeof edit === "object") push(edit.file_path);
     }
   }
-  return [...new Set(paths)];
+  return [...new Set(paths2)];
 }
 function toRepoRelative(repositoryRoot, path) {
-  const absolute = isAbsolute(path) ? resolve9(path) : resolve9(repositoryRoot, path);
-  const rel = relative5(repositoryRoot, absolute);
-  if (rel === "" || rel === ".." || rel.startsWith(`..${sep5}`) || isAbsolute(rel)) return null;
+  const absolute = isAbsolute2(path) ? resolve10(path) : resolve10(repositoryRoot, path);
+  const rel = relative6(repositoryRoot, absolute);
+  if (rel === "" || rel === ".." || rel.startsWith(`..${sep6}`) || isAbsolute2(rel)) return null;
   return rel.replace(/\\/g, "/").replace(/^\.\//, "");
 }
 async function deriveSummary(transcriptPath, changedFiles, lastAssistantText) {
@@ -3473,71 +4438,36 @@ async function deriveSummary(transcriptPath, changedFiles, lastAssistantText) {
   const assistantText = transcriptPath ? await lastAssistantMessage(transcriptPath) : lastAssistantText?.trim().slice(0, 2e3) ?? "";
   return [assistantText, fileList].filter(Boolean).join("\n\n");
 }
-var VERIFICATION_SEGMENT = /^\s*(?:\w+=\S*\s+)*(?:npm|pnpm|yarn|bun|npx|cargo|go|make|mvn|gradle|\.\/gradlew|tsc|vitest|jest|pytest|python3? -m pytest|ruff|mypy|eslint|biome)\b.*\b(?:test|tests|lint|typecheck|tsc|build|check|vet|clippy|vitest|jest|pytest|ruff|mypy|eslint|biome)\b/;
-function isVerificationCommand(command) {
-  return command.split(/&&|\|\||;/).some((segment) => VERIFICATION_SEGMENT.test(segment));
-}
 async function turnVerification(transcriptPath) {
-  let raw;
-  try {
-    raw = await readFile7(transcriptPath, "utf8");
-  } catch {
-    return [];
-  }
-  let commands = /* @__PURE__ */ new Map();
-  const outcomes = /* @__PURE__ */ new Map();
-  for (const line of raw.split("\n")) {
-    let entry;
-    try {
-      entry = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    const message = entry.message ?? {};
-    const content = message.content;
-    if (message.role === "user") {
-      const isPrompt = typeof content === "string" || Array.isArray(content) && content.some((block) => block?.type === "text");
-      if (isPrompt) {
-        commands = /* @__PURE__ */ new Map();
-        outcomes.clear();
-      }
-      for (const block of Array.isArray(content) ? content : []) {
-        if (block?.type === "tool_result" && typeof block.tool_use_id === "string") {
-          outcomes.set(block.tool_use_id, block.is_error !== true);
-        }
-      }
-      continue;
-    }
-    for (const block of Array.isArray(content) ? content : []) {
-      const command = block?.input?.command;
-      if (block?.type !== "tool_use" || block.name !== "Bash" || typeof command !== "string") {
-        continue;
-      }
-      if (isVerificationCommand(command)) commands.set(block.id, command);
-    }
-  }
-  return verificationLines(
-    [...commands].map(([id, command]) => ({ command, ok: outcomes.get(id) }))
-  );
+  return (await readCaptureTurn(transcriptPath)).verification;
 }
 function verificationLines(runs) {
-  const lines = runs.filter((run) => isVerificationCommand(run.command)).map(({ command, ok }) => {
+  const lines = runs.filter((run2) => isVerificationCommand(run2.command)).map(({ command, ok }) => {
     const label = ok === void 0 ? "no result" : ok ? "passed" : "failed";
     return `${command.replace(/\s+/g, " ").trim().slice(0, 120)}: ${label}`;
   });
   return lines.slice(-10);
 }
 var MAX_RULE_PROMPT_CHARS = 1500;
-var TAGGED_BLOCK = /<([a-z][\w-]*)[^>]*>[\s\S]*?<\/\1>/gi;
+var TAGGED_BLOCK2 = /<([a-z][\w-]*)[^>]*>[\s\S]*?<\/\1>/gi;
 async function turnUserPrompts(transcriptPath) {
+  return (await readCaptureTurn(transcriptPath)).prompts;
+}
+async function lastAssistantMessage(transcriptPath) {
+  return (await readCaptureTurn(transcriptPath)).assistant;
+}
+async function readCaptureTurn(transcriptPath) {
   let raw;
   try {
-    raw = await readFile7(transcriptPath, "utf8");
+    raw = await readFile10(transcriptPath, "utf8");
   } catch {
-    return [];
+    return { prompts: [], assistant: "", verification: [] };
   }
   let prompts = [];
   let answered = false;
+  let assistant = "";
+  const commands = /* @__PURE__ */ new Map();
+  const outcomes = /* @__PURE__ */ new Map();
   for (const line of raw.split("\n")) {
     let entry;
     try {
@@ -3545,43 +4475,42 @@ async function turnUserPrompts(transcriptPath) {
     } catch {
       continue;
     }
-    const message = entry.message ?? {};
-    if (message.role === "assistant") {
+    const message = entry.message ?? entry;
+    const role = message.role ?? entry.type;
+    const content = message.content;
+    const blocks = Array.isArray(content) ? content : [];
+    if (role === "assistant") {
       answered = true;
-      continue;
-    }
-    if (message.role !== "user" || entry.isMeta === true) continue;
-    const text = extractText(message.content).replace(TAGGED_BLOCK, " ").trim();
-    if (!text) continue;
-    if (answered) {
-      prompts = [];
-      answered = false;
-    }
-    if (text.length <= MAX_RULE_PROMPT_CHARS) prompts.push(text);
-  }
-  return prompts;
-}
-async function lastAssistantMessage(transcriptPath) {
-  try {
-    const raw = await readFile7(transcriptPath, "utf8");
-    let latest = "";
-    for (const line of raw.split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      try {
-        const entry = JSON.parse(trimmed);
-        const message = entry.message ?? entry;
-        const role = message.role ?? entry.type;
-        if (role !== "assistant") continue;
-        const text = extractText(message.content);
-        if (text) latest = text;
-      } catch {
+      const text = extractText(content);
+      if (text) assistant = text.slice(0, 2e3);
+      for (const block of blocks) {
+        if (block?.type === "tool_use" && block.name === "Bash" && typeof block.id === "string" && typeof block.input?.command === "string" && isVerificationCommand(block.input.command))
+          commands.set(block.id, block.input.command);
+      }
+    } else if (role === "user") {
+      const text = entry.isMeta === true ? "" : extractText(content).replace(TAGGED_BLOCK2, " ").trim();
+      if (text) {
+        commands.clear();
+        outcomes.clear();
+        if (answered) {
+          prompts = [];
+          answered = false;
+        }
+        if (text.length <= MAX_RULE_PROMPT_CHARS) prompts.push(text);
+      }
+      for (const block of blocks) {
+        if (block?.type === "tool_result" && typeof block.tool_use_id === "string")
+          outcomes.set(block.tool_use_id, block.is_error !== true);
       }
     }
-    return latest.slice(0, 2e3);
-  } catch {
-    return "";
   }
+  return {
+    prompts,
+    assistant,
+    verification: verificationLines(
+      [...commands].map(([id, command]) => ({ command, ok: outcomes.get(id) }))
+    )
+  };
 }
 function extractText(content) {
   if (typeof content === "string") return content;
@@ -3607,15 +4536,17 @@ async function renderContextBlock(bootstrap, beforeEdit, ledger, sessionId, anno
         }
       }
     ] : [],
-    { priority: 4, capsule: { key: "project", text: `project: ${bootstrap.project.namespace}` } },
-    {
-      priority: 4,
-      capsule: {
-        key: "plan",
-        text: `plan: ${bootstrap.plan ? `${bootstrap.plan.title} (${bootstrap.plan.status})` : "none"}`
+    // Benchmark v3: "project: <name>", "plan: none" and the architecture size
+    // were re-read every turn and never acted on, so only an active plan is shown.
+    ...bootstrap.plan ? [
+      {
+        priority: 4,
+        capsule: {
+          key: "plan",
+          text: `plan: ${bootstrap.plan.title} (${bootstrap.plan.status}); policy: ${bootstrap.policy}`
+        }
       }
-    },
-    { priority: 4, capsule: { key: "plan-policy", text: `plan policy: ${bootstrap.policy}` } }
+    ] : []
   ];
   const policyRules = beforeEdit?.policyRules ?? [];
   if (policyRules.length > 0) {
@@ -3673,58 +4604,61 @@ async function renderContextBlock(bootstrap, beforeEdit, ledger, sessionId, anno
       capsule: { key: "test-command", text: `test command: ${beforeEdit.testCommand}` }
     });
   }
-  capsules.push({
-    priority: 8,
-    capsule: {
-      key: "architecture",
-      text: `architecture: ${bootstrap.architecture.moduleCount} modules, ${bootstrap.architecture.edgeCount} edges`
-    }
-  });
-  const seen = await ledger.seen(
-    sessionId,
-    capsules.map((entry) => entry.capsule)
-  );
-  const items = [
-    { priority: 0, text: "## CodeBuddy project context (auto-recalled)" }
-  ];
-  const unchanged = [];
-  let newFacts = 0;
-  for (const { priority, capsule } of capsules) {
-    if (seen.has(capsule.key)) unchanged.push(capsule);
-    else if (ranked && capsule.key.startsWith("fact:") && ++newFacts > PROMPT_FACTS) continue;
-    else items.push({ priority, text: capsule.text, capsule });
-  }
-  if (unchanged.length > 0) {
-    const avoided = unchanged.reduce((sum, capsule) => sum + estimateTokens(capsule.text), 0);
-    items.push({
-      priority: 10,
-      text: `unchanged since earlier in this session (not resent, ~${avoided} tokens): ${describeKeys(unchanged.map((c) => c.key))}`
-    });
-  }
   if (beforeEdit && beforeEdit.targetPaths.length > 0) {
     const targetLabel = beforeEdit.pathSource === "git" ? "current changes" : "task files";
     const tests = (beforeEdit.tests ?? []).map((entry) => entry.test);
-    items.push({
+    const ranges = new Map(
+      (beforeEdit.symbols ?? []).map((file2) => [
+        file2.path,
+        (file2.spans ?? []).filter((span) => span.name).slice(0, HOOK_SPANS_PER_FILE).map((span) => `${span.name} L${span.startLine}-${span.endLine}`)
+      ])
+    );
+    const describe = (path) => {
+      const spans = ranges.get(path) ?? [];
+      return spans.length > 0 ? `${path} (${spans.join(", ")})` : path;
+    };
+    capsules.push({
       priority: 3,
-      text: bound(
-        `${targetLabel}: ${beforeEdit.targetPaths.slice(0, beforeEdit.pathSource === "task" ? HOOK_TASK_FILES : 8).join(", ")}` + (tests.length > 0 ? `; tests: ${tests.join(", ")}` : ""),
-        500
-      )
+      capsule: {
+        key: "task-files",
+        text: bound(
+          `${targetLabel}: ${beforeEdit.targetPaths.slice(0, beforeEdit.pathSource === "task" ? HOOK_TASK_FILES : 8).map(describe).join(", ")}${tests.length > 0 ? `; tests: ${tests.join(", ")}` : ""}`,
+          500
+        )
+      }
     });
     const targets = new Set(beforeEdit.targetPaths);
     const risks = beforeEdit.risks.items.filter(
       (item) => targets.has(item.path) && item.score >= RISK_LINE_MIN_SCORE
     );
     if (risks.length > 0) {
-      items.push({
+      capsules.push({
         priority: 1,
-        text: bound(
-          `risk: ${risks.slice(0, 3).map((item) => `${item.path}=${item.score}`).join(", ")}`,
-          500
-        )
+        capsule: {
+          key: "risk",
+          text: bound(
+            `risk: ${risks.slice(0, 3).map((item) => `${item.path}=${item.score}`).join(", ")}`,
+            500
+          )
+        }
       });
     }
   }
+  const seen = await ledger.seen(
+    sessionId,
+    capsules.map((entry) => entry.capsule)
+  );
+  const items = [
+    { priority: 0, text: "## CodeBuddy project context (auto-recalled)" }
+  ];
+  let newFacts = 0;
+  for (const { priority, capsule } of capsules) {
+    if (seen.has(capsule.key)) continue;
+    if (ranked && capsule.key.startsWith("fact:") && ++newFacts > PROMPT_FACTS) continue;
+    else items.push({ priority, text: capsule.text, capsule });
+  }
+  if (!items.some((item) => item.capsule && !STANDALONE_FREE.has(item.capsule.key)))
+    return { text: "", emitted: [] };
   const chosen = /* @__PURE__ */ new Set();
   let used = -1;
   const byPriority = items.map((item, index) => ({ item, index })).sort((a, b) => a.item.priority - b.item.priority || a.index - b.index);
@@ -3740,15 +4674,6 @@ async function renderContextBlock(bootstrap, beforeEdit, ledger, sessionId, anno
     emitted: packed.flatMap((item) => item.capsule ? [item.capsule] : [])
   };
 }
-function describeKeys(keys) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const key of keys) {
-    const kind = key.includes(":") ? key.slice(0, key.indexOf(":")) : key;
-    counts.set(kind, (counts.get(kind) ?? 0) + 1);
-  }
-  return [...counts].map(([kind, count]) => count > 1 || kinds.has(kind) ? `${count} ${kind}` : kind).join(", ");
-}
-var kinds = /* @__PURE__ */ new Set(["fact", "incident", "handoff", "rule", "procedure"]);
 
 export {
   PLAN_STATUSES,
@@ -3767,28 +4692,45 @@ export {
   PlanNotFoundError,
   ActivePlanExistsError,
   PlanLifecycle,
-  enforceContextBudget,
+  appendHostEvents,
+  journalLag,
+  forgetJournal,
+  readCheckpoint,
+  listJournals,
+  findCodexRollouts,
+  importCodexRollout,
+  renderCheckpointNow,
+  isUnfinished,
+  latestUnfinished,
   WorklogStore,
+  enforceContextBudget,
   buildBootstrapContext,
   buildBeforeEditContext,
+  syncReuseVectors,
+  rankSemanticReuse,
   ReviewStore,
   captureAfterTurn,
   approveReviewItem,
   configuredReranker,
   openHookSemantics,
+  HookStagingStore,
   CONTEXT_HOOK_BUDGET_MS,
   runContextHook,
+  isFollowUpPrompt,
   runStageHook,
   llmMemoryOptions,
   runCaptureHook,
   runSyncHook,
   runResetHook,
+  runCheckpointHook,
+  runResumeHook,
   extractEditedPaths,
   deriveSummary,
   turnVerification,
   verificationLines,
   turnUserPrompts,
   lastAssistantMessage,
+  readCaptureTurn,
   renderContextBlock
 };
-//# sourceMappingURL=chunk-F4BJ3DXW.js.map
+//# sourceMappingURL=chunk-KQCP3ZYH.js.map