@askexenow/exe-os 0.9.299 → 0.9.301

package/dist/chunk-6UVUJNLY.js

@@ -0,0 +1,1186 @@
+import {
+  formatDegradations,
+  getRetrievalHealth
+} from "./chunk-F7MZA3QP.js";
+import {
+  buildRestartReport,
+  formatRestartReport
+} from "./chunk-KQ4Z2G24.js";
+import {
+  blobToVector
+} from "./chunk-OTVEIJUQ.js";
+import {
+  EXE_HOOK_MANIFEST,
+  LEGACY_SPLIT_POST_TOOL_HOOK_MARKERS,
+  manifestEntryForCommand
+} from "./chunk-L3TB7CC3.js";
+import {
+  isMainModule
+} from "./chunk-6Y4B3QF6.js";
+
+// src/bin/exe-doctor.ts
+import os from "os";
+import { existsSync, readFileSync } from "fs";
+import { spawn } from "child_process";
+import path from "path";
+import { randomUUID } from "crypto";
+
+// src/lib/conflict-detector.ts
+var DEFAULT_MAX_PAIRS = 100;
+var SIM_LOW = 0.85;
+var SIM_HIGH = 0.95;
+var LLM_BATCH_SIZE = 15;
+function cosineSimilarity(a, b) {
+  let dot = 0, normA = 0, normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+async function fetchMemoriesWithVectors(client, projectFilter, agentFilter2) {
+  let hasStatusCol = false;
+  try {
+    const info = await client.execute("PRAGMA table_info(memories)");
+    hasStatusCol = info.rows.some((r) => r.name === "status");
+  } catch {
+  }
+  const clauses = ["vector IS NOT NULL"];
+  if (hasStatusCol) clauses.push("status = 'active'");
+  const args = [];
+  if (projectFilter) {
+    clauses.push("project_name = ?");
+    args.push(projectFilter);
+  }
+  if (agentFilter2) {
+    clauses.push("agent_id = ?");
+    args.push(agentFilter2);
+  }
+  const where = " WHERE " + clauses.join(" AND ");
+  const result = await client.execute({
+    sql: `SELECT id, agent_id, raw_text, timestamp, project_name, vector
+          FROM memories${where}
+          ORDER BY project_name, timestamp DESC`,
+    args
+  });
+  const byProject = /* @__PURE__ */ new Map();
+  for (const row of result.rows) {
+    const project = row.project_name;
+    const vec = row.vector == null ? null : Array.isArray(row.vector) ? row.vector : blobToVector(row.vector);
+    if (!vec || vec.length === 0) continue;
+    const mem = {
+      id: row.id,
+      agent_id: row.agent_id,
+      raw_text: row.raw_text,
+      timestamp: row.timestamp,
+      vector: vec
+    };
+    const list = byProject.get(project);
+    if (list) list.push(mem);
+    else byProject.set(project, [mem]);
+  }
+  return byProject;
+}
+function findCandidatePairs(memories, maxPairs) {
+  const pairs = [];
+  for (let i = 0; i < memories.length && pairs.length < maxPairs; i++) {
+    for (let j = i + 1; j < memories.length && pairs.length < maxPairs; j++) {
+      const sim = cosineSimilarity(memories[i].vector, memories[j].vector);
+      if (sim >= SIM_LOW && sim <= SIM_HIGH) {
+        pairs.push({ a: memories[i], b: memories[j], similarity: sim });
+      }
+    }
+  }
+  pairs.sort((x, y) => y.similarity - x.similarity);
+  return pairs;
+}
+async function classifyPairsBatch(pairs) {
+  const Anthropic = (await import("@anthropic-ai/sdk")).default;
+  const client = new Anthropic();
+  const pairDescriptions = pairs.map(
+    (p, i) => `Pair ${i + 1}:
+Memory A (${p.a.agent_id}, ${p.a.timestamp}): "${p.a.raw_text.slice(0, 300)}"
+Memory B (${p.b.agent_id}, ${p.b.timestamp}): "${p.b.raw_text.slice(0, 300)}"`
+  ).join("\n\n");
+  const prompt = `You are classifying pairs of memory records for contradictions.
+
+For each pair, classify as:
+- AGREE: Both memories say the same thing (no action needed).
+- CONFLICT: The memories contradict each other (one must be wrong).
+- SUPERSEDED: One memory replaces/updates the other (the older one is outdated).
+
+Respond with a JSON array. Each element: {"pair": <1-indexed>, "classification": "AGREE"|"CONFLICT"|"SUPERSEDED", "explanation": "<brief reason>"}
+
+${pairDescriptions}
+
+Respond ONLY with the JSON array, no markdown fences.`;
+  const response = await client.messages.create({
+    model: "claude-haiku-4-5-20251001",
+    max_tokens: 1024,
+    messages: [{ role: "user", content: prompt }]
+  });
+  const text = response.content[0]?.type === "text" ? response.content[0].text : "";
+  try {
+    const parsed = JSON.parse(text);
+    return parsed.map((r) => ({
+      classification: ["AGREE", "CONFLICT", "SUPERSEDED"].includes(
+        r.classification
+      ) ? r.classification : "AGREE",
+      explanation: r.explanation ?? ""
+    }));
+  } catch {
+    return pairs.map(() => ({
+      classification: "AGREE",
+      explanation: "LLM response parse error"
+    }));
+  }
+}
+function recommend(classification) {
+  switch (classification) {
+    case "CONFLICT":
+      return "manual_review";
+    case "SUPERSEDED":
+      return "deactivate_older";
+    case "AGREE":
+      return "merge";
+    case "UNCLASSIFIED":
+      return "none";
+  }
+}
+async function detectConflicts(client, projectFilter, agentFilter2) {
+  const maxPairs = parseInt(
+    process.env.CONFLICT_MAX_PAIRS ?? String(DEFAULT_MAX_PAIRS),
+    10
+  );
+  const byProject = await fetchMemoriesWithVectors(
+    client,
+    projectFilter,
+    agentFilter2
+  );
+  const allCandidates = [];
+  for (const [, memories] of byProject) {
+    if (memories.length < 2) continue;
+    const candidates2 = findCandidatePairs(
+      memories,
+      maxPairs - allCandidates.length
+    );
+    allCandidates.push(...candidates2);
+    if (allCandidates.length >= maxPairs) break;
+  }
+  if (allCandidates.length === 0) {
+    return {
+      candidateCount: 0,
+      classified: 0,
+      conflicts: 0,
+      superseded: 0,
+      agree: 0,
+      unclassified: 0,
+      pairs: [],
+      skipped: false
+    };
+  }
+  const truncated = allCandidates.length > maxPairs;
+  const candidates = allCandidates.slice(0, maxPairs);
+  const hasApiKey = !!process.env.ANTHROPIC_API_KEY;
+  const pairs = [];
+  if (hasApiKey) {
+    for (let i = 0; i < candidates.length; i += LLM_BATCH_SIZE) {
+      const batch = candidates.slice(i, i + LLM_BATCH_SIZE);
+      try {
+        const results = await classifyPairsBatch(batch);
+        for (let j = 0; j < batch.length; j++) {
+          const c = batch[j];
+          const r = results[j] ?? {
+            classification: "AGREE",
+            explanation: "No result"
+          };
+          pairs.push({
+            memoryA: {
+              id: c.a.id,
+              agentId: c.a.agent_id,
+              text: c.a.raw_text,
+              timestamp: c.a.timestamp
+            },
+            memoryB: {
+              id: c.b.id,
+              agentId: c.b.agent_id,
+              text: c.b.raw_text,
+              timestamp: c.b.timestamp
+            },
+            similarity: c.similarity,
+            classification: r.classification,
+            explanation: r.explanation,
+            recommendation: recommend(r.classification)
+          });
+        }
+      } catch (err) {
+        for (const c of batch) {
+          pairs.push({
+            memoryA: {
+              id: c.a.id,
+              agentId: c.a.agent_id,
+              text: c.a.raw_text,
+              timestamp: c.a.timestamp
+            },
+            memoryB: {
+              id: c.b.id,
+              agentId: c.b.agent_id,
+              text: c.b.raw_text,
+              timestamp: c.b.timestamp
+            },
+            similarity: c.similarity,
+            classification: "UNCLASSIFIED",
+            explanation: `LLM error: ${err instanceof Error ? err.message : String(err)}`,
+            recommendation: "none"
+          });
+        }
+      }
+    }
+  } else {
+    for (const c of candidates) {
+      pairs.push({
+        memoryA: {
+          id: c.a.id,
+          agentId: c.a.agent_id,
+          text: c.a.raw_text,
+          timestamp: c.a.timestamp
+        },
+        memoryB: {
+          id: c.b.id,
+          agentId: c.b.agent_id,
+          text: c.b.raw_text,
+          timestamp: c.b.timestamp
+        },
+        similarity: c.similarity,
+        classification: "UNCLASSIFIED",
+        explanation: "ANTHROPIC_API_KEY not set \u2014 skipped LLM classification",
+        recommendation: "none"
+      });
+    }
+  }
+  const severityOrder = { CONFLICT: 0, SUPERSEDED: 1, UNCLASSIFIED: 2, AGREE: 3 };
+  pairs.sort(
+    (a, b) => severityOrder[a.classification] - severityOrder[b.classification]
+  );
+  const conflicts = pairs.filter((p) => p.classification === "CONFLICT").length;
+  const superseded = pairs.filter(
+    (p) => p.classification === "SUPERSEDED"
+  ).length;
+  const agree = pairs.filter((p) => p.classification === "AGREE").length;
+  const unclassified = pairs.filter(
+    (p) => p.classification === "UNCLASSIFIED"
+  ).length;
+  return {
+    candidateCount: candidates.length,
+    classified: conflicts + superseded + agree,
+    conflicts,
+    superseded,
+    agree,
+    unclassified,
+    pairs,
+    skipped: truncated,
+    skipReason: truncated ? `Exceeded max ${maxPairs} pairs \u2014 increase CONFLICT_MAX_PAIRS to analyze more` : void 0
+  };
+}
+
+// src/bin/exe-doctor.ts
+function parseFlags(argv) {
+  const flags = { fix: false, dryRun: false, verbose: false, conflicts: false, restarts: false };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--fix") flags.fix = true;
+    else if (arg === "--dry-run") flags.dryRun = true;
+    else if (arg === "--verbose") flags.verbose = true;
+    else if (arg === "--conflicts") flags.conflicts = true;
+    else if (arg === "--restarts" || arg === "--daemon-restarts") flags.restarts = true;
+    else if (arg === "--agent" && argv[i + 1]) flags.agent = argv[++i];
+    else if (arg === "--project" && argv[i + 1]) flags.project = argv[++i];
+  }
+  return flags;
+}
+function agentFilter(flags) {
+  const clauses = [];
+  const args = [];
+  if (flags.agent) {
+    clauses.push("agent_id = ?");
+    args.push(flags.agent);
+  }
+  if (flags.project) {
+    clauses.push("project_name = ?");
+    args.push(flags.project);
+  }
+  const clause = clauses.length > 0 ? " WHERE " + clauses.join(" AND ") : "";
+  return { clause, args };
+}
+async function auditStats(client, flags) {
+  const { clause, args } = agentFilter(flags);
+  const summary = await client.execute({
+    sql: `SELECT COUNT(*) as total,
+                 COUNT(DISTINCT agent_id) as agents,
+                 COUNT(DISTINCT project_name) as projects,
+                 MIN(timestamp) as oldest,
+                 MAX(timestamp) as newest
+          FROM memories${clause}`,
+    args
+  });
+  const row = summary.rows[0];
+  const perAgent = await client.execute({
+    sql: `SELECT agent_id, COUNT(*) as count,
+                 SUM(CASE WHEN vector IS NULL THEN 1 ELSE 0 END) as null_vectors
+          FROM memories${clause}
+          GROUP BY agent_id
+          ORDER BY count DESC`,
+    args
+  });
+  return {
+    total: Number(row.total),
+    agents: Number(row.agents),
+    projects: Number(row.projects),
+    oldest: row.oldest ?? null,
+    newest: row.newest ?? null,
+    perAgent: perAgent.rows.map((r) => ({
+      agent_id: r.agent_id,
+      count: Number(r.count),
+      null_vectors: Number(r.null_vectors)
+    }))
+  };
+}
+async function auditNullVectors(client, flags) {
+  const { clause, args } = agentFilter(flags);
+  const where = clause ? clause + " AND vector IS NULL" : " WHERE vector IS NULL";
+  const result = await client.execute({
+    sql: `SELECT COUNT(*) as cnt FROM memories${where}`,
+    args
+  });
+  return Number(result.rows[0].cnt);
+}
+async function auditDuplicates(client, flags) {
+  const { clause, args } = agentFilter(flags);
+  const backfillExclude = clause ? " AND tool_name != 'ConversationBackfill'" : " WHERE tool_name != 'ConversationBackfill'";
+  const groups = await client.execute({
+    sql: `SELECT SUBSTR(raw_text, 1, 200) as text_head, LENGTH(raw_text) as text_len, COUNT(*) as cnt
+          FROM memories${clause}${backfillExclude}
+          GROUP BY text_head, text_len
+          HAVING cnt > 1
+          ORDER BY cnt DESC
+          LIMIT 500`,
+    args
+  });
+  const duplicates = [];
+  for (const g of groups.rows) {
+    const textHead = g.text_head;
+    const textLen = Number(g.text_len);
+    const filterArgs = [textHead, textLen, ...args];
+    let filterClause = " WHERE SUBSTR(raw_text, 1, 200) = ? AND LENGTH(raw_text) = ?";
+    if (flags.agent) filterClause += " AND agent_id = ?";
+    if (flags.project) filterClause += " AND project_name = ?";
+    const ids = await client.execute({
+      sql: `SELECT id, raw_text FROM memories${filterClause} ORDER BY timestamp DESC LIMIT 10000`,
+      args: filterArgs
+    });
+    const byText = /* @__PURE__ */ new Map();
+    for (const r of ids.rows) {
+      const text = r.raw_text;
+      const id = r.id;
+      const existing = byText.get(text);
+      if (existing) existing.push(id);
+      else byText.set(text, [id]);
+    }
+    for (const [text, allIds] of byText) {
+      if (allIds.length <= 1) continue;
+      duplicates.push({
+        raw_text: text.length > 100 ? text.slice(0, 100) + "..." : text,
+        count: allIds.length,
+        keep_id: allIds[0],
+        delete_ids: allIds.slice(1)
+      });
+    }
+  }
+  return duplicates;
+}
+async function auditBloated(client, flags) {
+  const { clause, args } = agentFilter(flags);
+  const where = clause ? clause + " AND LENGTH(raw_text) > 5120 AND tool_name != 'ConversationBackfill'" : " WHERE LENGTH(raw_text) > 5120 AND tool_name != 'ConversationBackfill'";
+  const result = await client.execute({
+    sql: `SELECT id, agent_id, LENGTH(raw_text) as size, tool_name
+          FROM memories${where}
+          ORDER BY size DESC
+          LIMIT 100`,
+    args
+  });
+  return result.rows.map((r) => ({
+    id: r.id,
+    agent_id: r.agent_id,
+    size: Number(r.size),
+    tool_name: r.tool_name
+  }));
+}
+async function auditFts(client) {
+  const memCount = await client.execute("SELECT COUNT(*) as cnt FROM memories");
+  const ftsCount = await client.execute("SELECT COUNT(*) as cnt FROM memories_fts");
+  const mc = Number(memCount.rows[0].cnt);
+  const fc = Number(ftsCount.rows[0].cnt);
+  return { memoryCount: mc, ftsCount: fc, inSync: mc === fc };
+}
+async function auditOrphanedProjects(client) {
+  const result = await client.execute(
+    `SELECT project_name, COUNT(*) as cnt
+     FROM memories
+     WHERE tool_name != 'ConversationBackfill'
+     GROUP BY project_name
+     ORDER BY cnt DESC`
+  );
+  const orphans = [];
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  for (const row of result.rows) {
+    const name = row.project_name;
+    const count = Number(row.cnt);
+    const exists = existsSync(path.join(home, name)) || existsSync(path.join(home, "..", name)) || existsSync(path.join(process.cwd(), "..", name));
+    if (!exists) {
+      orphans.push({ project_name: name, count });
+    }
+  }
+  return orphans;
+}
+function auditHookHealth() {
+  const logPath = path.join(
+    process.env.HOME ?? process.env.USERPROFILE ?? "",
+    ".exe-os",
+    "logs",
+    "hooks.log"
+  );
+  if (!existsSync(logPath)) {
+    return { logExists: false, totalLines: 0, errorsLastHour: 0, topPatterns: [] };
+  }
+  let content;
+  try {
+    content = readFileSync(logPath, "utf-8");
+  } catch {
+    return { logExists: false, totalLines: 0, errorsLastHour: 0, topPatterns: [] };
+  }
+  const lines = content.split("\n").filter(Boolean);
+  const totalLines = lines.length;
+  const recent = lines.slice(-200);
+  const oneHourAgo = new Date(Date.now() - 36e5).toISOString();
+  let errorsLastHour = 0;
+  const patternCounts = /* @__PURE__ */ new Map();
+  for (const line of recent) {
+    const isError = /error|Error|ERR|FAIL|throw|exception|TypeError|ReferenceError|SyntaxError/i.test(line);
+    if (!isError) continue;
+    const tsMatch = line.match(/(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})/);
+    if (tsMatch && tsMatch[1] >= oneHourAgo) {
+      errorsLastHour++;
+    } else if (!tsMatch) {
+      errorsLastHour++;
+    }
+    const patternMatch = line.match(/((?:TypeError|ReferenceError|SyntaxError|Error):[^\n]{0,80})/);
+    if (patternMatch) {
+      const p = patternMatch[1];
+      patternCounts.set(p, (patternCounts.get(p) ?? 0) + 1);
+    }
+  }
+  const topPatterns = [...patternCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([pattern, count]) => ({ pattern, count }));
+  return { logExists: true, totalLines, errorsLastHour, topPatterns };
+}
+function safeReadJson(filePath) {
+  if (!existsSync(filePath)) return null;
+  try {
+    return JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function collectHookCommandsFromClaudeSettings(settings) {
+  const hooks = settings?.hooks;
+  if (!hooks || typeof hooks !== "object") return [];
+  const commands = [];
+  for (const [event, groups] of Object.entries(hooks)) {
+    if (!Array.isArray(groups)) continue;
+    for (const group of groups) {
+      const hooksForGroup = group?.hooks;
+      if (!Array.isArray(hooksForGroup)) continue;
+      for (const hook of hooksForGroup) {
+        const command = hook?.command;
+        if (typeof command === "string") commands.push({ event, command });
+      }
+    }
+  }
+  return commands;
+}
+function collectHookCommandsFromCodexHooks(config) {
+  const commands = [];
+  if (!config || typeof config !== "object") return commands;
+  const root = config;
+  for (const [event, value] of Object.entries(root)) {
+    const entries = Array.isArray(value) ? value : value && typeof value === "object" ? Object.values(value) : [];
+    for (const entry of entries) {
+      if (typeof entry === "string") commands.push({ event, command: entry });
+      const command = entry?.command;
+      if (typeof command === "string") commands.push({ event, command });
+    }
+  }
+  return commands;
+}
+function buildHookOwnershipIssues(runtime, commands) {
+  const issues = [];
+  for (const marker of LEGACY_SPLIT_POST_TOOL_HOOK_MARKERS) {
+    const count = commands.filter((cmd) => cmd.command.includes(marker)).length;
+    if (count > 0) {
+      issues.push({
+        runtime,
+        event: "PostToolUse",
+        marker,
+        count,
+        message: `Legacy split PostToolUse hook still installed: ${marker}`
+      });
+    }
+  }
+  for (const entry of EXE_HOOK_MANIFEST.filter((hook) => hook.runtimes.includes(runtime))) {
+    const matching = commands.filter((cmd) => cmd.command.includes(entry.commandMarker));
+    if (matching.length > 1) {
+      issues.push({
+        runtime,
+        event: entry.event,
+        marker: entry.commandMarker,
+        count: matching.length,
+        message: `Duplicate exe-os hook owner for ${entry.event}: ${entry.commandMarker}`
+      });
+    }
+    for (const cmd of matching) {
+      if (cmd.event !== entry.event) {
+        issues.push({
+          runtime,
+          event: cmd.event,
+          marker: entry.commandMarker,
+          count: 1,
+          message: `exe-os hook ${entry.commandMarker} is registered under ${cmd.event}, expected ${entry.event}`
+        });
+      }
+    }
+  }
+  for (const cmd of commands) {
+    if (!cmd.command.includes("dist/hooks/")) continue;
+    if (!cmd.command.includes("exe-os")) continue;
+    const entry = manifestEntryForCommand(cmd.command);
+    const isLegacy = LEGACY_SPLIT_POST_TOOL_HOOK_MARKERS.some((marker) => cmd.command.includes(marker));
+    if (!entry && !isLegacy) {
+      issues.push({
+        runtime,
+        event: cmd.event,
+        marker: "dist/hooks/",
+        count: 1,
+        message: `Unknown exe-os hook command not present in ownership manifest: ${cmd.command.slice(0, 160)}`
+      });
+    }
+  }
+  return issues;
+}
+function auditHookOwnership() {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  const checkedFiles = [];
+  const issues = [];
+  const claudeSettingsPath = path.join(home, ".claude", "settings.json");
+  const claudeSettings = safeReadJson(claudeSettingsPath);
+  if (claudeSettings) {
+    checkedFiles.push(claudeSettingsPath);
+    issues.push(...buildHookOwnershipIssues("claude", collectHookCommandsFromClaudeSettings(claudeSettings)));
+  }
+  const codexHooksPath = path.join(home, ".codex", "hooks.json");
+  const codexHooks = safeReadJson(codexHooksPath);
+  if (codexHooks) {
+    checkedFiles.push(codexHooksPath);
+    issues.push(...buildHookOwnershipIssues("codex", collectHookCommandsFromCodexHooks(codexHooks)));
+  }
+  return {
+    checkedFiles,
+    issues,
+    staleLegacyHooks: issues.filter((issue) => issue.message.includes("Legacy split"))
+  };
+}
+async function auditShards() {
+  try {
+    const { auditShardHealth } = await import("./shard-manager-P5ZJH4AX.js");
+    const report = await auditShardHealth();
+    return {
+      total: report.total,
+      ok: report.ok,
+      unreadable: report.unreadable,
+      schemaMismatches: report.schemaMismatches,
+      archived: report.archived,
+      unreadableNames: report.shards.filter((s) => s.unreadable).map((s) => s.name),
+      schemaIssueNames: report.shards.filter((s) => s.schemaIssues.length > 0).map((s) => `${s.name}: ${s.schemaIssues.join(", ")}`)
+    };
+  } catch {
+    return { total: 0, ok: 0, unreadable: 0, schemaMismatches: 0, archived: 0, unreadableNames: [], schemaIssueNames: [] };
+  }
+}
+async function auditKeyHealth() {
+  try {
+    const { getMasterKey } = await import("./lib/keychain.js");
+    const { getKeyBackupStatus } = await import("./key-backup-status-2EPRIAXU.js");
+    const key = await getMasterKey();
+    const backup = getKeyBackupStatus();
+    return {
+      masterKeyPresent: Boolean(key),
+      recoveryBackupMarked: backup.exists,
+      recoveryBackupConfirmedAt: backup.confirmedAt,
+      recoveryBackupSource: backup.source
+    };
+  } catch {
+    return { masterKeyPresent: false, recoveryBackupMarked: false };
+  }
+}
+async function auditOutbox() {
+  try {
+    const { getOutboxStatus } = await import("./support-outbox-QPQQK7F7.js");
+    return await getOutboxStatus();
+  } catch {
+    return {
+      bugReports: { total: 0, unsent: 0 },
+      featureRequests: { total: 0, unsent: 0 }
+    };
+  }
+}
+async function auditCpuSteal() {
+  try {
+    const { checkCpuSteal } = await import("./cpu-steal-5YKTUPWF.js");
+    const result = await checkCpuSteal();
+    return {
+      available: result.available,
+      stealPercent: result.stealPercent,
+      severity: result.severity,
+      source: result.source,
+      message: result.message
+    };
+  } catch {
+    return {
+      available: false,
+      stealPercent: null,
+      severity: "na",
+      source: "none",
+      message: "CPU steal check unavailable"
+    };
+  }
+}
+async function runAudit(client, flags) {
+  const runConflicts = flags.conflicts || process.env.EXE_AUDIT_CONFLICTS === "1";
+  const [stats, nullVectors, duplicates, bloated, fts, orphanedProjects, shards, keyHealth, outbox, cpuSteal] = await Promise.all([
+    auditStats(client, flags),
+    auditNullVectors(client, flags),
+    auditDuplicates(client, flags),
+    auditBloated(client, flags),
+    auditFts(client),
+    auditOrphanedProjects(client),
+    auditShards(),
+    auditKeyHealth(),
+    auditOutbox(),
+    auditCpuSteal()
+  ]);
+  let conflicts;
+  if (runConflicts) {
+    conflicts = await detectConflicts(client, flags.project, flags.agent);
+  } else {
+    conflicts = {
+      candidateCount: 0,
+      classified: 0,
+      conflicts: 0,
+      superseded: 0,
+      agree: 0,
+      unclassified: 0,
+      pairs: [],
+      skipped: true,
+      skipReason: "Conflict detection skipped (O(n\xB2) on 97K memories). Use --conflicts flag to enable."
+    };
+  }
+  const duplicateCount = duplicates.reduce((sum, d) => sum + d.delete_ids.length, 0);
+  const hookHealth = auditHookHealth();
+  const hookOwnership = auditHookOwnership();
+  let retrievalHealth;
+  try {
+    retrievalHealth = await getRetrievalHealth();
+  } catch {
+    retrievalHealth = void 0;
+  }
+  return { stats, nullVectors, duplicates, duplicateCount, bloated, fts, orphanedProjects, conflicts, hookHealth, hookOwnership, shards, keyHealth, outbox, cpuSteal, retrievalHealth };
+}
+function indicator(value, warn) {
+  if (value === 0) return "\u{1F7E2}";
+  if (value <= warn) return "\u{1F7E0}";
+  return "\u{1F534}";
+}
+function pct(count, total) {
+  if (total === 0) return "0.0%";
+  return (count / total * 100).toFixed(1) + "%";
+}
+function fmtNum(n) {
+  return n.toLocaleString("en-US");
+}
+function formatReport(report, flags) {
+  const lines = [];
+  const s = report.stats;
+  lines.push("");
+  lines.push("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+  lines.push("\u2551          Memory Health Report          \u2551");
+  lines.push("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
+  lines.push("");
+  lines.push(`Total: ${fmtNum(s.total)} memories across ${s.agents} agents, ${s.projects} projects`);
+  if (s.oldest && s.newest) {
+    lines.push(`Date range: ${s.oldest.slice(0, 10)} \u2192 ${s.newest.slice(0, 10)}`);
+  }
+  lines.push("");
+  if (s.perAgent.length > 0) {
+    lines.push("By agent:");
+    for (const a of s.perAgent) {
+      const nullNote = a.null_vectors > 0 ? `  (${fmtNum(a.null_vectors)} null vectors)` : "";
+      lines.push(`  ${a.agent_id.padEnd(12)} ${fmtNum(a.count).padStart(8)}${nullNote}`);
+    }
+    lines.push("");
+  }
+  const totalMemGB = os.totalmem() / (1024 * 1024 * 1024);
+  const isLowMemSystem = totalMemGB <= 8;
+  if (isLowMemSystem && report.nullVectors > 0) {
+    lines.push(`\u{1F7E2} Null vectors:     ${fmtNum(report.nullVectors)} / ${fmtNum(s.total)} (expected \u2014 8GB system, keyword search mode)`);
+  } else {
+    lines.push(`${indicator(report.nullVectors, 50)} Null vectors:     ${fmtNum(report.nullVectors)} / ${fmtNum(s.total)} (${pct(report.nullVectors, s.total)})`);
+  }
+  const dupPct = s.total > 0 ? report.duplicateCount / s.total * 100 : 0;
+  const dupIndicator = dupPct === 0 ? "\u{1F7E2}" : dupPct <= 5 ? "\u{1F7E0}" : "\u{1F534}";
+  lines.push(`${dupIndicator} Duplicates:       ${fmtNum(report.duplicateCount)} / ${fmtNum(s.total)} (${pct(report.duplicateCount, s.total)})`);
+  lines.push(`${indicator(report.bloated.length, 20)} Bloated (>5KB):   ${fmtNum(report.bloated.length)} / ${fmtNum(s.total)} (${pct(report.bloated.length, s.total)})`);
+  const ftsIndicator = report.fts.inSync ? "\u{1F7E2}" : "\u{1F534}";
+  lines.push(`${ftsIndicator} FTS index:        ${report.fts.inSync ? "in sync" : "OUT OF SYNC"} (${fmtNum(report.fts.memoryCount)} / ${fmtNum(report.fts.ftsCount)})`);
+  const kh = report.keyHealth;
+  if (!kh.masterKeyPresent) {
+    lines.push("\u{1F534} Recovery key:    master key missing \u2014 import phrase or run setup before syncing");
+  } else if (!kh.recoveryBackupMarked) {
+    lines.push("\u{1F534} Recovery backup: not confirmed \u2014 run `exe-os cloud link --show-full` in your local Terminal and save the 24-word phrase");
+  } else {
+    const suffix = kh.recoveryBackupConfirmedAt ? ` (${kh.recoveryBackupConfirmedAt.slice(0, 10)}${kh.recoveryBackupSource ? ` via ${kh.recoveryBackupSource}` : ""})` : "";
+    lines.push(`\u{1F7E2} Recovery backup: confirmed${suffix}`);
+  }
+  if (report.orphanedProjects.length > 0) {
+    const orphanList = report.orphanedProjects.map((o) => `${o.project_name} \u2014 ${o.count} memories`).join(", ");
+    lines.push(`\u2139\uFE0F  Orphaned projects: ${report.orphanedProjects.length} (${orphanList})`);
+  }
+  const cr = report.conflicts;
+  if (cr.candidateCount > 0) {
+    const conflictIndicator = cr.conflicts > 0 ? "\u{1F534}" : cr.superseded > 0 ? "\u{1F7E0}" : "\u{1F7E2}";
+    lines.push(`${conflictIndicator} Conflicts:        ${fmtNum(cr.candidateCount)} candidate pairs`);
+    if (cr.classified > 0) {
+      lines.push(`                     CONFLICT: ${cr.conflicts}, SUPERSEDED: ${cr.superseded}, AGREE: ${cr.agree}`);
+    }
+    if (cr.unclassified > 0) {
+      lines.push(`                     Unclassified: ${cr.unclassified}`);
+    }
+    if (cr.skipped) {
+      lines.push(`  \u26A0\uFE0F  ${cr.skipReason}`);
+    }
+  } else {
+    lines.push("\u{1F7E2} Conflicts:        none detected");
+  }
+  const hh = report.hookHealth;
+  if (!hh.logExists) {
+    lines.push("\u{1F7E0} Hook logs:        no log file (run installer to enable stderr capture)");
+  } else if (hh.errorsLastHour === 0) {
+    lines.push(`\u{1F7E2} Hook logs:        ${fmtNum(hh.totalLines)} lines, 0 errors in last hour`);
+  } else {
+    lines.push(`\u{1F534} Hook logs:        ${fmtNum(hh.errorsLastHour)} errors in last hour (${fmtNum(hh.totalLines)} total lines)`);
+    for (const p of hh.topPatterns) {
+      lines.push(`                     ${p.count}x: ${p.pattern}`);
+    }
+  }
+  const ho = report.hookOwnership;
+  if (ho.issues.length === 0) {
+    lines.push(`\u{1F7E2} Hook ownership:  ${ho.checkedFiles.length > 0 ? "manifest clean" : "no local hook config found"}`);
+  } else {
+    lines.push(`\u{1F534} Hook ownership:  ${fmtNum(ho.issues.length)} issue(s)`);
+    for (const issue of ho.issues.slice(0, 5)) {
+      lines.push(`                     [${issue.runtime}/${issue.event}] ${issue.message}`);
+    }
+  }
+  const sh = report.shards;
+  if (sh.total > 0) {
+    if (sh.unreadable === 0 && sh.schemaMismatches === 0) {
+      lines.push(`\u{1F7E2} Shards:           ${fmtNum(sh.ok)} / ${fmtNum(sh.total)} readable`);
+    } else {
+      const unreadable = sh.unreadableNames.slice(0, 5).join(", ");
+      const schema = sh.schemaIssueNames.slice(0, 3).join("; ");
+      const parts = [
+        sh.unreadable > 0 ? `${fmtNum(sh.unreadable)} unreadable (${unreadable}${sh.unreadableNames.length > 5 ? ", ..." : ""})` : null,
+        sh.schemaMismatches > 0 ? `${fmtNum(sh.schemaMismatches)} schema mismatch (${schema}${sh.schemaIssueNames.length > 3 ? "; ..." : ""})` : null
+      ].filter(Boolean);
+      lines.push(`\u{1F534} Shards:           ${parts.join("; ")}`);
+    }
+  }
+  const ob = report.outbox;
+  const unsentTotal = ob.bugReports.unsent + ob.featureRequests.unsent;
+  if (unsentTotal === 0) {
+    lines.push("\u{1F7E2} Support outbox:   all items sent");
+  } else {
+    lines.push(`\u{1F7E0} Support outbox:   ${fmtNum(unsentTotal)} unsent (${ob.bugReports.unsent} bugs, ${ob.featureRequests.unsent} features)`);
+  }
+  const cs = report.cpuSteal;
+  if (!cs.available) {
+    lines.push("\u{1F7E2} CPU steal:        n/a (not measurable on this platform)");
+  } else if (cs.severity === "critical") {
+    lines.push(`\u{1F534} CPU steal:        ${Math.round(cs.stealPercent ?? 0)}% \u2014 ${cs.message}`);
+  } else if (cs.severity === "warning") {
+    lines.push(`\u{1F7E0} CPU steal:        ${Math.round(cs.stealPercent ?? 0)}% \u2014 ${cs.message}`);
+  } else {
+    lines.push(`\u{1F7E2} CPU steal:        ${Math.round(cs.stealPercent ?? 0)}% (host healthy)`);
+  }
+  const rh = report.retrievalHealth;
+  if (rh) {
+    lines.push("");
+    lines.push(`   Search mode: ${rh.searchMode.actual}${rh.searchMode.actual !== rh.searchMode.configured ? ` (configured: ${rh.searchMode.configured})` : ""}`);
+    lines.push(`   Embed daemon: ${rh.embedDaemon} \xB7 Query router: ${rh.queryRouter} \xB7 Vector coverage: ${rh.vectorBackfill.coveragePct ?? 0}%`);
+    if (rh.dbRestore.hasEvents) {
+      const last = rh.dbRestore.last;
+      lines.push(`   DB restore events: ${rh.dbRestore.count}${last ? ` (last: ${last.kind} @ ${last.at})` : ""}; ${rh.dbRestore.quarantineFiles} quarantined file(s)`);
+    }
+    lines.push("");
+    lines.push(formatDegradations(rh.degradations, "Degradations"));
+  }
+  lines.push("");
+  if (flags.verbose) {
+    if (report.duplicates.length > 0) {
+      lines.push("Duplicate groups (top 10):");
+      for (const d of report.duplicates.slice(0, 10)) {
+        lines.push(`  ${d.count}x: ${d.raw_text}`);
+      }
+      lines.push("");
+    }
+    if (report.bloated.length > 0) {
+      lines.push("Bloated records:");
+      for (const b of report.bloated.slice(0, 20)) {
+        lines.push(`  ${b.id.slice(0, 8)}... ${b.agent_id} ${b.tool_name} (${fmtNum(b.size)} bytes)`);
+      }
+      lines.push("");
+    }
+    try {
+      const restartReport = buildRestartReport({ topTimers: 25 });
+      if (restartReport.logsFound) {
+        lines.push(formatRestartReport(restartReport).trimEnd());
+        lines.push("");
+      }
+    } catch {
+    }
+    const actionable = report.conflicts.pairs.filter(
+      (p) => p.classification === "CONFLICT" || p.classification === "SUPERSEDED"
+    );
+    if (actionable.length > 0) {
+      lines.push("Conflict Detection");
+      lines.push("==================");
+      for (const p of actionable.slice(0, 10)) {
+        const aShort = p.memoryA.text.length > 60 ? p.memoryA.text.slice(0, 60) + "..." : p.memoryA.text;
+        const bShort = p.memoryB.text.length > 60 ? p.memoryB.text.slice(0, 60) + "..." : p.memoryB.text;
+        lines.push(
+          `  [${p.classification}] ${p.memoryA.id.slice(0, 8)} (${p.memoryA.agentId}, ${p.memoryA.timestamp.slice(0, 10)}) vs ${p.memoryB.id.slice(0, 8)} (${p.memoryB.agentId}, ${p.memoryB.timestamp.slice(0, 10)})`
+        );
+        lines.push(`    "${aShort}" vs "${bShort}"`);
+        lines.push(`    ${p.explanation} \u2192 Recommendation: ${p.recommendation}`);
+      }
+      lines.push("");
+    }
+  }
+  const recs = [];
+  if (report.nullVectors > 0 && !isLowMemSystem) {
+    recs.push(`Run --fix to backfill ${fmtNum(report.nullVectors)} null vectors`);
+  }
+  if (report.duplicateCount > 0) {
+    recs.push(`Run --fix to remove ${fmtNum(report.duplicateCount)} duplicates`);
+  }
+  if (report.bloated.length > 0) {
+    recs.push(`${fmtNum(report.bloated.length)} bloated records will be split into ~2KB chunks`);
+  }
+  if (!report.fts.inSync) {
+    recs.push("Run --fix to rebuild FTS index");
+  }
+  if (report.shards.unreadable > 0) {
+    recs.push(`Run --fix to archive ${fmtNum(report.shards.unreadable)} unreadable shard(s); global DB remains authoritative`);
+  }
+  if (report.shards.schemaMismatches > 0) {
+    recs.push(`Run --fix to migrate ${fmtNum(report.shards.schemaMismatches)} shard schema mismatch(es) in place`);
+  }
+  if (report.orphanedProjects.length > 0) {
+    const names = report.orphanedProjects.map((o) => `"${o.project_name}"`).join(", ");
+    recs.push(`Consider /exe-forget for orphaned project${report.orphanedProjects.length > 1 ? "s" : ""} ${names}`);
+  }
+  if (report.conflicts.conflicts > 0) {
+    recs.push(`${fmtNum(report.conflicts.conflicts)} conflicting memory pairs need manual review`);
+  }
+  if (report.conflicts.superseded > 0) {
+    recs.push(`${fmtNum(report.conflicts.superseded)} superseded memories can be deactivated`);
+  }
+  if (report.hookOwnership.issues.length > 0) {
+    recs.push(`Run exe-os install to refresh hook config; remove stale exe-os hook commands if they remain`);
+  }
+  if (report.retrievalHealth) {
+    for (const d of report.retrievalHealth.degradations) {
+      if (d.severity === "critical" || d.severity === "warn") {
+        recs.push(d.remediation ? `${d.message} \u2014 ${d.remediation}` : d.message);
+      }
+    }
+  }
+  if (report.cpuSteal.available && (report.cpuSteal.severity === "warning" || report.cpuSteal.severity === "critical")) {
+    recs.push(`${report.cpuSteal.message} Migrate to a less oversubscribed host or contact your VPS provider \u2014 exe-os cannot fix host contention.`);
+  }
+  if (recs.length > 0) {
+    lines.push("Recommendations:");
+    for (const r of recs) {
+      lines.push(`  \u2022 ${r}`);
+    }
+  } else {
+    lines.push("All clear \u2014 memory database is healthy.");
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+async function fixNullVectors() {
+  const { tryAcquireWorkerSlot, registerWorkerPid } = await import("./worker-gate-OQMKAMP7.js");
+  if (!tryAcquireWorkerSlot()) {
+    process.stderr.write("[exe-doctor] Worker gate full \u2014 waiting for existing backfill workers to finish\n");
+    await new Promise((r) => setTimeout(r, 5e3));
+    if (!tryAcquireWorkerSlot()) {
+      throw new Error("Worker gate still full after 5s \u2014 try again later or kill stale workers");
+    }
+  }
+  const npmRoot = (await import("child_process")).execSync("npm root -g", { encoding: "utf8" }).trim();
+  const backfillPath = path.join(npmRoot, "exe-os", "dist", "bin", "backfill-vectors.js");
+  return new Promise((resolve, reject) => {
+    const child = spawn("node", [backfillPath], { stdio: "inherit" });
+    if (child.pid) registerWorkerPid(child.pid);
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`backfill-vectors exited with code ${code}`));
+    });
+    child.on("error", reject);
+  });
+}
+async function fixDuplicates(client, duplicates, dryRun) {
+  let deleted = 0;
+  for (const dup of duplicates) {
+    if (dup.delete_ids.length === 0) continue;
+    if (dryRun) {
+      console.log(`  [dry-run] Would delete ${dup.delete_ids.length} duplicates: ${dup.raw_text}`);
+      deleted += dup.delete_ids.length;
+      continue;
+    }
+    const placeholders = dup.delete_ids.map(() => "?").join(",");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await client.execute({
+      sql: `UPDATE memories SET status = 'deleted', deleted_at = ? WHERE id IN (${placeholders})`,
+      args: [now, ...dup.delete_ids]
+    });
+    deleted += dup.delete_ids.length;
+  }
+  return deleted;
+}
+async function fixBloated(client, bloated, dryRun) {
+  let chunksCreated = 0;
+  const CHUNK_SIZE = 2048;
+  for (const b of bloated) {
+    const result = await client.execute({
+      sql: `SELECT * FROM memories WHERE id = ?`,
+      args: [b.id]
+    });
+    if (result.rows.length === 0) continue;
+    const row = result.rows[0];
+    const text = row.raw_text;
+    const chunks = splitAtSentences(text, CHUNK_SIZE);
+    if (chunks.length <= 1) continue;
+    if (dryRun) {
+      console.log(`  [dry-run] Would split ${b.id.slice(0, 8)}... (${fmtNum(b.size)} bytes) into ${chunks.length} chunks`);
+      chunksCreated += chunks.length;
+      continue;
+    }
+    const stmts = chunks.map((chunk, i) => ({
+      sql: `INSERT INTO memories
+              (id, agent_id, agent_role, session_id, timestamp,
+               tool_name, project_name, has_error, raw_text, vector, version, consolidated)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, 0, 0)`,
+      args: [
+        randomUUID(),
+        row.agent_id,
+        row.agent_role,
+        row.session_id,
+        row.timestamp,
+        row.tool_name,
+        row.project_name,
+        row.has_error,
+        `[chunk ${i + 1}/${chunks.length} of ${b.id}] ${chunk}`
+      ]
+    }));
+    stmts.push({
+      sql: `UPDATE memories SET consolidated = 1 WHERE id = ?`,
+      args: [b.id]
+    });
+    await client.batch(stmts, "write");
+    chunksCreated += chunks.length;
+  }
+  return chunksCreated;
+}
+async function fixShards(dryRun) {
+  const { auditShardHealth } = await import("./shard-manager-P5ZJH4AX.js");
+  const report = await auditShardHealth({ repair: true, dryRun });
+  return {
+    total: report.total,
+    ok: report.ok,
+    unreadable: report.unreadable,
+    schemaMismatches: report.schemaMismatches,
+    archived: report.archived,
+    unreadableNames: report.shards.filter((s) => s.unreadable).map((s) => s.name),
+    schemaIssueNames: report.shards.filter((s) => s.schemaIssues.length > 0).map((s) => `${s.name}: ${s.schemaIssues.join(", ")}`)
+  };
+}
+function splitAtSentences(text, maxChunkSize) {
+  if (text.length <= maxChunkSize) return [text];
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= maxChunkSize) {
+      chunks.push(remaining);
+      break;
+    }
+    const window = remaining.slice(0, maxChunkSize);
+    let splitIdx = -1;
+    for (const sep of [". ", ".\n", "! ", "!\n", "? ", "?\n"]) {
+      const idx = window.lastIndexOf(sep);
+      if (idx > splitIdx) splitIdx = idx + sep.length;
+    }
+    if (splitIdx <= 0) {
+      const nlIdx = window.lastIndexOf("\n");
+      if (nlIdx > 0) splitIdx = nlIdx + 1;
+    }
+    if (splitIdx <= 0) splitIdx = maxChunkSize;
+    chunks.push(remaining.slice(0, splitIdx).trimEnd());
+    remaining = remaining.slice(splitIdx).trimStart();
+  }
+  return chunks;
+}
+function emptyAuditReport() {
+  return {
+    stats: { total: 0, agents: 0, projects: 0, oldest: null, newest: null, perAgent: [] },
+    nullVectors: 0,
+    duplicates: [],
+    duplicateCount: 0,
+    bloated: [],
+    fts: { memoryCount: 0, ftsCount: 0, inSync: true },
+    orphanedProjects: [],
+    conflicts: {
+      candidateCount: 0,
+      classified: 0,
+      conflicts: 0,
+      superseded: 0,
+      agree: 0,
+      unclassified: 0,
+      pairs: [],
+      skipped: true
+    },
+    hookHealth: { logExists: false, totalLines: 0, errorsLastHour: 0, topPatterns: [] },
+    hookOwnership: { checkedFiles: [], issues: [], staleLegacyHooks: [] },
+    shards: { total: 0, ok: 0, unreadable: 0, schemaMismatches: 0, archived: 0, unreadableNames: [], schemaIssueNames: [] },
+    keyHealth: { masterKeyPresent: true, recoveryBackupMarked: true },
+    outbox: { bugReports: { total: 0, unsent: 0 }, featureRequests: { total: 0, unsent: 0 } },
+    cpuSteal: { available: false, stealPercent: null, severity: "na", source: "none", message: "not checked" }
+  };
+}
+async function main(argv = process.argv.slice(2)) {
+  const flags = parseFlags(argv);
+  if (flags.restarts) {
+    const restartReport = buildRestartReport({ topTimers: flags.verbose ? 25 : 10 });
+    console.log(formatRestartReport(restartReport));
+    return emptyAuditReport();
+  }
+  const { fastDbInit } = await import("./fast-db-init-IU7GYFWB.js");
+  const client = await fastDbInit();
+  const report = await runAudit(client, flags);
+  console.log(formatReport(report, flags));
+  if (flags.fix || flags.dryRun) {
+    const mode = flags.dryRun ? "[dry-run]" : "[fix]";
+    console.log(`
+${mode} Applying repairs...
+`);
+    if (!flags.dryRun) {
+      try {
+        const { createBackup } = await import("./db-backup-NVUTS7L5.js");
+        const backupPath = await createBackup("pre-fix");
+        if (backupPath) {
+          console.log(`  Backup created: ${backupPath.split("/").pop()}`);
+        }
+      } catch {
+        console.log("  Warning: backup failed \u2014 proceeding with fix anyway");
+      }
+    }
+    if (report.nullVectors > 0) {
+      console.log(`${mode} Backfilling ${fmtNum(report.nullVectors)} null vectors...`);
+      if (!flags.dryRun) {
+        try {
+          await fixNullVectors();
+          console.log("  Done.");
+        } catch (err) {
+          console.error(`  Failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    }
+    if (report.duplicateCount > 0) {
+      console.log(`${mode} Removing ${fmtNum(report.duplicateCount)} duplicates...`);
+      const deleted = await fixDuplicates(client, report.duplicates, flags.dryRun);
+      console.log(`  ${flags.dryRun ? "Would remove" : "Removed"} ${fmtNum(deleted)} records.`);
+    }
+    if (report.bloated.length > 0) {
+      console.log(`${mode} Splitting ${fmtNum(report.bloated.length)} bloated records...`);
+      const chunks = await fixBloated(client, report.bloated, flags.dryRun);
+      console.log(`  ${flags.dryRun ? "Would create" : "Created"} ${fmtNum(chunks)} chunks.`);
+    }
+    if (!report.fts.inSync) {
+      console.log(`${mode} Rebuilding FTS index...`);
+      if (!flags.dryRun) {
+        await client.execute("INSERT INTO memories_fts(memories_fts) VALUES('rebuild')");
+        console.log("  Done.");
+      }
+    }
+    if (report.shards.unreadable > 0 || report.shards.schemaMismatches > 0) {
+      console.log(`${mode} Repairing ${fmtNum(report.shards.unreadable)} unreadable shard(s) and ${fmtNum(report.shards.schemaMismatches)} schema mismatch(es)...`);
+      const fixed = await fixShards(flags.dryRun);
+      console.log(
+        `  ${flags.dryRun ? "Would archive" : "Archived"} ${fmtNum(flags.dryRun ? fixed.unreadable : fixed.archived)} unreadable shard(s); ${flags.dryRun ? "would migrate" : "migrated"} ${fmtNum(flags.dryRun ? fixed.schemaMismatches : report.shards.schemaMismatches - fixed.schemaMismatches)} schema mismatch(es).`
+      );
+    }
+    console.log(`
+${mode} Complete.`);
+  }
+  return report;
+}
+if (isMainModule(import.meta.url) && (process.argv[1] ?? "").includes("exe-doctor")) {
+  main().catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  });
+}
+
+export {
+  parseFlags,
+  auditStats,
+  auditNullVectors,
+  auditDuplicates,
+  auditBloated,
+  auditFts,
+  auditOrphanedProjects,
+  auditHookHealth,
+  auditHookOwnership,
+  auditShards,
+  auditKeyHealth,
+  auditOutbox,
+  auditCpuSteal,
+  runAudit,
+  formatReport,
+  fixNullVectors,
+  fixDuplicates,
+  fixBloated,
+  fixShards,
+  splitAtSentences,
+  main
+};