@orquentra/codebuddy 2.5.0 → 2.6.2

package/dist/chunk-IMFUYEZA.js

@@ -0,0 +1,1607 @@
+import {
+  PlanFileStore,
+  PlanLifecycle,
+  assessRisk,
+  buildBeforeEditContext,
+  buildBootstrapContext,
+  captureAfterTurn,
+  configuredReranker,
+  enforceContextBudget,
+  llmMemoryOptions,
+  readPolicyFile,
+  recordTrace,
+  resolveRiskPaths
+} from "./chunk-R7CD6EXS.js";
+import {
+  SessionCapsuleLedger,
+  estimateTokens
+} from "./chunk-J2EAZ4MA.js";
+import {
+  buildArchitectureMap,
+  generateGraphifyGraph,
+  indexRepository,
+  loadArchitectureMap,
+  loadFreshIndex,
+  neighbours,
+  queryMap
+} from "./chunk-NERKZSSE.js";
+import {
+  codeBuddyConfigSchema,
+  createRuntime,
+  listFactsPage
+} from "./chunk-2XDPKFUW.js";
+import {
+  MemoryFileStore,
+  VERSION
+} from "./chunk-S6VEG4S2.js";
+import {
+  redactPersisted
+} from "./chunk-GDJH7XJC.js";
+import {
+  refreshZvecIndex
+} from "./chunk-5FW3PMNP.js";
+import {
+  configPath,
+  loadPlanPolicy,
+  loadRuntimeConfig,
+  redactSecrets
+} 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/mcp/tools/index.ts
+import { z } from "zod";
+
+// src/context/delivery.ts
+import { createHash as createHash2 } from "crypto";
+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/suggest/engine.ts
+import { constants } from "fs";
+import { access } from "fs/promises";
+import { extname, join, resolve } 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 = resolve(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 } : {}
+    }),
+    resolveRelevantPlan(planStore, namespace, input.planId),
+    memoryStore.findIncidentFactsForPaths({ namespace, paths: targetPaths }),
+    buildArchitectureMap(repositoryRoot),
+    readPolicyFile(join(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) => normalize(file.path)));
+    const strays = targetPaths.filter((path) => !planned.has(normalize(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(join(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 resolveRelevantPlan(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(join(repositoryRoot, candidate))) return true;
+  }
+  return false;
+}
+function literalPrefix(pattern) {
+  const normalized = normalize(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 normalize(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: z.string().min(1).max(200).optional(),
+  ack: z.string().regex(/^dlv_[a-z0-9]+$/).optional(),
+  full: z.boolean().optional()
+};
+var rememberSchema = {
+  sessionId: z.string().min(1).max(200).optional(),
+  content: z.string().min(1).max(INPUT_LIMITS.contentChars),
+  type: z.enum(["interaction", "fact", "summary"]).optional(),
+  idempotencyKey: z.string().min(1).max(200).optional(),
+  agentId: z.string().min(1).max(INPUT_LIMITS.agentIdChars).optional()
+};
+var recallSchema = {
+  sessionId: z.string().min(1).max(200),
+  query: z.string().min(1).max(INPUT_LIMITS.taskChars),
+  budget: z.number().int().positive().optional(),
+  callerModel: z.string().min(1).max(200).optional(),
+  conflictMode: z.enum(["all", "latest", "highest_confidence"]).optional()
+};
+var shareSchema = {
+  from: z.string().min(1).max(INPUT_LIMITS.agentIdChars).optional(),
+  to_namespace: z.string().min(1).max(INPUT_LIMITS.agentIdChars),
+  factIds: z.array(z.string().min(1).max(100)).min(1).max(INPUT_LIMITS.arrayItems),
+  mode: z.enum(["reference", "snapshot"]).optional(),
+  /** Snapshot mode: the target project's root; its Markdown store receives the copy. */
+  to_project_root: z.string().min(1).max(INPUT_LIMITS.pathChars).optional(),
+  agentId: z.string().min(1).max(INPUT_LIMITS.agentIdChars).optional()
+};
+var unshareSchema = {
+  to_namespace: z.string().min(1).max(INPUT_LIMITS.agentIdChars),
+  factIds: z.array(z.string().min(1).max(100)).min(1).max(INPUT_LIMITS.arrayItems),
+  agentId: z.string().min(1).max(INPUT_LIMITS.agentIdChars).optional()
+};
+var plannedFileSchema = z.object({
+  path: z.string().min(1).max(INPUT_LIMITS.pathChars),
+  action: z.enum(["create", "edit", "delete"]),
+  notes: z.string().max(INPUT_LIMITS.taskChars).optional()
+});
+var plannedTestSchema = z.object({
+  path: z.string().min(1).max(INPUT_LIMITS.pathChars),
+  description: z.string().max(INPUT_LIMITS.taskChars).optional()
+});
+var planPatchSchema = {
+  title: z.string().min(1).max(INPUT_LIMITS.titleChars).optional(),
+  brief: z.string().max(INPUT_LIMITS.planBriefChars).optional(),
+  body: z.string().max(INPUT_LIMITS.planBodyChars).optional(),
+  filesToTouch: z.array(plannedFileSchema).max(INPUT_LIMITS.arrayItems).optional(),
+  testsToAdd: z.array(plannedTestSchema).max(INPUT_LIMITS.arrayItems).optional(),
+  outOfScope: z.array(z.string().max(INPUT_LIMITS.pathChars)).max(INPUT_LIMITS.arrayItems).optional(),
+  risks: z.array(z.string().max(INPUT_LIMITS.taskChars)).max(INPUT_LIMITS.arrayItems).optional()
+};
+var mcpToolInputSchemas = {
+  remember: z.object(rememberSchema),
+  remember_batch: z.object({ items: z.array(z.object(rememberSchema)).min(1) }),
+  recall: z.object(recallSchema),
+  list_facts: z.object({
+    subject: z.string().optional(),
+    limit: z.number().int().positive().max(100).default(50),
+    cursor: z.string().optional()
+  }),
+  list_namespaces: z.object({}),
+  forget: z.object({ id: z.string().min(1) }),
+  share: z.object(shareSchema),
+  unshare: z.object(unshareSchema),
+  plan_current: z.object({}),
+  plan_create: z.object({
+    title: z.string().min(1).max(INPUT_LIMITS.titleChars),
+    brief: z.string().min(1).max(INPUT_LIMITS.planBriefChars),
+    body: z.string().max(INPUT_LIMITS.planBodyChars).optional(),
+    filesToTouch: z.array(plannedFileSchema).max(INPUT_LIMITS.arrayItems).optional(),
+    testsToAdd: z.array(plannedTestSchema).max(INPUT_LIMITS.arrayItems).optional(),
+    outOfScope: z.array(z.string().max(INPUT_LIMITS.pathChars)).max(INPUT_LIMITS.arrayItems).optional(),
+    risks: z.array(z.string().max(INPUT_LIMITS.taskChars)).max(INPUT_LIMITS.arrayItems).optional(),
+    agentId: z.string().min(1).max(INPUT_LIMITS.agentIdChars).optional()
+  }),
+  plan_amend: z.object({ id: z.string().min(1), patch: z.object(planPatchSchema) }),
+  plan_status: z.object({
+    id: z.string().min(1),
+    status: z.enum(["approved", "executing", "complete", "abandoned"]),
+    commitSha: z.string().optional(),
+    notes: z.string().optional(),
+    reason: z.string().optional()
+  }),
+  risk_assess: z.object({
+    planId: z.string().min(1).max(100).optional(),
+    paths: z.array(z.string().min(1).max(INPUT_LIMITS.pathChars)).max(INPUT_LIMITS.arrayItems).optional(),
+    evidence: z.enum(["overview", "source"]).optional(),
+    useGit: z.boolean().optional(),
+    limit: z.number().int().positive().max(100).optional()
+  }),
+  map_query: z.object({
+    from: z.string().min(1).max(INPUT_LIMITS.pathChars).optional(),
+    to: z.string().min(1).max(INPUT_LIMITS.pathChars).optional(),
+    limit: z.number().int().positive().max(100).optional()
+  }),
+  map_neighbours: z.object({
+    module: z.string().min(1).max(INPUT_LIMITS.pathChars),
+    direction: z.enum(["in", "out", "both"]).default("both")
+  }),
+  context_bootstrap: z.object({ ...deliverySchema }),
+  context_before_edit: z.object({
+    task: z.string().min(1).max(INPUT_LIMITS.taskChars).optional(),
+    paths: z.array(z.string().min(1).max(INPUT_LIMITS.pathChars)).max(INPUT_LIMITS.arrayItems).optional(),
+    planId: z.string().min(1).max(100).optional(),
+    evidence: z.enum(["overview", "source"]).optional(),
+    useGit: z.boolean().optional(),
+    tokenBudget: z.number().int().positive().max(1e5).optional(),
+    ...deliverySchema
+  }),
+  context_pack: z.object({
+    task: z.string().min(1).max(INPUT_LIMITS.taskChars),
+    paths: z.array(z.string().min(1).max(INPUT_LIMITS.pathChars)).max(INPUT_LIMITS.arrayItems).optional(),
+    planId: z.string().min(1).max(100).optional(),
+    evidence: z.enum(["overview", "source"]).optional(),
+    useGit: z.boolean().optional(),
+    tokenBudget: z.number().int().positive().max(1e5).optional(),
+    ...deliverySchema
+  }),
+  context_after_turn: z.object({
+    summary: z.string().min(1).max(INPUT_LIMITS.summaryChars),
+    changedFiles: z.array(z.string().min(1).max(INPUT_LIMITS.pathChars)).max(INPUT_LIMITS.arrayItems).optional(),
+    planId: z.string().min(1).max(100).optional(),
+    taskType: z.string().min(1).max(100).optional(),
+    agentId: z.string().min(1).max(INPUT_LIMITS.agentIdChars).optional(),
+    sessionId: z.string().min(1).max(200).optional(),
+    verification: z.array(z.string().min(1).max(500)).max(20).optional(),
+    commitSha: z.string().min(7).max(64).optional()
+  }),
+  code_suggestions: z.object({
+    paths: z.array(z.string().min(1).max(INPUT_LIMITS.pathChars)).max(INPUT_LIMITS.arrayItems).optional(),
+    planId: z.string().min(1).max(100).optional(),
+    evidence: z.enum(["overview", "source"]).optional(),
+    useGit: z.boolean().optional(),
+    limit: z.number().int().positive().max(100).optional()
+  }),
+  health: z.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({ respace: false });
+      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 join2, relative, resolve as resolve3, sep } from "path";
+
+// src/indexer/watch.ts
+import { watch as fsWatch } from "fs";
+import { resolve as resolve2 } 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 = resolve2(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 = resolve3(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 ? relative(repositoryRoot, resolve3(repositoryRoot, options.graphify.graphPath)).split(sep).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(
+        join2(repositoryRoot, ".codebuddy", "memory"),
+        { recursive: true },
+        (_event, filename) => {
+          const name = filename?.replace(/\\/g, "/") ?? "";
+          if (/^(facts\/fact|summaries\/sum)_[a-z0-9]+\.md$/.test(name)) memoryRefresh?.trigger();
+        }
+      );
+      memoryWatcher.on("error", () => memoryWatcher?.close());
+    } catch (error) {
+      logger.error(`[sync] live memory watch unavailable: ${error.message}`);
+    }
+  }
+  async function refreshGraph() {
+    const result = await generateGraphifyGraph({
+      repositoryRoot,
+      ...options.graphify?.graphPath ? { graphPath: options.graphify.graphPath } : {}
+    });
+    logger.info(`[sync] Graphify updated (${result.nodes} nodes, ${result.edges} edges)`);
+  }
+  return {
+    ready,
+    async close() {
+      closing = true;
+      controller.abort();
+      memoryRefresh?.stop();
+      memoryWatcher?.close();
+      await watcher?.catch(() => void 0);
+      await Promise.all([graphRefresh.settled(), zvecRefresh.settled()]);
+    }
+  };
+}
+
+// src/core/project-root.ts
+import { realpath, stat } from "fs/promises";
+import { homedir } from "os";
+import { isAbsolute, parse, resolve as resolve4 } from "path";
+async function resolveInitializedProjectRoot(configuredRoot, cwd = process.cwd()) {
+  if (configuredRoot !== void 0 && !isAbsolute(configuredRoot)) {
+    throw new Error("CODEBUDDY_PROJECT_ROOT must be an absolute path to an initialized project.");
+  }
+  const selected = resolve4(configuredRoot ?? cwd);
+  const root = await realpath(selected);
+  if (root === parse(root).root || root === await realpath(homedir())) {
+    throw new Error(
+      "Select an initialized project folder, not the filesystem root or home folder."
+    );
+  }
+  const initialized = await stat(configPath(root)).then(
+    (info) => info.isFile(),
+    () => false
+  );
+  if (!initialized) {
+    throw new Error(
+      `CodeBuddy will not scan ${root}: run codebuddy use (or codebuddy init) in your project folder first. For a desktop client, re-register CodeBuddy from that folder to save its project path.`
+    );
+  }
+  return root;
+}
+
+// src/mcp/database.ts
+function createLazyDatabase(connect, options = {}) {
+  const retryMs = options.retryMs ?? 5e3;
+  let runtime;
+  let pending;
+  let failure;
+  let closed = false;
+  return {
+    get() {
+      if (runtime) return Promise.resolve(runtime);
+      if (closed) return Promise.reject(new Error("CodeBuddy MCP server is shutting down."));
+      if (pending) return pending;
+      if (failure && Date.now() - failure.at < retryMs) {
+        return Promise.reject(new Error(failure.error));
+      }
+      pending = connect().then(
+        async (handle) => {
+          if (closed) {
+            await handle.close();
+            throw new Error("CodeBuddy MCP server is shutting down.");
+          }
+          runtime = handle;
+          failure = void 0;
+          return handle;
+        },
+        (error) => {
+          failure = { error: describeError(error), at: Date.now() };
+          throw error;
+        }
+      ).finally(() => {
+        pending = void 0;
+      });
+      return pending;
+    },
+    status() {
+      if (runtime) return { available: true, state: "ready" };
+      if (pending) return { available: false, state: "connecting" };
+      if (!failure) return { available: false, state: "idle" };
+      return {
+        available: false,
+        state: "unavailable",
+        error: failure.error,
+        retryInMs: Math.max(0, failure.at + retryMs - Date.now())
+      };
+    },
+    async close() {
+      closed = true;
+      await pending?.catch(() => void 0);
+      const current = runtime;
+      runtime = void 0;
+      await current?.close();
+    }
+  };
+}
+function describeError(error) {
+  const err = error;
+  const text = err?.message || err?.code || String(error);
+  return String(redactSecrets(text)).slice(0, 300);
+}
+
+// src/mcp/server.ts
+async function startMcpServer(options = {}) {
+  const logger = pino({ level: process.env.LOG_LEVEL ?? "info" }, process.stderr);
+  let projectRoot;
+  try {
+    projectRoot = await resolveInitializedProjectRoot(
+      options.config?.projectRoot ?? process.env.CODEBUDDY_PROJECT_ROOT
+    );
+  } catch (error) {
+    logger.error(error.message);
+    await startSetupServer(error.message);
+    return;
+  }
+  const config = {
+    ...options.config ?? await loadRuntimeConfig(projectRoot, { requireDatabase: false }),
+    projectRoot
+  };
+  (config.postgresUrl ? codeBuddyConfigSchema : codeBuddyConfigSchema.omit({ postgresUrl: true })).parse(config);
+  const toolProfile = resolveToolProfile();
+  const importMemory = async (memory, respace) => {
+    try {
+      const result = await memory.reindexMemory(respace ? {} : { respace: false });
+      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 }).catch(
+        (error) => {
+          void startBundledPostgres(config.postgresUrl, error, logger).then((started) => {
+            if (started) retryUntilConnected();
+          });
+          throw error;
+        }
+      );
+      await importMemory(runtime.memory, true);
+      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 retryUntilConnected = (attempt = 0) => {
+    if (attempt >= 20 || database.status().state === "ready") return;
+    setTimeout(() => {
+      void database.get().then(
+        () => void 0,
+        () => retryUntilConnected(attempt + 1)
+      );
+    }, 6e3).unref();
+  };
+  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, false);
+      }
+    }
+  });
+  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})`);
+}
+async function startSetupServer(problem) {
+  const fix = [
+    "Open your project folder in a terminal and run `codebuddy use` (or `codebuddy init`) if it has no .codebuddy/config.json.",
+    "Then register CodeBuddy from that folder so the client starts it there: `codebuddy claude install` (Claude Desktop) or `codebuddy codex install` (Codex), and restart the client.",
+    "Or set CODEBUDDY_PROJECT_ROOT to the project's absolute path in this server's env."
+  ];
+  const server = new McpServer(
+    { name: "codebuddy", version: VERSION },
+    {
+      instructions: `CodeBuddy is connected but not serving a project: ${problem} To fix it: ${fix.join(" ")}`
+    }
+  );
+  server.registerTool(
+    "health",
+    {
+      title: "Health",
+      description: "Report CodeBuddy's status. This server has no project yet; the result says why and how to fix it."
+    },
+    async () => serializeToolResult({ ok: false, project: null, problem, fix })
+  );
+  const stop = () => void server.close().finally(() => process.exit(0));
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+  process.stdin.once("end", stop);
+  await server.connect(new StdioServerTransport());
+}
+var triedBundledPostgres = false;
+async function startBundledPostgres(postgresUrl, error, logger) {
+  if (triedBundledPostgres || process.env.CODEBUDDY_DOCKER_AUTOSTART === "0") return false;
+  if (!isBundledPostgres(postgresUrl) || !isConnectionRefused(error)) return false;
+  triedBundledPostgres = true;
+  const { isDockerDaemonRunning } = await import("./docker-autostart-KDME7TVC.js");
+  if (!await isDockerDaemonRunning()) {
+    logger.warn(
+      "PostgreSQL is down and Docker is not running; start Docker Desktop, then `codebuddy postgres up`."
+    );
+    return false;
+  }
+  const { execFile } = await import("child_process");
+  const started = await new Promise(
+    (done) => execFile(
+      "docker",
+      ["start", "codebuddy-postgres"],
+      { timeout: 3e4 },
+      (failed) => done(failed === null)
+    )
+  );
+  if (started) {
+    logger.info("Started the stopped codebuddy-postgres container; retrying PostgreSQL.");
+    return true;
+  }
+  const { postgresUp } = await import("./postgres-docker-QQZQ2ABK.js");
+  const result = await postgresUp().catch(() => ({ code: 1, stderr: "docker compose failed" }));
+  if (result.code === 0) {
+    logger.info("Started the bundled PostgreSQL container; retrying PostgreSQL.");
+    return true;
+  }
+  logger.warn(
+    `Could not start the bundled PostgreSQL container: ${String(result.stderr).trim().slice(0, 200)}`
+  );
+  return false;
+}
+function isBundledPostgres(postgresUrl) {
+  try {
+    const url = new URL(postgresUrl);
+    return ["localhost", "127.0.0.1", "::1", "[::1]"].includes(url.hostname) && (url.port === "" || url.port === "5432") && url.username === "codebuddy";
+  } catch {
+    return false;
+  }
+}
+function isConnectionRefused(error) {
+  for (let current = error; current; ) {
+    if (current.code === "ECONNREFUSED") return true;
+    if (Array.isArray(current.errors) && current.errors.some((inner) => isConnectionRefused(inner))) {
+      return true;
+    }
+    current = current.cause;
+  }
+  return false;
+}
+
+export {
+  migrateMemoryToFiles,
+  watchRepository,
+  generateSuggestions,
+  mcpToolInputSchemas,
+  registerCodeBuddyTools,
+  startMcpServer
+};
+//# sourceMappingURL=chunk-IMFUYEZA.js.map