@orquentra/codebuddy 2.6.0 → 2.7.0

package/dist/{chunk-VAKBJV26.js → chunk-YJIA2MFL.js}

@@ -1,188 +1,81 @@
+import {
+  recordTrace
+} from "./chunk-TUR6YKEE.js";
 import {
   MEMORY_CLASSES,
   memoryCandidateSchema
-} from "./chunk-IHQM2ZDV.js";
+} from "./chunk-DFV2SK6C.js";
 import {
   SessionCapsuleLedger,
   detectTestCommand,
   estimateTokens,
   findCoveringTest
-} from "./chunk-SYWJG5NA.js";
+} from "./chunk-GKNYMNFM.js";
+import {
+  hookRoot
+} from "./chunk-TGFTKWOR.js";
+import {
+  INCIDENT_SEVERITIES,
+  MemoryFileStore,
+  admitsLexically,
+  isEligibleMemory,
+  lexicalTerms,
+  termOverlap
+} from "./chunk-JUAFCLRB.js";
+import {
+  generateEntityId
+} from "./chunk-CAEPHLHC.js";
 import {
   TASK_PATH_LIMIT,
-  buildArchitectureMap,
   countTerms,
   discoverTaskPaths,
-  generateGraphifyGraph,
   identifierTokens,
-  indexRepository,
-  loadArchitectureMap,
   loadFreshIndex,
   loadProjectArchitectureMap,
   namedSegments,
-  neighbours,
-  queryMap,
   readBoundedSource,
+  syncFileVectors,
   taskTerms
-} from "./chunk-L5AYZC3F.js";
+} from "./chunk-5EDGAZQN.js";
 import {
   extractSymbolTable,
   supportsSymbols
-} from "./chunk-PQK3GKZH.js";
-import {
-  INCIDENT_SEVERITIES,
-  MemoryFileStore,
-  codeBuddyConfigSchema,
-  createRuntime,
-  isEligibleMemory,
-  lexicalTerms,
-  listFactsPage,
-  termOverlap
-} from "./chunk-UN57FKQX.js";
+} from "./chunk-Y7D7PUBE.js";
 import {
+  REDACTED_LINE,
   claimText,
+  isCredentialPath,
+  loadKnownSecretValues,
   redactPersisted,
   redactSensitive,
+  redactSourceText,
   scanFields,
   scanSensitive
-} from "./chunk-GDJH7XJC.js";
-import {
-  generateEntityId
-} from "./chunk-XBJQKCLU.js";
+} from "./chunk-AL6VBTNA.js";
 import {
   DEFAULT_RERANK_MODELS
-} from "./chunk-JPHJBCZB.js";
+} from "./chunk-HPOR6YXA.js";
 import {
-  refreshZvecIndex
-} from "./chunk-QDBDYCM2.js";
+  loadPlanPolicy,
+  loadRuntimeConfig,
+  readConfigFile
+} from "./chunk-KNR2P2UY.js";
 import {
   assertNoSymlinkBetween,
   composeMarkdown,
-  configPath,
-  loadPlanPolicy,
-  loadRuntimeConfig,
   parseFrontMatter,
-  readConfigFile,
-  redactSecrets,
   writeAtomic
-} from "./chunk-776EQXDV.js";
+} from "./chunk-CG5B3LYG.js";
 
-// src/core/migrate-to-files.ts
-import { createHash } from "crypto";
-async function migrateMemoryToFiles(input) {
-  const namespace = await input.repository.getNamespaceByName(input.namespace);
-  if (!namespace) {
-    return {
-      namespace: input.namespace,
-      dryRun: !input.write,
-      facts: { found: 0, existing: 0, toWrite: 0, conflicts: 0, written: 0 },
-      summaries: { found: 0, existing: 0, toWrite: 0, conflicts: 0, written: 0 },
-      conflicts: [],
-      failures: []
-    };
-  }
-  const [facts, summaries, existingFacts, existingSummaries] = await Promise.all([
-    input.repository.listFacts({ namespaceId: namespace.id, limit: 1e5 }),
-    input.repository.listSummaries({ namespaceId: namespace.id, limit: 1e5 }),
-    input.store.listFacts(),
-    input.store.listSummaries()
-  ]);
-  const warnings = facts.length >= 1e5 || summaries.length >= 1e5 ? [
-    "namespace is at or above the 100,000-row read cap; the migration may be partial \u2014 prune or export in batches"
-  ] : [];
-  const existingFactsById = new Map(existingFacts.map((fact) => [fact.id, fact]));
-  const existingSummariesById = new Map(existingSummaries.map((summary) => [summary.id, summary]));
-  const conflicts = [];
-  const failures = [];
-  const factsToWrite = facts.filter((fact) => {
-    const existing = existingFactsById.get(fact.id);
-    if (!existing) return true;
-    const databaseChecksum = checksum(redactPersisted(fact).content);
-    const fileChecksum = checksum(existing.content);
-    if (databaseChecksum !== fileChecksum) {
-      conflicts.push({ kind: "fact", id: fact.id, databaseChecksum, fileChecksum });
-    }
-    return false;
-  });
-  const summariesToWrite = summaries.filter((summary) => {
-    const existing = existingSummariesById.get(summary.id);
-    if (!existing) return true;
-    const databaseChecksum = checksum(summary.content);
-    const fileChecksum = checksum(existing.content);
-    if (databaseChecksum !== fileChecksum) {
-      conflicts.push({ kind: "summary", id: summary.id, databaseChecksum, fileChecksum });
-    }
-    return false;
-  });
-  let factsWritten = 0;
-  let summariesWritten = 0;
-  if (input.write) {
-    for (const fact of factsToWrite) {
-      try {
-        await input.store.writeFact({
-          id: fact.id,
-          namespace: input.namespace,
-          subject: fact.subject,
-          predicate: fact.predicate,
-          object: fact.object,
-          confidence: fact.confidence,
-          createdAt: fact.createdAt.toISOString(),
-          createdByAgent: fact.createdByAgent,
-          sourceInteractionId: fact.sourceInteractionId,
-          sourceDeleted: fact.sourceDeleted,
-          supersededBy: fact.supersededBy,
-          content: fact.content
-        });
-        factsWritten += 1;
-      } catch (error) {
-        failures.push({ kind: "fact", id: fact.id, error: error.message });
-      }
-    }
-    for (const summary of summariesToWrite) {
-      try {
-        await input.store.writeSummary({
-          id: summary.id,
-          namespace: input.namespace,
-          sessionId: summary.sessionId,
-          version: summary.version,
-          tokenCount: summary.tokenCount,
-          createdAt: summary.createdAt.toISOString(),
-          createdByAgent: summary.createdByAgent,
-          content: summary.content
-        });
-        summariesWritten += 1;
-      } catch (error) {
-        failures.push({ kind: "summary", id: summary.id, error: error.message });
-      }
-    }
-  }
-  const factConflicts = conflicts.filter((conflict) => conflict.kind === "fact").length;
-  const summaryConflicts = conflicts.length - factConflicts;
-  return {
-    namespace: input.namespace,
-    dryRun: !input.write,
-    ...warnings.length > 0 ? { warnings } : {},
-    facts: {
-      found: facts.length,
-      existing: facts.length - factsToWrite.length - factConflicts,
-      toWrite: factsToWrite.length,
-      conflicts: factConflicts,
-      written: factsWritten
-    },
-    summaries: {
-      found: summaries.length,
-      existing: summaries.length - summariesToWrite.length - summaryConflicts,
-      toWrite: summariesToWrite.length,
-      conflicts: summaryConflicts,
-      written: summariesWritten
-    },
-    conflicts,
-    failures
-  };
-}
-function checksum(content) {
-  return createHash("sha256").update(content).digest("hex");
-}
+// 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";
+
+// src/context/engine.ts
+import { execFile } from "child_process";
+import { join as join4, resolve as resolve5 } from "path";
+import { promisify } from "util";
 
 // src/core/plan-file-store.ts
 import { mkdir, open, readdir, readFile, rm, stat } from "fs/promises";
@@ -413,7 +306,7 @@ function formatIssues(error) {
   });
 }
 function delay(ms) {
-  return new Promise((resolve14) => setTimeout(resolve14, ms));
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 async function releaseOwnedLock(lockPath) {
   try {
@@ -426,357 +319,60 @@ async function releaseOwnedLock(lockPath) {
   }
 }
 
-// src/core/plan-lifecycle.ts
-var TRANSITIONS = {
-  draft: ["approved", "abandoned"],
-  approved: ["executing", "abandoned"],
-  executing: ["complete", "abandoned"],
-  complete: [],
-  abandoned: []
-};
-var AMENDABLE = ["draft", "executing"];
-var PlanTransitionError = class extends Error {
-  constructor(from, to) {
-    super(`Illegal plan transition: ${from} \u2192 ${to}.`);
-    this.name = "PlanTransitionError";
-  }
-};
-var PlanNotFoundError = class extends Error {
-  constructor(id) {
-    super(`Plan ${id} not found.`);
-    this.name = "PlanNotFoundError";
+// src/risk/service.ts
+import { spawn as spawn2 } from "child_process";
+import { realpath as realpath2 } from "fs/promises";
+import { dirname as dirname2, relative as relative2, resolve as resolve3, sep as sep2 } from "path";
+
+// src/risk/assessor.ts
+var RiskAssessor = class {
+  signals;
+  minScore;
+  constructor(signals, options = {}) {
+    this.signals = signals;
+    this.minScore = options.minScore ?? 0;
   }
-};
-var ActivePlanExistsError = class extends Error {
-  activePlanId;
-  constructor(namespace, activePlanId) {
-    super(
-      `Namespace "${namespace}" already has an active plan (${activePlanId}). Complete or abandon it before approving another.`
+  async assess(input) {
+    const enabled = this.signals.filter((signal) => signal.enabled);
+    const settled = await Promise.all(
+      enabled.map(async (signal) => ({
+        signal,
+        contributions: await signal.assess(input)
+      }))
     );
-    this.name = "ActivePlanExistsError";
-    this.activePlanId = activePlanId;
-  }
-};
-var DEFAULT_BODY = [
-  "# Goal",
-  "",
-  "(what this plan achieves)",
-  "",
-  "# Approach",
-  "",
-  "(ordered steps)",
-  "",
-  "# Notes",
-  "",
-  "(freeform; ignored by tooling)"
-].join("\n");
-var PlanLifecycle = class {
-  store;
-  constructor(store) {
-    this.store = store;
-  }
-  async create(input) {
-    const id = generateEntityId("pln");
-    const now = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
-    await this.store.writePlan({
-      id,
-      namespace: input.namespace,
-      title: input.title,
-      status: "draft",
-      brief: input.brief,
-      filesToTouch: input.filesToTouch ?? [],
-      testsToAdd: input.testsToAdd ?? [],
-      outOfScope: input.outOfScope ?? [],
-      risks: input.risks ?? [],
-      createdAt: now,
-      createdByAgent: input.createdByAgent ?? null,
-      approvedAt: null,
-      executingAt: null,
-      completedAt: null,
-      abandonedAt: null,
-      commitSha: null,
-      abandonReason: null,
-      body: input.body ?? DEFAULT_BODY
-    });
-    return this.store.readPlan(id);
-  }
-  async approve(id, now = (/* @__PURE__ */ new Date()).toISOString()) {
-    const current = await this.require(id);
-    return this.store.withNamespaceLock(current.namespace, async () => {
-      const fresh = await this.require(id);
-      this.assertTransition(fresh.status, "approved");
-      const active = await this.store.findActivePlan(fresh.namespace);
-      if (active && active.id !== id) {
-        throw new ActivePlanExistsError(fresh.namespace, active.id);
-      }
-      return this.rewrite(fresh, { status: "approved", approvedAt: now });
-    });
-  }
-  async start(id, now = (/* @__PURE__ */ new Date()).toISOString()) {
-    const current = await this.require(id);
-    return this.store.withNamespaceLock(current.namespace, async () => {
-      const fresh = await this.require(id);
-      this.assertTransition(fresh.status, "executing");
-      return this.rewrite(fresh, { status: "executing", executingAt: now });
-    });
-  }
-  async complete(id, options = {}, now = (/* @__PURE__ */ new Date()).toISOString()) {
-    const current = await this.require(id);
-    return this.store.withNamespaceLock(current.namespace, async () => {
-      const fresh = await this.require(id);
-      this.assertTransition(fresh.status, "complete");
-      return this.rewrite(fresh, {
-        status: "complete",
-        completedAt: now,
-        ...options.commitSha !== void 0 ? { commitSha: options.commitSha } : {}
-      });
-    });
-  }
-  async abandon(id, options = {}, now = (/* @__PURE__ */ new Date()).toISOString()) {
-    const current = await this.require(id);
-    return this.store.withNamespaceLock(current.namespace, async () => {
-      const fresh = await this.require(id);
-      this.assertTransition(fresh.status, "abandoned");
-      return this.rewrite(fresh, {
-        status: "abandoned",
-        abandonedAt: now,
-        ...options.reason !== void 0 ? { abandonReason: options.reason } : {}
-      });
-    });
-  }
-  async amend(id, patch) {
-    const current = await this.require(id);
-    return this.store.withNamespaceLock(current.namespace, async () => {
-      const fresh = await this.require(id);
-      if (!AMENDABLE.includes(fresh.status)) {
-        throw new Error(
-          `Plan ${id} is ${fresh.status}; only draft or executing plans can be amended.`
-        );
+    const byPath = /* @__PURE__ */ new Map();
+    const perSignal = /* @__PURE__ */ new Map();
+    for (const { signal, contributions } of settled) {
+      const stat5 = perSignal.get(signal.id) ?? {
+        id: signal.id,
+        category: signal.category,
+        contributions: 0,
+        totalWeight: 0
+      };
+      for (const contribution of contributions) {
+        if (contribution.evidence.length === 0) continue;
+        const list = byPath.get(contribution.path) ?? [];
+        list.push({ signal, contribution });
+        byPath.set(contribution.path, list);
+        stat5.contributions += 1;
+        stat5.totalWeight += contribution.weight;
       }
-      return this.rewrite(fresh, {
-        ...patch.title !== void 0 ? { title: patch.title } : {},
-        ...patch.brief !== void 0 ? { brief: patch.brief } : {},
-        ...patch.filesToTouch !== void 0 ? { filesToTouch: patch.filesToTouch } : {},
-        ...patch.testsToAdd !== void 0 ? { testsToAdd: patch.testsToAdd } : {},
-        ...patch.outOfScope !== void 0 ? { outOfScope: patch.outOfScope } : {},
-        ...patch.risks !== void 0 ? { risks: patch.risks } : {},
-        ...patch.body !== void 0 ? { body: patch.body } : {}
-      });
-    });
-  }
-  async current(namespace) {
-    return this.store.findActivePlan(namespace);
-  }
-  assertTransition(from, to) {
-    if (!TRANSITIONS[from].includes(to)) {
-      throw new PlanTransitionError(from, to);
+      perSignal.set(signal.id, stat5);
     }
-  }
-  async require(id) {
-    try {
-      return await this.store.readPlan(id);
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        throw new PlanNotFoundError(id);
-      }
-      throw error;
+    const items = [];
+    for (const [path, contributions] of byPath) {
+      items.push(this.fold(path, contributions));
     }
-  }
-  /** Rewrite the plan file with a partial set of changed fields. */
-  async rewrite(plan, changes) {
-    const next = { ...plan, ...changes };
-    await this.store.writePlan({
-      id: next.id,
-      namespace: next.namespace,
-      title: next.title,
-      status: next.status,
-      brief: next.brief,
-      filesToTouch: next.filesToTouch,
-      testsToAdd: next.testsToAdd,
-      outOfScope: next.outOfScope,
-      risks: next.risks,
-      createdAt: next.createdAt,
-      createdByAgent: next.createdByAgent,
-      approvedAt: next.approvedAt,
-      executingAt: next.executingAt,
-      completedAt: next.completedAt,
-      abandonedAt: next.abandonedAt,
-      commitSha: next.commitSha,
-      abandonReason: next.abandonReason,
-      body: next.body
-    });
-    return this.store.readPlan(next.id);
-  }
-};
-
-// package.json
-var package_default = {
-  name: "@orquentra/codebuddy",
-  version: "2.6.0",
-  description: "Local-first project context and memory for AI coding agents.",
-  type: "module",
-  license: "MIT",
-  publishConfig: {
-    access: "public"
-  },
-  author: "Orquentra Inc",
-  repository: {
-    type: "git",
-    url: "https://github.com/Orquentra-Inc/CodeBuddy"
-  },
-  engines: {
-    node: ">=20"
-  },
-  bin: {
-    codebuddy: "./dist/cli/index.js"
-  },
-  exports: {
-    ".": {
-      types: "./dist/index.d.ts",
-      import: "./dist/index.js"
-    },
-    "./langgraph": {
-      types: "./dist/langgraph/index.d.ts",
-      import: "./dist/langgraph/index.js"
-    }
-  },
-  files: [
-    "dist",
-    "src/db/migrations",
-    "README.md",
-    "CLAUDE_CODEX.md",
-    "ARCHITECTURE.md",
-    "WORKFLOW.md",
-    "LICENSE",
-    "docker-compose.yml",
-    "examples"
-  ],
-  scripts: {
-    build: "tsup",
-    dev: "tsx src/cli/index.ts",
-    "db:generate": "drizzle-kit generate",
-    "db:migrate": "drizzle-kit migrate",
-    typecheck: "tsc --noEmit",
-    test: "vitest run --passWithNoTests",
-    "test:pg": "bash scripts/test-pg-recovery.sh",
-    "eval:agent-ab": "tsx scripts/eval-agent-ab.mts",
-    "eval:memory-ab": "tsx scripts/eval-memory-ab.mts",
-    "eval:retrieval": "tsx scripts/eval-retrieval.mts",
-    "eval:savings": "tsx scripts/eval-task-savings.mts",
-    "branches:prune": "bash scripts/prune-merged-branches.sh",
-    lint: "biome check .",
-    format: "biome format --write .",
-    prepublishOnly: "npm run typecheck && npm test && npm run build",
-    "eval:semantic": "tsx scripts/eval-semantic.mts"
-  },
-  keywords: [
-    "mcp",
-    "memory",
-    "agent",
-    "multi-agent",
-    "huggingface",
-    "pgvector",
-    "postgres",
-    "langgraph",
-    "claude"
-  ],
-  homepage: "https://github.com/Orquentra-Inc/CodeBuddy",
-  bugs: {
-    url: "https://github.com/Orquentra-Inc/CodeBuddy/issues"
-  },
-  dependencies: {
-    "@clack/prompts": "^0.11.0",
-    "@huggingface/inference": "^4.13.19",
-    "@modelcontextprotocol/sdk": "^1.17.5",
-    commander: "^14.0.0",
-    "drizzle-orm": "^0.45.2",
-    "js-tiktoken": "^1.0.21",
-    langsmith: "^0.7.10",
-    ora: "^8.2.0",
-    "p-queue": "^8.1.0",
-    "p-retry": "^6.2.1",
-    "p-timeout": "^6.1.4",
-    picocolors: "^1.1.1",
-    pino: "^9.9.0",
-    "pino-pretty": "^13.1.1",
-    postgres: "^3.4.7",
-    yaml: "^2.9.0",
-    zod: "^4.6.7"
-  },
-  peerDependencies: {
-    "@langchain/langgraph": "^0.2.0 || ^0.3.0"
-  },
-  peerDependenciesMeta: {
-    "@langchain/langgraph": {
-      optional: true
-    }
-  },
-  devDependencies: {
-    "@biomejs/biome": "^2.5.0",
-    "@types/node": "^24.3.0",
-    "drizzle-kit": "^0.31.10",
-    tsup: "^8.5.0",
-    tsx: "^4.20.5",
-    typescript: "^5.9.2",
-    vitest: "^4.1.12"
-  },
-  optionalDependencies: {
-    "@huggingface/transformers": "^4.3.2"
-  }
-};
-
-// src/version.ts
-var VERSION = package_default.version;
-
-// src/risk/assessor.ts
-var RiskAssessor = class {
-  signals;
-  minScore;
-  constructor(signals, options = {}) {
-    this.signals = signals;
-    this.minScore = options.minScore ?? 0;
-  }
-  async assess(input) {
-    const enabled = this.signals.filter((signal) => signal.enabled);
-    const settled = await Promise.all(
-      enabled.map(async (signal) => ({
-        signal,
-        contributions: await signal.assess(input)
-      }))
-    );
-    const byPath = /* @__PURE__ */ new Map();
-    const perSignal = /* @__PURE__ */ new Map();
-    for (const { signal, contributions } of settled) {
-      const stat6 = perSignal.get(signal.id) ?? {
-        id: signal.id,
-        category: signal.category,
-        contributions: 0,
-        totalWeight: 0
-      };
-      for (const contribution of contributions) {
-        if (contribution.evidence.length === 0) continue;
-        const list = byPath.get(contribution.path) ?? [];
-        list.push({ signal, contribution });
-        byPath.set(contribution.path, list);
-        stat6.contributions += 1;
-        stat6.totalWeight += contribution.weight;
-      }
-      perSignal.set(signal.id, stat6);
-    }
-    const items = [];
-    for (const [path, contributions] of byPath) {
-      items.push(this.fold(path, contributions));
-    }
-    const ranked = items.filter((item) => item.score >= this.minScore).sort(compareRiskItems);
-    return {
-      items: ranked,
-      stats: {
-        pathsConsidered: input.paths.length,
-        itemsProduced: ranked.length,
-        signalsRun: enabled.length,
-        perSignal: [...perSignal.values()].sort((a, b) => a.id.localeCompare(b.id))
-      }
-    };
+    const ranked = items.filter((item) => item.score >= this.minScore).sort(compareRiskItems);
+    return {
+      items: ranked,
+      stats: {
+        pathsConsidered: input.paths.length,
+        itemsProduced: ranked.length,
+        signalsRun: enabled.length,
+        perSignal: [...perSignal.values()].sort((a, b) => a.id.localeCompare(b.id))
+      }
+    };
   }
   /** Fold all contributions for one path into a single RiskItem. */
   fold(path, contributions) {
@@ -827,9 +423,10 @@ function round2(value) {
 
 // src/risk/signals/churn.ts
 import { spawn } from "child_process";
-import { realpath } from "fs/promises";
+import { readFile as readFile2, realpath } from "fs/promises";
 import { resolve as resolve2 } from "path";
 var GIT_LOG_CONCURRENCY = 4;
+var DAY_MS = 864e5;
 function createChurnSignal(options) {
   return {
     id: "git-churn",
@@ -844,20 +441,56 @@ function createChurnSignal(options) {
       if (root.code !== 0 || resolve2(root.stdout.trim()) !== expected) {
         return [];
       }
-      const since = options.since ?? "30 days ago";
+      const lifetime = options.mode === "lifetime-size";
+      const asOf = options.asOf === void 0 ? void 0 : new Date(options.asOf);
+      const end = asOf ?? /* @__PURE__ */ new Date();
+      const range = [
+        ...lifetime ? [] : [
+          `--since=${options.since ?? new Date(end.getTime() - (options.windowDays ?? 30) * DAY_MS).toISOString()}`
+        ],
+        ...asOf ? [`--until=${asOf.toISOString()}`] : []
+      ];
+      const revision = lifetime && asOf ? (await runGit(options.repositoryRoot, [
+        "rev-list",
+        "-1",
+        `--before=${asOf.toISOString()}`,
+        "HEAD"
+      ])).stdout.trim() : null;
       const logs = [];
+      const sizes = [];
       for (let start = 0; start < input.paths.length; start += GIT_LOG_CONCURRENCY) {
         const batch = input.paths.slice(start, start + GIT_LOG_CONCURRENCY);
         logs.push(
           ...await Promise.all(
-            batch.map((path) => gitLogForPath(options.repositoryRoot, path, since))
+            batch.map((path) => gitLogForPath(options.repositoryRoot, path, range))
           )
         );
+        if (lifetime) {
+          sizes.push(
+            ...await Promise.all(
+              batch.map((path) => lineCount(options.repositoryRoot, path, revision))
+            )
+          );
+        }
       }
       const contributions = [];
       for (const [index, path] of input.paths.entries()) {
         const commits = logs[index] ?? [];
         if (commits.length === 0) continue;
+        if (lifetime) {
+          const lines = sizes[index] ?? 0;
+          contributions.push({
+            path,
+            // ponytail: hand-picked coefficients; fit them on the time-split eval before defaulting on.
+            weight: Math.min(
+              100,
+              Math.round(8 * Math.log2(1 + commits.length) + 4 * Math.log2(1 + lines))
+            ),
+            reason: `${path} has ${commits.length} commit${commits.length === 1 ? "" : "s"}, ${lines} line${lines === 1 ? "" : "s"} (lifetime churn and size).`,
+            evidence: evidenceOf(commits)
+          });
+          continue;
+        }
         const authors = new Set(commits.map((commit) => commit.author));
         const reverts = commits.filter((commit) => /revert|rollback|backout/i.test(commit.message));
         const weight = Math.min(100, commits.length * 8 + authors.size * 12 + reverts.length * 20);
@@ -865,23 +498,38 @@ function createChurnSignal(options) {
           path,
           weight,
           reason: `${path} changed ${commits.length} time${commits.length === 1 ? "" : "s"} in the recent git history by ${authors.size} author${authors.size === 1 ? "" : "s"}.`,
-          evidence: commits.slice(0, 5).map((commit) => ({
-            kind: "git_commit",
-            sha: commit.sha,
-            message: commit.message,
-            ts: commit.ts
-          }))
+          evidence: evidenceOf(commits)
         });
       }
       return contributions;
     }
   };
 }
-async function gitLogForPath(repositoryRoot, path, since) {
+function evidenceOf(commits) {
+  return commits.slice(0, 5).map((commit) => ({
+    kind: "git_commit",
+    sha: commit.sha,
+    message: commit.message,
+    ts: commit.ts
+  }));
+}
+async function lineCount(repositoryRoot, path, revision) {
+  let text = "";
+  if (revision === null) {
+    text = await readFile2(resolve2(repositoryRoot, path), "utf8").catch(() => "");
+  } else if (revision) {
+    const shown = await runGit(repositoryRoot, ["show", `${revision}:${path}`]);
+    if (shown.code === 0) text = shown.stdout;
+  }
+  if (text.length === 0) return 0;
+  return text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
+}
+async function gitLogForPath(repositoryRoot, path, range) {
   const result = await runGit(repositoryRoot, [
     "log",
     "--follow",
-    `--since=${since}`,
+    "--max-count=1000",
+    ...range,
     "--format=%H%x1f%an%x1f%cI%x1f%s%x1e",
     "--",
     path
@@ -893,7 +541,7 @@ async function gitLogForPath(repositoryRoot, path, since) {
   }).filter((record) => record.sha.length > 0);
 }
 function runGit(cwd, args) {
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve10, reject) => {
     const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
@@ -904,7 +552,7 @@ function runGit(cwd, args) {
       stderr += String(chunk);
     });
     child.on("error", reject);
-    child.on("close", (code) => resolve14({ code: code ?? 0, stdout, stderr }));
+    child.on("close", (code) => resolve10({ code: code ?? 0, stdout, stderr }));
   });
 }
 
@@ -967,7 +615,7 @@ function severityWeight(severity) {
 }
 
 // src/risk/signals/policy.ts
-import { readFile as readFile2 } from "fs/promises";
+import { readFile as readFile3 } from "fs/promises";
 import { join as join2 } from "path";
 import { parse as parseYaml2 } from "yaml";
 import { z as z2 } from "zod";
@@ -1019,7 +667,7 @@ function createPolicySignal(options) {
 }
 async function readPolicyFile(path) {
   try {
-    const raw = await readFile2(path, "utf8");
+    const raw = await readFile3(path, "utf8");
     return policyFileSchema.parse(parseYaml2(raw) ?? {});
   } catch (error) {
     if (error.code === "ENOENT") return { rules: [] };
@@ -1040,8 +688,6 @@ function escapeRegExp(value) {
 }
 
 // src/risk/service.ts
-import { spawn as spawn2 } from "child_process";
-import { relative as relative2, resolve as resolve3, sep as sep2 } from "path";
 async function assessRisk(input) {
   const repositoryRoot = resolve3(input.repositoryRoot ?? process.cwd());
   const paths = await resolveRiskPaths({
@@ -1057,10 +703,17 @@ async function assessRisk(input) {
     };
   }
   const memoryStore = new MemoryFileStore(repositoryRoot);
+  const churn = (await readConfigFile(repositoryRoot).catch(() => ({ risk: void 0 }))).risk;
   const signals = input.signals ?? [
     createIncidentSignal({ store: memoryStore }),
     createPolicySignal({ repositoryRoot }),
-    ...input.useGit === false ? [] : [createChurnSignal({ repositoryRoot })]
+    ...input.useGit === false ? [] : [
+      createChurnSignal({
+        repositoryRoot,
+        ...churn?.churnWindowDays !== void 0 ? { windowDays: churn.churnWindowDays } : {},
+        ...churn?.churnMode !== void 0 ? { mode: churn.churnMode } : {}
+      })
+    ]
   ];
   const assessment = await new RiskAssessor(signals).assess({
     paths,
@@ -1092,10 +745,27 @@ async function resolveRiskPaths(input) {
       if (contained) paths.add(contained);
     }
   }
-  const resolved = [...paths].sort();
+  const realRoot = await realpath2(input.repositoryRoot).catch(() => resolve3(input.repositoryRoot));
+  const inside = await Promise.all(
+    [...paths].map((path) => realPathInside(realRoot, resolve3(input.repositoryRoot, path)))
+  );
+  const resolved = [...paths].filter((_, index) => inside[index]).sort();
   return resolved.length > MAX_RESOLVED_PATHS ? resolved.slice(0, MAX_RESOLVED_PATHS) : resolved;
 }
 var MAX_RESOLVED_PATHS = 200;
+async function containedRepoPath(root, path) {
+  const contained = containedRelativePath(root, path);
+  if (contained === null) return null;
+  const realRoot = await realpath2(root).catch(() => resolve3(root));
+  return await realPathInside(realRoot, resolve3(root, contained)) ? contained : null;
+}
+async function realPathInside(realRoot, absolute) {
+  for (let current = absolute; ; current = dirname2(current)) {
+    const real = await realpath2(current).catch(() => null);
+    if (real !== null) return real === realRoot || real.startsWith(`${realRoot}${sep2}`);
+    if (dirname2(current) === current) return false;
+  }
+}
 function containedRelativePath(root, path) {
   const trimmed = normalizePath2(path);
   if (!trimmed || trimmed.includes("\0")) return null;
@@ -1106,18 +776,18 @@ function containedRelativePath(root, path) {
 }
 async function changedGitPaths(repositoryRoot) {
   const [tracked, untracked] = await Promise.all([
-    runGit2(repositoryRoot, ["diff", "--name-only", "HEAD"]),
-    runGit2(repositoryRoot, ["ls-files", "--others", "--exclude-standard"])
+    // `-z`: NUL-separated, unquoted names (non-ASCII, quotes, tabs, newlines).
+    runGit2(repositoryRoot, ["diff", "--name-only", "-z", "HEAD"]),
+    runGit2(repositoryRoot, ["ls-files", "-z", "--others", "--exclude-standard"])
   ]);
-  return [...tracked.stdout.split("\n"), ...untracked.stdout.split("\n")].map((path) => path.trim()).filter(
-    (path) => path && !path.startsWith(".codebuddy/cache/") && !path.startsWith(".codebuddy/worklog/")
-  );
+  return [...tracked.stdout.split("\0"), ...untracked.stdout.split("\0")].filter((path) => path && !path.split("/").some((segment) => segment.startsWith(".")));
 }
 function runGit2(cwd, args) {
   return new Promise((resolveResult, reject) => {
     const child = spawn2("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
+    child.stdout.setEncoding("utf8");
     child.stdout.on("data", (chunk) => {
       stdout += String(chunk);
     });
@@ -1129,212 +799,206 @@ function runGit2(cwd, args) {
   });
 }
 function normalizePath2(path) {
-  return path.replace(/\\/g, "/").replace(/^\.\//, "");
+  return (sep2 === "\\" ? path.replace(/\\/g, "/") : path).replace(/^\.\//, "");
 }
 
-// src/mcp/tools/index.ts
-import { z as z6 } from "zod";
-
-// src/context/delivery.ts
-import { createHash as createHash2 } from "crypto";
-
-// src/context/budget.ts
-var WARNING = "Context incomplete: inspect omitted policies, risks and incidents before editing.";
-function enforceContextBudget(input) {
-  const output = structuredClone(input);
-  if (!output.tokens) return input;
-  output.tokens.essentialOmitted ??= 0;
-  if (account(output) <= output.tokens.budget) return output;
-  const candidates = [];
-  const add = (section, value, priority, essential = false) => {
-    candidates.push({ section, value, priority, essential });
-  };
-  for (const [section, priority] of [
-    ["diffs", 10],
-    ["neighbours", 20],
-    ["handoffs", 30],
-    ["facts", 40],
-    ["rules", 45],
-    ["symbols", 50],
-    ["policyRules", 90],
-    ["incidents", 80]
-  ]) {
-    const values = output[section];
-    if (!Array.isArray(values)) continue;
-    for (const value of values) {
-      const essential = section === "policyRules" || section === "incidents" && !value.resolved;
-      const severity = section === "incidents" ? { critical: 4, high: 3, medium: 2, low: 1 }[value.severity] ?? 0 : 0;
-      add(section, value, priority + severity, essential);
-    }
-    output[section] = [];
+// src/core/plan-lifecycle.ts
+var TRANSITIONS = {
+  draft: ["approved", "abandoned"],
+  approved: ["executing", "abandoned"],
+  executing: ["complete", "abandoned"],
+  complete: [],
+  abandoned: []
+};
+var AMENDABLE = ["draft", "executing"];
+var PlanTransitionError = class extends Error {
+  constructor(from, to) {
+    super(`Illegal plan transition: ${from} \u2192 ${to}.`);
+    this.name = "PlanTransitionError";
   }
-  const risks = output.risks;
-  if (risks) {
-    for (const value of risks.items)
-      add(
-        "risks",
-        value,
-        value.score >= 50 ? 100 + value.score : 60 + value.score / 100,
-        value.score > 0
-      );
-    risks.items = [];
+};
+var PlanNotFoundError = class extends Error {
+  constructor(id) {
+    super(`Plan ${id} not found.`);
+    this.name = "PlanNotFoundError";
   }
-  if (output.plan) {
-    add("plan", output.plan, 55);
-    output.plan = null;
+};
+var ActivePlanExistsError = class extends Error {
+  activePlanId;
+  constructor(namespace, activePlanId) {
+    super(
+      `Namespace "${namespace}" already has an active plan (${activePlanId}). Complete or abandon it before approving another.`
+    );
+    this.name = "ActivePlanExistsError";
+    this.activePlanId = activePlanId;
   }
-  const architecture = output.architecture;
-  if (architecture) {
-    for (const value of architecture.hotspots) add("hotspots", value, 25);
-    architecture.hotspots = [];
+};
+var DEFAULT_BODY = [
+  "# Goal",
+  "",
+  "(what this plan achieves)",
+  "",
+  "# Approach",
+  "",
+  "(ordered steps)",
+  "",
+  "# Notes",
+  "",
+  "(freeform; ignored by tooling)"
+].join("\n");
+var PlanLifecycle = class {
+  store;
+  constructor(store) {
+    this.store = store;
   }
-  output.explain = [];
-  if (typeof output.task === "string") output.task = compact(output.task, 160);
-  const riskStats = output.risks?.stats;
-  if (riskStats) riskStats.perSignal = [];
-  const previousOmitted = output.tokens.essentialOmitted;
-  output.tokens.essentialOmitted = previousOmitted + candidates.filter((c) => c.essential).length;
-  output.tokens.warning = WARNING;
-  if (account(output) > output.tokens.budget && output.task) output.task = null;
-  if (estimateTokens({ project: output.project, targetPaths: output.targetPaths }) > output.tokens.budget) {
-    account(output);
-    return output;
+  async create(input) {
+    await this.assertPathsInside(input);
+    const id = generateEntityId("pln");
+    const now = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+    await this.store.writePlan({
+      id,
+      namespace: input.namespace,
+      title: input.title,
+      status: "draft",
+      brief: input.brief,
+      filesToTouch: input.filesToTouch ?? [],
+      testsToAdd: input.testsToAdd ?? [],
+      outOfScope: input.outOfScope ?? [],
+      risks: input.risks ?? [],
+      createdAt: now,
+      createdByAgent: input.createdByAgent ?? null,
+      approvedAt: null,
+      executingAt: null,
+      completedAt: null,
+      abandonedAt: null,
+      commitSha: null,
+      abandonReason: null,
+      body: input.body ?? DEFAULT_BODY
+    });
+    return this.store.readPlan(id);
   }
-  candidates.sort((a, b) => b.priority - a.priority);
-  for (const candidate of candidates) {
-    const insert = (value) => {
-      if (candidate.section === "plan") output.plan = value;
-      else if (candidate.section === "risks") risks?.items.push(value);
-      else if (candidate.section === "hotspots") architecture?.hotspots.push(value);
-      else output[candidate.section].push(value);
-    };
-    const remove = () => {
-      if (candidate.section === "plan") output.plan = null;
-      else if (candidate.section === "risks") risks?.items.pop();
-      else if (candidate.section === "hotspots") architecture?.hotspots.pop();
-      else output[candidate.section].pop();
-    };
-    insert(candidate.value);
-    if (candidate.essential) output.tokens.essentialOmitted--;
-    if (account(output) <= output.tokens.budget) continue;
-    remove();
-    if (candidate.essential) output.tokens.essentialOmitted++;
-    const smaller = candidate.essential ? compactSafety(candidate.value) : compact(candidate.value, 100);
-    insert(smaller);
-    if (account(output) <= output.tokens.budget) continue;
-    remove();
+  async approve(id, now = (/* @__PURE__ */ new Date()).toISOString()) {
+    const current = await this.require(id);
+    return this.store.withNamespaceLock(current.namespace, async () => {
+      const fresh = await this.require(id);
+      this.assertTransition(fresh.status, "approved");
+      const active = await this.store.findActivePlan(fresh.namespace);
+      if (active && active.id !== id) {
+        throw new ActivePlanExistsError(fresh.namespace, active.id);
+      }
+      return this.rewrite(fresh, { status: "approved", approvedAt: now });
+    });
   }
-  if (output.tokens.essentialOmitted === 0) delete output.tokens.warning;
-  account(output);
-  return output;
-}
-function compactSafety(value) {
-  if (!value || typeof value !== "object") return value;
-  const item = value;
-  return {
-    ...item,
-    ...typeof item.reason === "string" ? { reason: compact(item.reason, 100) } : {},
-    ...typeof item.summary === "string" ? { summary: compact(item.summary, 100) } : {},
-    ...Array.isArray(item.evidence) ? { evidence: item.evidence.slice(0, 1).map((entry) => compact(entry, 100)) } : {}
-  };
-}
-function compact(value, limit) {
-  if (typeof value === "string")
-    return value.length > limit ? `${value.slice(0, limit - 1)}\u2026` : value;
-  if (Array.isArray(value)) return value.slice(0, 3).map((item) => compact(item, limit));
-  if (value && typeof value === "object")
-    return Object.fromEntries(
-      Object.entries(value).map(([key, item]) => [key, compact(item, limit)])
-    );
-  return value;
-}
-function account(output) {
-  const tokens = output.tokens;
-  const set = (count) => {
-    tokens.returnedEstimate = count;
-    tokens.countedSurface = "compact_json";
-    tokens.status = count > tokens.budget ? "overflow" : tokens.essentialOmitted > 0 ? "minimum_envelope" : "within_budget";
-    if (tokens.status === "overflow") tokens.warning = WARNING;
-  };
-  for (let padding = 0; padding < 32; padding++) {
-    if (padding > 0) output.accountingPadding = " ".repeat(padding);
-    let count = estimateTokens(output);
-    for (let attempt = 0; attempt < 12; attempt++) {
-      set(count);
-      const measured = estimateTokens(output);
-      if (measured === count) return count;
-      count = measured;
+  async start(id, now = (/* @__PURE__ */ new Date()).toISOString()) {
+    const current = await this.require(id);
+    return this.store.withNamespaceLock(current.namespace, async () => {
+      const fresh = await this.require(id);
+      this.assertTransition(fresh.status, "executing");
+      return this.rewrite(fresh, { status: "executing", executingAt: now });
+    });
+  }
+  async complete(id, options = {}, now = (/* @__PURE__ */ new Date()).toISOString()) {
+    const current = await this.require(id);
+    return this.store.withNamespaceLock(current.namespace, async () => {
+      const fresh = await this.require(id);
+      this.assertTransition(fresh.status, "complete");
+      return this.rewrite(fresh, {
+        status: "complete",
+        completedAt: now,
+        ...options.commitSha !== void 0 ? { commitSha: options.commitSha } : {}
+      });
+    });
+  }
+  async abandon(id, options = {}, now = (/* @__PURE__ */ new Date()).toISOString()) {
+    const current = await this.require(id);
+    return this.store.withNamespaceLock(current.namespace, async () => {
+      const fresh = await this.require(id);
+      this.assertTransition(fresh.status, "abandoned");
+      return this.rewrite(fresh, {
+        status: "abandoned",
+        abandonedAt: now,
+        ...options.reason !== void 0 ? { abandonReason: options.reason } : {}
+      });
+    });
+  }
+  async amend(id, patch) {
+    await this.assertPathsInside(patch);
+    const current = await this.require(id);
+    return this.store.withNamespaceLock(current.namespace, async () => {
+      const fresh = await this.require(id);
+      if (!AMENDABLE.includes(fresh.status)) {
+        throw new Error(
+          `Plan ${id} is ${fresh.status}; only draft or executing plans can be amended.`
+        );
+      }
+      return this.rewrite(fresh, {
+        ...patch.title !== void 0 ? { title: patch.title } : {},
+        ...patch.brief !== void 0 ? { brief: patch.brief } : {},
+        ...patch.filesToTouch !== void 0 ? { filesToTouch: patch.filesToTouch } : {},
+        ...patch.testsToAdd !== void 0 ? { testsToAdd: patch.testsToAdd } : {},
+        ...patch.outOfScope !== void 0 ? { outOfScope: patch.outOfScope } : {},
+        ...patch.risks !== void 0 ? { risks: patch.risks } : {},
+        ...patch.body !== void 0 ? { body: patch.body } : {}
+      });
+    });
+  }
+  /** Plan paths flow into risk, context and file reads; none may leave the repository. */
+  async assertPathsInside(input) {
+    for (const { path } of [...input.filesToTouch ?? [], ...input.testsToAdd ?? []]) {
+      if (await containedRepoPath(this.store.repositoryRoot, path) === null) {
+        throw new Error(`Plan path is outside the repository: ${path}`);
+      }
     }
   }
-  throw new Error("Could not stabilize compact context token accounting");
-}
-
-// src/context/delivery.ts
-var DELIVERY_VERSION = 1;
-var OMITTABLE_SECTIONS = [
-  "plan",
-  "policyRules",
-  "incidents",
-  "facts",
-  "rules",
-  "handoffs",
-  "architecture",
-  "symbols",
-  "neighbours"
-];
-var SESSION_TTL_MS = 30 * 60 * 1e3;
-async function applySessionDelivery(repositoryRoot, payload, options) {
-  let output = { ...payload };
-  if (!options.sessionId) return output;
-  const sections = OMITTABLE_SECTIONS.filter((key) => output[key] !== void 0).map((key) => ({
-    key: `mcp:${key}`,
-    hash: createHash2("sha256").update(JSON.stringify(output[key])).digest("hex")
-  }));
-  try {
-    await new SessionCapsuleLedger(repositoryRoot).exchange(options.sessionId, sections, {
-      ...options.ack !== void 0 ? { ack: options.ack } : {},
-      ttlMs: SESSION_TTL_MS,
-      ...options.full ? { full: true } : {},
-      prepare: (exchange) => {
-        const unchanged = exchange.unchanged.map((key) => key.slice("mcp:".length));
-        let avoidedTokens = 0;
-        for (const key of unchanged) {
-          avoidedTokens += estimateTokens(output[key]);
-          delete output[key];
-        }
-        const delivery = {
-          version: DELIVERY_VERSION,
-          sessionId: options.sessionId,
-          deliveryId: exchange.deliveryId,
-          ack: exchange.ack,
-          unchanged,
-          avoidedTokens,
-          note: "Pass deliveryId as ack. Use full=true after losing context."
-        };
-        output.delivery = delivery;
-        output = enforceContextBudget(output);
-        return OMITTABLE_SECTIONS.filter((key) => output[key] !== void 0).map((key) => ({
-          key: `mcp:${key}`,
-          hash: createHash2("sha256").update(JSON.stringify(output[key])).digest("hex")
-        }));
+  async current(namespace) {
+    return this.store.findActivePlan(namespace);
+  }
+  assertTransition(from, to) {
+    if (!TRANSITIONS[from].includes(to)) {
+      throw new PlanTransitionError(from, to);
+    }
+  }
+  async require(id) {
+    try {
+      return await this.store.readPlan(id);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new PlanNotFoundError(id);
       }
+      throw error;
+    }
+  }
+  /** Rewrite the plan file with a partial set of changed fields. */
+  async rewrite(plan, changes) {
+    const next = { ...plan, ...changes };
+    await this.store.writePlan({
+      id: next.id,
+      namespace: next.namespace,
+      title: next.title,
+      status: next.status,
+      brief: next.brief,
+      filesToTouch: next.filesToTouch,
+      testsToAdd: next.testsToAdd,
+      outOfScope: next.outOfScope,
+      risks: next.risks,
+      createdAt: next.createdAt,
+      createdByAgent: next.createdByAgent,
+      approvedAt: next.approvedAt,
+      executingAt: next.executingAt,
+      completedAt: next.completedAt,
+      abandonedAt: next.abandonedAt,
+      commitSha: next.commitSha,
+      abandonReason: next.abandonReason,
+      body: next.body
     });
-    return output;
-  } catch {
-    return enforceContextBudget({ ...payload });
+    return this.store.readPlan(next.id);
   }
-}
-
-// src/context/engine.ts
-import { execFile } from "child_process";
-import { readFile as readFile4 } from "fs/promises";
-import { join as join4, resolve as resolve5 } from "path";
-import { promisify } from "util";
+};
 
 // src/worklog/store.ts
-import { createHash as createHash3 } from "crypto";
-import { mkdir as mkdir2, readdir as readdir2, readFile as readFile3, stat as stat2 } from "fs/promises";
-import { dirname as dirname2, join as join3, relative as relative3, resolve as resolve4, sep as sep3 } from "path";
+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 { parse as parseYaml3, stringify as stringifyYaml2 } from "yaml";
 import { z as z3 } from "zod";
 var LIMITS = {
@@ -1375,7 +1039,7 @@ var WorklogStore = class {
     const files = [...new Set((input.files ?? []).map(normalizePath3))].filter(Boolean).sort().slice(0, LIMITS.files);
     const summary = boundSummary(input.summary, files);
     const verification = (input.verification ?? []).map((line) => line.trim().slice(0, LIMITS.verificationChars)).filter((line) => line && !scanSensitive(line).sensitive).slice(0, LIMITS.verification);
-    const fingerprint = createHash3("sha256").update(
+    const fingerprint = createHash("sha256").update(
       JSON.stringify({
         namespace: input.namespace.trim().toLowerCase(),
         session: input.sessionId ?? null,
@@ -1387,7 +1051,7 @@ var WorklogStore = class {
     if (existing) return existing.id;
     const id = generateEntityId("wlg", now.getTime());
     const path = this.entryPath(id);
-    await assertNoSymlinkBetween(this.repositoryRoot, dirname2(path));
+    await assertNoSymlinkBetween(this.repositoryRoot, dirname3(path));
     await mkdir2(this.directory, { recursive: true, mode: 448 });
     const frontMatter = stringifyYaml2({
       schemaVersion: 1,
@@ -1410,7 +1074,7 @@ var WorklogStore = class {
   async read(id) {
     const path = this.entryPath(id);
     await assertNoSymlinkBetween(this.repositoryRoot, path);
-    const parsed = parseFrontMatter(await readFile3(path, "utf8"));
+    const parsed = parseFrontMatter(await readFile4(path, "utf8"));
     return {
       ...entrySchema.parse(parseYaml3(parsed.frontMatter)),
       summary: parsed.content.trim(),
@@ -1522,90 +1186,221 @@ function words(text) {
   return new Set(text.toLowerCase().match(/[a-z0-9_]{4,}/g) ?? []);
 }
 
-// src/context/engine.ts
-var LIMITS2 = {
-  bootstrapIncidents: 5,
-  beforeEditIncidents: 8,
-  policyRules: 5,
-  hotspots: 5,
-  neighbourPaths: 10,
-  neighbourEdges: 10,
-  incidentSummaryChars: 140,
-  symbolFiles: TASK_PATH_LIMIT,
-  symbolsPerFile: 12,
-  spanFiles: 3,
-  excerptLines: 6,
-  excerptCharsPerSpan: 400,
-  excerptChars: 1200,
-  relevantFacts: 5
-};
-var DEFAULT_TOKEN_BUDGET = 4e3;
-var MAX_DIFF_FILES = 8;
-var MAX_DIFF_CHARS_PER_FILE = 2400;
-var execFileAsync = promisify(execFile);
-async function buildBootstrapContext(input) {
-  const repositoryRoot = resolve5(input.repositoryRoot ?? process.cwd());
-  const namespace = input.namespace;
-  const planStore = new PlanFileStore(repositoryRoot);
-  const memoryStore = new MemoryFileStore(repositoryRoot);
-  const freshPromise = loadFreshIndex(repositoryRoot);
-  const manifestPromise = freshPromise.then((fresh2) => fresh2.manifest);
-  const mapPromise = loadProjectArchitectureMap(repositoryRoot, manifestPromise);
-  const [activePlan, policy, policyFile, incidents, facts, fresh, map, handoffs] = await Promise.all([
-    new PlanLifecycle(planStore).current(namespace),
-    loadPlanPolicy(repositoryRoot),
-    readPolicyFile(join4(repositoryRoot, ".codebuddy", "policies.yaml")),
-    memoryStore.listIncidentFacts({ namespace }),
-    memoryStore.listFacts(),
-    freshPromise,
-    mapPromise,
-    recallHandoffs(repositoryRoot, { namespace })
-  ]);
-  const explain = [fresh.explain];
-  const plan = summarizePlan(activePlan);
-  explain.push(plan ? `plan: active plan ${plan.id} (${plan.status})` : "plan: no active plan");
-  explain.push(`policy: plan policy is "${policy}"`);
-  const policyRules = summarizePolicyRules(policyFile.rules);
-  if (policyRules.length > 0) explain.push(`policyRules: ${policyRules.length} rule(s) by weight`);
-  const incidentSummaries = sortIncidents(incidents).slice(0, LIMITS2.bootstrapIncidents).map(summarizeIncident);
-  if (incidentSummaries.length > 0) {
-    explain.push(`incidents: ${incidentSummaries.length} unresolved incident hotspot(s)`);
-  }
-  const architecture = summarizeArchitecture(map);
-  explain.push(
-    `architecture: ${architecture.moduleCount} module(s), ${architecture.edgeCount} edge(s)` + (map.source ? ` (${map.source})` : "")
-  );
-  const rules = selectRules(facts, namespace);
-  if (rules.length > 0) {
-    const procedures = rules.filter((rule) => rule.subject === "procedure").length;
-    explain.push(`rules: ${rules.length - procedures} rule(s), ${procedures} procedure(s)`);
-  }
-  const bootstrapFacts = await rankRelevantFacts(
-    facts.filter((fact) => !STANDING_PREDICATES.has(fact.predicate)),
-    namespace,
-    "",
-    []
-  );
-  explainHandoffs(explain, handoffs);
-  const assembled = {
-    project: { namespace, root: repositoryRoot },
-    plan,
-    policy,
-    policyRules,
-    incidents: incidentSummaries,
-    facts: bootstrapFacts,
-    rules,
-    handoffs,
-    architecture,
-    explain
+// src/context/budget.ts
+var WARNING = "Context incomplete: inspect omitted policies, risks and incidents before editing.";
+function enforceContextBudget(input) {
+  const output = structuredClone(input);
+  if (!output.tokens) return input;
+  output.tokens.essentialOmitted ??= 0;
+  if (account(output) <= output.tokens.budget) return output;
+  const candidates = [];
+  const add = (section, value, priority, essential = false) => {
+    candidates.push({ section, value, priority, essential });
   };
-  const tokens = buildTokenStats(assembled, input.tokenBudget);
-  return enforceContextBudget({ ...assembled, tokens });
-}
-async function buildBeforeEditContext(input) {
-  const repositoryRoot = resolve5(input.repositoryRoot ?? process.cwd());
-  const namespace = input.namespace;
-  const hasExplicitTargets = (input.paths?.length ?? 0) > 0 || input.planId !== void 0;
+  for (const [section, priority] of [
+    ["diffs", 10],
+    ["neighbours", 20],
+    ["handoffs", 30],
+    ["facts", 40],
+    ["rules", 45],
+    ["symbols", 50],
+    ["policyRules", 90],
+    ["incidents", 80]
+  ]) {
+    const values = output[section];
+    if (!Array.isArray(values)) continue;
+    for (const value of values) {
+      const essential = section === "policyRules" || section === "incidents" && !value.resolved;
+      const severity = section === "incidents" ? { critical: 4, high: 3, medium: 2, low: 1 }[value.severity] ?? 0 : 0;
+      add(section, value, priority + severity, essential);
+    }
+    output[section] = [];
+  }
+  const risks = output.risks;
+  if (risks) {
+    for (const value of risks.items)
+      add(
+        "risks",
+        value,
+        value.score >= 50 ? 100 + value.score : 60 + value.score / 100,
+        value.score > 0
+      );
+    risks.items = [];
+  }
+  if (output.plan) {
+    add("plan", output.plan, 55);
+    output.plan = null;
+  }
+  const architecture = output.architecture;
+  if (architecture) {
+    for (const value of architecture.hotspots) add("hotspots", value, 25);
+    architecture.hotspots = [];
+  }
+  output.explain = [];
+  if (typeof output.task === "string") output.task = compact(output.task, 160);
+  const riskStats = output.risks?.stats;
+  if (riskStats) riskStats.perSignal = [];
+  const previousOmitted = output.tokens.essentialOmitted;
+  output.tokens.essentialOmitted = previousOmitted + candidates.filter((c) => c.essential).length;
+  output.tokens.warning = WARNING;
+  if (account(output) > output.tokens.budget && output.task) output.task = null;
+  if (estimateTokens({ project: output.project, targetPaths: output.targetPaths }) > output.tokens.budget) {
+    account(output);
+    return output;
+  }
+  candidates.sort((a, b) => b.priority - a.priority);
+  for (const candidate of candidates) {
+    const insert = (value) => {
+      if (candidate.section === "plan") output.plan = value;
+      else if (candidate.section === "risks") risks?.items.push(value);
+      else if (candidate.section === "hotspots") architecture?.hotspots.push(value);
+      else output[candidate.section].push(value);
+    };
+    const remove = () => {
+      if (candidate.section === "plan") output.plan = null;
+      else if (candidate.section === "risks") risks?.items.pop();
+      else if (candidate.section === "hotspots") architecture?.hotspots.pop();
+      else output[candidate.section].pop();
+    };
+    insert(candidate.value);
+    if (candidate.essential) output.tokens.essentialOmitted--;
+    if (account(output) <= output.tokens.budget) continue;
+    remove();
+    if (candidate.essential) output.tokens.essentialOmitted++;
+    const smaller = candidate.essential ? compactSafety(candidate.value) : compact(candidate.value, 100);
+    insert(smaller);
+    if (account(output) <= output.tokens.budget) continue;
+    remove();
+  }
+  if (output.tokens.essentialOmitted === 0) delete output.tokens.warning;
+  account(output);
+  return output;
+}
+function compactSafety(value) {
+  if (!value || typeof value !== "object") return value;
+  const item = value;
+  return {
+    ...item,
+    ...typeof item.reason === "string" ? { reason: compact(item.reason, 100) } : {},
+    ...typeof item.summary === "string" ? { summary: compact(item.summary, 100) } : {},
+    ...Array.isArray(item.evidence) ? { evidence: item.evidence.slice(0, 1).map((entry) => compact(entry, 100)) } : {}
+  };
+}
+function compact(value, limit) {
+  if (typeof value === "string")
+    return value.length > limit ? `${value.slice(0, limit - 1)}\u2026` : value;
+  if (Array.isArray(value)) return value.slice(0, 3).map((item) => compact(item, limit));
+  if (value && typeof value === "object")
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [key, compact(item, limit)])
+    );
+  return value;
+}
+function account(output) {
+  const tokens = output.tokens;
+  const set = (count) => {
+    tokens.returnedEstimate = count;
+    tokens.countedSurface = "compact_json";
+    tokens.status = count > tokens.budget ? "overflow" : tokens.essentialOmitted > 0 ? "minimum_envelope" : "within_budget";
+    if (tokens.status === "overflow") tokens.warning = WARNING;
+  };
+  for (let padding = 0; padding < 32; padding++) {
+    if (padding > 0) output.accountingPadding = " ".repeat(padding);
+    let count = estimateTokens(output);
+    for (let attempt = 0; attempt < 12; attempt++) {
+      set(count);
+      const measured = estimateTokens(output);
+      if (measured === count) return count;
+      count = measured;
+    }
+  }
+  throw new Error("Could not stabilize compact context token accounting");
+}
+
+// src/context/engine.ts
+var LIMITS2 = {
+  bootstrapIncidents: 5,
+  beforeEditIncidents: 8,
+  policyRules: 5,
+  hotspots: 5,
+  neighbourPaths: 10,
+  neighbourEdges: 10,
+  incidentSummaryChars: 140,
+  symbolFiles: TASK_PATH_LIMIT,
+  symbolsPerFile: 12,
+  spanFiles: 3,
+  excerptLines: 6,
+  excerptCharsPerSpan: 400,
+  excerptChars: 1200,
+  relevantFacts: 5
+};
+var DEFAULT_TOKEN_BUDGET = 4e3;
+var MAX_DIFF_FILES = 8;
+var MAX_DIFF_CHARS_PER_FILE = 2400;
+var execFileAsync = promisify(execFile);
+async function buildBootstrapContext(input) {
+  const repositoryRoot = resolve5(input.repositoryRoot ?? process.cwd());
+  const namespace = input.namespace;
+  const planStore = new PlanFileStore(repositoryRoot);
+  const memoryStore = new MemoryFileStore(repositoryRoot);
+  const freshPromise = loadFreshIndex(repositoryRoot);
+  const manifestPromise = freshPromise.then((fresh2) => fresh2.manifest);
+  const mapPromise = loadProjectArchitectureMap(repositoryRoot, manifestPromise);
+  const [activePlan, policy, policyFile, incidents, facts, fresh, map, handoffs] = await Promise.all([
+    new PlanLifecycle(planStore).current(namespace),
+    loadPlanPolicy(repositoryRoot),
+    readPolicyFile(join4(repositoryRoot, ".codebuddy", "policies.yaml")),
+    memoryStore.listIncidentFacts({ namespace }),
+    memoryStore.listFacts(),
+    freshPromise,
+    mapPromise,
+    recallHandoffs(repositoryRoot, { namespace })
+  ]);
+  const explain = [fresh.explain];
+  const plan = summarizePlan(activePlan);
+  explain.push(plan ? `plan: active plan ${plan.id} (${plan.status})` : "plan: no active plan");
+  explain.push(`policy: plan policy is "${policy}"`);
+  const policyRules = summarizePolicyRules(policyFile.rules);
+  if (policyRules.length > 0) explain.push(`policyRules: ${policyRules.length} rule(s) by weight`);
+  const incidentSummaries = sortIncidents(incidents).slice(0, LIMITS2.bootstrapIncidents).map(summarizeIncident);
+  if (incidentSummaries.length > 0) {
+    explain.push(`incidents: ${incidentSummaries.length} unresolved incident hotspot(s)`);
+  }
+  const architecture = summarizeArchitecture(map);
+  explain.push(
+    `architecture: ${architecture.moduleCount} module(s), ${architecture.edgeCount} edge(s)` + (map.source ? ` (${map.source})` : "")
+  );
+  const rules = selectRules(facts, namespace);
+  if (rules.length > 0) {
+    const procedures = rules.filter((rule) => rule.subject === "procedure").length;
+    explain.push(`rules: ${rules.length - procedures} rule(s), ${procedures} procedure(s)`);
+  }
+  const bootstrapFacts = await rankRelevantFacts(
+    facts.filter((fact) => !STANDING_PREDICATES.has(fact.predicate)),
+    namespace,
+    "",
+    []
+  );
+  explainHandoffs(explain, handoffs);
+  const assembled = {
+    project: { namespace, root: repositoryRoot },
+    plan,
+    policy,
+    policyRules,
+    incidents: incidentSummaries,
+    facts: bootstrapFacts,
+    rules,
+    handoffs,
+    architecture,
+    explain
+  };
+  const tokens = buildTokenStats(assembled, input.tokenBudget);
+  return enforceContextBudget({ ...assembled, tokens });
+}
+async function buildBeforeEditContext(input) {
+  const repositoryRoot = resolve5(input.repositoryRoot ?? process.cwd());
+  const namespace = input.namespace;
+  const hasExplicitTargets = (input.paths?.length ?? 0) > 0 || input.planId !== void 0;
   const fresh = await loadFreshIndex(repositoryRoot);
   const manifest = fresh.manifest;
   const resolvedPaths = await resolveRiskPaths({
@@ -1617,11 +1412,13 @@ async function buildBeforeEditContext(input) {
   const mapPromise = loadProjectArchitectureMap(repositoryRoot, manifest);
   const discovery = !hasExplicitTargets && input.task ? await discoverTaskPaths(repositoryRoot, input.task, manifest, mapPromise) : { paths: [], hits: [], explain: [] };
   const taskPaths = discovery.paths;
-  const targetPaths = hasExplicitTargets ? resolvedPaths : taskPaths.length > 0 ? taskPaths : resolvedPaths;
+  const askedTask = Boolean(input.task?.trim());
+  const targetPaths = hasExplicitTargets ? resolvedPaths : taskPaths.length > 0 ? taskPaths : askedTask && input.useGit !== true ? [] : resolvedPaths;
   const discoveredFromTask = taskPaths.length > 0;
   const pathSource = classifyPathSource(input, targetPaths.length, discoveredFromTask);
   const planStore = new PlanFileStore(repositoryRoot);
   const memoryStore = new MemoryFileStore(repositoryRoot);
+  const knownSecrets = await loadKnownSecretValues(repositoryRoot);
   const [referencedPlan, policy, policyFile, incidents, facts, risks, map, diffs, handoffs] = await Promise.all([
     resolveRelevantPlan(planStore, namespace, input.planId),
     loadPlanPolicy(repositoryRoot),
@@ -1636,7 +1433,7 @@ async function buildBeforeEditContext(input) {
       useGit: !hasExplicitTargets && input.useGit !== false
     }),
     mapPromise,
-    input.useGit === false ? Promise.resolve([]) : readGitDiffs(repositoryRoot, targetPaths),
+    input.useGit === false ? Promise.resolve([]) : readGitDiffs(repositoryRoot, targetPaths, knownSecrets),
     recallHandoffs(repositoryRoot, {
       namespace,
       paths: targetPaths,
@@ -1652,6 +1449,11 @@ async function buildBeforeEditContext(input) {
     );
   }
   explain.push(...discovery.explain);
+  if (askedTask && !hasExplicitTargets && taskPaths.length === 0) {
+    explain.push(
+      targetPaths.length > 0 ? "paths: no file matched the task; useGit asked for the uncommitted changes instead" : "paths: no file matched the task; none returned rather than unrelated changes"
+    );
+  }
   const plan = summarizePlan(referencedPlan);
   if (plan) explain.push(`plan: ${plan.id} (${plan.status})`);
   const policyRules = summarizeMatchingPolicyRules(policyFile.rules, targetPaths);
@@ -1663,10 +1465,10 @@ async function buildBeforeEditContext(input) {
     explain.push(`incidents: ${incidentSummaries.length} incident(s) touch target paths`);
   }
   if (risks.items.length > 0) explain.push(`risks: ${risks.items.length} scored path(s)`);
-  const neighbours2 = computeNeighbours(map, targetPaths);
-  if (neighbours2.length > 0)
+  const neighbours = computeNeighbours(map, targetPaths);
+  if (neighbours.length > 0)
     explain.push(
-      `neighbours: import graph for ${neighbours2.length} file(s)` + (map.source ? ` (${map.source})` : "")
+      `neighbours: import graph for ${neighbours.length} file(s)` + (map.source ? ` (${map.source})` : "")
     );
   const symbols = await computeTargetSymbols(
     repositoryRoot,
@@ -1674,7 +1476,8 @@ async function buildBeforeEditContext(input) {
     input.task ?? "",
     discovery.hits,
     "symbols" in discovery ? discovery.symbols ?? {} : {},
-    input.evidence ?? "overview"
+    input.evidence ?? "overview",
+    knownSecrets
   );
   if (symbols.length > 0) {
     const spans = symbols.reduce((total, file) => total + (file.spans?.length ?? 0), 0);
@@ -1720,7 +1523,7 @@ async function buildBeforeEditContext(input) {
     facts: relevantFacts,
     handoffs,
     risks,
-    neighbours: neighbours2,
+    neighbours,
     symbols,
     tests,
     testCommand,
@@ -1841,7 +1644,7 @@ function computeNeighbours(map, paths) {
   }
   return result;
 }
-async function computeTargetSymbols(repositoryRoot, targetPaths, task, hits, picked = {}, evidence = "overview") {
+async function computeTargetSymbols(repositoryRoot, targetPaths, task, hits, picked = {}, evidence = "overview", knownSecrets = []) {
   const terms = taskTerms(task);
   const tokens = identifierTokens(task);
   const result = [];
@@ -1850,9 +1653,9 @@ async function computeTargetSymbols(repositoryRoot, targetPaths, task, hits, pic
   for (const path of targetPaths.slice(0, LIMITS2.symbolFiles)) {
     const source = await readBoundedSource(repositoryRoot, path);
     if (source === null) continue;
-    const lines = source.split(/\r?\n/);
+    const lines = redactSourceText(source, knownSecrets).split(/\r?\n/);
     const fileHits = hits.filter((hit2) => hit2.path === path && hit2.endLine <= lines.length);
-    const table = supportsSymbols(path) ? extractSymbolTable(source) : [];
+    const table = supportsSymbols(path) ? extractSymbolTable(source, path) : [];
     const credited = /* @__PURE__ */ new Map();
     for (const hit2 of fileHits) {
       const owner = table.filter((symbol) => hit2.startLine <= symbol.endLine && hit2.endLine >= symbol.startLine).sort(
@@ -1868,7 +1671,9 @@ async function computeTargetSymbols(repositoryRoot, targetPaths, task, hits, pic
     }).sort(
       (left, right) => right.score - left.score || left.symbol.startLine - right.symbol.startLine
     );
-    const signatures = ranked.filter(({ symbol, score }) => symbol.kind !== "method" || score > 0).slice(0, LIMITS2.symbolsPerFile).map(({ symbol }) => symbol.signature);
+    const signatures = ranked.filter(({ symbol, score }) => symbol.kind !== "method" || score > 0).slice(0, LIMITS2.symbolsPerFile).map(
+      ({ symbol }) => lines[symbol.startLine - 1] === REDACTED_LINE ? REDACTED_LINE : redactSourceText(symbol.signature, knownSecrets)
+    );
     const best = ranked[0]?.score ? ranked[0] : void 0;
     const hit = best ? best.hit : fileHits[0];
     const range = best?.symbol ?? hit;
@@ -1937,20 +1742,38 @@ 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) {
+async function readGitDiffs(repositoryRoot, paths, knownSecrets = []) {
   if (paths.length === 0) return [];
   const sections = [];
   try {
     const { stdout } = await execFileAsync(
       "git",
-      ["diff", "HEAD", "--no-ext-diff", "--unified=3", "--", ...paths],
+      [
+        "-c",
+        "core.quotePath=false",
+        "diff",
+        "HEAD",
+        "--no-ext-diff",
+        "--unified=3",
+        "--",
+        ...paths
+      ],
       { cwd: repositoryRoot, maxBuffer: 2e6 }
     );
     sections.push(stdout);
   } catch {
     for (const args of [
-      ["diff", "--cached", "--no-ext-diff", "--unified=3", "--", ...paths],
-      ["diff", "--no-ext-diff", "--unified=3", "--", ...paths]
+      [
+        "-c",
+        "core.quotePath=false",
+        "diff",
+        "--cached",
+        "--no-ext-diff",
+        "--unified=3",
+        "--",
+        ...paths
+      ],
+      ["-c", "core.quotePath=false", "diff", "--no-ext-diff", "--unified=3", "--", ...paths]
     ]) {
       try {
         const { stdout } = await execFileAsync("git", args, {
@@ -1962,21 +1785,59 @@ async function readGitDiffs(repositoryRoot, paths) {
       }
     }
   }
-  const parsed = parseGitDiff(sections.join("\n"));
+  const parsed = parseGitDiff(sections.join("\n"), knownSecrets);
   const known = new Set(parsed.map((diff) => diff.path));
   const untracked = await listUntrackedPaths(repositoryRoot, paths);
   for (const path of untracked) {
     if (known.has(path)) continue;
-    const patch = await buildUntrackedPatch(repositoryRoot, path);
+    const patch = isCredentialPath(path) ? withheldPatch(path) : await buildUntrackedPatch(repositoryRoot, path, knownSecrets);
     if (patch) parsed.push(patch);
   }
   return parsed.slice(0, MAX_DIFF_FILES);
 }
-function parseGitDiff(diff) {
+function diffHeaderPaths(section) {
+  const quoted = '"(?:[^"\\\\]|\\\\.)*"';
+  const header = new RegExp(`^diff --git (${quoted}|a/.+?) (${quoted}|b/.+?)\\n`, "m").exec(
+    section
+  );
+  if (!header?.[1] || !header[2]) return null;
+  const path = (raw) => (raw.startsWith('"') ? unquoteGitPath(raw) : raw).slice(2);
+  return [header[0], path(header[1]), path(header[2])];
+}
+var C_ESCAPES = { a: 7, b: 8, t: 9, n: 10, v: 11, f: 12, r: 13 };
+function unquoteGitPath(raw) {
+  const bytes = [];
+  const body = raw.slice(1, -1);
+  for (let at = 0; at < body.length; at++) {
+    const char = body[at];
+    if (char !== "\\") {
+      bytes.push(...Buffer.from(char, "utf8"));
+      continue;
+    }
+    const next = body[++at] ?? "";
+    const octal = /^[0-7]{3}/.exec(body.slice(at))?.[0];
+    if (octal) {
+      bytes.push(Number.parseInt(octal, 8));
+      at += 2;
+    } else bytes.push(C_ESCAPES[next] ?? next.charCodeAt(0));
+  }
+  return Buffer.from(bytes).toString("utf8");
+}
+function withheldPatch(path) {
+  return {
+    path,
+    patch: `diff --git a/${path} b/${path}
+(contents withheld: credential file)`
+  };
+}
+function parseGitDiff(diff, knownSecrets = []) {
   return diff.split(/(?=^diff --git )/m).filter((section) => section.startsWith("diff --git ")).flatMap((section) => {
-    const header = section.match(/^diff --git a\/(.+?) b\/(.+?)\n/m);
+    const header = diffHeaderPaths(section);
     if (!header?.[2]) return [];
-    const rawPatch = section.trim();
+    if (isCredentialPath(header[1] ?? "") || isCredentialPath(header[2])) {
+      return [withheldPatch(header[2])];
+    }
+    const rawPatch = redactSourceText(section.trim(), knownSecrets, true);
     const patch = rawPatch.slice(0, MAX_DIFF_CHARS_PER_FILE).trim();
     return patch ? [
       {
@@ -1991,20 +1852,20 @@ async function listUntrackedPaths(repositoryRoot, paths) {
   try {
     const { stdout } = await execFileAsync(
       "git",
-      ["ls-files", "--others", "--exclude-standard", "--", ...paths],
+      ["ls-files", "-z", "--others", "--exclude-standard", "--", ...paths],
       { cwd: repositoryRoot, maxBuffer: 1e6 }
     );
-    return stdout.split(/\r?\n/).map((path) => path.trim()).filter(Boolean);
+    return stdout.split("\0").filter(Boolean);
   } catch {
     return [];
   }
 }
-async function buildUntrackedPatch(repositoryRoot, path) {
+async function buildUntrackedPatch(repositoryRoot, path, knownSecrets) {
   try {
-    const content = await readFile4(join4(repositoryRoot, path), "utf8");
-    if (content.includes("\0")) return null;
+    const content = await readBoundedSource(repositoryRoot, path);
+    if (content === null) return null;
     const lines = content.split(/\r?\n/);
-    const body = lines.map((line) => `+${line}`).join("\n");
+    const body = redactSourceText(lines.map((line) => `+${line}`).join("\n"), knownSecrets, true);
     const rawPatch = [
       `diff --git a/${path} b/${path}`,
       "new file mode 100644",
@@ -2025,8 +1886,10 @@ async function buildUntrackedPatch(repositoryRoot, path) {
 }
 var STANDING_PREDICATES = /* @__PURE__ */ new Set(["rule", "procedure"]);
 var STANDING_LIMITS = { rule: 5, procedure: 3, chars: 200 };
+var SHELL_CONTROL = /[;&|`$<>\n\r]/;
 function selectRules(facts, namespace) {
-  const newest = (predicate) => facts.filter((fact) => fact.predicate === predicate && isEligibleMemory(fact, { namespace })).sort((left, right) => right.createdAt.localeCompare(left.createdAt)).slice(0, STANDING_LIMITS[predicate]);
+  const latest = new Date(Date.now() + 864e5).toISOString();
+  const newest = (predicate) => facts.filter((fact) => fact.predicate === predicate && isEligibleMemory(fact, { namespace })).filter((fact) => fact.createdAt <= latest).filter((fact) => predicate !== "procedure" || !SHELL_CONTROL.test(fact.object)).sort((left, right) => right.createdAt.localeCompare(left.createdAt)).slice(0, STANDING_LIMITS[predicate]);
   return [...newest("rule"), ...newest("procedure")].map((fact) => ({
     id: fact.id,
     subject: fact.predicate,
@@ -2046,11 +1909,27 @@ async function rankRelevantFacts(facts, namespace, task, targetPaths, semanticRa
   const incidentText = new Set(
     eligible.filter((fact) => fact.category === "incident").map((fact) => normalizeText(fact.content || fact.object))
   );
-  const candidates = eligible.filter((fact) => fact.category !== "incident").filter((fact) => !incidentText.has(normalizeText(fact.content || fact.object))).map((fact) => {
+  const terms = lexicalTerms(task).filter((term) => term.length > 2);
+  const withTerms = eligible.filter((fact) => fact.category !== "incident").filter((fact) => !incidentText.has(normalizeText(fact.content || fact.object))).map((fact) => {
     const text = `${fact.subject} ${fact.predicate} ${fact.object} ${fact.content}`;
-    const taskScore = relevanceScore(text, task);
+    const words2 = new Set(text.toLowerCase().match(/[\p{L}\p{N}_]+/gu) ?? []);
+    return { fact, text, shared: terms.filter((term) => words2.has(term)) };
+  });
+  const documentFrequency = new Map(
+    terms.map((term) => [term, withTerms.filter(({ shared }) => shared.includes(term)).length])
+  );
+  const candidates = withTerms.map(({ fact, text, shared }) => {
+    const taskScore = shared.length * 3;
     const pathScore = fact.paths.some((path) => targetPaths.includes(path)) ? 5 : 0;
-    return { fact, text, taskScore, pathScore, lexical: taskScore + pathScore };
+    const admitted = admitsLexically(shared, documentFrequency, withTerms.length);
+    return {
+      fact,
+      text,
+      taskScore,
+      pathScore,
+      admitted,
+      lexical: (admitted ? taskScore : 0) + pathScore
+    };
   });
   const summarize = (fact, relevance, reason) => ({
     id: fact.id,
@@ -2126,10 +2005,10 @@ async function rankRelevantFacts(facts, namespace, task, targetPaths, semanticRa
     }
     selected.push(candidate);
   }
-  return selected.map(({ fact, taskScore, pathScore, score }) => {
+  return selected.map(({ fact, taskScore, pathScore, score, admitted }) => {
     const evidence = [
       pathScore > 0 ? "matches a target path" : "",
-      taskScore > 0 ? `shares ${taskScore / 3} task term(s)` : "",
+      admitted && taskScore > 0 ? `shares ${taskScore / 3} task term(s)` : "",
       cosine(fact.id) !== void 0 ? `semantic ${cosine(fact.id)?.toFixed(2)}` : ""
     ].filter(Boolean);
     return summarize(
@@ -2140,12 +2019,6 @@ async function rankRelevantFacts(facts, namespace, task, targetPaths, semanticRa
     );
   });
 }
-function relevanceScore(value, task) {
-  const terms = lexicalTerms(task).filter((term) => term.length > 2);
-  if (terms.length === 0) return 0;
-  const haystack = new Set(value.toLowerCase().match(/[\p{L}\p{N}_]+/gu) ?? []);
-  return terms.filter((term) => haystack.has(term)).length * 3;
-}
 function normalizeText(value) {
   return value.toLowerCase().replace(/[^a-z0-9_./-]+/g, " ").trim();
 }
@@ -2170,13 +2043,8 @@ function truncate(value, max) {
   return trimmed.length <= max ? trimmed : `${trimmed.slice(0, max - 1)}\u2026`;
 }
 
-// src/hooks/runtime.ts
-import { readFile as readFile8 } from "fs/promises";
-import { basename, isAbsolute, relative as relative5, resolve as resolve9, sep as sep5 } from "path";
-import pTimeout2 from "p-timeout";
-
 // src/memory-extract/engine.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import { resolve as resolve7 } from "path";
 
 // src/memory-extract/deterministic.ts
@@ -2197,6 +2065,21 @@ var RULES = [
     confidence: 0.8,
     regex: EXPLICIT_RESOLUTION
   },
+  {
+    // An explicit label ("Decision: …") is the agent saying this is durable.
+    class: "decision",
+    subject: "decision",
+    predicate: "made",
+    confidence: 0.8,
+    regex: /^(?:decision|decided)\s*:/i
+  },
+  {
+    class: "fact",
+    subject: "project",
+    predicate: "fact",
+    confidence: 0.75,
+    regex: /^(?:convention|fact|rule|policy)\s*:/i
+  },
   {
     class: "decision",
     subject: "decision",
@@ -2216,11 +2099,20 @@ var RULES = [
     subject: "project",
     predicate: "fact",
     confidence: 0.55,
-    regex: /\b(uses?|is|are|requires?|depends on|stores?|returns?|implemented|added|supports?|configured|lives in|located|handles?)\b/i
+    regex: /\b(uses?|is|are|requires?|depends on|stores?|returns?|implemented|added|supports?|configured|lives in|located|handles?|must)\b|\b(?:always|never)\b(?!\s+(?:the|a|an|mind)\b)/i
   }
 ];
 var INCIDENT_REGEX = RULES.find((rule) => rule.predicate === "occurred").regex;
 var SPECULATIVE = /\b(might|maybe|possibly|could|consider(?:ing)?|planned|planning|should|if|would|unless|whether|suppose|hypothetical(?:ly)?|in theory|in case)\b/i;
+var HEDGED = /\b(might|maybe|perhaps|possibly|probably|could|consider(?:ing)?|planned|planning|would|whether|suppose|hypothetical(?:ly)?|in theory)\b/i;
+var NOT_DURABLE = /\b(?:for now|for the moment|right now|today|tonight|tomorrow|yesterday|this (?:session|turn|time|week|sprint)|for this (?:pr|change|task|ticket|branch|commit|session)|temporarily|as a temporary|i['’]ll|i will|i['’]m going to|let me|never ?mind|i think|i guess|i suspect)\b|^(?:it|this|that|there)\s+must\s+be\b/i;
+var DURABLE_LABEL = /^(?:decision|decided|rule|policy|convention|fact)\s*:/i;
+function stripDecoration(sentence) {
+  return sentence.replace(/^(?:[-*•]\s+|\d+[.)]\s+)/, "").replace(
+    /^(?:\*{1,2}|_{1,2})?(decision|decided|rule|policy|convention|fact)(?:\*{1,2}|_{1,2})?\s*:\s*(?:\*{1,2}|_{1,2})?\s*/i,
+    "$1: "
+  ).trim();
+}
 var NEGATION = /\b(no|not|never|none|nothing|nobody|without|zero|neither|nor|cannot)\b(?!\s+longer)|\w+n['’]t\b/i;
 var EXAMPLE = /\b(?:e\.g|i\.e|for example|for instance|such as|example|sample|hypothetical)\b/i;
 var QUOTED = /"[^"]*"|\u201c[^\u201d]*\u201d|`[^`]*`/g;
@@ -2247,17 +2139,19 @@ var SEVERITY_MARKERS = [
 function deterministicExtract(input) {
   const changedFiles = (input.changedFiles ?? []).filter(Boolean);
   const candidates = [];
-  for (const sentence of splitSentences(input.summary)) {
+  for (const sentence of splitSentences(input.summary).map(stripDecoration)) {
     const classified = classify(sentence);
     const doubt = classified?.class === "incident" ? incidentDoubt(sentence) : null;
-    const rule = doubt || SPECULATIVE.test(sentence) && !EXPLICIT_DECISION.test(sentence) && !EXPLICIT_RESOLUTION.test(sentence) ? {
+    const speculative = DURABLE_LABEL.test(sentence) ? HEDGED.test(sentence) : SPECULATIVE.test(sentence) && !EXPLICIT_DECISION.test(sentence) && !EXPLICIT_RESOLUTION.test(sentence);
+    const rule = doubt || speculative ? {
       class: "note",
       subject: "speculation",
       predicate: "consider",
       confidence: 0.3,
       regex: SPECULATIVE
     } : classified;
-    if (!rule) {
+    const passing = (rule?.class === "decision" || rule?.class === "fact") && NOT_DURABLE.test(sentence);
+    if (!rule || passing) {
       candidates.push(ignoredCandidate(sentence));
       continue;
     }
@@ -2395,7 +2289,7 @@ 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 dirname3, join as join5, relative as relative4, resolve as resolve6, sep as sep4 } from "path";
+import { dirname as dirname4, join as join5, relative as relative4, resolve as resolve6, sep as sep4 } from "path";
 import { parse as parseYaml4, stringify as stringifyYaml3 } from "yaml";
 import { z as z5 } from "zod";
 var reviewSchema = z5.object({
@@ -2438,7 +2332,7 @@ var ReviewStore = class {
     const input = redactPersisted(raw);
     const path = this.itemPath(input.id);
     await this.prepareDirectory();
-    await assertNoSymlinkBetween(this.repositoryRoot, dirname3(path));
+    await assertNoSymlinkBetween(this.repositoryRoot, dirname4(path));
     const frontMatter = stringifyYaml3({
       schemaVersion: 1,
       id: input.id,
@@ -2533,7 +2427,7 @@ var ReviewStore = class {
     return absolute;
   }
   async prepareDirectory() {
-    await assertNoSymlinkBetween(this.repositoryRoot, dirname3(this.reviewDirectory));
+    await assertNoSymlinkBetween(this.repositoryRoot, dirname4(this.reviewDirectory));
     await mkdir3(this.reviewDirectory, { recursive: true, mode: 448 });
   }
 };
@@ -2544,7 +2438,8 @@ var INJECTED_BLOCK = /^##\s*CodeBuddy\b/m;
 var FENCED_CODE = /```[\s\S]*?(?:```|$)/g;
 var QUOTE_LINE = /^\s*>.*$/gm;
 var RULE_PREFIX = /^(?:also,?\s+|please,?\s+)?(?:from now on|going forward|(?:a\s+)?rule\b[^:.]{0,60}:)[,:]?\s*/i;
-var IMPERATIVE = /^(?:please,?\s+)?(?:always|never)\s+\S+\s+\S+|^(?:we|you)\s+(?:always|never|must)\b|^every\s+(?!time\b)\S+.*\bmust\b/i;
+var IMPERATIVE = /^(?:please,?\s+)?(?:always|never)\s+(?!(?:the|a|an|mind|so|again|ever)\b)\S+\s+\S+|^(?:we|you)\s+(?:always|never|must)\b|^every\s+(?!time\b)\S+.*\bmust\b/i;
+var POLICY = /^(?:decision|decided|convention|policy)\s*:\s*\S+\s+\S+|^we\s+(?:decided|agreed|settled on|chose)\b|^(?!(?:i|it|this|that|there|he|she|they|which|what)\b)[a-z][\w-]*(?:\s+[\w./-]+){0,6}\s+must(?:\s+not|n['’]t)?\s+(?!be\s+\w+ing\b|have\s+(?:been\b|\w+ed\b))\w+/i;
 var QUESTION_START = /^(?:why|how|what|when|where|which|who|can|could|would|will|do|does|did|is|are|should)\b/i;
 var REVOCATION_MARKER = /^(?:please,?\s+)?stop\s+\w+ing\b|\bno longer\b|\b(?:don't|do not)\b.*\banymore\b|\b(?:forget|drop|remove)\s+the\s+rule\b/i;
 var STOPWORDS = /* @__PURE__ */ new Set([
@@ -2572,21 +2467,31 @@ var STOPWORDS = /* @__PURE__ */ new Set([
 function extractUserRules(prompts) {
   const rules = /* @__PURE__ */ new Map();
   const revocations = /* @__PURE__ */ new Map();
+  const policies = /* @__PURE__ */ new Map();
   for (const prompt of prompts) {
     const own = (prompt.split(INJECTED_BLOCK)[0] ?? "").replace(FENCED_CODE, "\n").replace(QUOTE_LINE, "");
     for (const raw of own.split(/(?<=[.!?])\s+|\n+/)) {
-      const sentence = raw.trim();
+      const sentence = stripDecoration(raw.trim());
       if (!sentence || sentence.length > MAX_RULE_CHARS || sentence.endsWith("?")) continue;
       if (QUESTION_START.test(sentence)) continue;
       const key = sentence.toLowerCase().replace(/\s+/g, " ").replace(/[.!]+$/, "");
       if (REVOCATION_MARKER.test(sentence)) {
         if (!revocations.has(key)) revocations.set(key, sentence);
-      } else if (isRule(sentence) && !SPECULATIVE.test(sentence)) {
+        continue;
+      }
+      if (HEDGED.test(sentence) || NOT_DURABLE.test(sentence)) continue;
+      if (isRule(sentence)) {
         if (!rules.has(key)) rules.set(key, sentence);
+      } else if (POLICY.test(sentence) && !policies.has(key)) {
+        policies.set(key, sentence);
       }
     }
   }
-  return { rules: [...rules.values()], revocations: [...revocations.values()] };
+  return {
+    rules: [...rules.values()],
+    revocations: [...revocations.values()],
+    policies: [...policies.values()]
+  };
 }
 function isRule(sentence) {
   const rest = sentence.replace(RULE_PREFIX, "");
@@ -2608,6 +2513,7 @@ function revokes(revocation, rule) {
 // src/memory-extract/engine.ts
 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 now = options.now ?? (() => /* @__PURE__ */ new Date());
@@ -2617,7 +2523,8 @@ async function captureAfterTurn(input, options = {}) {
   const source = extracted.source;
   const candidates = [
     ...extracted.candidates,
-    ...(input.userRules ?? []).map(ruleCandidate),
+    ...(input.userRules ?? []).map((rule) => ruleCandidate(rule)),
+    ...(input.userPolicies ?? []).map((policy) => ruleCandidate(policy, POLICY_CONFIDENCE)),
     ...await procedureCandidates(input, repositoryRoot)
   ];
   const saved = [];
@@ -2692,14 +2599,14 @@ async function recordWorklog(input, saved, queued, repositoryRoot, now, reasons)
     return null;
   }
 }
-function ruleCandidate(rule) {
+function ruleCandidate(rule, confidence = STATED_CONFIDENCE) {
   return {
     class: "decision",
     content: rule,
     subject: "rule",
     predicate: "rule",
     object: rule,
-    confidence: STATED_CONFIDENCE,
+    confidence,
     paths: [],
     severity: null
   };
@@ -2972,7 +2879,7 @@ function candidateFingerprint(namespace, raw) {
     content: candidate.content.trim().replace(/\s+/g, " ").toLowerCase(),
     paths: [...new Set(candidate.paths.map((path) => path.replace(/\\/g, "/")))].sort()
   });
-  return createHash4("sha256").update(canonical).digest("hex");
+  return createHash2("sha256").update(canonical).digest("hex");
 }
 async function approveReviewItem(id, options = {}) {
   const repositoryRoot = resolve7(options.repositoryRoot ?? process.cwd());
@@ -3021,50 +2928,6 @@ async function approveReviewItem(id, options = {}) {
   return factId;
 }
 
-// src/tracing/log.ts
-import { appendFile, mkdir as mkdir4, readFile as readFile6, stat as stat3, writeFile } from "fs/promises";
-import { dirname as dirname4, join as join6 } from "path";
-var MAX_BYTES = 4 * 1024 * 1024;
-function tracePath(repositoryRoot) {
-  return join6(repositoryRoot, ".codebuddy", "cache", "traces.jsonl");
-}
-async function recordTrace(repositoryRoot, event) {
-  if (process.env.CODEBUDDY_TRACE === "0") return;
-  const path = tracePath(repositoryRoot);
-  try {
-    await mkdir4(dirname4(path), { recursive: true });
-    await appendFile(path, `${JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), ...event })}
-`);
-    if ((await stat3(path)).size > MAX_BYTES) {
-      const lines = (await readFile6(path, "utf8")).split("\n").filter(Boolean);
-      await writeFile(path, `${lines.slice(Math.floor(lines.length / 2)).join("\n")}
-`);
-    }
-  } catch {
-  }
-}
-async function readTraces(repositoryRoot, limit = 2e3) {
-  let raw;
-  try {
-    raw = await readFile6(tracePath(repositoryRoot), "utf8");
-  } catch {
-    return [];
-  }
-  return parseTraceLines(raw).slice(-limit);
-}
-function parseTraceLines(raw) {
-  const events = [];
-  for (const line of raw.split("\n")) {
-    if (!line.trim()) continue;
-    try {
-      const event = JSON.parse(line);
-      if (typeof event.ts === "string" && typeof event.name === "string") events.push(event);
-    } catch {
-    }
-  }
-  return events;
-}
-
 // src/hooks/semantic.ts
 import pTimeout from "p-timeout";
 var CONNECT_BUDGET_MS = 2500;
@@ -3080,7 +2943,7 @@ async function configuredReranker(repositoryRoot) {
   if (provider === "local") {
     const revision = model === DEFAULT_RERANK_MODELS.local.id ? DEFAULT_RERANK_MODELS.local.revision : void 0;
     return async (task, documents) => {
-      const { rerankLocally } = await import("./local-OTOY56B4.js");
+      const { rerankLocally } = await import("./local-ST4WMRCG.js");
       return bounded(
         rerankLocally({ id: model, ...revision ? { revision } : {} }, task, documents)
       );
@@ -3088,7 +2951,7 @@ async function configuredReranker(repositoryRoot) {
   }
   const apiKey = provider === "openrouter" ? process.env.OPENROUTER_API_KEY : process.env.HF_TOKEN ?? file.provider?.apiKey;
   if (!apiKey) return void 0;
-  const { rerankHuggingFace, rerankOpenRouter } = await import("./cloud-7WM3YLI4.js");
+  const { rerankHuggingFace, rerankOpenRouter } = await import("./cloud-LXZUR3U2.js");
   const call = provider === "openrouter" ? rerankOpenRouter : rerankHuggingFace;
   return (task, documents) => call({ apiKey, model, timeoutMs: RERANK_BUDGET_MS }, task, documents);
 }
@@ -3097,8 +2960,8 @@ async function openHookSemantics(repositoryRoot) {
   const connect = async () => {
     const config = await loadRuntimeConfig(repositoryRoot, { requireDatabase: false });
     if (!config.postgresUrl) return null;
-    const { createRuntime: createRuntime2 } = await import("./operations-LOBAQRLO.js");
-    const opening = createRuntime2(config, {
+    const { createRuntime } = await import("./operations-7BTAAUHF.js");
+    const opening = createRuntime(config, {
       repositoryRoot,
       startWorker: false,
       connectTimeoutSeconds: 2
@@ -3132,19 +2995,20 @@ async function openHookSemantics(repositoryRoot) {
 }
 
 // src/hooks/staging.ts
-import { mkdir as mkdir5, readFile as readFile7, rename as rename2, rm as rm3, stat as stat4 } from "fs/promises";
-import { join as join7, resolve as resolve8 } from "path";
+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";
+var STAGING_LOCK_STALE_MS = 1e4;
 var HookStagingStore = class {
   directory;
   operations = Promise.resolve();
   constructor(repositoryRoot = process.cwd()) {
-    this.directory = join7(resolve8(repositoryRoot), ".codebuddy", "cache", "hooks");
+    this.directory = join6(resolve8(repositoryRoot), ".codebuddy", "cache", "hooks");
   }
   async add(sessionId, paths) {
     await this.serialize(async () => {
       const clean = paths.map(normalize2).filter(Boolean);
       if (clean.length === 0) return;
-      await mkdir5(this.directory, { recursive: true, mode: 448 });
+      await mkdir4(this.directory, { recursive: true, mode: 448 });
       await this.withFileLock(sessionId, async () => {
         const merged = [.../* @__PURE__ */ new Set([...await this.read(sessionId), ...clean])].sort();
         await writeAtomic(
@@ -3157,7 +3021,7 @@ var HookStagingStore = class {
   }
   async read(sessionId) {
     try {
-      const parsed = JSON.parse(await readFile7(this.filePath(sessionId), "utf8"));
+      const parsed = JSON.parse(await readFile6(this.filePath(sessionId), "utf8"));
       return Array.isArray(parsed?.paths) ? parsed.paths.filter((p) => typeof p === "string") : [];
     } catch {
       return [];
@@ -3166,7 +3030,7 @@ var HookStagingStore = class {
   /** Return the staged paths and clear them. */
   async drain(sessionId) {
     return this.serialize(async () => {
-      await mkdir5(this.directory, { recursive: true, mode: 448 });
+      await mkdir4(this.directory, { recursive: true, mode: 448 });
       return this.withFileLock(sessionId, async () => {
         const path = this.filePath(sessionId);
         const draining = `${path}.${process.pid}.${Date.now()}.drain`;
@@ -3177,7 +3041,7 @@ var HookStagingStore = class {
           throw error;
         }
         try {
-          const parsed = JSON.parse(await readFile7(draining, "utf8"));
+          const parsed = JSON.parse(await readFile6(draining, "utf8"));
           return Array.isArray(parsed?.paths) ? parsed.paths.filter((item) => typeof item === "string") : [];
         } finally {
           await rm3(draining, { force: true });
@@ -3187,15 +3051,15 @@ var HookStagingStore = class {
   }
   /** Claim a batch without consuming edits staged while capture runs. */
   async claim(sessionId) {
-    await mkdir5(this.directory, { recursive: true, mode: 448 });
+    await mkdir4(this.directory, { recursive: true, mode: 448 });
     const captureLock = `${this.filePath(sessionId)}.capture-lock`;
     for (let attempt = 0; ; attempt++) {
       try {
-        await mkdir5(captureLock);
+        await mkdir4(captureLock);
         break;
       } catch (error) {
         if (error.code !== "EEXIST") throw error;
-        const age = Date.now() - (await stat4(captureLock).catch(() => ({ mtimeMs: Date.now() }))).mtimeMs;
+        const age = Date.now() - (await stat3(captureLock).catch(() => ({ mtimeMs: Date.now() }))).mtimeMs;
         if (age > 6e4) {
           await rm3(captureLock, { recursive: true, force: true });
           continue;
@@ -3208,13 +3072,13 @@ var HookStagingStore = class {
       return await this.withFileLock(sessionId, async () => {
         const claimed = this.claimPath(sessionId);
         try {
-          return parsePaths(await readFile7(claimed, "utf8"));
+          return parsePaths(await readFile6(claimed, "utf8"));
         } catch (error) {
           if (error.code !== "ENOENT") throw error;
         }
         try {
           await rename2(this.filePath(sessionId), claimed);
-          return parsePaths(await readFile7(claimed, "utf8"));
+          return parsePaths(await readFile6(claimed, "utf8"));
         } catch (error) {
           if (error.code === "ENOENT") return [];
           throw error;
@@ -3235,7 +3099,7 @@ var HookStagingStore = class {
   /** Restore the claimed batch for retry, merging edits that arrived during capture. */
   async rollback(sessionId) {
     await this.withFileLock(sessionId, async () => {
-      const claimed = await readFile7(this.claimPath(sessionId), "utf8").then(parsePaths).catch(() => []);
+      const claimed = await readFile6(this.claimPath(sessionId), "utf8").then(parsePaths).catch(() => []);
       const merged = [.../* @__PURE__ */ new Set([...claimed, ...await this.read(sessionId)])].sort();
       if (merged.length > 0)
         await writeAtomic(
@@ -3254,10 +3118,18 @@ var HookStagingStore = class {
     const lock = `${this.filePath(sessionId)}.lock`;
     for (let attempt = 0; ; attempt++) {
       try {
-        await mkdir5(lock);
+        await mkdir4(lock);
         break;
       } catch (error) {
         if (error.code !== "EEXIST" || attempt >= 200) throw error;
+        const age = await stat3(lock).then(
+          (info) => Date.now() - info.mtimeMs,
+          () => 0
+        );
+        if (age > STAGING_LOCK_STALE_MS) {
+          await rm3(lock, { recursive: true, force: true });
+          continue;
+        }
         await new Promise((resolveWait) => setTimeout(resolveWait, 10));
       }
     }
@@ -3282,7 +3154,7 @@ var HookStagingStore = class {
   }
   filePath(sessionId) {
     const safe = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_") || "default";
-    return join7(this.directory, `${safe}.json`);
+    return join6(this.directory, `${safe}.json`);
   }
 };
 function normalize2(path) {
@@ -3295,6 +3167,7 @@ function parsePaths(raw) {
 
 // src/hooks/runtime.ts
 var CONTEXT_BLOCK_MAX_CHARS = 1800;
+var HOOK_TASK_FILES = 2;
 var PROMPT_FACTS = 3;
 var CONTEXT_HOOK_BUDGET_MS = 15e3;
 async function resolveNamespace(repositoryRoot) {
@@ -3304,7 +3177,7 @@ async function resolveNamespace(repositoryRoot) {
 }
 async function runContextHook(input, emit, budgetMs = CONTEXT_HOOK_BUDGET_MS) {
   const started = Date.now();
-  const repositoryRoot = resolve9(input.cwd ?? process.cwd());
+  const repositoryRoot = hookRoot(input.cwd);
   const namespace = await resolveNamespace(repositoryRoot);
   const bootstrap = await buildBootstrapContext({ repositoryRoot, namespace });
   let beforeEdit = null;
@@ -3313,7 +3186,8 @@ async function runContextHook(input, emit, budgetMs = CONTEXT_HOOK_BUDGET_MS) {
     beforeEdit = await buildBeforeEditContext({
       repositoryRoot,
       namespace,
-      useGit: true,
+      // 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 } : {}
@@ -3358,25 +3232,29 @@ function recallTrace(input, beforeEdit, emitted, text, started, late) {
     tokensOut: estimateTokens(text),
     ...input.session_id ? { session: input.session_id } : {},
     detail: {
-      prompt: prompt.length > 120 ? `${prompt.slice(0, 119)}\u2026` : prompt,
+      prompt: clip2(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) } : {},
       ...late ? { dropped: "built after the hook budget" } : {}
     }
   };
 }
+function clip2(text, max) {
+  return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+}
 async function runStageHook(input) {
-  const repositoryRoot = resolve9(input.cwd ?? process.cwd());
+  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;
 }
 async function llmMemoryOptions(repositoryRoot) {
   try {
-    return await (await import("./memory-4RGVLPKG.js")).llmCaptureOptions(repositoryRoot);
+    return await (await import("./memory-TGHVTBME.js")).llmCaptureOptions(repositoryRoot);
   } catch {
     return {};
   }
@@ -3385,7 +3263,7 @@ var INVESTIGATION_MIN_CHARS = 200;
 var NAMES_CODE = /[\w.-]+\/[\w./-]*\.\w{1,5}\b|\b[\w-]+\.(?:ts|tsx|js|jsx|mjs|py|go|rs|java|rb|php|cs|c|cpp|h|swift|kt)\b|`[^`\s]+`/;
 async function runCaptureHook(input) {
   const captureStarted = Date.now();
-  const repositoryRoot = resolve9(input.cwd ?? process.cwd());
+  const repositoryRoot = hookRoot(input.cwd);
   const staging = new HookStagingStore(repositoryRoot);
   const sessionId = input.session_id ?? "default";
   const claimed = await staging.claim(sessionId);
@@ -3393,12 +3271,12 @@ async function runCaptureHook(input) {
   const changedFiles = claimed;
   try {
     const prompts = input.transcript_path ? await turnUserPrompts(input.transcript_path) : [];
-    const { rules, revocations } = extractUserRules(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() ?? "";
       investigation = assistant.length >= INVESTIGATION_MIN_CHARS && NAMES_CODE.test(assistant);
-      if (!investigation && rules.length === 0 && revocations.length === 0) {
+      if (!investigation && rules.length === 0 && revocations.length === 0 && policies.length === 0) {
         await staging.acknowledge(sessionId);
         return { changedFiles, result: null };
       }
@@ -3423,6 +3301,7 @@ async function runCaptureHook(input) {
         sessionId,
         ...verification.length > 0 ? { verification } : {},
         ...rules.length > 0 ? { userRules: rules } : {},
+        ...policies.length > 0 ? { userPolicies: policies } : {},
         ...revocations.length > 0 ? { revokedRules: revocations } : {},
         ...investigation ? { investigation } : {},
         // Without edits, only the user's own rules and a handoff are kept: an
@@ -3455,40 +3334,107 @@ async function runCaptureHook(input) {
   }
 }
 var SYNC_BUDGET_MS = 5 * 6e4;
-async function runSyncHook(repositoryRoot) {
+async function runSyncHook(repositoryRoot, options = {}) {
   const config = await loadRuntimeConfig(repositoryRoot, { requireDatabase: false });
   if (!config.postgresUrl) return null;
-  const { createRuntime: createRuntime2 } = await import("./operations-LOBAQRLO.js");
-  const started = Date.now();
-  const runtime = await createRuntime2(config, { repositoryRoot });
+  const lock = join7(repositoryRoot, ".codebuddy", "cache", "sync.lock");
+  const dirty = join7(repositoryRoot, ".codebuddy", "cache", "sync.dirty");
+  await mkdir5(dirname5(lock), { recursive: true });
+  if (!await takeLock(lock)) {
+    await writeFile(dirty, "").catch(() => void 0);
+    return null;
+  }
+  const { createRuntime } = await import("./operations-7BTAAUHF.js");
+  const runtime = await createRuntime(config, { repositoryRoot }).catch(async (error) => {
+    await rm4(lock, { recursive: true, force: true });
+    throw error;
+  });
   try {
-    const reindex = await runtime.memory.reindexMemory();
-    const drained = await pTimeout2(runtime.memory.getWorker().drain(), {
-      milliseconds: SYNC_BUDGET_MS
-    }).then(
+    let result;
+    let round = 0;
+    do {
+      await rm4(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(), {
+        milliseconds: SYNC_BUDGET_MS
+      }).then(
+        () => true,
+        () => false
+      );
+      await recordTrace(repositoryRoot, {
+        kind: "sync",
+        name: "sync",
+        ms: Date.now() - started,
+        ok: drained,
+        detail: {
+          imported: reindex.facts.imported,
+          updated: reindex.facts.updated,
+          reembedding: reindex.reembedding ?? 0,
+          failures: reindex.failures.length
+        }
+      });
+      result = { reindex, drained };
+      round += 1;
+    } while (round < 3 && await stat4(dirty).then(
       () => true,
       () => false
-    );
-    await recordTrace(repositoryRoot, {
-      kind: "sync",
-      name: "sync",
-      ms: Date.now() - started,
-      ok: drained,
-      detail: {
-        imported: reindex.facts.imported,
-        updated: reindex.facts.updated,
-        reembedding: reindex.reembedding ?? 0,
-        failures: reindex.failures.length
+    ));
+    if (config.provider.type === "local") {
+      const started = Date.now();
+      const vectors = await syncFileVectors(repositoryRoot, SYNC_BUDGET_MS);
+      if (vectors) {
+        await recordTrace(repositoryRoot, {
+          kind: "sync",
+          name: "file-vectors",
+          ms: Date.now() - started,
+          ok: true,
+          detail: { ...vectors }
+        });
       }
-    });
-    return { reindex, drained };
+    }
+    return result;
   } finally {
     await runtime.close();
+    await rm4(lock, { recursive: true, force: true });
   }
 }
-async function runResetHook(input) {
-  const repositoryRoot = resolve9(input.cwd ?? process.cwd());
-  await new SessionCapsuleLedger(repositoryRoot).reset(input.session_id ?? "default");
+var SYNC_LOCK_STALE_MS = SYNC_BUDGET_MS + 6e4;
+async function takeLock(path) {
+  try {
+    await mkdir5(path);
+    return true;
+  } catch {
+    const age = await stat4(path).then(
+      (info) => Date.now() - info.mtimeMs,
+      () => 0
+    );
+    if (age < SYNC_LOCK_STALE_MS) return false;
+    await rm4(path, { recursive: true, force: true });
+    return mkdir5(path).then(
+      () => true,
+      () => false
+    );
+  }
+}
+async function runResetHook(input, emit) {
+  const repositoryRoot = hookRoot(input.cwd);
+  const sessionId = input.session_id ?? "default";
+  const ledger = new SessionCapsuleLedger(repositoryRoot);
+  await ledger.reset(sessionId);
+  if (input.hook_event_name !== "SessionStart") return "";
+  const namespace = await resolveNamespace(repositoryRoot);
+  const bootstrap = await buildBootstrapContext({ repositoryRoot, namespace });
+  const { text, emitted } = await renderContextBlock(
+    bootstrap,
+    null,
+    ledger,
+    sessionId,
+    input.session_id !== void 0
+  );
+  if (text.trim()) await emit?.(text);
+  await ledger.markSent(sessionId, emitted);
+  return text;
 }
 function extractEditedPaths(toolInput) {
   if (!toolInput) return [];
@@ -3532,7 +3478,7 @@ function isVerificationCommand(command) {
 async function turnVerification(transcriptPath) {
   let raw;
   try {
-    raw = await readFile8(transcriptPath, "utf8");
+    raw = await readFile7(transcriptPath, "utf8");
   } catch {
     return [];
   }
@@ -3584,7 +3530,7 @@ var TAGGED_BLOCK = /<([a-z][\w-]*)[^>]*>[\s\S]*?<\/\1>/gi;
 async function turnUserPrompts(transcriptPath) {
   let raw;
   try {
-    raw = await readFile8(transcriptPath, "utf8");
+    raw = await readFile7(transcriptPath, "utf8");
   } catch {
     return [];
   }
@@ -3615,7 +3561,7 @@ async function turnUserPrompts(transcriptPath) {
 }
 async function lastAssistantMessage(transcriptPath) {
   try {
-    const raw = await readFile8(transcriptPath, "utf8");
+    const raw = await readFile7(transcriptPath, "utf8");
     let latest = "";
     for (const line of raw.split("\n")) {
       const trimmed = line.trim();
@@ -3759,7 +3705,7 @@ async function renderContextBlock(bootstrap, beforeEdit, ledger, sessionId, anno
     items.push({
       priority: 3,
       text: bound(
-        `${targetLabel}: ${beforeEdit.targetPaths.slice(0, 8).join(", ")}` + (tests.length > 0 ? `; tests: ${tests.join(", ")}` : ""),
+        `${targetLabel}: ${beforeEdit.targetPaths.slice(0, beforeEdit.pathSource === "task" ? HOOK_TASK_FILES : 8).join(", ")}` + (tests.length > 0 ? `; tests: ${tests.join(", ")}` : ""),
         500
       )
     });
@@ -3802,1286 +3748,12 @@ function describeKeys(keys) {
 }
 var kinds = /* @__PURE__ */ new Set(["fact", "incident", "handoff", "rule", "procedure"]);
 
-// src/suggest/engine.ts
-import { constants } from "fs";
-import { access } from "fs/promises";
-import { extname, join as join8, resolve as resolve10 } from "path";
-
-// src/suggest/types.ts
-var SEVERITY_RANK = {
-  high: 3,
-  medium: 2,
-  low: 1,
-  info: 0
-};
-
-// src/suggest/engine.ts
-var RISK_SUGGEST_THRESHOLD = 50;
-var BLAST_RADIUS_MEDIUM = 5;
-var BLAST_RADIUS_HIGH = 10;
-var CODE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
-async function generateSuggestions(input) {
-  const repositoryRoot = resolve10(input.repositoryRoot ?? process.cwd());
-  const namespace = input.namespace;
-  const targetPaths = await resolveRiskPaths({
-    repositoryRoot,
-    ...input.paths !== void 0 ? { paths: input.paths } : {},
-    ...input.planId !== void 0 ? { planId: input.planId } : {},
-    ...input.useGit !== void 0 ? { useGit: input.useGit } : {}
-  });
-  const planStore = new PlanFileStore(repositoryRoot);
-  const memoryStore = new MemoryFileStore(repositoryRoot);
-  const [risks, plan, incidents, map, policyFile] = await Promise.all([
-    assessRisk({
-      repositoryRoot,
-      namespace,
-      ...input.paths !== void 0 ? { paths: input.paths } : {},
-      ...input.planId !== void 0 ? { planId: input.planId } : {},
-      ...input.useGit !== void 0 ? { useGit: input.useGit } : {}
-    }),
-    resolveRelevantPlan2(planStore, namespace, input.planId),
-    memoryStore.findIncidentFactsForPaths({ namespace, paths: targetPaths }),
-    buildArchitectureMap(repositoryRoot),
-    readPolicyFile(join8(repositoryRoot, ".codebuddy", "policies.yaml"))
-  ]);
-  const suggestions = [];
-  for (const item of risks.items) {
-    if (item.score < RISK_SUGGEST_THRESHOLD) continue;
-    suggestions.push({
-      id: `risk:${item.path}`,
-      category: "risk",
-      severity: item.score >= 75 ? "high" : "medium",
-      title: `Review high-risk change to ${item.path}`,
-      detail: item.reason,
-      path: item.path,
-      evidence: [
-        { kind: "risk_score", detail: `score ${item.score} (${item.category})` },
-        ...item.evidence.length > 0 ? [{ kind: "risk_evidence", detail: `${item.evidence.length} evidence item(s)` }] : []
-      ],
-      commandHint: `codebuddy risk assess --paths ${item.path} --explain`
-    });
-  }
-  for (const incident of incidents) {
-    const path = incident.paths[0] ?? "(unknown)";
-    suggestions.push({
-      id: `incident:${path}`,
-      category: "incident",
-      severity: "high",
-      title: `Recurring incident hotspot: ${path}`,
-      detail: `${incident.subject} \u2014 proceed carefully; this area has an unresolved incident.`,
-      path,
-      evidence: [{ kind: "incident", detail: `${incident.id} severity=${incident.severity}` }]
-    });
-  }
-  const inbound = inboundDegrees(map);
-  for (const path of targetPaths) {
-    const dependents = inbound.get(path) ?? 0;
-    if (dependents < BLAST_RADIUS_MEDIUM) continue;
-    suggestions.push({
-      id: `architecture:${path}`,
-      category: "architecture",
-      severity: dependents >= BLAST_RADIUS_HIGH ? "high" : "medium",
-      title: `High blast radius: ${path}`,
-      detail: `${dependents} module(s) import ${path}; a change here ripples widely.`,
-      path,
-      evidence: [{ kind: "dependents", detail: `${dependents} inbound import(s)` }],
-      commandHint: `codebuddy map dependents ${path}`
-    });
-  }
-  if (plan) {
-    const planned = new Set(plan.filesToTouch.map((file) => normalize3(file.path)));
-    const strays = targetPaths.filter((path) => !planned.has(normalize3(path)));
-    if (planned.size > 0 && strays.length > 0) {
-      suggestions.push({
-        id: `plan_divergence:${plan.id}`,
-        category: "plan_divergence",
-        severity: "medium",
-        title: `Change set diverges from plan ${plan.id}`,
-        detail: `${strays.length} target file(s) are outside the active plan's scope: ${strays.slice(0, 5).join(", ")}.`,
-        evidence: [
-          { kind: "plan", detail: `plan ${plan.id} (${plan.status})` },
-          { kind: "out_of_scope", detail: strays.slice(0, 5).join(", ") }
-        ],
-        commandHint: `codebuddy plan show ${plan.id}`
-      });
-    }
-  }
-  for (const path of targetPaths) {
-    if (!isTestableCode(path)) continue;
-    if (await hasSiblingTest(repositoryRoot, path)) continue;
-    suggestions.push({
-      id: `missing_test:${path}`,
-      category: "missing_test",
-      severity: "low",
-      title: `No test found for ${path}`,
-      detail: "Consider adding a test alongside this change.",
-      path,
-      evidence: [{ kind: "no_test", detail: "no *.test.* / *.spec.* sibling found" }]
-    });
-  }
-  for (const rule of policyFile.rules) {
-    const prefix = literalPrefix(rule.pattern);
-    if (!prefix) continue;
-    if (await pathExists(join8(repositoryRoot, prefix))) continue;
-    suggestions.push({
-      id: `stale_policy:${rule.id}`,
-      category: "stale_policy",
-      severity: "low",
-      title: `Stale policy rule "${rule.id}"`,
-      detail: `Pattern "${rule.pattern}" targets "${prefix}", which does not exist.`,
-      evidence: [{ kind: "policy_rule", detail: `${rule.id} \u2192 ${rule.pattern}` }]
-    });
-  }
-  const deduped = dedupe(suggestions).sort(compareSuggestions);
-  const limited = input.limit ? deduped.slice(0, input.limit) : deduped;
-  return {
-    suggestions: limited,
-    stats: buildStats(targetPaths.length, limited)
-  };
-}
-async function resolveRelevantPlan2(store, namespace, planId) {
-  if (planId) {
-    try {
-      return await store.readPlan(planId);
-    } catch (error) {
-      if (error.code === "ENOENT") return null;
-      throw error;
-    }
-  }
-  return new PlanLifecycle(store).current(namespace);
-}
-function inboundDegrees(map) {
-  const inbound = /* @__PURE__ */ new Map();
-  for (const edge of map.edges) inbound.set(edge.to, (inbound.get(edge.to) ?? 0) + 1);
-  return inbound;
-}
-function isTestableCode(path) {
-  if (/\.(test|spec)\.[cm]?[jt]sx?$/.test(path)) return false;
-  if (path.endsWith(".d.ts")) return false;
-  if (path.includes("__tests__/")) return false;
-  return CODE_EXTENSIONS.has(extname(path).toLowerCase());
-}
-async function hasSiblingTest(repositoryRoot, path) {
-  const ext = extname(path);
-  const base = path.slice(0, path.length - ext.length);
-  const dir = base.includes("/") ? base.slice(0, base.lastIndexOf("/")) : "";
-  const name = base.includes("/") ? base.slice(base.lastIndexOf("/") + 1) : base;
-  const candidates = [
-    `${base}.test${ext}`,
-    `${base}.spec${ext}`,
-    `${dir ? `${dir}/` : ""}__tests__/${name}${ext}`,
-    `${dir ? `${dir}/` : ""}__tests__/${name}.test${ext}`
-  ];
-  for (const candidate of candidates) {
-    if (await pathExists(join8(repositoryRoot, candidate))) return true;
-  }
-  return false;
-}
-function literalPrefix(pattern) {
-  const normalized = normalize3(pattern);
-  const wildcard = normalized.search(/[*?[]/);
-  if (wildcard === -1) return normalized.replace(/\/+$/, "");
-  const beforeWildcard = normalized.slice(0, wildcard);
-  const lastSlash = beforeWildcard.lastIndexOf("/");
-  return lastSlash === -1 ? "" : beforeWildcard.slice(0, lastSlash);
-}
-function dedupe(suggestions) {
-  const byId = /* @__PURE__ */ new Map();
-  for (const suggestion of suggestions) {
-    const existing = byId.get(suggestion.id);
-    if (!existing || SEVERITY_RANK[suggestion.severity] > SEVERITY_RANK[existing.severity]) {
-      byId.set(suggestion.id, suggestion);
-    }
-  }
-  return [...byId.values()];
-}
-function compareSuggestions(left, right) {
-  const severity = SEVERITY_RANK[right.severity] - SEVERITY_RANK[left.severity];
-  if (severity !== 0) return severity;
-  if (left.category !== right.category) return left.category.localeCompare(right.category);
-  return (left.path ?? "").localeCompare(right.path ?? "");
-}
-function buildStats(pathsConsidered, suggestions) {
-  const byCategory = {};
-  const bySeverity = {};
-  for (const suggestion of suggestions) {
-    byCategory[suggestion.category] = (byCategory[suggestion.category] ?? 0) + 1;
-    bySeverity[suggestion.severity] = (bySeverity[suggestion.severity] ?? 0) + 1;
-  }
-  return { pathsConsidered, produced: suggestions.length, byCategory, bySeverity };
-}
-async function pathExists(path) {
-  try {
-    await access(path, constants.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function normalize3(path) {
-  return path.replace(/\\/g, "/").replace(/^\.\//, "");
-}
-
-// src/mcp/tool-result.ts
-function serializeToolResult(value, format = process.env.CODEBUDDY_RESPONSE_FORMAT ?? "both") {
-  if (format !== "text" && format !== "both") {
-    throw new Error('CODEBUDDY_RESPONSE_FORMAT must be "text" or "both"');
-  }
-  return {
-    content: [{ type: "text", text: JSON.stringify(value) }],
-    ...format === "both" && value !== null && typeof value === "object" && !Array.isArray(value) ? { structuredContent: value } : {}
-  };
-}
-
-// src/mcp/tools/index.ts
-var INPUT_LIMITS = {
-  contentChars: 32e3,
-  batchItems: 100,
-  summaryChars: 32e3,
-  planBodyChars: 64e3,
-  planBriefChars: 4e3,
-  titleChars: 300,
-  arrayItems: 100,
-  pathChars: 1024,
-  taskChars: 2e3,
-  agentIdChars: 200
-};
-var deliverySchema = {
-  sessionId: z6.string().min(1).max(200).optional(),
-  ack: z6.string().regex(/^dlv_[a-z0-9]+$/).optional(),
-  full: z6.boolean().optional()
-};
-var rememberSchema = {
-  sessionId: z6.string().min(1).max(200).optional(),
-  content: z6.string().min(1).max(INPUT_LIMITS.contentChars),
-  type: z6.enum(["interaction", "fact", "summary"]).optional(),
-  idempotencyKey: z6.string().min(1).max(200).optional(),
-  agentId: z6.string().min(1).max(INPUT_LIMITS.agentIdChars).optional()
-};
-var recallSchema = {
-  sessionId: z6.string().min(1).max(200),
-  query: z6.string().min(1).max(INPUT_LIMITS.taskChars),
-  budget: z6.number().int().positive().optional(),
-  callerModel: z6.string().min(1).max(200).optional(),
-  conflictMode: z6.enum(["all", "latest", "highest_confidence"]).optional()
-};
-var shareSchema = {
-  from: z6.string().min(1).max(INPUT_LIMITS.agentIdChars).optional(),
-  to_namespace: z6.string().min(1).max(INPUT_LIMITS.agentIdChars),
-  factIds: z6.array(z6.string().min(1).max(100)).min(1).max(INPUT_LIMITS.arrayItems),
-  mode: z6.enum(["reference", "snapshot"]).optional(),
-  /** Snapshot mode: the target project's root; its Markdown store receives the copy. */
-  to_project_root: z6.string().min(1).max(INPUT_LIMITS.pathChars).optional(),
-  agentId: z6.string().min(1).max(INPUT_LIMITS.agentIdChars).optional()
-};
-var unshareSchema = {
-  to_namespace: z6.string().min(1).max(INPUT_LIMITS.agentIdChars),
-  factIds: z6.array(z6.string().min(1).max(100)).min(1).max(INPUT_LIMITS.arrayItems),
-  agentId: z6.string().min(1).max(INPUT_LIMITS.agentIdChars).optional()
-};
-var plannedFileSchema2 = z6.object({
-  path: z6.string().min(1).max(INPUT_LIMITS.pathChars),
-  action: z6.enum(["create", "edit", "delete"]),
-  notes: z6.string().max(INPUT_LIMITS.taskChars).optional()
-});
-var plannedTestSchema2 = z6.object({
-  path: z6.string().min(1).max(INPUT_LIMITS.pathChars),
-  description: z6.string().max(INPUT_LIMITS.taskChars).optional()
-});
-var planPatchSchema = {
-  title: z6.string().min(1).max(INPUT_LIMITS.titleChars).optional(),
-  brief: z6.string().max(INPUT_LIMITS.planBriefChars).optional(),
-  body: z6.string().max(INPUT_LIMITS.planBodyChars).optional(),
-  filesToTouch: z6.array(plannedFileSchema2).max(INPUT_LIMITS.arrayItems).optional(),
-  testsToAdd: z6.array(plannedTestSchema2).max(INPUT_LIMITS.arrayItems).optional(),
-  outOfScope: z6.array(z6.string().max(INPUT_LIMITS.pathChars)).max(INPUT_LIMITS.arrayItems).optional(),
-  risks: z6.array(z6.string().max(INPUT_LIMITS.taskChars)).max(INPUT_LIMITS.arrayItems).optional()
-};
-var mcpToolInputSchemas = {
-  remember: z6.object(rememberSchema),
-  remember_batch: z6.object({ items: z6.array(z6.object(rememberSchema)).min(1) }),
-  recall: z6.object(recallSchema),
-  list_facts: z6.object({
-    subject: z6.string().optional(),
-    limit: z6.number().int().positive().max(100).default(50),
-    cursor: z6.string().optional()
-  }),
-  list_namespaces: z6.object({}),
-  forget: z6.object({ id: z6.string().min(1) }),
-  share: z6.object(shareSchema),
-  unshare: z6.object(unshareSchema),
-  plan_current: z6.object({}),
-  plan_create: z6.object({
-    title: z6.string().min(1).max(INPUT_LIMITS.titleChars),
-    brief: z6.string().min(1).max(INPUT_LIMITS.planBriefChars),
-    body: z6.string().max(INPUT_LIMITS.planBodyChars).optional(),
-    filesToTouch: z6.array(plannedFileSchema2).max(INPUT_LIMITS.arrayItems).optional(),
-    testsToAdd: z6.array(plannedTestSchema2).max(INPUT_LIMITS.arrayItems).optional(),
-    outOfScope: z6.array(z6.string().max(INPUT_LIMITS.pathChars)).max(INPUT_LIMITS.arrayItems).optional(),
-    risks: z6.array(z6.string().max(INPUT_LIMITS.taskChars)).max(INPUT_LIMITS.arrayItems).optional(),
-    agentId: z6.string().min(1).max(INPUT_LIMITS.agentIdChars).optional()
-  }),
-  plan_amend: z6.object({ id: z6.string().min(1), patch: z6.object(planPatchSchema) }),
-  plan_status: z6.object({
-    id: z6.string().min(1),
-    status: z6.enum(["approved", "executing", "complete", "abandoned"]),
-    commitSha: z6.string().optional(),
-    notes: z6.string().optional(),
-    reason: z6.string().optional()
-  }),
-  risk_assess: z6.object({
-    planId: z6.string().min(1).max(100).optional(),
-    paths: z6.array(z6.string().min(1).max(INPUT_LIMITS.pathChars)).max(INPUT_LIMITS.arrayItems).optional(),
-    evidence: z6.enum(["overview", "source"]).optional(),
-    useGit: z6.boolean().optional(),
-    limit: z6.number().int().positive().max(100).optional()
-  }),
-  map_query: z6.object({
-    from: z6.string().min(1).max(INPUT_LIMITS.pathChars).optional(),
-    to: z6.string().min(1).max(INPUT_LIMITS.pathChars).optional(),
-    limit: z6.number().int().positive().max(100).optional()
-  }),
-  map_neighbours: z6.object({
-    module: z6.string().min(1).max(INPUT_LIMITS.pathChars),
-    direction: z6.enum(["in", "out", "both"]).default("both")
-  }),
-  context_bootstrap: z6.object({ ...deliverySchema }),
-  context_before_edit: z6.object({
-    task: z6.string().min(1).max(INPUT_LIMITS.taskChars).optional(),
-    paths: z6.array(z6.string().min(1).max(INPUT_LIMITS.pathChars)).max(INPUT_LIMITS.arrayItems).optional(),
-    planId: z6.string().min(1).max(100).optional(),
-    evidence: z6.enum(["overview", "source"]).optional(),
-    useGit: z6.boolean().optional(),
-    tokenBudget: z6.number().int().positive().max(1e5).optional(),
-    ...deliverySchema
-  }),
-  context_pack: z6.object({
-    task: z6.string().min(1).max(INPUT_LIMITS.taskChars),
-    paths: z6.array(z6.string().min(1).max(INPUT_LIMITS.pathChars)).max(INPUT_LIMITS.arrayItems).optional(),
-    planId: z6.string().min(1).max(100).optional(),
-    evidence: z6.enum(["overview", "source"]).optional(),
-    useGit: z6.boolean().optional(),
-    tokenBudget: z6.number().int().positive().max(1e5).optional(),
-    ...deliverySchema
-  }),
-  context_after_turn: z6.object({
-    summary: z6.string().min(1).max(INPUT_LIMITS.summaryChars),
-    changedFiles: z6.array(z6.string().min(1).max(INPUT_LIMITS.pathChars)).max(INPUT_LIMITS.arrayItems).optional(),
-    planId: z6.string().min(1).max(100).optional(),
-    taskType: z6.string().min(1).max(100).optional(),
-    agentId: z6.string().min(1).max(INPUT_LIMITS.agentIdChars).optional(),
-    sessionId: z6.string().min(1).max(200).optional(),
-    verification: z6.array(z6.string().min(1).max(500)).max(20).optional(),
-    commitSha: z6.string().min(7).max(64).optional()
-  }),
-  code_suggestions: z6.object({
-    paths: z6.array(z6.string().min(1).max(INPUT_LIMITS.pathChars)).max(INPUT_LIMITS.arrayItems).optional(),
-    planId: z6.string().min(1).max(100).optional(),
-    evidence: z6.enum(["overview", "source"]).optional(),
-    useGit: z6.boolean().optional(),
-    limit: z6.number().int().positive().max(100).optional()
-  }),
-  health: z6.object({})
-};
-var DATABASE_TOOLS = [
-  "remember",
-  "remember_batch",
-  "recall",
-  "list_facts",
-  "list_namespaces",
-  "forget",
-  "share",
-  "unshare"
-];
-var FILE_TOOLS = Object.keys(mcpToolInputSchemas).filter(
-  (name) => !DATABASE_TOOLS.includes(name)
-);
-var DEGRADED_FALLBACK = "PostgreSQL is unavailable, so this call did nothing. File-based tools still work; read the repository directly and say recall is unavailable instead of guessing. Run `codebuddy db doctor` to diagnose; the next call after retryInMs reconnects.";
-var CORE_TOOLS = [
-  "context_pack",
-  "context_bootstrap",
-  "context_before_edit",
-  "context_after_turn",
-  "code_suggestions",
-  "health"
-];
-function resolveToolProfile(value = process.env.CODEBUDDY_TOOL_PROFILE) {
-  if (value === void 0 || value === "" || value === "full") return "full";
-  if (value === "core") return "core";
-  throw new Error(`CODEBUDDY_TOOL_PROFILE must be "core" or "full", got "${value}"`);
-}
-var PLAN_BODY_LIMIT = 8e3;
-function serializePlan(plan) {
-  if (!plan) return { plan: null };
-  const body = plan.body.length > PLAN_BODY_LIMIT ? `${plan.body.slice(0, PLAN_BODY_LIMIT)}
-
-\u2026[truncated]` : plan.body;
-  return { plan: { ...plan, body } };
-}
-function registerCodeBuddyTools(server, options, profile = "full") {
-  const exposed = (name) => profile === "full" || CORE_TOOLS.includes(name);
-  const config = "database" in options ? options.config : options.memory.config;
-  const traceRoot = config.projectRoot ?? process.cwd();
-  const register = (name, toolConfig, callback) => {
-    const traced = (async (...args) => {
-      const started = Date.now();
-      const input = args.length > 1 ? args[0] : void 0;
-      const trace = (ok, output) => void recordTrace(traceRoot, {
-        kind: "tool",
-        name,
-        ms: Date.now() - started,
-        ok,
-        tokensIn: estimateTokens(input),
-        tokensOut: estimateTokens(output),
-        ...typeof input?.sessionId === "string" ? { session: input.sessionId } : {}
-      });
-      try {
-        const result = await callback(...args);
-        trace(result?.isError !== true, result?.content?.map((part) => part.text ?? "").join(""));
-        return result;
-      } catch (error) {
-        trace(false);
-        throw error;
-      }
-    });
-    const tool = server.registerTool(name, toolConfig, traced);
-    if (!exposed(name)) tool.remove();
-    return tool;
-  };
-  const json = serializeToolResult;
-  const database = "database" in options ? options.database : { get: async () => options, status: () => ({ available: true, state: "ready" }) };
-  const viaDatabase = async (tool, run) => {
-    let db;
-    try {
-      db = await database.get();
-    } catch {
-      return {
-        ...json({ degraded: true, tool, database: database.status(), fallback: DEGRADED_FALLBACK }),
-        isError: true
-      };
-    }
-    return json(await run(db));
-  };
-  const namespace = config.namespace;
-  const projectRoot = config.projectRoot ?? process.cwd();
-  const rankContextFacts = async (task, candidates) => {
-    if (database.status().state !== "ready") return {};
-    try {
-      const { memory } = await database.get();
-      return await memory.rankContextFacts(
-        task,
-        candidates.map(({ id }) => id)
-      );
-    } catch {
-      return {};
-    }
-  };
-  const reranker = configuredReranker(projectRoot).catch(() => void 0);
-  const rerankerOption = async () => {
-    const configured = await reranker;
-    return configured ? { reranker: configured } : {};
-  };
-  const planStore = new PlanFileStore(projectRoot);
-  const planLifecycle = new PlanLifecycle(planStore);
-  const toFiles = (items) => items?.map((item) => ({ path: item.path, action: item.action, notes: item.notes ?? "" }));
-  const toTests = (items) => items?.map((item) => ({ path: item.path, description: item.description ?? "" }));
-  register(
-    "remember",
-    {
-      title: "Remember",
-      description: "Store one CodeBuddy memory item.",
-      inputSchema: mcpToolInputSchemas.remember.shape
-    },
-    async (input) => viaDatabase("remember", (db) => db.memory.remember(toRememberInput(input)))
-  );
-  register(
-    "remember_batch",
-    {
-      title: "Remember batch",
-      description: "Store multiple CodeBuddy memory items.",
-      inputSchema: mcpToolInputSchemas.remember_batch.shape
-    },
-    async (input) => viaDatabase("remember_batch", async (db) => ({
-      items: await db.memory.rememberBatch(input.items.map(toRememberInput))
-    }))
-  );
-  register(
-    "recall",
-    {
-      title: "Recall",
-      description: "Recall prompt-ready CodeBuddy context.",
-      inputSchema: mcpToolInputSchemas.recall.shape
-    },
-    async (input) => viaDatabase("recall", (db) => db.memory.recall(toRecallInput(input)))
-  );
-  register(
-    "list_facts",
-    {
-      title: "List facts",
-      description: "List facts in the configured namespace.",
-      inputSchema: mcpToolInputSchemas.list_facts.shape
-    },
-    async (input) => viaDatabase(
-      "list_facts",
-      (db) => listFactsPage(
-        db.memory,
-        db.repository,
-        cleanOptional(input)
-      )
-    )
-  );
-  register(
-    "list_namespaces",
-    {
-      title: "List namespaces",
-      description: "List CodeBuddy namespaces.",
-      inputSchema: mcpToolInputSchemas.list_namespaces.shape
-    },
-    async () => viaDatabase("list_namespaces", async (db) => ({
-      namespaces: await db.repository.listNamespaces()
-    }))
-  );
-  register(
-    "forget",
-    {
-      title: "Forget",
-      description: "Delete an interaction or fact by id.",
-      inputSchema: mcpToolInputSchemas.forget.shape
-    },
-    async (input) => viaDatabase("forget", (db) => db.memory.forget(input.id))
-  );
-  register(
-    "share",
-    {
-      title: "Share",
-      description: "Share facts from the configured namespace to another namespace. Reference (default) is a live, revocable grant; snapshot copies the fact into the target project's Markdown store (requires to_project_root).",
-      inputSchema: mcpToolInputSchemas.share.shape
-    },
-    async (input) => viaDatabase(
-      "share",
-      (db) => db.memory.share({
-        from: input.from ?? namespace,
-        to: input.to_namespace,
-        factIds: input.factIds,
-        ...input.mode ? { mode: input.mode } : {},
-        ...input.to_project_root ? { targetProjectRoot: input.to_project_root } : {},
-        ...input.agentId ? { agentId: input.agentId } : {}
-      })
-    )
-  );
-  register(
-    "unshare",
-    {
-      title: "Unshare",
-      description: "Revoke live reference shares of configured-namespace facts to another namespace.",
-      inputSchema: mcpToolInputSchemas.unshare.shape
-    },
-    async (input) => viaDatabase(
-      "unshare",
-      (db) => db.memory.unshare({
-        to: input.to_namespace,
-        factIds: input.factIds,
-        ...input.agentId ? { agentId: input.agentId } : {}
-      })
-    )
-  );
-  register(
-    "plan_current",
-    {
-      title: "Current plan",
-      description: "Return the active (approved or executing) plan for this namespace, or null.",
-      inputSchema: mcpToolInputSchemas.plan_current.shape
-    },
-    async () => {
-      const [current, policy] = await Promise.all([
-        planLifecycle.current(namespace),
-        loadPlanPolicy(projectRoot)
-      ]);
-      return json({ ...serializePlan(current), policy });
-    }
-  );
-  register(
-    "plan_create",
-    {
-      title: "Create plan",
-      description: "Create a draft plan in this namespace.",
-      inputSchema: mcpToolInputSchemas.plan_create.shape
-    },
-    async (input) => {
-      const files = toFiles(input.filesToTouch);
-      const tests = toTests(input.testsToAdd);
-      const created = await planLifecycle.create({
-        namespace,
-        title: input.title,
-        brief: input.brief,
-        ...input.body !== void 0 ? { body: input.body } : {},
-        ...files ? { filesToTouch: files } : {},
-        ...tests ? { testsToAdd: tests } : {},
-        ...input.outOfScope !== void 0 ? { outOfScope: input.outOfScope } : {},
-        ...input.risks !== void 0 ? { risks: input.risks } : {},
-        ...input.agentId !== void 0 ? { createdByAgent: input.agentId } : {}
-      });
-      return json(serializePlan(created));
-    }
-  );
-  register(
-    "plan_amend",
-    {
-      title: "Amend plan",
-      description: "Amend a draft or executing plan's content fields.",
-      inputSchema: mcpToolInputSchemas.plan_amend.shape
-    },
-    async (input) => {
-      const patch = input.patch;
-      const files = toFiles(patch.filesToTouch);
-      const tests = toTests(patch.testsToAdd);
-      const amended = await planLifecycle.amend(input.id, {
-        ...patch.title !== void 0 ? { title: patch.title } : {},
-        ...patch.brief !== void 0 ? { brief: patch.brief } : {},
-        ...patch.body !== void 0 ? { body: patch.body } : {},
-        ...files ? { filesToTouch: files } : {},
-        ...tests ? { testsToAdd: tests } : {},
-        ...patch.outOfScope !== void 0 ? { outOfScope: patch.outOfScope } : {},
-        ...patch.risks !== void 0 ? { risks: patch.risks } : {}
-      });
-      return json(serializePlan(amended));
-    }
-  );
-  register(
-    "plan_status",
-    {
-      title: "Transition plan",
-      description: "Move a plan through its lifecycle: approved, executing, complete, abandoned.",
-      inputSchema: mcpToolInputSchemas.plan_status.shape
-    },
-    async (input) => {
-      let next;
-      if (input.status === "approved") next = await planLifecycle.approve(input.id);
-      else if (input.status === "executing") next = await planLifecycle.start(input.id);
-      else if (input.status === "complete")
-        next = await planLifecycle.complete(input.id, {
-          ...input.commitSha !== void 0 ? { commitSha: input.commitSha } : {},
-          ...input.notes !== void 0 ? { notes: input.notes } : {}
-        });
-      else
-        next = await planLifecycle.abandon(
-          input.id,
-          input.reason !== void 0 ? { reason: input.reason } : {}
-        );
-      return json(serializePlan(next));
-    }
-  );
-  register(
-    "risk_assess",
-    {
-      title: "Assess risk",
-      description: "Assess evidence-backed risk for a plan, explicit paths, or git changes.",
-      inputSchema: mcpToolInputSchemas.risk_assess.shape
-    },
-    async (input) => json(
-      await assessRisk({
-        repositoryRoot: projectRoot,
-        namespace,
-        ...input.planId !== void 0 ? { planId: input.planId } : {},
-        ...input.paths !== void 0 ? { paths: input.paths } : {},
-        ...input.useGit !== void 0 ? { useGit: input.useGit } : {},
-        ...input.limit !== void 0 ? { limit: input.limit } : {}
-      })
-    )
-  );
-  register(
-    "map_query",
-    {
-      title: "Query architecture map",
-      description: "Query lightweight module import edges in the current repository.",
-      inputSchema: mcpToolInputSchemas.map_query.shape
-    },
-    async (input) => {
-      const graph = await cachedMap();
-      return json(
-        queryMap(graph, {
-          ...input.from !== void 0 ? { from: input.from } : {},
-          ...input.to !== void 0 ? { to: input.to } : {},
-          ...input.limit !== void 0 ? { limit: input.limit } : {}
-        })
-      );
-    }
-  );
-  register(
-    "map_neighbours",
-    {
-      title: "Module neighbours",
-      description: "Return inbound/outbound neighbours for a repository module.",
-      inputSchema: mcpToolInputSchemas.map_neighbours.shape
-    },
-    async (input) => json(neighbours(await cachedMap(), input.module, input.direction))
-  );
-  const tokenBudget = config.tokenBudget;
-  const cachedMap = async () => {
-    const { manifest } = await loadFreshIndex(projectRoot);
-    const cached = await loadArchitectureMap(projectRoot, manifest);
-    if (cached.map.modules.length > 0) return cached.map;
-    return buildArchitectureMap(projectRoot);
-  };
-  register(
-    "context_bootstrap",
-    {
-      title: "Bootstrap project context",
-      description: "Return compact project awareness for the start of a turn: identity, active plan and policy, top policy rules, incident hotspots, and an architecture summary. Prefer this over a manual recall at session start. Optional sessionId enables session-aware delivery: pass the previous response's delivery.deliveryId as ack and unchanged sections are omitted (listed in delivery.unchanged); pass full=true to get everything again.",
-      inputSchema: mcpToolInputSchemas.context_bootstrap.shape
-    },
-    async (input) => json(
-      await applySessionDelivery(
-        projectRoot,
-        await buildBootstrapContext({
-          repositoryRoot: projectRoot,
-          namespace,
-          ...tokenBudget !== void 0 ? { tokenBudget } : {}
-        }),
-        deliveryOptions(input)
-      )
-    )
-  );
-  register(
-    "context_before_edit",
-    {
-      title: "Context before edit",
-      description: "Assemble relevant context before changing code: resolves target files from paths, a plan, or git, then returns the relevant plan, matching policy rules, incident memory, an evidence-backed risk assessment, and import neighbours. Optional sessionId enables session-aware delivery: pass the previous response's delivery.deliveryId as ack and unchanged sections are omitted (listed in delivery.unchanged); pass full=true to get everything again.",
-      inputSchema: mcpToolInputSchemas.context_before_edit.shape
-    },
-    async (input) => json(
-      await applySessionDelivery(
-        projectRoot,
-        await buildBeforeEditContext({
-          repositoryRoot: projectRoot,
-          namespace,
-          semanticRanker: rankContextFacts,
-          ...await rerankerOption(),
-          ...input.evidence ? { evidence: input.evidence } : {},
-          ...input.task !== void 0 ? { task: input.task } : {},
-          ...input.paths !== void 0 ? { paths: input.paths } : {},
-          ...input.planId !== void 0 ? { planId: input.planId } : {},
-          ...input.useGit !== void 0 ? { useGit: input.useGit } : {},
-          ...input.tokenBudget !== void 0 ? { tokenBudget: input.tokenBudget } : {},
-          ...tokenBudget !== void 0 && input.tokenBudget === void 0 ? { tokenBudget } : {}
-        }),
-        deliveryOptions(input)
-      )
-    )
-  );
-  register(
-    "context_pack",
-    {
-      title: "Build task context pack",
-      description: "Build the smallest useful context pack for a coding task. Automatically finds relevant files from the local index when paths are omitted, then includes only bounded symbols, policies, risks, incidents, architecture neighbours, and relevant team facts within the requested token budget. Use this once at the start of a task instead of manually chaining context, risk, map, and memory tools. Request evidence=source with exact paths when short excerpts omit needed behavior; source excerpts remain bounded by the token budget. Optional sessionId enables session-aware delivery: pass the previous response's delivery.deliveryId as ack and unchanged sections are omitted (listed in delivery.unchanged); pass full=true to get everything again.",
-      inputSchema: mcpToolInputSchemas.context_pack.shape
-    },
-    async (input) => json(
-      await applySessionDelivery(
-        projectRoot,
-        await buildBeforeEditContext({
-          repositoryRoot: projectRoot,
-          namespace,
-          task: input.task,
-          semanticRanker: rankContextFacts,
-          ...await rerankerOption(),
-          ...input.evidence ? { evidence: input.evidence } : {},
-          ...input.paths !== void 0 ? { paths: input.paths } : {},
-          ...input.planId !== void 0 ? { planId: input.planId } : {},
-          ...input.useGit !== void 0 ? { useGit: input.useGit } : {},
-          tokenBudget: input.tokenBudget ?? tokenBudget ?? 4e3
-        }),
-        deliveryOptions(input)
-      )
-    )
-  );
-  register(
-    "context_after_turn",
-    {
-      title: "Capture context after a turn",
-      description: "Extract durable knowledge from a turn summary. Confident facts/decisions/incidents are auto-saved as Markdown; temporary notes, low-confidence, and sensitive items are queued for review under .codebuddy/memory/review/; chatter is ignored. Never saves sensitive content automatically. Turns that changed files or report verification also record a bounded worklog handoff under .codebuddy/worklog/ so later chats can recover the work.",
-      inputSchema: mcpToolInputSchemas.context_after_turn.shape
-    },
-    async (input) => {
-      const result = await captureAfterTurn(
-        {
-          summary: input.summary,
-          namespace,
-          ...input.changedFiles !== void 0 ? { changedFiles: input.changedFiles } : {},
-          ...input.planId !== void 0 ? { planId: input.planId } : {},
-          ...input.taskType !== void 0 ? { taskType: input.taskType } : {},
-          ...input.agentId !== void 0 ? { agentId: input.agentId } : {},
-          ...input.sessionId !== void 0 ? { sessionId: input.sessionId } : {},
-          ...input.verification !== void 0 ? { verification: input.verification } : {},
-          ...input.commitSha !== void 0 ? { commitSha: input.commitSha } : {}
-        },
-        {
-          repositoryRoot: projectRoot,
-          ...(input.changedFiles?.length ?? 0) > 0 ? await llmMemoryOptions(projectRoot) : {}
-        }
-      );
-      const db = await database.get().catch(() => void 0);
-      await db?.memory.reindexMemory();
-      return json({
-        saved: result.saved.map((d) => ({
-          id: d.ref,
-          class: d.candidate.class,
-          subject: d.candidate.subject
-        })),
-        queuedForReview: result.queuedForReview.map((d) => ({
-          id: d.ref,
-          class: d.candidate.class,
-          reason: d.reason,
-          sensitive: d.sensitive
-        })),
-        ignored: result.ignored.length,
-        reasons: result.reasons,
-        extractor: result.extractor,
-        worklogId: result.worklogId,
-        ...db ? {} : { degraded: true, database: database.status() }
-      });
-    }
-  );
-  register(
-    "code_suggestions",
-    {
-      title: "Code suggestions",
-      description: "Return read-only, evidence-backed code-quality suggestions for a change set (paths, a plan, or git). Composes risk, plan divergence, architecture blast radius, incident history, missing tests, and stale policies. Never edits code.",
-      inputSchema: mcpToolInputSchemas.code_suggestions.shape
-    },
-    async (input) => json(
-      await generateSuggestions({
-        repositoryRoot: projectRoot,
-        namespace,
-        ...input.paths !== void 0 ? { paths: input.paths } : {},
-        ...input.planId !== void 0 ? { planId: input.planId } : {},
-        ...input.useGit !== void 0 ? { useGit: input.useGit } : {},
-        ...input.limit !== void 0 ? { limit: input.limit } : {}
-      })
-    )
-  );
-  register(
-    "health",
-    {
-      title: "Health",
-      description: "Report which CodeBuddy tools are available right now: file-based tools always work; database tools (recall, remember, facts) need PostgreSQL. Does not wait on a connection attempt.",
-      inputSchema: mcpToolInputSchemas.health.shape
-    },
-    async () => json({
-      database: database.status(),
-      tools: {
-        profile,
-        file: FILE_TOOLS.filter(exposed),
-        database: DATABASE_TOOLS.filter(exposed)
-      }
-    })
-  );
-}
-function deliveryOptions(input) {
-  return cleanOptional(input);
-}
-function toRememberInput(input) {
-  return cleanOptional(input);
-}
-function toRecallInput(input) {
-  return cleanOptional(input);
-}
-function cleanOptional(input) {
-  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0));
-}
-
-// src/mcp/server.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import pino from "pino";
-
-// src/automation/project-sync.ts
-import { watch as fsWatch2 } from "fs";
-import { join as join9, relative as relative6, resolve as resolve12, sep as sep6 } from "path";
-
-// src/indexer/watch.ts
-import { watch as fsWatch } from "fs";
-import { resolve as resolve11 } from "path";
-var DEFAULT_DEBOUNCE_MS = 300;
-function createCoalescer(fn, delayMs) {
-  let timer = null;
-  let running = null;
-  let dirty = false;
-  let stopped = false;
-  let firstTriggerAt = null;
-  let maxWaitTimer = null;
-  const clearTimers = () => {
-    if (timer) {
-      clearTimeout(timer);
-      timer = null;
-    }
-    if (maxWaitTimer) {
-      clearTimeout(maxWaitTimer);
-      maxWaitTimer = null;
-    }
-    firstTriggerAt = null;
-  };
-  const run = () => {
-    if (stopped || running) return;
-    clearTimers();
-    dirty = false;
-    running = (async () => {
-      try {
-        await fn();
-      } finally {
-        running = null;
-        if (dirty) schedule();
-      }
-    })();
-  };
-  const schedule = () => {
-    if (stopped) return;
-    dirty = true;
-    if (firstTriggerAt === null) {
-      firstTriggerAt = Date.now();
-      maxWaitTimer = setTimeout(run, MAX_WAIT_MS);
-    }
-    if (timer) clearTimeout(timer);
-    timer = setTimeout(run, delayMs);
-  };
-  return {
-    trigger: schedule,
-    stop: async () => {
-      stopped = true;
-      clearTimers();
-      await running?.catch(() => void 0);
-    }
-  };
-}
-var MAX_WAIT_MS = 5e3;
-function isIgnoredEvent(filename, ignoredPaths = []) {
-  if (!filename) return false;
-  const normalized = filename.replace(/\\/g, "/");
-  return ignoredPaths.some((path) => normalized === path || normalized.startsWith(`${path}/`)) || normalized.startsWith(".codebuddy/") || normalized.includes("/.git/") || normalized.startsWith(".git/") || normalized.includes("/node_modules/") || normalized.startsWith("node_modules/") || normalized.endsWith(".tmp");
-}
-async function watchRepository(options = {}) {
-  const repositoryRoot = resolve11(options.repositoryRoot ?? process.cwd());
-  const debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
-  const runIndex = async () => {
-    try {
-      const result = await indexRepository({
-        repositoryRoot,
-        ...options.now ? { now: options.now } : {}
-      });
-      options.onIndex?.(result);
-    } catch (error) {
-      options.onError?.(error);
-    }
-  };
-  await runIndex();
-  const coalescer = createCoalescer(runIndex, debounceMs);
-  const watcher = fsWatch(repositoryRoot, { recursive: true }, (_event, filename) => {
-    if (isIgnoredEvent(filename, options.ignoredPaths)) return;
-    coalescer.trigger();
-  });
-  return new Promise((resolvePromise) => {
-    const stop = () => {
-      watcher.close();
-      void coalescer.stop().then(() => resolvePromise());
-    };
-    if (options.signal) {
-      if (options.signal.aborted) return stop();
-      options.signal.addEventListener("abort", stop, { once: true });
-    }
-    watcher.on("error", () => stop());
-  });
-}
-
-// src/automation/project-sync.ts
-function startProjectSync(options) {
-  const repositoryRoot = resolve12(options.repositoryRoot);
-  const logger = options.logger ?? console;
-  const controller = new AbortController();
-  let watcher = null;
-  let closing = false;
-  let memoryWatcher = null;
-  let memoryRefresh = null;
-  const backgroundRefresh = (task) => {
-    let current = null;
-    let pending = false;
-    const schedule = () => {
-      if (closing) return;
-      if (current) {
-        pending = true;
-        return;
-      }
-      current = (async () => {
-        do {
-          pending = false;
-          await task();
-        } while (pending && !closing);
-      })().finally(() => {
-        current = null;
-        if (pending && !closing) schedule();
-      });
-    };
-    return { schedule, settled: async () => current?.catch(() => void 0) };
-  };
-  const graphRefresh = backgroundRefresh(
-    () => refreshGraph().catch(
-      (error) => logger.error(`[sync] Graphify refresh failed: ${error.message}`)
-    )
-  );
-  const zvecRefresh = backgroundRefresh(async () => {
-    const result = await refreshZvecIndex(repositoryRoot, { signal: controller.signal }).catch(
-      (error) => ({
-        status: "failed",
-        reason: error.message
-      })
-    );
-    if (result.status !== "disabled") logger.info(`[sync] ${result.reason}`);
-  });
-  const ready = (async () => {
-    await indexRepository({ repositoryRoot });
-    zvecRefresh.schedule();
-    watchMemory();
-    if (options.graphify?.enabled) {
-      await refreshGraph().catch(
-        (error) => logger.error(`[sync] Graphify startup refresh failed: ${error.message}`)
-      );
-    }
-    watcher = watchRepository({
-      repositoryRoot,
-      signal: controller.signal,
-      ...options.graphify?.enabled ? {
-        ignoredPaths: [
-          options.graphify.graphPath ? relative6(repositoryRoot, resolve12(repositoryRoot, options.graphify.graphPath)).split(sep6).join("/") : "graphify-out"
-        ]
-      } : {},
-      onIndex: (result) => {
-        if (result.added + result.changed + result.removed === 0) return;
-        zvecRefresh.schedule();
-        if (options.graphify?.enabled) graphRefresh.schedule();
-      },
-      onError: (error) => logger.error(`[sync] repository watch failed: ${error.message}`)
-    });
-    void watcher.catch(
-      (error) => logger.error(`[sync] live repository watch unavailable: ${error.message}`)
-    );
-  })().catch((error) => {
-    logger.error(`[sync] startup synchronization failed: ${error.message}`);
-    throw error;
-  });
-  function watchMemory() {
-    const onMemoryChange = options.onMemoryChange;
-    if (closing || !onMemoryChange) return;
-    try {
-      memoryRefresh = createCoalescer(
-        () => onMemoryChange().catch(
-          (error) => logger.error(`[sync] memory reindex failed: ${error.message}`)
-        ),
-        300
-      );
-      memoryWatcher = fsWatch2(
-        join9(repositoryRoot, ".codebuddy", "memory"),
-        { recursive: true },
-        (_event, filename) => {
-          const name = filename?.replace(/\\/g, "/") ?? "";
-          if (/^(facts\/fact|summaries\/sum)_[a-z0-9]+\.md$/.test(name)) memoryRefresh?.trigger();
-        }
-      );
-      memoryWatcher.on("error", () => memoryWatcher?.close());
-    } catch (error) {
-      logger.error(`[sync] live memory watch unavailable: ${error.message}`);
-    }
-  }
-  async function refreshGraph() {
-    const result = await generateGraphifyGraph({
-      repositoryRoot,
-      ...options.graphify?.graphPath ? { graphPath: options.graphify.graphPath } : {}
-    });
-    logger.info(`[sync] Graphify updated (${result.nodes} nodes, ${result.edges} edges)`);
-  }
-  return {
-    ready,
-    async close() {
-      closing = true;
-      controller.abort();
-      memoryRefresh?.stop();
-      memoryWatcher?.close();
-      await watcher?.catch(() => void 0);
-      await Promise.all([graphRefresh.settled(), zvecRefresh.settled()]);
-    }
-  };
-}
-
-// src/core/project-root.ts
-import { realpath as realpath2, stat as stat5 } from "fs/promises";
-import { homedir } from "os";
-import { isAbsolute as isAbsolute2, parse, resolve as resolve13 } from "path";
-async function resolveInitializedProjectRoot(configuredRoot, cwd = process.cwd()) {
-  if (configuredRoot !== void 0 && !isAbsolute2(configuredRoot)) {
-    throw new Error("CODEBUDDY_PROJECT_ROOT must be an absolute path to an initialized project.");
-  }
-  const selected = resolve13(configuredRoot ?? cwd);
-  const root = await realpath2(selected);
-  if (root === parse(root).root || root === await realpath2(homedir())) {
-    throw new Error(
-      "Select an initialized project folder, not the filesystem root or home folder."
-    );
-  }
-  const initialized = await stat5(configPath(root)).then(
-    (info) => info.isFile(),
-    () => false
-  );
-  if (!initialized) {
-    throw new Error(
-      `CodeBuddy will not scan ${root}: run codebuddy init in your project folder first. For a desktop client, re-register CodeBuddy from that folder to save its project path.`
-    );
-  }
-  return root;
-}
-
-// src/mcp/database.ts
-function createLazyDatabase(connect, options = {}) {
-  const retryMs = options.retryMs ?? 5e3;
-  let runtime;
-  let pending;
-  let failure;
-  let closed = false;
-  return {
-    get() {
-      if (runtime) return Promise.resolve(runtime);
-      if (closed) return Promise.reject(new Error("CodeBuddy MCP server is shutting down."));
-      if (pending) return pending;
-      if (failure && Date.now() - failure.at < retryMs) {
-        return Promise.reject(new Error(failure.error));
-      }
-      pending = connect().then(
-        async (handle) => {
-          if (closed) {
-            await handle.close();
-            throw new Error("CodeBuddy MCP server is shutting down.");
-          }
-          runtime = handle;
-          failure = void 0;
-          return handle;
-        },
-        (error) => {
-          failure = { error: describeError(error), at: Date.now() };
-          throw error;
-        }
-      ).finally(() => {
-        pending = void 0;
-      });
-      return pending;
-    },
-    status() {
-      if (runtime) return { available: true, state: "ready" };
-      if (pending) return { available: false, state: "connecting" };
-      if (!failure) return { available: false, state: "idle" };
-      return {
-        available: false,
-        state: "unavailable",
-        error: failure.error,
-        retryInMs: Math.max(0, failure.at + retryMs - Date.now())
-      };
-    },
-    async close() {
-      closed = true;
-      await pending?.catch(() => void 0);
-      const current = runtime;
-      runtime = void 0;
-      await current?.close();
-    }
-  };
-}
-function describeError(error) {
-  const err = error;
-  const text = err?.message || err?.code || String(error);
-  return String(redactSecrets(text)).slice(0, 300);
-}
-
-// src/mcp/server.ts
-async function startMcpServer(options = {}) {
-  const logger = pino({ level: process.env.LOG_LEVEL ?? "info" }, process.stderr);
-  const projectRoot = await resolveInitializedProjectRoot(
-    options.config?.projectRoot ?? process.env.CODEBUDDY_PROJECT_ROOT
-  );
-  const config = {
-    ...options.config ?? await loadRuntimeConfig(projectRoot, { requireDatabase: false }),
-    projectRoot
-  };
-  (config.postgresUrl ? codeBuddyConfigSchema : codeBuddyConfigSchema.omit({ postgresUrl: true })).parse(config);
-  const toolProfile = resolveToolProfile();
-  const importMemory = async (memory) => {
-    try {
-      const result = await memory.reindexMemory();
-      for (const failure of result.failures) {
-        logger.error(`[sync] memory file skipped (${failure.id}): ${failure.error}`);
-      }
-    } catch (error) {
-      logger.error(`[sync] Markdown memory import failed: ${error.message}`);
-    }
-  };
-  const database = createLazyDatabase(async () => {
-    try {
-      const runtime = await createRuntime(config, { autoBootstrap: true });
-      await importMemory(runtime.memory);
-      logger.info("PostgreSQL connected; memory tools available");
-      return runtime;
-    } catch (error) {
-      logger.warn(
-        `PostgreSQL unavailable; serving file-based tools only: ${error.message}`
-      );
-      throw error;
-    }
-  });
-  void database.get().catch(() => void 0);
-  const sync = startProjectSync({
-    repositoryRoot: projectRoot,
-    ...config.graphify ? { graphify: config.graphify } : {},
-    logger,
-    // Hand edits re-import live once PostgreSQL is connected; until then the
-    // next successful connect imports everything.
-    onMemoryChange: async () => {
-      if (database.status().state === "ready") await importMemory((await database.get()).memory);
-    }
-  });
-  const server = new McpServer({ name: "codebuddy", version: VERSION });
-  registerCodeBuddyTools(server, { config, database }, toolProfile);
-  const shutdown = async () => {
-    logger.info("codebuddy MCP server shutting down");
-    await server.close();
-    await sync.close();
-    await database.close();
-  };
-  let stopping;
-  const stop = () => {
-    stopping ??= shutdown().finally(() => process.exit(0));
-  };
-  process.once("SIGINT", stop);
-  process.once("SIGTERM", stop);
-  process.stdin.once("end", stop);
-  try {
-    await sync.ready;
-    await server.connect(new StdioServerTransport());
-  } catch (error) {
-    await sync.close();
-    await database.close();
-    throw error;
-  }
-  logger.info(`codebuddy MCP server started over stdio (tool profile: ${toolProfile})`);
-}
-
 export {
-  migrateMemoryToFiles,
   PLAN_STATUSES,
   ACTIVE_PLAN_STATUSES,
   PlanLockError,
   PlanValidationError,
   PlanFileStore,
-  PlanTransitionError,
-  PlanNotFoundError,
-  ActivePlanExistsError,
-  PlanLifecycle,
-  watchRepository,
-  VERSION,
   RiskAssessor,
   createChurnSignal,
   createIncidentSignal,
@@ -5089,24 +3761,32 @@ export {
   readPolicyFile,
   assessRisk,
   resolveRiskPaths,
+  PlanTransitionError,
+  PlanNotFoundError,
+  ActivePlanExistsError,
+  PlanLifecycle,
+  enforceContextBudget,
   WorklogStore,
   buildBootstrapContext,
   buildBeforeEditContext,
   ReviewStore,
+  captureAfterTurn,
   approveReviewItem,
-  tracePath,
-  readTraces,
-  parseTraceLines,
+  configuredReranker,
   openHookSemantics,
+  CONTEXT_HOOK_BUDGET_MS,
   runContextHook,
   runStageHook,
+  llmMemoryOptions,
   runCaptureHook,
   runSyncHook,
   runResetHook,
-  renderContextBlock,
-  generateSuggestions,
-  mcpToolInputSchemas,
-  registerCodeBuddyTools,
-  startMcpServer
+  extractEditedPaths,
+  deriveSummary,
+  turnVerification,
+  verificationLines,
+  turnUserPrompts,
+  lastAssistantMessage,
+  renderContextBlock
 };
-//# sourceMappingURL=chunk-VAKBJV26.js.map
+//# sourceMappingURL=chunk-YJIA2MFL.js.map