@orquentra/codebuddy 2.5.0 → 2.6.2

package/dist/{chunk-Z5QB367W.js → chunk-R7CD6EXS.js}

@@ -6,25 +6,20 @@ import {
   SessionCapsuleLedger,
   detectTestCommand,
   estimateTokens,
-  findCoveringTest
-} from "./chunk-CQPCHMBS.js";
+  findCoveringTest,
+  hookRoot
+} from "./chunk-J2EAZ4MA.js";
 import {
   TASK_PATH_LIMIT,
-  buildArchitectureMap,
   countTerms,
   discoverTaskPaths,
-  generateGraphifyGraph,
   identifierTokens,
-  indexRepository,
-  loadArchitectureMap,
   loadFreshIndex,
   loadProjectArchitectureMap,
   namedSegments,
-  neighbours,
-  queryMap,
   readBoundedSource,
   taskTerms
-} from "./chunk-L5AYZC3F.js";
+} from "./chunk-NERKZSSE.js";
 import {
   extractSymbolTable,
   supportsSymbols
@@ -32,12 +27,10 @@ import {
 import {
   INCIDENT_SEVERITIES,
   MemoryFileStore,
-  codeBuddyConfigSchema,
-  createRuntime,
   isEligibleMemory,
   lexicalTerms,
-  listFactsPage
-} from "./chunk-JDZ3VK26.js";
+  termOverlap
+} from "./chunk-S6VEG4S2.js";
 import {
   claimText,
   redactPersisted,
@@ -47,13 +40,10 @@ import {
 } from "./chunk-GDJH7XJC.js";
 import {
   generateEntityId
-} from "./chunk-4BYGTEJT.js";
+} from "./chunk-XBJQKCLU.js";
 import {
   DEFAULT_RERANK_MODELS
-} from "./chunk-JMWJ7V6Y.js";
-import {
-  refreshZvecIndex
-} from "./chunk-QDBDYCM2.js";
+} from "./chunk-JPHJBCZB.js";
 import {
   assertNoSymlinkBetween,
   composeMarkdown,
@@ -61,126 +51,19 @@ import {
   loadRuntimeConfig,
   parseFrontMatter,
   readConfigFile,
-  redactSecrets,
   writeAtomic
-} from "./chunk-776EQXDV.js";
+} from "./chunk-5KZY6OTG.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 mkdir6, readFile as readFile8, rm as rm4, stat as stat5, writeFile } from "fs/promises";
+import { basename, dirname as dirname5, isAbsolute, join as join8, 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 { readFile as readFile4 } from "fs/promises";
+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";
@@ -411,7 +294,7 @@ function formatIssues(error) {
   });
 }
 function delay(ms) {
-  return new Promise((resolve13) => setTimeout(resolve13, ms));
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 async function releaseOwnedLock(lockPath) {
   try {
@@ -607,124 +490,10 @@ var PlanLifecycle = class {
   }
 };
 
-// package.json
-var package_default = {
-  name: "@orquentra/codebuddy",
-  version: "2.5.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/service.ts
+import { spawn as spawn2 } from "child_process";
+import { realpath as realpath2 } from "fs/promises";
+import { relative as relative2, resolve as resolve3, sep as sep2 } from "path";
 
 // src/risk/assessor.ts
 var RiskAssessor = class {
@@ -745,7 +514,7 @@ var RiskAssessor = class {
     const byPath = /* @__PURE__ */ new Map();
     const perSignal = /* @__PURE__ */ new Map();
     for (const { signal, contributions } of settled) {
-      const stat5 = perSignal.get(signal.id) ?? {
+      const stat6 = perSignal.get(signal.id) ?? {
         id: signal.id,
         category: signal.category,
         contributions: 0,
@@ -756,10 +525,10 @@ var RiskAssessor = class {
         const list = byPath.get(contribution.path) ?? [];
         list.push({ signal, contribution });
         byPath.set(contribution.path, list);
-        stat5.contributions += 1;
-        stat5.totalWeight += contribution.weight;
+        stat6.contributions += 1;
+        stat6.totalWeight += contribution.weight;
       }
-      perSignal.set(signal.id, stat5);
+      perSignal.set(signal.id, stat6);
     }
     const items = [];
     for (const [path, contributions] of byPath) {
@@ -891,7 +660,7 @@ async function gitLogForPath(repositoryRoot, path, since) {
   }).filter((record) => record.sha.length > 0);
 }
 function runGit(cwd, args) {
-  return new Promise((resolve13, reject) => {
+  return new Promise((resolve10, reject) => {
     const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
@@ -902,7 +671,7 @@ function runGit(cwd, args) {
       stderr += String(chunk);
     });
     child.on("error", reject);
-    child.on("close", (code) => resolve13({ code: code ?? 0, stdout, stderr }));
+    child.on("close", (code) => resolve10({ code: code ?? 0, stdout, stderr }));
   });
 }
 
@@ -1038,8 +807,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({
@@ -1090,7 +857,14 @@ 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(async (path) => {
+      const real = await realpath2(resolve3(input.repositoryRoot, path)).catch(() => null);
+      return real === null || real === realRoot || real.startsWith(`${realRoot}${sep2}`);
+    })
+  );
+  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;
@@ -1107,9 +881,7 @@ async function changedGitPaths(repositoryRoot) {
     runGit2(repositoryRoot, ["diff", "--name-only", "HEAD"]),
     runGit2(repositoryRoot, ["ls-files", "--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("\n"), ...untracked.stdout.split("\n")].map((path) => path.trim()).filter((path) => path && !path.startsWith(".codebuddy/"));
 }
 function runGit2(cwd, args) {
   return new Promise((resolveResult, reject) => {
@@ -1130,207 +902,8 @@ function normalizePath2(path) {
   return path.replace(/\\/g, "/").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] = [];
-  }
-  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/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")
-        }));
-      }
-    });
-    return output;
-  } catch {
-    return enforceContextBudget({ ...payload });
-  }
-}
-
-// 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 { createHash } 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 { parse as parseYaml3, stringify as stringifyYaml2 } from "yaml";
@@ -1373,7 +946,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,
@@ -1520,45 +1093,176 @@ 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 })
-  ]);
+// 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] = [];
+  }
+  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");
@@ -1661,10 +1365,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,
@@ -1718,7 +1422,7 @@ async function buildBeforeEditContext(input) {
     facts: relevantFacts,
     handoffs,
     risks,
-    neighbours: neighbours2,
+    neighbours,
     symbols,
     tests,
     testCommand,
@@ -2023,8 +1727,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,
@@ -2115,7 +1821,16 @@ async function rankRelevantFacts(facts, namespace, task, targetPaths, semanticRa
     } catch {
     }
   }
-  return fused.slice(0, LIMITS2.relevantFacts).map(({ fact, taskScore, pathScore, score }) => {
+  const selected = [];
+  for (const candidate of fused) {
+    if (selected.length >= LIMITS2.relevantFacts) break;
+    const text = candidate.fact.content || candidate.fact.object;
+    if (selected.some((kept) => termOverlap(text, kept.fact.content || kept.fact.object) >= 0.8)) {
+      continue;
+    }
+    selected.push(candidate);
+  }
+  return selected.map(({ fact, taskScore, pathScore, score }) => {
     const evidence = [
       pathScore > 0 ? "matches a target path" : "",
       taskScore > 0 ? `shares ${taskScore / 3} task term(s)` : "",
@@ -2159,13 +1874,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
@@ -2835,8 +2545,36 @@ async function gate(args) {
       ref: match.incident.id
     };
   }
-  const ref = await saveDurable(args);
   const superseded = candidate.content.match(/\bsupersedes\s+(fact_[a-z0-9]+)\b/i)?.[1];
+  if (candidate.class !== "incident" && !superseded) {
+    const similar = await nearestFact(
+      args.memoryStore,
+      args.input.namespace,
+      candidate,
+      fingerprint
+    );
+    if (similar && similar.overlap >= DUPLICATE_OVERLAP) {
+      return {
+        ...base,
+        outcome: "ignored",
+        reason: `near-duplicate of ${similar.id} (${Math.round(similar.overlap * 100)}% shared words)`,
+        ref: similar.id
+      };
+    }
+    if (similar && similar.overlap >= UPDATE_OVERLAP) {
+      const existing = (await args.reviewStore.list()).find(
+        (item) => item.fingerprint === fingerprint
+      );
+      const ref2 = existing?.id ?? await queue(args, `possible update of ${similar.id}`);
+      return {
+        ...base,
+        outcome: "queued",
+        reason: `overlaps ${similar.id} (${Math.round(similar.overlap * 100)}% shared words): review as a possible update`,
+        ref: ref2
+      };
+    }
+  }
+  const ref = await saveDurable(args);
   if (superseded && superseded !== ref) {
     try {
       await args.memoryStore.markFactSuperseded(superseded, ref);
@@ -2845,6 +2583,19 @@ async function gate(args) {
   }
   return { ...base, outcome: "saved", reason: `confident ${candidate.class} auto-saved`, ref };
 }
+var DUPLICATE_OVERLAP = 0.8;
+var UPDATE_OVERLAP = 0.5;
+async function nearestFact(memoryStore, namespace, candidate, fingerprint) {
+  let best = null;
+  for (const fact of await memoryStore.listFacts()) {
+    if (fact.fingerprint === fingerprint || fact.category === "incident") continue;
+    if (fact.predicate === "rule" || fact.predicate === "procedure") continue;
+    if (!isEligibleMemory(fact, { namespace })) continue;
+    const overlap = termOverlap(candidate.content, fact.content || fact.object);
+    if (!best || overlap > best.overlap) best = { id: fact.id, overlap };
+  }
+  return best;
+}
 async function saveDurable(args) {
   const { candidate, input, memoryStore, now } = args;
   const fingerprint = candidateFingerprint(input.namespace, candidate);
@@ -2920,7 +2671,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());
@@ -2970,7 +2721,7 @@ async function approveReviewItem(id, options = {}) {
 }
 
 // src/tracing/log.ts
-import { appendFile, mkdir as mkdir4, readFile as readFile6, stat as stat3, writeFile } from "fs/promises";
+import { appendFile, mkdir as mkdir4, readFile as readFile6, stat as stat3 } from "fs/promises";
 import { dirname as dirname4, join as join6 } from "path";
 var MAX_BYTES = 4 * 1024 * 1024;
 function tracePath(repositoryRoot) {
@@ -2985,7 +2736,7 @@ async function recordTrace(repositoryRoot, 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")}
+      await writeAtomic(path, `${lines.slice(Math.floor(lines.length / 2)).join("\n")}
 `);
     }
   } catch {
@@ -3028,7 +2779,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-3NGNESNB.js");
+      const { rerankLocally } = await import("./local-5MZURLCZ.js");
       return bounded(
         rerankLocally({ id: model, ...revision ? { revision } : {} }, task, documents)
       );
@@ -3036,7 +2787,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-GP6G3EAK.js");
+  const { rerankHuggingFace, rerankOpenRouter } = await import("./cloud-7WM3YLI4.js");
   const call = provider === "openrouter" ? rerankOpenRouter : rerankHuggingFace;
   return (task, documents) => call({ apiKey, model, timeoutMs: RERANK_BUDGET_MS }, task, documents);
 }
@@ -3045,8 +2796,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-EQGOFCBD.js");
-    const opening = createRuntime2(config, {
+    const { createRuntime } = await import("./operations-POCHY3WR.js");
+    const opening = createRuntime(config, {
       repositoryRoot,
       startWorker: false,
       connectTimeoutSeconds: 2
@@ -3082,6 +2833,7 @@ 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";
+var STAGING_LOCK_STALE_MS = 1e4;
 var HookStagingStore = class {
   directory;
   operations = Promise.resolve();
@@ -3206,6 +2958,14 @@ var HookStagingStore = class {
         break;
       } catch (error) {
         if (error.code !== "EEXIST" || attempt >= 200) throw error;
+        const age = await stat4(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));
       }
     }
@@ -3252,7 +3012,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;
@@ -3317,14 +3077,14 @@ function recallTrace(input, beforeEdit, emitted, text, started, late) {
   };
 }
 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-KIC5FJVW.js")).llmCaptureOptions(repositoryRoot);
   } catch {
     return {};
   }
@@ -3333,7 +3093,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);
@@ -3403,39 +3163,78 @@ 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-EQGOFCBD.js");
-  const started = Date.now();
-  const runtime = await createRuntime2(config, { repositoryRoot });
+  const lock = join8(repositoryRoot, ".codebuddy", "cache", "sync.lock");
+  const dirty = join8(repositoryRoot, ".codebuddy", "cache", "sync.dirty");
+  await mkdir6(dirname5(lock), { recursive: true });
+  if (!await takeLock(lock)) {
+    await writeFile(dirty, "").catch(() => void 0);
+    return null;
+  }
+  const { createRuntime } = await import("./operations-POCHY3WR.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 stat5(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
-      }
-    });
-    return { reindex, drained };
+    ));
+    return result;
   } finally {
     await runtime.close();
+    await rm4(lock, { recursive: true, force: true });
+  }
+}
+var SYNC_LOCK_STALE_MS = SYNC_BUDGET_MS + 6e4;
+async function takeLock(path) {
+  try {
+    await mkdir6(path);
+    return true;
+  } catch {
+    const age = await stat5(path).then(
+      (info) => Date.now() - info.mtimeMs,
+      () => 0
+    );
+    if (age < SYNC_LOCK_STALE_MS) return false;
+    await rm4(path, { recursive: true, force: true });
+    return mkdir6(path).then(
+      () => true,
+      () => false
+    );
   }
 }
 async function runResetHook(input) {
-  const repositoryRoot = resolve9(input.cwd ?? process.cwd());
+  const repositoryRoot = hookRoot(input.cwd);
   await new SessionCapsuleLedger(repositoryRoot).reset(input.session_id ?? "default");
 }
 function extractEditedPaths(toolInput) {
@@ -3750,1243 +3549,7 @@ 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/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 config = options.config ?? await loadRuntimeConfig(process.cwd(), { requireDatabase: false });
-  (config.postgresUrl ? codeBuddyConfigSchema : codeBuddyConfigSchema.omit({ postgresUrl: true })).parse(config);
-  const toolProfile = resolveToolProfile();
-  const projectRoot = config.projectRoot ?? process.env.CODEBUDDY_PROJECT_ROOT ?? process.cwd();
-  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,
@@ -4996,8 +3559,7 @@ export {
   PlanNotFoundError,
   ActivePlanExistsError,
   PlanLifecycle,
-  watchRepository,
-  VERSION,
+  enforceContextBudget,
   RiskAssessor,
   createChurnSignal,
   createIncidentSignal,
@@ -5009,20 +3571,27 @@ export {
   buildBootstrapContext,
   buildBeforeEditContext,
   ReviewStore,
+  captureAfterTurn,
   approveReviewItem,
   tracePath,
+  recordTrace,
   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-Z5QB367W.js.map
+//# sourceMappingURL=chunk-R7CD6EXS.js.map