claude-memory-layer 1.0.43 → 1.0.44

package/README.md

@@ -489,7 +489,7 @@ claude-memory-layer dashboard --bind localhost --port 37777 --password "<local-p
 claude-memory-layer market-context --company 삼성전자 --dart-corp-code 00126380 --symbol 005930.KS --json
 ```
 
-MongoDB 동기화는 선택 기능입니다. 여러 서버에서 같은 프로젝트를 개발할 때, 각 서버의 로컬 SQLite 이벤트를 하나의 MongoDB로 모아 push/pull할 수 있습니다.
+MongoDB 동기화는 선택 기능입니다. 여러 서버에서 같은 프로젝트를 개발할 때, 각 서버의 로컬 SQLite 이벤트를 하나의 MongoDB로 모아 push/pull할 수 있습니다. Pull된 이벤트를 바로 semantic search/context-pack에서 쓰고 싶다면 `--process-after-sync`를 함께 켜서 새 이벤트가 내려온 뒤 pending embedding/vector outbox를 처리하세요.
 
 ```bash
 export CLAUDE_MEMORY_MONGO_URI="mongodb://USER:***@HOST:PORT/"
@@ -497,8 +497,11 @@ export CLAUDE_MEMORY_MONGO_DB="claude_memory_layer"
 export CLAUDE_MEMORY_MONGO_PROJECT="my-project"
 claude-memory-layer mongo-sync
 claude-memory-layer mongo-sync --watch --interval 30000
+claude-memory-layer mongo-sync --watch --interval 30000 --process-after-sync --process-interval 120000
 ```
 
+`--process-after-sync`는 pull된 이벤트가 있을 때만 실행되며, `--process-interval` 동안 debounce되어 매 sync tick마다 불필요하게 임베딩을 재처리하지 않습니다. 내부적으로 project-scoped `vector-worker.lock`을 사용하므로 별도 `process` worker가 이미 실행 중이면 skip합니다.
+
 ### memU-inspired Retrieval 사용 예시
 
 아래 예시는 SDK/서비스 레벨에서 `retrieveMemories()` 호출 시 적용되는 옵션입니다.

package/dist/cli/index.js

@@ -10,7 +10,7 @@ const __dirname = dirname(__filename);
 import { Command } from "commander";
 import { exec } from "child_process";
 import * as fs18 from "fs";
-import * as path23 from "path";
+import * as path24 from "path";
 import * as os13 from "os";
 
 // src/services/memory-service.ts
@@ -2241,12 +2241,12 @@ function resolveProjectStoragePath(projectOrHash) {
 import Database from "better-sqlite3";
 import * as fs4 from "fs";
 import * as nodePath from "path";
-function createSQLiteDatabase(path24, options) {
-  const dir = nodePath.dirname(path24);
+function createSQLiteDatabase(path25, options) {
+  const dir = nodePath.dirname(path25);
   if (!fs4.existsSync(dir)) {
     fs4.mkdirSync(dir, { recursive: true });
   }
-  const db = new Database(path24, {
+  const db = new Database(path25, {
     readonly: options?.readonly ?? false
   });
   if (!options?.readonly && (options?.walMode ?? true)) {
@@ -2697,18 +2697,18 @@ function emptyOutboxRecoveryResult() {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function getNestedRecord(root, path24) {
+function getNestedRecord(root, path25) {
   let cursor = root;
-  for (const key of path24) {
+  for (const key of path25) {
     if (!isRecord(cursor))
       return void 0;
     cursor = cursor[key];
   }
   return isRecord(cursor) ? cursor : void 0;
 }
-function getNestedString(root, path24) {
+function getNestedString(root, path25) {
   let cursor = root;
-  for (const key of path24) {
+  for (const key of path25) {
     if (!isRecord(cursor))
       return void 0;
     cursor = cursor[key];
@@ -7777,9 +7777,9 @@ function safeParseObject(value) {
     return void 0;
   }
 }
-function nestedString(root, path24) {
+function nestedString(root, path25) {
   let cursor = root;
-  for (const key of path24) {
+  for (const key of path25) {
     if (!isRecord2(cursor))
       return void 0;
     cursor = cursor[key];
@@ -7856,12 +7856,12 @@ var GraphPathService = class {
         }
       }
     }
-    const paths = Array.from(bestByTarget.entries()).map(([key, path24]) => ({
+    const paths = Array.from(bestByTarget.entries()).map(([key, path25]) => ({
       target: graph.node(nodeFromKey(key)),
-      hops: path24.hops,
-      totalCost: path24.totalCost,
-      scoreContribution: path24.totalCost > 0 ? 1 / path24.totalCost : 0,
-      steps: path24.steps
+      hops: path25.hops,
+      totalCost: path25.totalCost,
+      scoreContribution: path25.totalCost > 0 ? 1 / path25.totalCost : 0,
+      steps: path25.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 };
   }
@@ -10843,14 +10843,14 @@ var Retriever = class {
         direction: "both"
       });
       const titleByEntityId = new Map(startNodes.map((node) => [node.entityId, node.title]));
-      for (const path24 of expansion.paths) {
-        if (path24.target.type !== "event")
+      for (const path25 of expansion.paths) {
+        if (path25.target.type !== "event")
           continue;
-        const target = await this.eventStore.getEvent(path24.target.id);
+        const target = await this.eventStore.getEvent(path25.target.id);
         if (!target)
           continue;
-        const graphPath = toRetrievalGraphPathDebug(path24, titleByEntityId);
-        const score = graphPathScore(path24, opts.hopPenalty);
+        const graphPath = toRetrievalGraphPathDebug(path25, titleByEntityId);
+        const score = graphPathScore(path25, opts.hopPenalty);
         const existing = byId.get(target.id);
         const graphPaths = mergeGraphPaths(existing?.graphPaths ?? [], [graphPath]);
         const graphLane = {
@@ -10859,7 +10859,7 @@ var Retriever = class {
           score
         };
         const row = {
-          id: existing?.id ?? `graph-path-${path24.hops}-${target.id}`,
+          id: existing?.id ?? `graph-path-${path25.hops}-${target.id}`,
           eventId: target.id,
           content: target.content,
           score: Math.max(existing?.score ?? 0, score),
@@ -11206,8 +11206,8 @@ _Context:_ ${sessionContext}`;
   matchesMetadataScope(metadata, expected) {
     if (!metadata)
       return false;
-    return Object.entries(expected).every(([path24, value]) => {
-      const actual = path24.split(".").reduce((acc, key) => {
+    return Object.entries(expected).every(([path25, value]) => {
+      const actual = path25.split(".").reduce((acc, key) => {
         if (typeof acc !== "object" || acc === null)
           return void 0;
         return acc[key];
@@ -11267,22 +11267,22 @@ function uniqueEntityStartNodes(candidates) {
   }
   return nodes;
 }
-function toRetrievalGraphPathDebug(path24, titleByEntityId) {
-  const firstStep = path24.steps[0];
+function toRetrievalGraphPathDebug(path25, titleByEntityId) {
+  const firstStep = path25.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: path24.target.id,
-    targetType: path24.target.type,
-    hops: path24.hops,
-    relationPath: path24.steps.map((step) => step.relationType)
+    targetId: path25.target.id,
+    targetType: path25.target.type,
+    hops: path25.hops,
+    relationPath: path25.steps.map((step) => step.relationType)
   };
 }
-function graphPathScore(path24, hopPenalty) {
-  const base = Math.min(0.95, Math.max(0, path24.scoreContribution));
-  return Math.max(0.05, base - hopPenalty * Math.max(0, path24.hops - 1));
+function graphPathScore(path25, hopPenalty) {
+  const base = Math.min(0.95, Math.max(0, path25.scoreContribution));
+  return Math.max(0.05, base - hopPenalty * Math.max(0, path25.hops - 1));
 }
 function clampGraphHops(maxHops) {
   if (!Number.isFinite(maxHops))
@@ -11291,15 +11291,15 @@ function clampGraphHops(maxHops) {
 }
 function mergeGraphPaths(existing, incoming) {
   const byKey = /* @__PURE__ */ new Map();
-  for (const path24 of [...existing, ...incoming]) {
-    const key = [path24.startEntityId, path24.targetType, path24.targetId, path24.hops, ...path24.relationPath].join("\0");
+  for (const path25 of [...existing, ...incoming]) {
+    const key = [path25.startEntityId, path25.targetType, path25.targetId, path25.hops, ...path25.relationPath].join("\0");
     if (!byKey.has(key))
-      byKey.set(key, path24);
+      byKey.set(key, path25);
   }
   return [...byKey.values()].sort((a, b) => a.hops - b.hops || compareStable(graphPathSignature(a), graphPathSignature(b))).slice(0, 3);
 }
-function graphPathSignature(path24) {
-  return [path24.startEntityId, path24.targetType, path24.targetId, path24.hops, ...path24.relationPath].join("|");
+function graphPathSignature(path25) {
+  return [path25.startEntityId, path25.targetType, path25.targetId, path25.hops, ...path25.relationPath].join("|");
 }
 function compareStable(a, b) {
   if (a < b)
@@ -21007,6 +21007,9 @@ function formatDuration2(ms) {
   return remainingHours === 0 ? `${days}d` : `${days}d ${remainingHours}h`;
 }
 
+// src/apps/cli/mongo-sync-command.ts
+import * as path23 from "node:path";
+
 // src/core/worker-lock.ts
 import { closeSync, existsSync as existsSync14, mkdirSync as mkdirSync10, openSync, readFileSync as readFileSync7, unlinkSync, writeFileSync as writeFileSync7 } from "node:fs";
 import * as os12 from "node:os";
@@ -21151,24 +21154,129 @@ function defaultIsProcessRunning(pid) {
   }
 }
 
+// src/apps/cli/mongo-sync-command.ts
+var DEFAULT_PROCESS_INTERVAL_MS = 12e4;
+function resolveMongoSyncProcessOptions(options, cwd = process.cwd(), deps = {}) {
+  const explicitProject = options.project;
+  if (explicitProject !== void 0 && explicitProject.trim().length === 0) {
+    throw new Error("--project must not be empty");
+  }
+  const explicitLockPath = options.processLockPath;
+  if (explicitLockPath !== void 0 && explicitLockPath.trim().length === 0) {
+    throw new Error("--process-lock-path must not be empty");
+  }
+  const projectPath = explicitProject ?? cwd;
+  const processIntervalMs = parsePositiveIntegerOption2(
+    options.processInterval ?? String(DEFAULT_PROCESS_INTERVAL_MS),
+    "--process-interval"
+  );
+  const getProjectStoragePath2 = deps.getProjectStoragePath ?? getProjectStoragePath;
+  return {
+    projectPath,
+    processAfterSync: options.processAfterSync === true,
+    processIntervalMs,
+    lockPath: explicitLockPath ?? path23.join(getProjectStoragePath2(projectPath), "vector-worker.lock")
+  };
+}
+function createMongoSyncPostProcessor(options, deps = {}) {
+  const now = deps.now ?? (() => Date.now());
+  const processOnce = deps.processOnce ?? processProjectEmbeddingsOnce;
+  const log = deps.log ?? (() => void 0);
+  let lastProcessAtMs = null;
+  return {
+    async afterSync(result) {
+      if (!options.processAfterSync)
+        return;
+      if (result.pulled <= 0)
+        return;
+      const currentTimeMs = now();
+      if (lastProcessAtMs !== null && currentTimeMs - lastProcessAtMs < options.processIntervalMs) {
+        return;
+      }
+      lastProcessAtMs = currentTimeMs;
+      log(`[mongo-sync] Processing pending embeddings after pulling ${result.pulled} events...`);
+      let outcome;
+      try {
+        outcome = await processOnce({
+          projectPath: options.projectPath,
+          lockPath: options.lockPath
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        log(`[mongo-sync] Process-after-sync failed: ${message}`);
+        return;
+      }
+      if (outcome.skipped) {
+        const holder = outcome.holderPid === void 0 || outcome.holderPid === null ? "unknown" : String(outcome.holderPid);
+        log(`[mongo-sync] Skipped embedding processing because another vector worker is running (holderPid=${holder})`);
+        return;
+      }
+      log(`[mongo-sync] Processed ${outcome.processed} embeddings after sync`);
+    }
+  };
+}
+async function processProjectEmbeddingsOnce(input, deps = {}) {
+  const createWorkerLock = deps.createWorkerLock ?? ((lockPath) => new WorkerLock(lockPath));
+  const createService = deps.createMemoryService ?? createMemoryService;
+  const getProjectStoragePath2 = deps.getProjectStoragePath ?? getProjectStoragePath;
+  const hashProjectPath2 = deps.hashProjectPath ?? hashProjectPath;
+  const workerLock = createWorkerLock(input.lockPath);
+  const lockResult = workerLock.acquire();
+  if (!lockResult.acquired) {
+    return {
+      skipped: true,
+      processed: 0,
+      holderPid: "holderPid" in lockResult ? lockResult.holderPid : null
+    };
+  }
+  let service;
+  try {
+    service = createService({
+      storagePath: getProjectStoragePath2(input.projectPath),
+      projectHash: hashProjectPath2(input.projectPath),
+      projectPath: input.projectPath,
+      sharedStoreConfig: DISABLED_SHARED_STORE_CONFIG,
+      analyticsEnabled: false
+    });
+    await service.initialize();
+    await service.recoverStuckOutboxItems();
+    const processed = await service.processPendingEmbeddings();
+    return { skipped: false, processed };
+  } finally {
+    workerLock.release();
+    await service?.shutdown().catch(() => void 0);
+  }
+}
+function parsePositiveIntegerOption2(raw, flagName) {
+  const value = raw.trim();
+  if (!/^\d+$/.test(value)) {
+    throw new Error(`${flagName} must be a positive integer number of milliseconds`);
+  }
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+    throw new Error(`${flagName} must be a positive integer number of milliseconds`);
+  }
+  return parsed;
+}
+
 // src/apps/cli/index.ts
-var CLAUDE_SETTINGS_PATH = path23.join(os13.homedir(), ".claude", "settings.json");
+var CLAUDE_SETTINGS_PATH = path24.join(os13.homedir(), ".claude", "settings.json");
 function getPluginPath() {
   const possiblePaths = [
-    path23.join(__dirname, ".."),
+    path24.join(__dirname, ".."),
     // When running from dist/cli
-    path23.join(__dirname, "../..", "dist"),
+    path24.join(__dirname, "../..", "dist"),
     // When running from src
-    path23.join(process.cwd(), "dist")
+    path24.join(process.cwd(), "dist")
     // Current working directory
   ];
   for (const p of possiblePaths) {
-    const hooksPath = path23.join(p, "hooks", "user-prompt-submit.js");
+    const hooksPath = path24.join(p, "hooks", "user-prompt-submit.js");
     if (fs18.existsSync(hooksPath)) {
       return p;
     }
   }
-  return path23.join(os13.homedir(), ".npm-global", "lib", "node_modules", "claude-memory-layer", "dist");
+  return path24.join(os13.homedir(), ".npm-global", "lib", "node_modules", "claude-memory-layer", "dist");
 }
 function loadClaudeSettings() {
   try {
@@ -21182,7 +21290,7 @@ function loadClaudeSettings() {
   return {};
 }
 function saveClaudeSettings(settings) {
-  const dir = path23.dirname(CLAUDE_SETTINGS_PATH);
+  const dir = path24.dirname(CLAUDE_SETTINGS_PATH);
   if (!fs18.existsSync(dir)) {
     fs18.mkdirSync(dir, { recursive: true });
   }
@@ -21211,7 +21319,7 @@ function parseMarketProviders(value) {
   }
   return selected;
 }
-function parsePositiveIntegerOption2(value, optionName) {
+function parsePositiveIntegerOption3(value, optionName) {
   if (value === void 0)
     return void 0;
   const normalized = value.trim();
@@ -21246,14 +21354,14 @@ async function runCodexValidationCommand(options) {
   const report = await validateCodexSessions({
     sessionsDir: options.sessionsDir,
     projectPath: options.project,
-    limit: parsePositiveIntegerOption2(options.limit, "limit"),
+    limit: parsePositiveIntegerOption3(options.limit, "limit"),
     anonymizeProjects: options.anonymizeProjects === true
   });
   const rendered = formatCodexValidationReport(report, format);
   process.stdout.write(rendered.endsWith("\n") ? rendered : `${rendered}
 `);
   if (options.output) {
-    const outputPath = path23.resolve(options.output);
+    const outputPath = path24.resolve(options.output);
     writeCodexValidationReport(outputPath, report, format);
     console.log(`
 Report written to ${outputPath}`);
@@ -21267,13 +21375,13 @@ async function runHermesValidationCommand(options) {
   const report = await validateHermesSessions({
     stateDbPath: options.stateDb,
     projectPath: options.project,
-    limit: parsePositiveIntegerOption2(options.limit, "limit")
+    limit: parsePositiveIntegerOption3(options.limit, "limit")
   });
   const rendered = formatHermesValidationReport(report, format);
   process.stdout.write(rendered.endsWith("\n") ? rendered : `${rendered}
 `);
   if (options.output) {
-    const outputPath = path23.resolve(options.output);
+    const outputPath = path24.resolve(options.output);
     writeHermesValidationReport(outputPath, report, format);
     console.log(`
 Report written to ${outputPath}`);
@@ -21307,14 +21415,14 @@ var OPERATION_PRIVACY_CONFIG = {
   }
 };
 function resolveOperationProject(project) {
-  const projectPath = path23.resolve(project ?? process.cwd());
+  const projectPath = path24.resolve(project ?? process.cwd());
   const projectHash = hashProjectPath(projectPath);
   const storagePath = getProjectStoragePath(projectPath);
   return {
     projectPath,
     projectHash,
     storagePath,
-    dbPath: path23.join(storagePath, "events.sqlite")
+    dbPath: path24.join(storagePath, "events.sqlite")
   };
 }
 function openOperationReadDatabase(context) {
@@ -21544,7 +21652,7 @@ async function runOperationCli(action, label) {
   }
 }
 var program = new Command();
-program.name("claude-memory-layer").description("Claude Code Memory Plugin CLI").version("1.0.43");
+program.name("claude-memory-layer").description("Claude Code Memory Plugin CLI").version("1.0.44");
 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);
@@ -21557,7 +21665,7 @@ program.command("install").description("Install hooks into Claude Code settings"
   try {
     const pluginPath = options.path || getPluginPath();
     const missingHooks = REQUIRED_HOOK_FILES.filter(
-      (file) => !fs18.existsSync(path23.join(pluginPath, "hooks", file))
+      (file) => !fs18.existsSync(path24.join(pluginPath, "hooks", file))
     );
     if (missingHooks.length > 0) {
       console.error(`
@@ -21623,7 +21731,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) => fs18.existsSync(path23.join(pluginPath, "hooks", file)));
+    const hooksExist = REQUIRED_HOOK_FILES.every((file) => fs18.existsSync(path24.join(pluginPath, "hooks", file)));
     console.log(`
 Plugin files: ${hooksExist ? "\u2705 Found" : "\u274C Not found"}`);
     console.log(`  Path: ${pluginPath}`);
@@ -21857,7 +21965,7 @@ repairCommand.command("legacy-project-scope").description("Dry-run or apply proj
       apply: options.apply
     });
     const storagePath = projectPath ? getProjectStoragePath(projectPath) : resolveProjectStoragePath(repairOptions.projectHash);
-    const dbPath = path23.join(storagePath, "events.sqlite");
+    const dbPath = path24.join(storagePath, "events.sqlite");
     if (repairOptions.dryRun && !fs18.existsSync(dbPath)) {
       const projectHash = repairOptions.projectHash || hashProjectPath(repairOptions.projectPath);
       console.log(formatLegacyProjectScopeRepairResult({
@@ -22108,7 +22216,7 @@ 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 = path23.join(storagePath, "events.sqlite");
+    const dbPath = path24.join(storagePath, "events.sqlite");
     if (!fs18.existsSync(dbPath)) {
       const emptyReport = emptyRetentionAuditReport(projectHash, auditOptions.limit);
       console.log(formatRetentionAuditReport(emptyReport, { json: auditOptions.json }));
@@ -22132,11 +22240,11 @@ retentionCommand.command("audit").description("Run a dry-run retention audit for
     process.exit(1);
   }
 });
-program.command("mongo-sync").description("Sync events with MongoDB for multi-server collaboration (optional)").option("-p, --project <path>", "Project path (defaults to cwd)").option("--mongo-uri <uri>", "MongoDB connection URI (env: CLAUDE_MEMORY_MONGO_URI)").option("--mongo-db <name>", "MongoDB database name (env: CLAUDE_MEMORY_MONGO_DB)").option("--mongo-project <key>", "Remote project key (env: CLAUDE_MEMORY_MONGO_PROJECT, default: basename(projectPath))").option("--direction <dir>", "push|pull|both", "both").option("--batch-size <n>", "Batch size", "500").option("--interval <ms>", "Watch interval ms", "30000").option("--watch", "Run continuously").action(async (options) => {
+program.command("mongo-sync").description("Sync events with MongoDB for multi-server collaboration (optional)").option("-p, --project <path>", "Project path (defaults to cwd)").option("--mongo-uri <uri>", "MongoDB connection URI (env: CLAUDE_MEMORY_MONGO_URI)").option("--mongo-db <name>", "MongoDB database name (env: CLAUDE_MEMORY_MONGO_DB)").option("--mongo-project <key>", "Remote project key (env: CLAUDE_MEMORY_MONGO_PROJECT, default: basename(projectPath))").option("--direction <dir>", "push|pull|both", "both").option("--batch-size <n>", "Batch size", "500").option("--interval <ms>", "Watch interval ms", "30000").option("--watch", "Run continuously").option("--process-after-sync", "Process pending embeddings after pull activity").option("--process-interval <ms>", "Minimum ms between process runs when --process-after-sync is enabled", "120000").option("--process-lock-path <path>", "Override process-after-sync lock path (advanced)").action(async (options) => {
   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 || path23.basename(projectPath);
+  const projectKey = options.mongoProject || process.env.CLAUDE_MEMORY_MONGO_PROJECT || path24.basename(projectPath);
   const direction = String(options.direction || "both").toLowerCase();
   if (!mongoUri || !mongoDb) {
     console.error("\n\u274C MongoDB sync is not configured.");
@@ -22147,15 +22255,33 @@ program.command("mongo-sync").description("Sync events with MongoDB for multi-se
     console.error("\n\u274C Invalid --direction. Use: push | pull | both\n");
     process.exit(1);
   }
-  const storagePath = getProjectStoragePath(projectPath);
-  if (!fs18.existsSync(storagePath)) {
-    fs18.mkdirSync(storagePath, { recursive: true });
-  }
   const batchSizeParsed = parseInt(options.batchSize, 10);
   const intervalParsed = parseInt(options.interval, 10);
   const batchSize = Number.isFinite(batchSizeParsed) && batchSizeParsed > 0 ? batchSizeParsed : 500;
   const intervalMs = Number.isFinite(intervalParsed) && intervalParsed > 0 ? intervalParsed : 3e4;
-  const sqliteStore = new SQLiteEventStore(path23.join(storagePath, "events.sqlite"));
+  const processOptions = (() => {
+    try {
+      return resolveMongoSyncProcessOptions({
+        project: projectPath,
+        processAfterSync: options.processAfterSync,
+        processInterval: options.processInterval,
+        processLockPath: options.processLockPath
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`[mongo-sync] Failed: ${message}`);
+      process.exit(1);
+    }
+  })();
+  const storagePath = getProjectStoragePath(projectPath);
+  if (!fs18.existsSync(storagePath)) {
+    fs18.mkdirSync(storagePath, { recursive: true });
+  }
+  const postProcessor = createMongoSyncPostProcessor(processOptions, {
+    log: (message) => process.stdout.write(`${message}
+`)
+  });
+  const sqliteStore = new SQLiteEventStore(path24.join(storagePath, "events.sqlite"));
   const worker = new MongoSyncWorker(sqliteStore, {
     uri: mongoUri,
     dbName: mongoDb,
@@ -22169,6 +22295,7 @@ program.command("mongo-sync").description("Sync events with MongoDB for multi-se
     const ts = (/* @__PURE__ */ new Date()).toISOString();
     process.stdout.write(`[mongo-sync] ${ts} project=${projectKey} pushed=${pushed} pulled=${pulled}
 `);
+    await postProcessor.afterSync({ pushed, pulled });
   };
   try {
     if (!options.watch) {
@@ -22214,7 +22341,7 @@ function renderProgress(event) {
       break;
     case "session-start": {
       const pct = Math.round(event.sessionIndex / event.totalSessions * 100);
-      const sessionName = path23.basename(event.filePath, ".jsonl").slice(0, 8);
+      const sessionName = path24.basename(event.filePath, ".jsonl").slice(0, 8);
       process.stdout.write(
         `\r  \u{1F4C4} [${event.sessionIndex + 1}/${event.totalSessions}] ${pct}% | Session ${sessionName}... `
       );
@@ -22291,7 +22418,7 @@ async function listMarkdownFiles(root) {
     const dir = stack.pop();
     const entries = await fs18.promises.readdir(dir, { withFileTypes: true });
     for (const e of entries) {
-      const full = path23.join(dir, e.name);
+      const full = path24.join(dir, e.name);
       if (e.isDirectory())
         stack.push(full);
       else if (e.isFile() && e.name.endsWith(".md") && e.name !== "_index.md")
@@ -22301,8 +22428,8 @@ async function listMarkdownFiles(root) {
   return out.sort();
 }
 function deriveNamespaceCategory(sourceRoot, filePath) {
-  const rel = path23.relative(sourceRoot, filePath);
-  const dirSeg = path23.dirname(rel).split(path23.sep).filter(Boolean);
+  const rel = path24.relative(sourceRoot, filePath);
+  const dirSeg = path24.dirname(rel).split(path24.sep).filter(Boolean);
   if (dirSeg.length >= 2) {
     const namespace = sanitizeSegment3(dirSeg[0], "default");
     const categoryPath = dirSeg.slice(1).map((s) => sanitizeSegment3(s, "uncategorized"));
@@ -22321,8 +22448,8 @@ 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 = path23.resolve(sourceDir || options.out || projectPath);
-  const repoPath = path23.resolve(options.repo || projectPath);
+  const sourceRoot = path24.resolve(sourceDir || options.out || projectPath);
+  const repoPath = path24.resolve(options.repo || projectPath);
   if (!fs18.existsSync(sourceRoot)) {
     fs18.mkdirSync(sourceRoot, { recursive: true });
   }
@@ -22334,7 +22461,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 = path23.resolve(options.out || path23.join(sourceRoot, "bootstrap-kb"));
+      const outDir = path24.resolve(options.out || path24.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...");
@@ -22379,7 +22506,7 @@ program.command("organize-import [sourceDir]").description("Import existing mark
         continue;
       }
       const { namespace, categoryPath } = deriveNamespaceCategory(activeSourceRoot, file);
-      const rel = path23.relative(activeSourceRoot, file);
+      const rel = path24.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}`);
@@ -22423,8 +22550,8 @@ program.command("import").description("Import existing Claude Code conversation
   const service = getMemoryServiceForProject(targetProjectPath);
   const importer = createSessionHistoryImporter(service);
   const importOpts = {
-    limit: parsePositiveIntegerOption2(options.limit, "limit"),
-    sessionLimit: parsePositiveIntegerOption2(options.sessionLimit, "session-limit"),
+    limit: parsePositiveIntegerOption3(options.limit, "limit"),
+    sessionLimit: parsePositiveIntegerOption3(options.sessionLimit, "session-limit"),
     force: options.force,
     verbose: options.verbose,
     onProgress: renderProgress