claude-memory-layer 1.1.1 → 1.1.2

package/dist/cli/index.js

@@ -22877,6 +22877,51 @@ function formatPruneToolObservationVectorsResult(result) {
   return lines.join("\n");
 }
 
+// src/apps/cli/auto-heal-tool-observation-vectors-command.ts
+function resolveAutoHealToolObservationVectorsOptions(options, cwd = process.cwd()) {
+  if (options.project !== void 0 && options.project.trim().length === 0) {
+    throw new Error("auto-heal-tool-observation-vectors --project must not be empty");
+  }
+  return {
+    projectPath: options.project ?? cwd,
+    lockPath: options.lockPath
+  };
+}
+function formatAutoHealToolObservationVectorsResult(outcome) {
+  switch (outcome.status) {
+    case "already-healed":
+      return "Auto-heal tool_observation vectors: already healed, nothing to do.";
+    case "lock-busy":
+      return "Auto-heal tool_observation vectors: another process is already healing this project, skipping.";
+    case "no-store":
+      return "Auto-heal tool_observation vectors: no store found for this project, nothing to do.";
+    case "healed":
+      return [
+        "Auto-heal tool_observation vectors: done.",
+        `Vectors deleted: ${outcome.result.vectorsDeleted}`,
+        `Outbox rows removed: ${outcome.result.outboxRowsRemoved}`
+      ].join("\n");
+  }
+}
+
+// src/core/operations/tool-observation-vector-auto-heal.ts
+var TOOL_OBSERVATION_VECTOR_AUTO_HEAL_KEY = "maintenance:tool_observation_vector_prune_v1";
+async function needsToolObservationVectorAutoHeal(store) {
+  const flag = await store.getEndlessConfig(TOOL_OBSERVATION_VECTOR_AUTO_HEAL_KEY);
+  return flag === null;
+}
+async function runToolObservationVectorAutoHeal(store, vectorStore) {
+  const result = await pruneToolObservationVectors(store, vectorStore, { dryRun: false });
+  await vectorStore.optimizeAll();
+  const record = {
+    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    vectorsDeleted: result.vectorsDeleted,
+    outboxRowsRemoved: result.outboxRowsRemoved
+  };
+  await store.setEndlessConfig(TOOL_OBSERVATION_VECTOR_AUTO_HEAL_KEY, record);
+  return result;
+}
+
 // src/apps/cli/retention-audit-command.ts
 var DEFAULT_RETENTION_AUDIT_LIMIT = 100;
 function resolveRetentionAuditOptions(options) {
@@ -24320,7 +24365,7 @@ async function runOperationCli(action, label) {
   }
 }
 var program = new Command();
-program.name("claude-memory-layer").description("Claude Code Memory Plugin CLI").version("1.1.1");
+program.name("claude-memory-layer").description("Claude Code Memory Plugin CLI").version("1.1.2");
 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);
@@ -24735,6 +24780,42 @@ repairCommand.command("prune-tool-observation-vectors").description("Delete alre
     process.exit(1);
   }
 });
+repairCommand.command("auto-heal-tool-observation-vectors").description("Internal: self-triggered one-time cleanup of already-embedded tool_observation vectors").option("-p, --project <path>", "Project path (defaults to cwd)").option("--lock-path <path>", "Override auto-heal lock path (advanced)").action(async (options) => {
+  let store;
+  let workerLock;
+  try {
+    const healOptions = resolveAutoHealToolObservationVectorsOptions(options);
+    const storagePath = getProjectStoragePath(healOptions.projectPath);
+    const dbPath = path28.join(storagePath, "events.sqlite");
+    if (!fs20.existsSync(dbPath)) {
+      console.log(formatAutoHealToolObservationVectorsResult({ status: "no-store" }));
+      return;
+    }
+    const lockPath = healOptions.lockPath ?? path28.join(storagePath, "auto-heal.lock");
+    workerLock = new WorkerLock(lockPath);
+    const lockResult = workerLock.acquire();
+    if (!lockResult.acquired) {
+      console.log(formatAutoHealToolObservationVectorsResult({ status: "lock-busy" }));
+      workerLock = void 0;
+      return;
+    }
+    store = new SQLiteEventStore(dbPath);
+    if (!await needsToolObservationVectorAutoHeal(store)) {
+      console.log(formatAutoHealToolObservationVectorsResult({ status: "already-healed" }));
+      return;
+    }
+    const vectorStore = new VectorStore(path28.join(storagePath, "vectors"));
+    const result = await runToolObservationVectorAutoHeal(store, vectorStore);
+    console.log(formatAutoHealToolObservationVectorsResult({ status: "healed", result }));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Auto-heal tool_observation vectors failed: ${message}`);
+    process.exitCode = 1;
+  } finally {
+    if (store) await store.close().catch(() => void 0);
+    if (workerLock) workerLock.release();
+  }
+});
 var actorsCommand = program.command("actors").description("Inspect and repair Perspective Memory actors and session memberships");
 actorsCommand.command("repair").description("Backfill Perspective Memory actors and session actor memberships from existing events").requiredOption("-p, --project <path>", "Project path").option("--session-id <id>", "Restrict backfill to a single session").option("--limit <count>", "Maximum events to scan", "10000").option("--sample-limit <count>", "Maximum privacy-safe samples to include", "10").option("--dry-run", "Inspect without mutating actors or session memberships").option("--apply", "Apply actor and membership backfill (default is dry-run)").option("--json", "Print machine-readable JSON").action((options) => runOperationCli(async () => {
   if (options.apply && options.dryRun) {