claude-memory-layer 1.0.54 → 1.0.55

package/dist/cli/index.js

@@ -9,8 +9,8 @@ const __dirname = dirname(__filename);
 // src/apps/cli/index.ts
 import { Command } from "commander";
 import { exec } from "child_process";
-import * as fs19 from "fs";
-import * as path25 from "path";
+import * as fs20 from "fs";
+import * as path26 from "path";
 import * as os13 from "os";
 
 // src/services/memory-service.ts
@@ -2245,12 +2245,12 @@ function resolveProjectStoragePath(projectOrHash) {
 import Database from "better-sqlite3";
 import * as fs4 from "fs";
 import * as nodePath from "path";
-function createSQLiteDatabase(path26, options) {
-  const dir = nodePath.dirname(path26);
+function createSQLiteDatabase(path27, options) {
+  const dir = nodePath.dirname(path27);
   if (!fs4.existsSync(dir)) {
     fs4.mkdirSync(dir, { recursive: true });
   }
-  const db = new Database(path26, {
+  const db = new Database(path27, {
     readonly: options?.readonly ?? false
   });
   if (!options?.readonly && (options?.walMode ?? true)) {
@@ -2713,17 +2713,17 @@ function emptyOutboxRecoveryResult() {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function getNestedRecord(root, path26) {
+function getNestedRecord(root, path27) {
   let cursor = root;
-  for (const key of path26) {
+  for (const key of path27) {
     if (!isRecord(cursor)) return void 0;
     cursor = cursor[key];
   }
   return isRecord(cursor) ? cursor : void 0;
 }
-function getNestedString(root, path26) {
+function getNestedString(root, path27) {
   let cursor = root;
-  for (const key of path26) {
+  for (const key of path27) {
     if (!isRecord(cursor)) return void 0;
     cursor = cursor[key];
   }
@@ -7895,9 +7895,9 @@ function safeParseObject(value) {
     return void 0;
   }
 }
-function nestedString(root, path26) {
+function nestedString(root, path27) {
   let cursor = root;
-  for (const key of path26) {
+  for (const key of path27) {
     if (!isRecord2(cursor)) return void 0;
     cursor = cursor[key];
   }
@@ -7972,12 +7972,12 @@ var GraphPathService = class {
         }
       }
     }
-    const paths = Array.from(bestByTarget.entries()).map(([key, path26]) => ({
+    const paths = Array.from(bestByTarget.entries()).map(([key, path27]) => ({
       target: graph.node(nodeFromKey(key)),
-      hops: path26.hops,
-      totalCost: path26.totalCost,
-      scoreContribution: path26.totalCost > 0 ? 1 / path26.totalCost : 0,
-      steps: path26.steps
+      hops: path27.hops,
+      totalCost: path27.totalCost,
+      scoreContribution: path27.totalCost > 0 ? 1 / path27.totalCost : 0,
+      steps: path27.steps
     })).sort((a, b) => b.scoreContribution - a.scoreContribution || a.hops - b.hops || a.target.name.localeCompare(b.target.name)).slice(0, maxResults);
     return { startNodes, effectiveMaxHops, paths };
   }
@@ -10940,12 +10940,12 @@ var Retriever = class {
         direction: "both"
       });
       const titleByEntityId = new Map(startNodes.map((node) => [node.entityId, node.title]));
-      for (const path26 of expansion.paths) {
-        if (path26.target.type !== "event") continue;
-        const target = await this.eventStore.getEvent(path26.target.id);
+      for (const path27 of expansion.paths) {
+        if (path27.target.type !== "event") continue;
+        const target = await this.eventStore.getEvent(path27.target.id);
         if (!target) continue;
-        const graphPath = toRetrievalGraphPathDebug(path26, titleByEntityId);
-        const score = graphPathScore(path26, opts.hopPenalty);
+        const graphPath = toRetrievalGraphPathDebug(path27, titleByEntityId);
+        const score = graphPathScore(path27, opts.hopPenalty);
         const existing = byId.get(target.id);
         const graphPaths = mergeGraphPaths(existing?.graphPaths ?? [], [graphPath]);
         const graphLane = {
@@ -10954,7 +10954,7 @@ var Retriever = class {
           score
         };
         const row = {
-          id: existing?.id ?? `graph-path-${path26.hops}-${target.id}`,
+          id: existing?.id ?? `graph-path-${path27.hops}-${target.id}`,
           eventId: target.id,
           content: target.content,
           score: Math.max(existing?.score ?? 0, score),
@@ -11294,8 +11294,8 @@ _Context:_ ${sessionContext}`;
   }
   matchesMetadataScope(metadata, expected) {
     if (!metadata) return false;
-    return Object.entries(expected).every(([path26, value]) => {
-      const actual = path26.split(".").reduce((acc, key) => {
+    return Object.entries(expected).every(([path27, value]) => {
+      const actual = path27.split(".").reduce((acc, key) => {
         if (typeof acc !== "object" || acc === null) return void 0;
         return acc[key];
       }, metadata);
@@ -11346,22 +11346,22 @@ function uniqueEntityStartNodes(candidates) {
   }
   return nodes;
 }
-function toRetrievalGraphPathDebug(path26, titleByEntityId) {
-  const firstStep = path26.steps[0];
+function toRetrievalGraphPathDebug(path27, titleByEntityId) {
+  const firstStep = path27.steps[0];
   const startNode = firstStep?.direction === "incoming" ? firstStep.to : firstStep?.from;
   const startEntityId = startNode?.type === "entity" ? startNode.id : "";
   return {
     startEntityId,
     startEntityTitle: titleByEntityId.get(startEntityId) ?? startNode?.name,
-    targetId: path26.target.id,
-    targetType: path26.target.type,
-    hops: path26.hops,
-    relationPath: path26.steps.map((step) => step.relationType)
+    targetId: path27.target.id,
+    targetType: path27.target.type,
+    hops: path27.hops,
+    relationPath: path27.steps.map((step) => step.relationType)
   };
 }
-function graphPathScore(path26, hopPenalty) {
-  const base = Math.min(0.95, Math.max(0, path26.scoreContribution));
-  return Math.max(0.05, base - hopPenalty * Math.max(0, path26.hops - 1));
+function graphPathScore(path27, hopPenalty) {
+  const base = Math.min(0.95, Math.max(0, path27.scoreContribution));
+  return Math.max(0.05, base - hopPenalty * Math.max(0, path27.hops - 1));
 }
 function clampGraphHops(maxHops) {
   if (!Number.isFinite(maxHops)) return 2;
@@ -11369,14 +11369,14 @@ function clampGraphHops(maxHops) {
 }
 function mergeGraphPaths(existing, incoming) {
   const byKey = /* @__PURE__ */ new Map();
-  for (const path26 of [...existing, ...incoming]) {
-    const key = [path26.startEntityId, path26.targetType, path26.targetId, path26.hops, ...path26.relationPath].join("\0");
-    if (!byKey.has(key)) byKey.set(key, path26);
+  for (const path27 of [...existing, ...incoming]) {
+    const key = [path27.startEntityId, path27.targetType, path27.targetId, path27.hops, ...path27.relationPath].join("\0");
+    if (!byKey.has(key)) byKey.set(key, path27);
   }
   return [...byKey.values()].sort((a, b) => a.hops - b.hops || compareStable(graphPathSignature(a), graphPathSignature(b))).slice(0, 3);
 }
-function graphPathSignature(path26) {
-  return [path26.startEntityId, path26.targetType, path26.targetId, path26.hops, ...path26.relationPath].join("|");
+function graphPathSignature(path27) {
+  return [path27.startEntityId, path27.targetType, path27.targetId, path27.hops, ...path27.relationPath].join("|");
 }
 function compareStable(a, b) {
   if (a < b) return -1;
@@ -16350,8 +16350,8 @@ import { getCookie, setCookie, deleteCookie } from "hono/cookie";
 import { logger } from "hono/logger";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
-import * as path18 from "path";
-import * as fs16 from "fs";
+import * as path19 from "path";
+import * as fs17 from "fs";
 import { createHmac, timingSafeEqual } from "crypto";
 import { fileURLToPath as fileUrlToPath } from "url";
 
@@ -19100,6 +19100,150 @@ function streamClaudeResponse(prompt, stream) {
 // src/apps/server/api/health.ts
 import { Hono as Hono9 } from "hono";
 import { spawnSync } from "child_process";
+import * as fs16 from "fs";
+import * as path18 from "path";
+
+// src/core/productivity-health-report.ts
+var PRODUCTIVITY_HEALTH_SCHEMA_VERSION = "agent-productivity-health-v1";
+var PRODUCTIVITY_HEALTH_PROFILES = ["coder", "reviewer", "pm", "support", "researcher", "team"];
+var PRODUCTIVITY_HEALTH_MODES = ["observe", "preview", "enforce"];
+function parseProductivityHealthProfile(value) {
+  const normalized = typeof value === "string" && value.trim().length > 0 ? value.trim() : "coder";
+  if (PRODUCTIVITY_HEALTH_PROFILES.includes(normalized)) {
+    return normalized;
+  }
+  throw new Error(`Invalid --profile: expected one of ${PRODUCTIVITY_HEALTH_PROFILES.join(", ")}`);
+}
+function parseProductivityHealthMode(value) {
+  const normalized = typeof value === "string" && value.trim().length > 0 ? value.trim() : "preview";
+  if (PRODUCTIVITY_HEALTH_MODES.includes(normalized)) {
+    return normalized;
+  }
+  throw new Error(`Invalid --mode: expected one of ${PRODUCTIVITY_HEALTH_MODES.join(", ")}`);
+}
+function buildProductivityHealthReport(input) {
+  const profile = input.profile ?? "coder";
+  const mode = input.mode ?? "preview";
+  const embedding = normalizeQueue(input.outbox.embedding);
+  const vector = normalizeQueue(input.outbox.vector);
+  const totals = sumQueues(embedding, vector);
+  const storage = {
+    totalEvents: numberOrZero(input.stats.totalEvents),
+    vectorCount: numberOrZero(input.stats.vectorCount),
+    levelStats: normalizeLevelStats(input.stats.levelStats)
+  };
+  const warningReasons = [];
+  const projectGate = buildProjectScopeGate(input.project);
+  const outboxGate = buildOutboxGate(totals);
+  const densityGate = buildMemoryDensityGate(storage.totalEvents);
+  const riskGates = [projectGate, outboxGate, densityGate];
+  if (projectGate.status === "warn") warningReasons.push("project_scope_unknown");
+  if (outboxGate.status === "warn") warningReasons.push("outbox_requires_attention");
+  if (densityGate.status === "warn") warningReasons.push("memory_density_low");
+  const status = riskGates.some((gate) => gate.status === "warn") ? "needs-attention" : "ok";
+  return {
+    schemaVersion: PRODUCTIVITY_HEALTH_SCHEMA_VERSION,
+    generatedAt: (input.generatedAt ?? /* @__PURE__ */ new Date()).toISOString(),
+    status,
+    profile,
+    mode,
+    project: input.project,
+    summary: { warningReasons },
+    signals: {
+      storage,
+      outbox: { embedding, vector, totals }
+    },
+    riskGates,
+    nextBestAction: selectNextBestAction({ projectGate, outboxGate, densityGate })
+  };
+}
+function buildProjectScopeGate(project) {
+  if (project.scope === "project") {
+    return { id: "project-scope-known", severity: "blocker", status: "pass" };
+  }
+  return {
+    id: "project-scope-known",
+    severity: "blocker",
+    status: "warn",
+    message: "No project parameter supplied; report uses global memory scope."
+  };
+}
+function buildOutboxGate(totals) {
+  if (totals.failed > 0 || totals.stuckProcessing > 0) {
+    return {
+      id: "outbox-healthy",
+      severity: "warning",
+      status: "warn",
+      message: "Outbox has failed or stuck processing items; run recovery before trusting retrieval freshness."
+    };
+  }
+  return { id: "outbox-healthy", severity: "warning", status: "pass" };
+}
+function buildMemoryDensityGate(totalEvents) {
+  if (totalEvents <= 0) {
+    return {
+      id: "memory-density",
+      severity: "warning",
+      status: "warn",
+      message: "No memories are available for this scope yet."
+    };
+  }
+  return { id: "memory-density", severity: "warning", status: "pass" };
+}
+function selectNextBestAction(input) {
+  if (input.outboxGate.status === "warn") {
+    return "Run claude-memory-layer process --dry-run-recovery, then process pending embeddings.";
+  }
+  if (input.densityGate.status === "warn") {
+    return "Import or capture project context before relying on productivity memory guidance.";
+  }
+  if (input.projectGate.status === "warn") {
+    return "Provide a project path or project hash before relying on project-scoped productivity guidance.";
+  }
+  return "No immediate maintenance action required.";
+}
+function normalizeLevelStats(levelStats) {
+  if (!Array.isArray(levelStats)) return [];
+  return levelStats.filter((entry) => typeof entry.level === "string" && entry.level.trim().length > 0).map((entry) => ({ level: entry.level.trim().slice(0, 20), count: numberOrZero(entry.count) }));
+}
+function normalizeQueue(queue) {
+  return {
+    pending: numberOrZero(queue.pending),
+    processing: numberOrZero(queue.processing),
+    failed: numberOrZero(queue.failed),
+    retryableFailed: numberOrZero(queue.retryableFailed),
+    quarantinedFailed: numberOrZero(queue.quarantinedFailed),
+    total: numberOrZero(queue.total),
+    stuckProcessing: numberOrZero(queue.stuckProcessing),
+    oldestProcessingAgeMs: normalizeNullableAge(queue.oldestProcessingAgeMs)
+  };
+}
+function sumQueues(a, b) {
+  return {
+    pending: a.pending + b.pending,
+    processing: a.processing + b.processing,
+    failed: a.failed + b.failed,
+    retryableFailed: (a.retryableFailed ?? 0) + (b.retryableFailed ?? 0),
+    quarantinedFailed: (a.quarantinedFailed ?? 0) + (b.quarantinedFailed ?? 0),
+    total: a.total + b.total,
+    stuckProcessing: a.stuckProcessing + b.stuckProcessing,
+    oldestProcessingAgeMs: maxNullable(a.oldestProcessingAgeMs, b.oldestProcessingAgeMs)
+  };
+}
+function normalizeNullableAge(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : null;
+}
+function maxNullable(a, b) {
+  if (a === null) return b;
+  if (b === null) return a;
+  return Math.max(a, b);
+}
+function numberOrZero(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return 0;
+  return Math.floor(value);
+}
+
+// src/apps/server/api/health.ts
 var healthRouter = new Hono9();
 function hasEnvSignal(name) {
   const value = process.env[name];
@@ -19140,6 +19284,33 @@ function aggregateOutbox(outbox) {
   const stuckProcessing = (outbox.embedding?.stuckProcessing || 0) + (outbox.vector?.stuckProcessing || 0);
   return { pending, processing, failed, retryableFailed, quarantinedFailed, stuckProcessing };
 }
+function resolveProductivityProjectIdentity(project) {
+  if (!project || project.trim().length === 0) return { scope: "global", id: "global" };
+  const normalized = project.trim();
+  return { scope: "project", id: /^[a-f0-9]{8}$/.test(normalized) ? normalized : hashProjectPath(normalized) };
+}
+function explicitProjectStoreExists(project) {
+  if (!project || project.trim().length === 0) return true;
+  return fs16.existsSync(path18.join(resolveProjectStoragePath(project.trim()), "events.sqlite"));
+}
+function emptyProductivityStats() {
+  return { totalEvents: 0, vectorCount: 0, levelStats: [] };
+}
+function emptyProductivityQueue() {
+  return {
+    pending: 0,
+    processing: 0,
+    failed: 0,
+    retryableFailed: 0,
+    quarantinedFailed: 0,
+    total: 0,
+    stuckProcessing: 0,
+    oldestProcessingAgeMs: null
+  };
+}
+function emptyProductivityOutbox() {
+  return { embedding: emptyProductivityQueue(), vector: emptyProductivityQueue() };
+}
 healthRouter.get("/setup", async (c) => {
   const memoryService = getLightweightServiceFromQuery(c);
   try {
@@ -19196,6 +19367,40 @@ healthRouter.get("/setup", async (c) => {
     await memoryService.shutdown();
   }
 });
+healthRouter.get("/productivity", async (c) => {
+  let memoryService;
+  try {
+    const profile = parseProductivityHealthProfile(c.req.query("profile"));
+    const mode = parseProductivityHealthMode(c.req.query("mode"));
+    const projectQuery = c.req.query("project") || c.req.query("projectId");
+    const project = resolveProductivityProjectIdentity(projectQuery);
+    if (!explicitProjectStoreExists(projectQuery)) {
+      return c.json(buildProductivityHealthReport({
+        stats: emptyProductivityStats(),
+        outbox: emptyProductivityOutbox(),
+        project,
+        profile,
+        mode
+      }));
+    }
+    memoryService = getLightweightServiceFromQuery(c);
+    await memoryService.initialize();
+    const [stats, outbox] = await Promise.all([
+      memoryService.getStats(),
+      memoryService.getOutboxStats()
+    ]);
+    return c.json(buildProductivityHealthReport({ stats, outbox, project, profile, mode }));
+  } catch (error) {
+    const status = error instanceof Error && error.message.startsWith("Invalid --") ? 400 : 500;
+    return c.json({
+      status: "error",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      error: status === 400 ? "Invalid productivity health option" : "Productivity health check failed"
+    }, status);
+  } finally {
+    if (memoryService) await memoryService.shutdown();
+  }
+});
 healthRouter.get("/", async (c) => {
   const memoryService = getLightweightServiceFromQuery(c);
   try {
@@ -19517,20 +19722,20 @@ playgroundRouter.post("/dry-run", async (c) => {
 var apiRouter = new Hono11().route("/sessions", sessionsRouter).route("/events", eventsRouter).route("/search", searchRouter).route("/stats", statsRouter).route("/citations", citationsRouter).route("/turns", turnsRouter).route("/projects", projectsRouter).route("/chat", chatRouter).route("/health", healthRouter).route("/playground", playgroundRouter);
 
 // src/apps/server/index.ts
-var moduleDir = path18.dirname(fileUrlToPath(import.meta.url));
+var moduleDir = path19.dirname(fileUrlToPath(import.meta.url));
 var DASHBOARD_SESSION_COOKIE = "cml_dashboard_session";
 var DEFAULT_SESSION_MAX_AGE_SECONDS = 60 * 60 * 24 * 30;
 function resolveUiPath() {
   const candidates = [
     // Built server: dist/server/index.js -> dist/ui
-    path18.resolve(moduleDir, "../ui"),
+    path19.resolve(moduleDir, "../ui"),
     // Source/dev server: src/apps/server/index.ts -> src/apps/dashboard
-    path18.resolve(moduleDir, "../dashboard"),
+    path19.resolve(moduleDir, "../dashboard"),
     // Fallback when running from a repository root.
-    path18.resolve(process.cwd(), "dist/ui"),
-    path18.resolve(process.cwd(), "src/apps/dashboard")
+    path19.resolve(process.cwd(), "dist/ui"),
+    path19.resolve(process.cwd(), "src/apps/dashboard")
   ];
-  return candidates.find((candidate) => fs16.existsSync(path18.join(candidate, "index.html"))) ?? candidates[0];
+  return candidates.find((candidate) => fs17.existsSync(path19.join(candidate, "index.html"))) ?? candidates[0];
 }
 function normalizeDashboardHost(host = "localhost") {
   const normalized = host.trim().toLowerCase();
@@ -19758,13 +19963,13 @@ function createDashboardApp(options = {}) {
   }
   app2.route("/api", apiRouter);
   const uiPath = resolveUiPath();
-  if (fs16.existsSync(uiPath)) {
+  if (fs17.existsSync(uiPath)) {
     app2.use("/*", serveStatic({ root: uiPath }));
   }
   app2.get("*", (c) => {
-    const indexPath = path18.join(uiPath, "index.html");
-    if (fs16.existsSync(indexPath)) {
-      return c.html(fs16.readFileSync(indexPath, "utf-8"));
+    const indexPath = path19.join(uiPath, "index.html");
+    if (fs17.existsSync(indexPath)) {
+      return c.html(fs17.readFileSync(indexPath, "utf-8"));
     }
     return c.text('UI not built. Run "npm run build:ui" first.', 404);
   });
@@ -20222,20 +20427,20 @@ function formatMetadataValue(value) {
 }
 
 // src/apps/cli/mcp-install.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync7, readFileSync as readFileSync6, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname7, join as join18 } from "node:path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync7, readFileSync as readFileSync6, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname7, join as join19 } from "node:path";
 import { homedir as homedir11 } from "node:os";
 function getDefaultClaudeDesktopConfigPath(platform = process.platform, env = process.env, home = homedir11()) {
   if (platform === "darwin") {
-    return join18(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    return join19(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
   }
   if (platform === "win32") {
-    return join18(env.APPDATA ?? join18(home, "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+    return join19(env.APPDATA ?? join19(home, "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
   }
-  return join18(env.XDG_CONFIG_HOME ?? join18(home, ".config"), "claude", "claude_desktop_config.json");
+  return join19(env.XDG_CONFIG_HOME ?? join19(home, ".config"), "claude", "claude_desktop_config.json");
 }
 function readJsonConfig(configPath) {
-  if (!existsSync14(configPath)) {
+  if (!existsSync15(configPath)) {
     return {};
   }
   const content = readFileSync6(configPath, "utf8").trim();
@@ -20284,7 +20489,7 @@ function installMcpServer(options = {}) {
 }
 
 // src/apps/cli/claude-settings-hooks.ts
-import * as path19 from "path";
+import * as path20 from "path";
 var REQUIRED_HOOK_FILES = [
   "user-prompt-submit.js",
   "post-tool-use.js",
@@ -20303,7 +20508,7 @@ function shellQuotePathForNode(filePath) {
   return `'${filePath.replace(/'/g, `'\\''`)}'`;
 }
 function buildHookCommand(pluginPath, fileName) {
-  return `node ${shellQuotePathForNode(path19.join(pluginPath, "hooks", fileName))}`;
+  return `node ${shellQuotePathForNode(path20.join(pluginPath, "hooks", fileName))}`;
 }
 function getHooksConfig(pluginPath) {
   const makeHook = (fileName) => [
@@ -20374,8 +20579,8 @@ function mergePluginHooksIntoSettings(settings, pluginPath) {
 }
 
 // src/apps/cli/codex-validation-output.ts
-import * as fs17 from "fs";
-import * as path20 from "path";
+import * as fs18 from "fs";
+import * as path21 from "path";
 function formatNumber(value) {
   return Number.isFinite(value) ? value.toLocaleString("en-US") : String(value);
 }
@@ -20449,14 +20654,14 @@ function formatCodexValidationReport(report, format = "markdown") {
   return lines.join("\n");
 }
 function writeCodexValidationReport(outputPath, report, format = "markdown") {
-  const dir = path20.dirname(outputPath);
-  fs17.mkdirSync(dir, { recursive: true });
-  fs17.writeFileSync(outputPath, formatCodexValidationReport(report, format), "utf8");
+  const dir = path21.dirname(outputPath);
+  fs18.mkdirSync(dir, { recursive: true });
+  fs18.writeFileSync(outputPath, formatCodexValidationReport(report, format), "utf8");
 }
 
 // src/apps/cli/hermes-validation-output.ts
-import * as fs18 from "fs";
-import * as path21 from "path";
+import * as fs19 from "fs";
+import * as path22 from "path";
 function formatNumber2(value) {
   return Number.isFinite(value) ? value.toLocaleString("en-US") : String(value);
 }
@@ -20526,9 +20731,9 @@ function formatHermesValidationReport(report, format = "markdown") {
   return lines.join("\n");
 }
 function writeHermesValidationReport(outputPath, report, format = "markdown") {
-  const dir = path21.dirname(outputPath);
-  fs18.mkdirSync(dir, { recursive: true });
-  fs18.writeFileSync(outputPath, formatHermesValidationReport(report, format), "utf8");
+  const dir = path22.dirname(outputPath);
+  fs19.mkdirSync(dir, { recursive: true });
+  fs19.writeFileSync(outputPath, formatHermesValidationReport(report, format), "utf8");
 }
 
 // src/apps/cli/codex-import-runner.ts
@@ -21215,7 +21420,7 @@ function redactSecrets(input) {
 }
 
 // src/apps/cli/process-command.ts
-import * as path22 from "node:path";
+import * as path23 from "node:path";
 function resolveProcessCommandOptions(options, cwd = process.cwd(), deps = {}) {
   const explicitProject = options.project;
   if (explicitProject !== void 0 && explicitProject.trim().length === 0) {
@@ -21236,7 +21441,7 @@ function resolveProcessCommandOptions(options, cwd = process.cwd(), deps = {}) {
     projectPath,
     recoverStuck,
     dryRunRecovery,
-    lockPath: explicitLockPath ?? path22.join(getProjectStoragePath2(projectPath), "vector-worker.lock")
+    lockPath: explicitLockPath ?? path23.join(getProjectStoragePath2(projectPath), "vector-worker.lock")
   };
 }
 function formatProcessLockBusy(input) {
@@ -21256,7 +21461,7 @@ function formatProcessRecoveryPreview(input) {
   const embeddingRetried = input.recovery.embedding.retriedFailed;
   const vectorRetried = input.recovery.vector.retriedFailed;
   const retriedTotal = embeddingRetried + vectorRetried;
-  const oldestProcessingAge = maxNullable(
+  const oldestProcessingAge = maxNullable2(
     input.stats.embedding.oldestProcessingAgeMs,
     input.stats.vector.oldestProcessingAgeMs
   );
@@ -21271,7 +21476,7 @@ function formatProcessRecoveryPreview(input) {
     `Next command: claude-memory-layer process --project ${quoteCliArg(input.projectPath)}`
   ].join("\n");
 }
-function maxNullable(a, b) {
+function maxNullable2(a, b) {
   if (a === null) return b;
   if (b === null) return a;
   return Math.max(a, b);
@@ -21331,15 +21536,15 @@ function formatVectorStatusJsonReport(input) {
   return JSON.stringify(buildVectorStatusReport(input), null, 2);
 }
 function buildVectorStatusReport(input) {
-  const embedding = normalizeQueue(input.outbox.embedding);
-  const vector = normalizeQueue(input.outbox.vector);
-  const totals = sumQueues(embedding, vector);
+  const embedding = normalizeQueue2(input.outbox.embedding);
+  const vector = normalizeQueue2(input.outbox.vector);
+  const totals = sumQueues2(embedding, vector);
   const status = totals.failed > 0 || totals.stuckProcessing > 0 ? "needs-attention" : "ok";
-  const oldestProcessingAgeMs = maxNullable2(embedding.oldestProcessingAgeMs, vector.oldestProcessingAgeMs);
+  const oldestProcessingAgeMs = maxNullable3(embedding.oldestProcessingAgeMs, vector.oldestProcessingAgeMs);
   return {
     storage: {
-      totalEvents: numberOrZero(input.stats.totalEvents),
-      vectorCount: numberOrZero(input.stats.vectorCount)
+      totalEvents: numberOrZero2(input.stats.totalEvents),
+      vectorCount: numberOrZero2(input.stats.vectorCount)
     },
     outbox: { embedding, vector, totals },
     status,
@@ -21352,19 +21557,19 @@ function selectRecommendedAction(totals) {
   if ((totals.quarantinedFailed ?? 0) > 0) return "inspect-quarantined";
   return "none";
 }
-function normalizeQueue(queue) {
+function normalizeQueue2(queue) {
   return {
-    pending: numberOrZero(queue.pending),
-    processing: numberOrZero(queue.processing),
-    failed: numberOrZero(queue.failed),
-    retryableFailed: numberOrZero(queue.retryableFailed),
-    quarantinedFailed: numberOrZero(queue.quarantinedFailed),
-    total: numberOrZero(queue.total),
-    stuckProcessing: numberOrZero(queue.stuckProcessing),
+    pending: numberOrZero2(queue.pending),
+    processing: numberOrZero2(queue.processing),
+    failed: numberOrZero2(queue.failed),
+    retryableFailed: numberOrZero2(queue.retryableFailed),
+    quarantinedFailed: numberOrZero2(queue.quarantinedFailed),
+    total: numberOrZero2(queue.total),
+    stuckProcessing: numberOrZero2(queue.stuckProcessing),
     oldestProcessingAgeMs: Number.isFinite(queue.oldestProcessingAgeMs ?? Number.NaN) ? queue.oldestProcessingAgeMs : null
   };
 }
-function sumQueues(a, b) {
+function sumQueues2(a, b) {
   return {
     pending: a.pending + b.pending,
     processing: a.processing + b.processing,
@@ -21373,7 +21578,7 @@ function sumQueues(a, b) {
     quarantinedFailed: (a.quarantinedFailed ?? 0) + (b.quarantinedFailed ?? 0),
     stuckProcessing: a.stuckProcessing + b.stuckProcessing,
     total: a.total + b.total,
-    oldestProcessingAgeMs: maxNullable2(a.oldestProcessingAgeMs, b.oldestProcessingAgeMs)
+    oldestProcessingAgeMs: maxNullable3(a.oldestProcessingAgeMs, b.oldestProcessingAgeMs)
   };
 }
 function formatQueueRow(label, queue) {
@@ -21389,12 +21594,12 @@ function formatQueueRow(label, queue) {
     formatDuration2(queue.oldestProcessingAgeMs).padStart(7)
   ].join("  ");
 }
-function maxNullable2(a, b) {
+function maxNullable3(a, b) {
   if (a === null) return b;
   if (b === null) return a;
   return Math.max(a, b);
 }
-function numberOrZero(value) {
+function numberOrZero2(value) {
   if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return 0;
   return Math.floor(value);
 }
@@ -21414,12 +21619,12 @@ function formatDuration2(ms) {
 }
 
 // src/apps/cli/mongo-sync-command.ts
-import * as path24 from "node:path";
+import * as path25 from "node:path";
 
 // src/core/worker-lock.ts
-import { closeSync, existsSync as existsSync15, mkdirSync as mkdirSync10, openSync, readFileSync as readFileSync7, unlinkSync, writeFileSync as writeFileSync7 } from "node:fs";
+import { closeSync, existsSync as existsSync16, mkdirSync as mkdirSync10, openSync, readFileSync as readFileSync7, unlinkSync, writeFileSync as writeFileSync7 } from "node:fs";
 import * as os12 from "node:os";
-import * as path23 from "node:path";
+import * as path24 from "node:path";
 import { randomUUID as randomUUID18 } from "node:crypto";
 var WorkerLock = class {
   lockPath;
@@ -21428,7 +21633,7 @@ var WorkerLock = class {
   now;
   isProcessRunning;
   acquired = false;
-  constructor(lockPath = path23.join(os12.tmpdir(), "claude-memory-layer", "vector-worker.lock"), options = {}) {
+  constructor(lockPath = path24.join(os12.tmpdir(), "claude-memory-layer", "vector-worker.lock"), options = {}) {
     this.lockPath = lockPath;
     this.pid = options.pid ?? process.pid;
     this.ownerId = options.ownerId ?? randomUUID18();
@@ -21441,7 +21646,7 @@ var WorkerLock = class {
   acquire() {
     let staleRecovered = false;
     for (; ; ) {
-      mkdirSync10(path23.dirname(this.lockPath), { recursive: true });
+      mkdirSync10(path24.dirname(this.lockPath), { recursive: true });
       const createResult = this.tryCreateLockFile();
       if (createResult === "created") {
         this.acquired = true;
@@ -21475,7 +21680,7 @@ var WorkerLock = class {
     }
   }
   release() {
-    if (!this.acquired || !existsSync15(this.lockPath)) return false;
+    if (!this.acquired || !existsSync16(this.lockPath)) return false;
     const existing = this.readPayload();
     if (!this.isOwnedPayload(existing)) return false;
     try {
@@ -21573,7 +21778,7 @@ function resolveMongoSyncProcessOptions(options, cwd = process.cwd(), deps = {})
     projectPath,
     processAfterSync: options.processAfterSync === true,
     processIntervalMs,
-    lockPath: explicitLockPath ?? path24.join(getProjectStoragePath2(projectPath), "vector-worker.lock")
+    lockPath: explicitLockPath ?? path25.join(getProjectStoragePath2(projectPath), "vector-worker.lock")
   };
 }
 function createMongoSyncPostProcessor(options, deps = {}) {
@@ -21656,28 +21861,28 @@ function parsePositiveIntegerOption2(raw, flagName) {
 }
 
 // src/apps/cli/index.ts
-var CLAUDE_SETTINGS_PATH = path25.join(os13.homedir(), ".claude", "settings.json");
+var CLAUDE_SETTINGS_PATH = path26.join(os13.homedir(), ".claude", "settings.json");
 function getPluginPath() {
   const possiblePaths = [
-    path25.join(__dirname, ".."),
+    path26.join(__dirname, ".."),
     // When running from dist/cli
-    path25.join(__dirname, "../..", "dist"),
+    path26.join(__dirname, "../..", "dist"),
     // When running from src
-    path25.join(process.cwd(), "dist")
+    path26.join(process.cwd(), "dist")
     // Current working directory
   ];
   for (const p of possiblePaths) {
-    const hooksPath = path25.join(p, "hooks", "user-prompt-submit.js");
-    if (fs19.existsSync(hooksPath)) {
+    const hooksPath = path26.join(p, "hooks", "user-prompt-submit.js");
+    if (fs20.existsSync(hooksPath)) {
       return p;
     }
   }
-  return path25.join(os13.homedir(), ".npm-global", "lib", "node_modules", "claude-memory-layer", "dist");
+  return path26.join(os13.homedir(), ".npm-global", "lib", "node_modules", "claude-memory-layer", "dist");
 }
 function loadClaudeSettings() {
   try {
-    if (fs19.existsSync(CLAUDE_SETTINGS_PATH)) {
-      const content = fs19.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
+    if (fs20.existsSync(CLAUDE_SETTINGS_PATH)) {
+      const content = fs20.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
       return JSON.parse(content);
     }
   } catch (error) {
@@ -21686,13 +21891,52 @@ function loadClaudeSettings() {
   return {};
 }
 function saveClaudeSettings(settings) {
-  const dir = path25.dirname(CLAUDE_SETTINGS_PATH);
-  if (!fs19.existsSync(dir)) {
-    fs19.mkdirSync(dir, { recursive: true });
+  const dir = path26.dirname(CLAUDE_SETTINGS_PATH);
+  if (!fs20.existsSync(dir)) {
+    fs20.mkdirSync(dir, { recursive: true });
   }
   const tempPath = CLAUDE_SETTINGS_PATH + ".tmp";
-  fs19.writeFileSync(tempPath, JSON.stringify(settings, null, 2));
-  fs19.renameSync(tempPath, CLAUDE_SETTINGS_PATH);
+  fs20.writeFileSync(tempPath, JSON.stringify(settings, null, 2));
+  fs20.renameSync(tempPath, CLAUDE_SETTINGS_PATH);
+}
+function resolveHealthProjectIdentity(projectPath) {
+  if (!projectPath || projectPath.trim().length === 0) return { scope: "global", id: "global" };
+  const normalized = projectPath.trim();
+  return { scope: "project", id: /^[a-f0-9]{8}$/.test(normalized) ? normalized : hashProjectPath(normalized) };
+}
+function resolveHealthStoragePath(projectPathOrHash) {
+  const normalized = projectPathOrHash?.trim();
+  return normalized && normalized.length > 0 ? resolveProjectStoragePath(normalized) : path26.join(os13.homedir(), ".claude-code", "memory");
+}
+function createHealthMemoryService(projectPathOrHash) {
+  return new MemoryService({
+    storagePath: resolveHealthStoragePath(projectPathOrHash),
+    readOnly: true,
+    lightweightMode: true,
+    analyticsEnabled: false,
+    sharedStoreConfig: DISABLED_SHARED_STORE_CONFIG
+  });
+}
+function healthStoreExists(projectPathOrHash) {
+  return fs20.existsSync(path26.join(resolveHealthStoragePath(projectPathOrHash), "events.sqlite"));
+}
+function emptyHealthStats() {
+  return { totalEvents: 0, vectorCount: 0, levelStats: [] };
+}
+function emptyHealthQueue() {
+  return {
+    pending: 0,
+    processing: 0,
+    failed: 0,
+    retryableFailed: 0,
+    quarantinedFailed: 0,
+    total: 0,
+    stuckProcessing: 0,
+    oldestProcessingAgeMs: null
+  };
+}
+function emptyHealthOutbox() {
+  return { embedding: emptyHealthQueue(), vector: emptyHealthQueue() };
 }
 function parseCommaList(value) {
   if (!value) return void 0;
@@ -21752,7 +21996,7 @@ async function runCodexValidationCommand(options) {
   process.stdout.write(rendered.endsWith("\n") ? rendered : `${rendered}
 `);
   if (options.output) {
-    const outputPath = path25.resolve(options.output);
+    const outputPath = path26.resolve(options.output);
     writeCodexValidationReport(outputPath, report, format);
     console.log(`
 Report written to ${outputPath}`);
@@ -21772,7 +22016,7 @@ async function runHermesValidationCommand(options) {
   process.stdout.write(rendered.endsWith("\n") ? rendered : `${rendered}
 `);
   if (options.output) {
-    const outputPath = path25.resolve(options.output);
+    const outputPath = path26.resolve(options.output);
     writeHermesValidationReport(outputPath, report, format);
     console.log(`
 Report written to ${outputPath}`);
@@ -21806,18 +22050,18 @@ var OPERATION_PRIVACY_CONFIG = {
   }
 };
 function resolveOperationProject(project) {
-  const projectPath = path25.resolve(project ?? process.cwd());
+  const projectPath = path26.resolve(project ?? process.cwd());
   const projectHash = hashProjectPath(projectPath);
   const storagePath = getProjectStoragePath(projectPath);
   return {
     projectPath,
     projectHash,
     storagePath,
-    dbPath: path25.join(storagePath, "events.sqlite")
+    dbPath: path26.join(storagePath, "events.sqlite")
   };
 }
 function openOperationReadDatabase(context) {
-  if (!fs19.existsSync(context.dbPath)) return null;
+  if (!fs20.existsSync(context.dbPath)) return null;
   return createSQLiteDatabase(context.dbPath, { readonly: true, walMode: false });
 }
 async function withOperationWriteDatabase(context, callback) {
@@ -22027,7 +22271,7 @@ async function runOperationCli(action, label) {
   }
 }
 var program = new Command();
-program.name("claude-memory-layer").description("Claude Code Memory Plugin CLI").version("1.0.54");
+program.name("claude-memory-layer").description("Claude Code Memory Plugin CLI").version("1.0.55");
 program.command("market-context").description("Fetch read-only DART/FRED/Finnhub context with structured MarketContextSnapshot bull/bear/risk/catalyst analysis").option("--company <name>", "Company name for DART fallback search and report subject").option("--dart-corp-code <code>", "Exact DART corp_code for issuer-specific filings").option("--symbol <ticker>", "Listed ticker for Finnhub company profile").option("--providers <list>", "Comma-separated providers: dart,fred,finnhub").option("--fred-series <list>", "Comma-separated FRED series IDs").option("--json", "Print structured JSON including analysis.marketSnapshot").option("--no-snapshot", "Disable MarketContextSnapshot and DART company snapshot analysis").action(async (options) => {
   try {
     await runMarketContextCommand(options);
@@ -22040,7 +22284,7 @@ program.command("install").description("Install hooks into Claude Code settings"
   try {
     const pluginPath = options.path || getPluginPath();
     const missingHooks = REQUIRED_HOOK_FILES.filter(
-      (file) => !fs19.existsSync(path25.join(pluginPath, "hooks", file))
+      (file) => !fs20.existsSync(path26.join(pluginPath, "hooks", file))
     );
     if (missingHooks.length > 0) {
       console.error(`
@@ -22106,7 +22350,7 @@ program.command("status").description("Check plugin installation status").action
     console.log(`  PostToolUse: ${hasPostToolHook ? "\u2705 Installed" : "\u274C Not installed"}`);
     console.log(`  Stop: ${hasStopHook ? "\u2705 Installed" : "\u274C Not installed"}`);
     console.log(`  SessionEnd: ${hasSessionEndHook ? "\u2705 Installed" : "\u274C Not installed"}`);
-    const hooksExist = REQUIRED_HOOK_FILES.every((file) => fs19.existsSync(path25.join(pluginPath, "hooks", file)));
+    const hooksExist = REQUIRED_HOOK_FILES.every((file) => fs20.existsSync(path26.join(pluginPath, "hooks", file)));
     console.log(`
 Plugin files: ${hooksExist ? "\u2705 Found" : "\u274C Not found"}`);
     console.log(`  Path: ${pluginPath}`);
@@ -22241,6 +22485,40 @@ program.command("stats").description("View memory statistics").option("-p, --pro
     process.exit(1);
   }
 });
+program.command("health").description("Show aggregate health reports for agent productivity workflows").option("--productivity", "Print Project Health Report for agent productivity workflows").option("--json", "Print health report as JSON").option("-p, --project <path>", "Project path or 8-character project hash").option("--profile <profile>", "Agent profile: coder, reviewer, pm, support, researcher, team", "coder").option("--mode <mode>", "Report mode: observe, preview, enforce", "preview").action(async (options) => {
+  let service;
+  try {
+    if (options.productivity !== true) {
+      throw new Error("Use --productivity to select the Project Health Report");
+    }
+    if (options.json !== true) {
+      throw new Error("Only --json output is currently supported for productivity health");
+    }
+    const profile = parseProductivityHealthProfile(options.profile);
+    const mode = parseProductivityHealthMode(options.mode);
+    const projectPath = options.project ?? process.cwd();
+    const project = resolveHealthProjectIdentity(projectPath);
+    let stats;
+    let outbox;
+    if (healthStoreExists(projectPath)) {
+      service = createHealthMemoryService(projectPath);
+      [stats, outbox] = await Promise.all([
+        service.getStats(),
+        service.getOutboxStats()
+      ]);
+    } else {
+      stats = emptyHealthStats();
+      outbox = emptyHealthOutbox();
+    }
+    console.log(JSON.stringify(buildProductivityHealthReport({ stats, outbox, project, profile, mode }), null, 2));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Health report failed";
+    console.error(message.startsWith("Invalid --") || message.startsWith("Use --") || message.startsWith("Only --") ? message : "Health report failed");
+    process.exit(1);
+  } finally {
+    await service?.shutdown().catch(() => void 0);
+  }
+});
 program.command("vector-status").description("Show aggregate vector outbox status").option("-p, --project <path>", "Project path (defaults to cwd)").option("--json", "Print aggregate vector outbox status as JSON for automation").action(async (options) => {
   let service;
   try {
@@ -22341,8 +22619,8 @@ repairCommand.command("legacy-project-scope").description("Dry-run or apply proj
       apply: options.apply
     });
     const storagePath = projectPath ? getProjectStoragePath(projectPath) : resolveProjectStoragePath(repairOptions.projectHash);
-    const dbPath = path25.join(storagePath, "events.sqlite");
-    if (repairOptions.dryRun && !fs19.existsSync(dbPath)) {
+    const dbPath = path26.join(storagePath, "events.sqlite");
+    if (repairOptions.dryRun && !fs20.existsSync(dbPath)) {
       const projectHash = repairOptions.projectHash || hashProjectPath(repairOptions.projectPath);
       console.log(formatLegacyProjectScopeRepairResult({
         dryRun: true,
@@ -22589,8 +22867,8 @@ retentionCommand.command("audit").description("Run a dry-run retention audit for
     });
     const projectHash = auditOptions.projectHash ?? hashProjectPath(auditOptions.projectPath);
     const storagePath = auditOptions.projectPath ? getProjectStoragePath(auditOptions.projectPath) : resolveProjectStoragePath(projectHash);
-    const dbPath = path25.join(storagePath, "events.sqlite");
-    if (!fs19.existsSync(dbPath)) {
+    const dbPath = path26.join(storagePath, "events.sqlite");
+    if (!fs20.existsSync(dbPath)) {
       const emptyReport = emptyRetentionAuditReport(projectHash, auditOptions.limit);
       console.log(formatRetentionAuditReport(emptyReport, { json: auditOptions.json }));
       return;
@@ -22617,7 +22895,7 @@ program.command("mongo-sync").description("Sync events with MongoDB for multi-se
   const projectPath = options.project || process.cwd();
   const mongoUri = options.mongoUri || process.env.CLAUDE_MEMORY_MONGO_URI;
   const mongoDb = options.mongoDb || process.env.CLAUDE_MEMORY_MONGO_DB;
-  const projectKey = options.mongoProject || process.env.CLAUDE_MEMORY_MONGO_PROJECT || path25.basename(projectPath);
+  const projectKey = options.mongoProject || process.env.CLAUDE_MEMORY_MONGO_PROJECT || path26.basename(projectPath);
   const direction = String(options.direction || "both").toLowerCase();
   if (!mongoUri || !mongoDb) {
     console.error("\n\u274C MongoDB sync is not configured.");
@@ -22647,14 +22925,14 @@ program.command("mongo-sync").description("Sync events with MongoDB for multi-se
     }
   })();
   const storagePath = getProjectStoragePath(projectPath);
-  if (!fs19.existsSync(storagePath)) {
-    fs19.mkdirSync(storagePath, { recursive: true });
+  if (!fs20.existsSync(storagePath)) {
+    fs20.mkdirSync(storagePath, { recursive: true });
   }
   const postProcessor = createMongoSyncPostProcessor(processOptions, {
     log: (message) => process.stdout.write(`${message}
 `)
   });
-  const sqliteStore = new SQLiteEventStore(path25.join(storagePath, "events.sqlite"));
+  const sqliteStore = new SQLiteEventStore(path26.join(storagePath, "events.sqlite"));
   const worker = new MongoSyncWorker(sqliteStore, {
     uri: mongoUri,
     dbName: mongoDb,
@@ -22714,7 +22992,7 @@ function renderProgress(event) {
       break;
     case "session-start": {
       const pct = Math.round(event.sessionIndex / event.totalSessions * 100);
-      const sessionName = path25.basename(event.filePath, ".jsonl").slice(0, 8);
+      const sessionName = path26.basename(event.filePath, ".jsonl").slice(0, 8);
       process.stdout.write(
         `\r  \u{1F4C4} [${event.sessionIndex + 1}/${event.totalSessions}] ${pct}% | Session ${sessionName}... `
       );
@@ -22789,9 +23067,9 @@ async function listMarkdownFiles(root) {
   const stack = [root];
   while (stack.length > 0) {
     const dir = stack.pop();
-    const entries = await fs19.promises.readdir(dir, { withFileTypes: true });
+    const entries = await fs20.promises.readdir(dir, { withFileTypes: true });
     for (const e of entries) {
-      const full = path25.join(dir, e.name);
+      const full = path26.join(dir, e.name);
       if (e.isDirectory()) stack.push(full);
       else if (e.isFile() && e.name.endsWith(".md") && e.name !== "_index.md") out.push(full);
     }
@@ -22799,8 +23077,8 @@ async function listMarkdownFiles(root) {
   return out.sort();
 }
 function deriveNamespaceCategory(sourceRoot, filePath) {
-  const rel = path25.relative(sourceRoot, filePath);
-  const dirSeg = path25.dirname(rel).split(path25.sep).filter(Boolean);
+  const rel = path26.relative(sourceRoot, filePath);
+  const dirSeg = path26.dirname(rel).split(path26.sep).filter(Boolean);
   if (dirSeg.length >= 2) {
     const namespace = sanitizeSegment3(dirSeg[0], "default");
     const categoryPath = dirSeg.slice(1).map((s) => sanitizeSegment3(s, "uncategorized"));
@@ -22819,10 +23097,10 @@ function extractImportEvidence(markdown) {
 program.command("organize-import [sourceDir]").description("Import existing markdown memory files, or bootstrap knowledge docs from codebase/git when markdown is missing").option("-p, --project <path>", "Project path (defaults to cwd)").option("--session <id>", "Session id for imported events (default: import:organized)").option("--limit <n>", "Limit number of files to import").option("--dry-run", "Preview mapping without writing").option("--bootstrap", "Force-generate structured markdown from codebase + git history before import").option("--bootstrap-if-empty", "Auto-bootstrap when source has no markdown files (default: true)", true).option("--no-bootstrap-if-empty", "Disable auto-bootstrap when source has no markdown files").option("--force-bootstrap", "Run bootstrap even when markdown files exist").option("--repo <path>", "Repository root for bootstrap analysis (default: project path)").option("--out <path>", "Output directory for generated bootstrap markdown (default: <sourceDir>/bootstrap-kb)").option("--since <range>", 'Git history range for bootstrap (default: "180 days ago")').option("--max-commits <n>", "Max commits to analyze for bootstrap (default: 1000)").option("--incremental", "Use previous bootstrap manifest as baseline for incremental updates (default: true)", true).option("--no-incremental", "Disable incremental bootstrap; regenerate full snapshot").action(async (sourceDir, options) => {
   const projectPath = options.project || process.cwd();
   const sessionId = options.session || "import:organized";
-  const sourceRoot = path25.resolve(sourceDir || options.out || projectPath);
-  const repoPath = path25.resolve(options.repo || projectPath);
-  if (!fs19.existsSync(sourceRoot)) {
-    fs19.mkdirSync(sourceRoot, { recursive: true });
+  const sourceRoot = path26.resolve(sourceDir || options.out || projectPath);
+  const repoPath = path26.resolve(options.repo || projectPath);
+  if (!fs20.existsSync(sourceRoot)) {
+    fs20.mkdirSync(sourceRoot, { recursive: true });
   }
   const service = getMemoryServiceForProject(projectPath);
   try {
@@ -22832,7 +23110,7 @@ program.command("organize-import [sourceDir]").description("Import existing mark
     const hasMarkdown = files.length > 0;
     const shouldBootstrap = Boolean(options.forceBootstrap || options.bootstrap || !hasMarkdown && options.bootstrapIfEmpty);
     if (shouldBootstrap) {
-      const outDir = path25.resolve(options.out || path25.join(sourceRoot, "bootstrap-kb"));
+      const outDir = path26.resolve(options.out || path26.join(sourceRoot, "bootstrap-kb"));
       const since = options.since || "180 days ago";
       const maxCommits = options.maxCommits ? Math.max(1, parseInt(options.maxCommits, 10)) : 1e3;
       console.log("\n\u{1F9E0} Bootstrapping markdown knowledge base...");
@@ -22871,13 +23149,13 @@ program.command("organize-import [sourceDir]").description("Import existing mark
     let imported = 0;
     let skipped = 0;
     for (const file of targets) {
-      const text = await fs19.promises.readFile(file, "utf8");
+      const text = await fs20.promises.readFile(file, "utf8");
       if (!text.trim()) {
         skipped += 1;
         continue;
       }
       const { namespace, categoryPath } = deriveNamespaceCategory(activeSourceRoot, file);
-      const rel = path25.relative(activeSourceRoot, file);
+      const rel = path26.relative(activeSourceRoot, file);
       const evidence = extractImportEvidence(text);
       if (options.dryRun) {
         console.log(`- ${rel} -> namespace=${namespace} category=${categoryPath.join("/")} confidence=${evidence.confidence || "n/a"} sources=${evidence.sources.length}`);