musememory 1.9.0 → 1.10.0

package/README.md

@@ -431,6 +431,7 @@ memory <command> [arguments] [flags]  # alias: musememory
 | `context` | `[query] [--token-budget N] [--limit N]` | Retrieve Top-$K$ ranked active context for prompt injection. |
 | `search` | `<query> [--limit N] [--token-budget N] [--type T]` | Ranked multi-factor token search with score breakdown. |
 | `search-transcript` | `<query> [file.jsonl] [--window N]` | Full-text search past transcripts with dialogue context windows. |
+| `learn` / `sync-chats` | `[--confirm] [--force] [--max N]` | **Universal auto-learner**: auto-discovers and distills memories from all agent chats across host machine. |
 | `harvest` | `<text\|file> --project P [--confirmed]` | Distill conversation turns into structured fix/decision memory units. |
 | `import-transcript` | `<file.jsonl> [--project P] [--confirmed]` | Ingest raw `.jsonl` session transcripts from coding agents. |
 | `capture` / `propose` | `<text> --project P [--title T] [--type T]` | Propose a memory entry with inline Vibeguard secret inspection. |

package/dist/index.js

@@ -4857,7 +4857,24 @@ function extractHarvestUnits(text) {
       continue;
     }
     const speakerStripped = trimmed.replace(/^(?:user|assistant|human|system|agent|client|developer)\s*[:\-\u2013]\s*/i, "");
-    const typeMatch = speakerStripped.match(/^(?:#{1,6}\s+|[-*]\s+)?\*{0,2}(fix|failure|decision|architecture|constraint|operation|preference|discovery|outcome|root cause|learned|rule)\*{0,2}\s*[:\-\u2013]\s*(.*)$/i);
+    const typeMatch = speakerStripped.match(/^(?:#{1,6}\s+|[-*]\s+)?\*{0,2}(fix|failure|decision|architecture|constraint|operation|preference|discovery|outcome|root cause|learned|rule|solution|resolution|workaround|hard rule|policy)\*{0,2}\s*[:\-\u2013]\s*(.*)$/i);
+    let naturalType = null;
+    let naturalContent = "";
+    if (!typeMatch) {
+      if (/\b(?:resolved|fixed|patched|worked around)\s+(?:the\s+)?([^.\n]+)/i.test(speakerStripped)) {
+        naturalType = "fix";
+        naturalContent = speakerStripped;
+      } else if (/\b(?:decided|chose|selected|agreed)\s+to\s+([^.\n]+)/i.test(speakerStripped)) {
+        naturalType = "decision";
+        naturalContent = speakerStripped;
+      } else if (/\b(?:must\s+always|must\s+never|never\s+commit|you\s+must\s+never|do\s+not\s+allow)\s+([^.\n]+)/i.test(speakerStripped)) {
+        naturalType = "constraint";
+        naturalContent = speakerStripped;
+      } else if (/\b(?:user\s+prefers|prefers\s+using|prefers\s+to)\s+([^.\n]+)/i.test(speakerStripped)) {
+        naturalType = "preference";
+        naturalContent = speakerStripped;
+      }
+    }
     if (typeMatch) {
       flush();
       const rawTag = typeMatch[1].toLowerCase();
@@ -4866,6 +4883,11 @@ function extractHarvestUnits(text) {
       if (currentTitle) {
         currentBuffer.push(currentTitle);
       }
+    } else if (naturalType && naturalContent) {
+      flush();
+      currentType = naturalType;
+      currentTitle = naturalContent.slice(0, 80);
+      currentBuffer.push(naturalContent);
     } else if (trimmed.match(/^(?:user|assistant|human|system|agent|client|developer)\s*[:\-\u2013]/i)) {
       flush();
     } else if (currentType !== null) {
@@ -4879,16 +4901,21 @@ function normalizeHarvestType(raw) {
   switch (raw) {
     case "fix":
     case "root cause":
+    case "solution":
+    case "resolution":
+    case "workaround":
       return "fix";
     case "failure":
       return "failure";
     case "decision":
     case "outcome":
     case "rule":
+    case "policy":
       return "decision";
     case "architecture":
       return "architecture";
     case "constraint":
+    case "hard rule":
       return "constraint";
     case "operation":
       return "operation";
@@ -15746,19 +15773,265 @@ var init_schema = __esm(() => {
   import_ajv = __toESM(require_ajv(), 1);
 });
 
+// src/harvester.ts
+var exports_harvester = {};
+__export(exports_harvester, {
+  discoverAgentTranscripts: () => discoverAgentTranscripts,
+  getHarvestedTranscriptLedger: () => getHarvestedTranscriptLedger,
+  getStandardAgentTranscriptDirs: () => getStandardAgentTranscriptDirs,
+  handleLearnCommand: () => handleLearnCommand,
+  harvestAllAgentTranscripts: () => harvestAllAgentTranscripts,
+  saveHarvestedTranscriptLedger: () => saveHarvestedTranscriptLedger
+});
+import {
+  existsSync as existsSync24,
+  readFileSync as readFileSync20,
+  writeFileSync as writeFileSync12,
+  readdirSync as readdirSync8,
+  statSync as statSync8,
+  mkdirSync as mkdirSync14,
+  openSync,
+  readSync,
+  closeSync
+} from "node:fs";
+import { join as join21, dirname as dirname5 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { createHash as createHash2 } from "node:crypto";
+function getStandardAgentTranscriptDirs(home = homedir5()) {
+  return [
+    join21(home, ".gemini", "antigravity-cli", "brain"),
+    join21(home, ".config", "opencode", "transcripts"),
+    join21(home, ".local", "share", "opencode", "transcripts"),
+    join21(home, ".claude", "transcripts"),
+    join21(home, ".claude", "projects"),
+    join21(home, ".config", "LIFEOS", "runtime", "transcripts"),
+    join21(home, ".hermes", "sessions"),
+    join21(home, ".hermes", "transcripts"),
+    join21(home, ".config", "goose", "sessions"),
+    join21(home, ".codex", "sessions"),
+    join21(home, ".config", "Cursor", "User", "workspaceStorage"),
+    join21(process.cwd(), ".memory", "inbox"),
+    join21(process.cwd(), ".logs")
+  ];
+}
+function findJsonlFilesInDir(dir, maxDepth = 4, currentDepth = 0, out = []) {
+  if (currentDepth > maxDepth || !existsSync24(dir))
+    return out;
+  let entries;
+  try {
+    entries = readdirSync8(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const e of entries) {
+    if (e.name === "node_modules" || e.name === ".git" || e.name === "dist" || e.name === "processed" || e.name === "chunks" || e.name === ".cache" || e.name === ".tmp" || e.name.startsWith("tmp")) {
+      continue;
+    }
+    const full = join21(dir, e.name);
+    if (e.isDirectory()) {
+      findJsonlFilesInDir(full, maxDepth, currentDepth + 1, out);
+    } else if (e.isFile() && e.name.endsWith(".jsonl")) {
+      if (!e.name.match(/^\d{8}\.jsonl$/) && e.name !== "transcript_full.jsonl") {
+        out.push(full);
+      }
+    }
+  }
+  return out;
+}
+function discoverAgentTranscripts(options = {}) {
+  const dirs = options.searchRoots && options.searchRoots.length > 0 ? options.searchRoots : getStandardAgentTranscriptDirs();
+  const found = new Set;
+  for (const d of dirs) {
+    if (existsSync24(d)) {
+      try {
+        const stat = statSync8(d);
+        if (stat.isDirectory()) {
+          const files = findJsonlFilesInDir(d);
+          for (const f of files)
+            found.add(f);
+        } else if (stat.isFile() && d.endsWith(".jsonl")) {
+          found.add(d);
+        }
+      } catch {}
+    }
+  }
+  const sorted = Array.from(found).sort((a, b) => {
+    try {
+      return statSync8(b).mtimeMs - statSync8(a).mtimeMs;
+    } catch {
+      return 0;
+    }
+  });
+  if (options.maxFiles && options.maxFiles > 0) {
+    return sorted.slice(0, options.maxFiles);
+  }
+  return sorted;
+}
+function getHarvestedTranscriptLedger(memoryDir) {
+  const ledgerPath = join21(memoryDir, "harvested-transcripts.json");
+  if (!existsSync24(ledgerPath))
+    return {};
+  try {
+    const raw = readFileSync20(ledgerPath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function saveHarvestedTranscriptLedger(memoryDir, ledger) {
+  const ledgerPath = join21(memoryDir, "harvested-transcripts.json");
+  const dir = dirname5(ledgerPath);
+  if (!existsSync24(dir))
+    mkdirSync14(dir, { recursive: true });
+  writeFileSync12(ledgerPath, JSON.stringify(ledger, null, 2) + `
+`, "utf8");
+}
+function harvestAllAgentTranscripts(store, options = {}) {
+  const memoryDir = options.memoryDir || join21(process.cwd(), ".memory");
+  const ledger = getHarvestedTranscriptLedger(memoryDir);
+  const files = discoverAgentTranscripts({
+    searchRoots: options.searchRoots,
+    maxFiles: options.maxFiles || 50
+  });
+  const result = {
+    harvestedFilesCount: 0,
+    totalFilesScanned: files.length,
+    memoriesImported: 0,
+    openLoopsDetected: 0,
+    processedFiles: [],
+    errors: []
+  };
+  for (const filePath of files) {
+    try {
+      const stat = statSync8(filePath);
+      const prevEntry = ledger[filePath];
+      if (!options.force && prevEntry && prevEntry.mtimeMs === stat.mtimeMs) {
+        continue;
+      }
+      let content = "";
+      if (stat.size > 2 * 1024 * 1024) {
+        const fd = openSync(filePath, "r");
+        const bufferSize = 512 * 1024;
+        const buffer = Buffer.alloc(bufferSize);
+        const position = Math.max(0, stat.size - bufferSize);
+        const bytesRead = readSync(fd, buffer, 0, bufferSize, position);
+        closeSync(fd);
+        content = buffer.toString("utf8", 0, bytesRead);
+      } else {
+        content = readFileSync20(filePath, "utf8");
+      }
+      const contentHash = createHash2("sha256").update(content).digest("hex").slice(0, 16);
+      if (!options.force && prevEntry && prevEntry.hash === contentHash) {
+        continue;
+      }
+      let inferredProject = options.project;
+      if (!inferredProject) {
+        if (filePath.includes("/Projects/github/") || filePath.includes("/Projects/")) {
+          const m = filePath.match(/\/Projects\/(?:github\/)?([^/]+)/);
+          if (m)
+            inferredProject = m[1];
+        }
+      }
+      if (!inferredProject)
+        inferredProject = "default";
+      const importRes = importTranscript(store, content, {
+        project: inferredProject,
+        confirmed: options.confirmed === true,
+        source: `auto_harvester:${filePath}`
+      });
+      ledger[filePath] = {
+        mtimeMs: stat.mtimeMs,
+        hash: contentHash,
+        importedCount: importRes.imported,
+        openLoopsCount: importRes.openLoops.length,
+        harvestedAt: new Date().toISOString()
+      };
+      if (importRes.imported > 0 || importRes.openLoops.length > 0) {
+        result.harvestedFilesCount++;
+        result.memoriesImported += importRes.imported;
+        result.openLoopsDetected += importRes.openLoops.length;
+        result.processedFiles.push({
+          path: filePath,
+          imported: importRes.imported,
+          openLoops: importRes.openLoops.length
+        });
+        recordAuditEvent(memoryDir, {
+          operation: "transcript_import",
+          entry_id: filePath,
+          actor: "auto-harvester",
+          details: {
+            imported: importRes.imported,
+            open_loops: importRes.openLoops.length,
+            inferred_project: inferredProject
+          }
+        });
+      }
+      if (importRes.errors.length > 0) {
+        result.errors.push(...importRes.errors.map((e) => `${filePath}: ${e}`));
+      }
+    } catch (err) {
+      result.errors.push(`${filePath}: ${err.message || err}`);
+    }
+  }
+  saveHarvestedTranscriptLedger(memoryDir, ledger);
+  return result;
+}
+async function handleLearnCommand({ flags }) {
+  const ctx = requireRoot(flags);
+  if (!ctx)
+    return 1;
+  const isConfirmed = flags["confirmed"] === "true" || flags["confirm"] === "true";
+  const force = flags["force"] === "true";
+  const project = flags["project"];
+  const maxFiles = flags["max"] ? parseInt(flags["max"], 10) : 50;
+  console.log(`[Auto-Learner] Probing workstation for active AI agent transcripts...`);
+  const res = harvestAllAgentTranscripts(ctx.store, {
+    memoryDir: ctx.memoryDir,
+    confirmed: isConfirmed,
+    force,
+    project,
+    maxFiles
+  });
+  console.log(`[Auto-Learner] Scanned ${res.totalFilesScanned} agent transcript files.`);
+  if (res.harvestedFilesCount === 0) {
+    console.log(`✓ Up to date. 0 new un-harvested turns found (all transcripts indexed).`);
+    return 0;
+  }
+  console.log(`
+\uD83C\uDF89 Distilled ${res.memoriesImported} new memories and ${res.openLoopsDetected} open loops from ${res.harvestedFilesCount} transcript(s):`);
+  for (const p of res.processedFiles) {
+    console.log(`  * ${p.path} -> +${p.imported} memories, +${p.openLoops} loops`);
+  }
+  if (res.errors.length > 0) {
+    console.log(`
+⚠️ Warnings / Redactions during harvest:`);
+    for (const err of res.errors.slice(0, 5)) {
+      console.log(`  - ${err}`);
+    }
+  }
+  console.log(`
+\uD83D\uDCA1 Open 'memory ui' or run 'memory stats' to view your newly indexed cognitive graph.`);
+  return 0;
+}
+var init_harvester = __esm(() => {
+  init_harvest();
+  init_audit();
+  init_shared();
+});
+
 // src/doctor.ts
 var exports_doctor = {};
 __export(exports_doctor, {
   printDoctorReport: () => printDoctorReport,
   runDoctor: () => runDoctor
 });
-import { existsSync as existsSync24, statSync as statSync8, readFileSync as readFileSync20 } from "node:fs";
-import { join as join21 } from "node:path";
-import { homedir as homedir5 } from "node:os";
+import { existsSync as existsSync25, statSync as statSync9, readFileSync as readFileSync21 } from "node:fs";
+import { join as join22 } from "node:path";
+import { homedir as homedir6 } from "node:os";
 async function runDoctor(targetDir, options = {}) {
-  const home = homedir5();
-  const storagePath = options.global ? getGlobalMemoryDir() : findOrCreateProjectRoot(targetDir || process.cwd())?.memoryDir || join21(home, ".memory");
-  const isInitialized = existsSync24(storagePath);
+  const home = homedir6();
+  const storagePath = options.global ? getGlobalMemoryDir() : findOrCreateProjectRoot(targetDir || process.cwd())?.memoryDir || join22(home, ".memory");
+  const isInitialized = existsSync25(storagePath);
   let currentMdExists = false;
   let currentMdLines = 0;
   let totalEntries = 0;
@@ -15776,10 +16049,10 @@ async function runDoctor(targetDir, options = {}) {
   let secretLeaksCount = 0;
   let brokenLinksCount = 0;
   if (isInitialized) {
-    const currentPath = join21(storagePath, "CURRENT.md");
-    if (existsSync24(currentPath)) {
+    const currentPath = join22(storagePath, "CURRENT.md");
+    if (existsSync25(currentPath)) {
       currentMdExists = true;
-      const content = readFileSync20(currentPath, "utf8");
+      const content = readFileSync21(currentPath, "utf8");
       currentMdLines = content.split(`
 `).filter((l) => l.trim().length > 0).length;
     }
@@ -15800,21 +16073,21 @@ async function runDoctor(targetDir, options = {}) {
       valid = false;
     }
   }
-  const auditPath = join21(storagePath, "audit.jsonl");
+  const auditPath = join22(storagePath, "audit.jsonl");
   let auditExists = false;
   let auditCount = 0;
   let auditSize = 0;
   let lastEvent;
-  if (existsSync24(auditPath)) {
+  if (existsSync25(auditPath)) {
     auditExists = true;
     try {
-      const stat = statSync8(auditPath);
+      const stat = statSync9(auditPath);
       auditSize = stat.size;
       const trail = getAuditTrail(storagePath, { limit: 1 });
       if (trail.length > 0) {
         lastEvent = `${trail[0].operation} on ${trail[0].entry_id} (${trail[0].timestamp})`;
       }
-      const raw = readFileSync20(auditPath, "utf8");
+      const raw = readFileSync21(auditPath, "utf8");
       auditCount = raw.split(`
 `).filter((l) => l.trim().length > 0).length;
     } catch {}
@@ -15823,6 +16096,11 @@ async function runDoctor(targetDir, options = {}) {
   const installed = agents.filter((a) => a.installed);
   const connected = installed.filter((a) => a.connected);
   const unwired = installed.filter((a) => !a.connected);
+  const { discoverAgentTranscripts: discoverAgentTranscripts2, getHarvestedTranscriptLedger: getHarvestedTranscriptLedger2 } = await Promise.resolve().then(() => (init_harvester(), exports_harvester));
+  const discoveredFiles = discoverAgentTranscripts2();
+  const ledger = getHarvestedTranscriptLedger2(storagePath);
+  const harvestedFiles = Object.keys(ledger);
+  const unharvestedCount = discoveredFiles.filter((f) => !ledger[f]).length;
   const memBin = findBinary("memory", home) || findBinary("musememory", home);
   const bunVer = typeof globalThis.Bun !== "undefined" ? globalThis.Bun.version : undefined;
   return {
@@ -15856,6 +16134,11 @@ async function runDoctor(targetDir, options = {}) {
       connectedList: connected.map((a) => a.name),
       unwiredList: unwired.map((a) => a.name)
     },
+    transcripts: {
+      discoveredCount: discoveredFiles.length,
+      harvestedCount: harvestedFiles.length,
+      unharvestedCount
+    },
     runtime: {
       nodeVersion: process.version,
       bunVersion: bunVer,
@@ -15913,6 +16196,16 @@ function printDoctorReport(report) {
     console.log(`     -> Run 'memory connect --all' or 'npx musememory connect --all' to wire them.`);
   }
   console.log(`
+[AUTO-LEARNER] Agent Chat Transcripts & Distillation:`);
+  console.log(`  Discovered Transcripts on Disk: ${report.transcripts.discoveredCount}`);
+  console.log(`  Harvested / Indexed:            ${report.transcripts.harvestedCount}`);
+  if (report.transcripts.unharvestedCount > 0) {
+    console.log(`  [!] New Un-Harvested Chats:     ${report.transcripts.unharvestedCount}`);
+    console.log(`     -> Run 'memory learn' or 'memory sync-chats' to auto-distill learnings from recent AI interactions.`);
+  } else {
+    console.log(`  [OK] All discovered chat transcripts are synchronized.`);
+  }
+  console.log(`
 [RUNTIME] Runtime & CLI Execution:`);
   console.log(`  Node.js: ${report.runtime.nodeVersion}${report.runtime.bunVersion ? ` | Bun: v${report.runtime.bunVersion}` : ""}`);
   if (report.runtime.globalBinaryFound) {
@@ -15940,27 +16233,27 @@ var init_doctor = __esm(() => {
 });
 
 // src/retrieval/tree-index.ts
-import { existsSync as existsSync25, readFileSync as readFileSync21, writeFileSync as writeFileSync12, mkdirSync as mkdirSync14, rmSync } from "node:fs";
-import { join as join22 } from "node:path";
+import { existsSync as existsSync26, readFileSync as readFileSync22, writeFileSync as writeFileSync13, mkdirSync as mkdirSync15, rmSync } from "node:fs";
+import { join as join23 } from "node:path";
 function tokenize2(text) {
   if (!text || typeof text !== "string")
     return [];
   return text.toLowerCase().match(/[a-z0-9]+/g) ?? [];
 }
 function indexDir(memoryDir) {
-  return join22(memoryDir, "tree-index");
+  return join23(memoryDir, "tree-index");
 }
 function partitionDir(idxDir, project, type2) {
-  return join22(idxDir, project, type2);
+  return join23(idxDir, project, type2);
 }
 function shardFilePath(pDir, shardId) {
-  return join22(pDir, `${shardId}.json`);
+  return join23(pDir, `${shardId}.json`);
 }
 function partitionIndexFilePath(pDir) {
-  return join22(pDir, "index.json");
+  return join23(pDir, "index.json");
 }
 function globalIndexFilePath(idxDir) {
-  return join22(idxDir, "index.json");
+  return join23(idxDir, "index.json");
 }
 function nowIso3() {
   return new Date().toISOString();
@@ -16050,7 +16343,7 @@ function countNodes(node) {
 function buildTreeIndex(store, memoryDir, config = {}) {
   const cfg = { ...DEFAULT_CONFIG, ...config };
   const allMemories = list(store).filter((e) => e.status === "confirmed");
-  mkdirSync14(indexDir(memoryDir), { recursive: true });
+  mkdirSync15(indexDir(memoryDir), { recursive: true });
   if (allMemories.length === 0) {
     const emptyIndex = {
       version: 1,
@@ -16059,7 +16352,7 @@ function buildTreeIndex(store, memoryDir, config = {}) {
       totalMemories: 0,
       builtAt: nowIso3()
     };
-    writeFileSync12(globalIndexFilePath(indexDir(memoryDir)), JSON.stringify(emptyIndex, null, 2), "utf8");
+    writeFileSync13(globalIndexFilePath(indexDir(memoryDir)), JSON.stringify(emptyIndex, null, 2), "utf8");
     return emptyIndex;
   }
   const groups = new Map;
@@ -16077,7 +16370,7 @@ function buildTreeIndex(store, memoryDir, config = {}) {
   for (const [key, memories] of groups) {
     const [project, type2] = key.split("|");
     const pDir = partitionDir(indexDir(memoryDir), project, type2);
-    mkdirSync14(pDir, { recursive: true });
+    mkdirSync15(pDir, { recursive: true });
     const maxShardSize = cfg.shardThreshold || 1e4;
     const finalShards = [];
     const memoryChunks = [];
@@ -16138,9 +16431,9 @@ function buildTreeIndex(store, memoryDir, config = {}) {
     partitions[`${project}|${type2}`] = partition;
     totalIndexNodes += partitionNodes;
     totalIndexMemories += partitionMemories;
-    writeFileSync12(partitionIndexFilePath(pDir), JSON.stringify(partition, null, 2), "utf8");
+    writeFileSync13(partitionIndexFilePath(pDir), JSON.stringify(partition, null, 2), "utf8");
     for (const shard of finalShards) {
-      writeFileSync12(shardFilePath(pDir, shard.id), JSON.stringify(shard, null, 2), "utf8");
+      writeFileSync13(shardFilePath(pDir, shard.id), JSON.stringify(shard, null, 2), "utf8");
     }
   }
   const index = {
@@ -16150,15 +16443,15 @@ function buildTreeIndex(store, memoryDir, config = {}) {
     totalMemories: totalIndexMemories,
     builtAt: nowIso3()
   };
-  writeFileSync12(globalIndexFilePath(indexDir(memoryDir)), JSON.stringify(index, null, 2), "utf8");
+  writeFileSync13(globalIndexFilePath(indexDir(memoryDir)), JSON.stringify(index, null, 2), "utf8");
   return index;
 }
 function loadTreeIndex(memoryDir) {
   const path = globalIndexFilePath(indexDir(memoryDir));
-  if (!existsSync25(path))
+  if (!existsSync26(path))
     return null;
   try {
-    const data = JSON.parse(readFileSync21(path, "utf8"));
+    const data = JSON.parse(readFileSync22(path, "utf8"));
     return data.version === 1 ? data : null;
   } catch {
     return null;
@@ -16303,10 +16596,10 @@ __export(exports_vector, {
   saveIndex: () => saveIndex,
   termFrequencies: () => termFrequencies
 });
-import { existsSync as existsSync26, readFileSync as readFileSync22, writeFileSync as writeFileSync13, mkdirSync as mkdirSync15 } from "node:fs";
-import { join as join23 } from "node:path";
+import { existsSync as existsSync27, readFileSync as readFileSync23, writeFileSync as writeFileSync14, mkdirSync as mkdirSync16 } from "node:fs";
+import { join as join24 } from "node:path";
 function indexFilePath(memoryDir) {
-  return join23(memoryDir, "index.json");
+  return join24(memoryDir, "index.json");
 }
 function hashTrigram(tri) {
   let h = 2166136261;
@@ -16353,16 +16646,16 @@ function rebuildIndex(store) {
   return index;
 }
 function saveIndex(index, memoryDir) {
-  if (!existsSync26(memoryDir))
-    mkdirSync15(memoryDir, { recursive: true });
-  writeFileSync13(indexFilePath(memoryDir), JSON.stringify(index), "utf8");
+  if (!existsSync27(memoryDir))
+    mkdirSync16(memoryDir, { recursive: true });
+  writeFileSync14(indexFilePath(memoryDir), JSON.stringify(index), "utf8");
 }
 function loadIndex(memoryDir) {
   const p = indexFilePath(memoryDir);
-  if (!existsSync26(p))
+  if (!existsSync27(p))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync22(p, "utf8"));
+    const parsed = JSON.parse(readFileSync23(p, "utf8"));
     return parsed.version === 1 ? parsed : null;
   } catch {
     return null;
@@ -16434,8 +16727,8 @@ var init_vector = __esm(() => {
 });
 
 // src/pageindex/engine.ts
-import { existsSync as existsSync27, mkdirSync as mkdirSync16, readFileSync as readFileSync23, writeFileSync as writeFileSync14, rmSync as rmSync2, readdirSync as readdirSync9 } from "node:fs";
-import { join as join24 } from "node:path";
+import { existsSync as existsSync28, mkdirSync as mkdirSync17, readFileSync as readFileSync24, writeFileSync as writeFileSync15, rmSync as rmSync2, readdirSync as readdirSync10 } from "node:fs";
+import { join as join25 } from "node:path";
 function slugify2(text) {
   return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
 }
@@ -16512,9 +16805,9 @@ function buildPageIndex(content, options) {
     root: rootNode
   };
   if (options.memoryDir && !options.dryRun) {
-    const dir = join24(options.memoryDir, "pageindex", project);
-    mkdirSync16(dir, { recursive: true });
-    writeFileSync14(join24(dir, `${indexId}.json`), JSON.stringify(doc, null, 2), "utf8");
+    const dir = join25(options.memoryDir, "pageindex", project);
+    mkdirSync17(dir, { recursive: true });
+    writeFileSync15(join25(dir, `${indexId}.json`), JSON.stringify(doc, null, 2), "utf8");
   }
   return doc;
 }
@@ -16578,29 +16871,29 @@ function searchPageIndex(doc, options) {
   };
 }
 function loadPageIndex(memoryDir, project, indexId) {
-  const filePath = join24(memoryDir, "pageindex", project, `${indexId}.json`);
-  if (!existsSync27(filePath))
+  const filePath = join25(memoryDir, "pageindex", project, `${indexId}.json`);
+  if (!existsSync28(filePath))
     return null;
   try {
-    return JSON.parse(readFileSync23(filePath, "utf8"));
+    return JSON.parse(readFileSync24(filePath, "utf8"));
   } catch {
     return null;
   }
 }
 function listPageIndexes(memoryDir, project) {
-  const base = join24(memoryDir, "pageindex");
-  if (!existsSync27(base))
+  const base = join25(memoryDir, "pageindex");
+  if (!existsSync28(base))
     return [];
   const results = [];
-  const projects = project ? [project] : readdirSync9(base);
+  const projects = project ? [project] : readdirSync10(base);
   for (const p of projects) {
-    const pDir = join24(base, p);
-    if (!existsSync27(pDir))
+    const pDir = join25(base, p);
+    if (!existsSync28(pDir))
       continue;
-    for (const f of readdirSync9(pDir)) {
+    for (const f of readdirSync10(pDir)) {
       if (f.endsWith(".json")) {
         try {
-          results.push(JSON.parse(readFileSync23(join24(pDir, f), "utf8")));
+          results.push(JSON.parse(readFileSync24(join25(pDir, f), "utf8")));
         } catch {}
       }
     }
@@ -16608,8 +16901,8 @@ function listPageIndexes(memoryDir, project) {
   return results;
 }
 function deletePageIndex(memoryDir, project, indexId) {
-  const base = join24(memoryDir, "pageindex");
-  if (!existsSync27(base))
+  const base = join25(memoryDir, "pageindex");
+  if (!existsSync28(base))
     return { deletedCount: 0 };
   let count = 0;
   if (!project && !indexId) {
@@ -16617,14 +16910,14 @@ function deletePageIndex(memoryDir, project, indexId) {
     return { deletedCount: 1 };
   }
   if (project && !indexId) {
-    const pDir = join24(base, project);
-    if (existsSync27(pDir)) {
+    const pDir = join25(base, project);
+    if (existsSync28(pDir)) {
       rmSync2(pDir, { recursive: true, force: true });
       count++;
     }
   } else if (project && indexId) {
-    const file = join24(base, project, `${indexId}.json`);
-    if (existsSync27(file)) {
+    const file = join25(base, project, `${indexId}.json`);
+    if (existsSync28(file)) {
       rmSync2(file, { force: true });
       count++;
     }
@@ -16637,13 +16930,13 @@ var init_engine2 = __esm(() => {
 });
 
 // src/retrieval/engine.ts
-import { existsSync as existsSync28 } from "node:fs";
-import { join as join25 } from "node:path";
+import { existsSync as existsSync29 } from "node:fs";
+import { join as join26 } from "node:path";
 
 class RetrievalEngine {
   static search(store, memoryDir, query, options = {}) {
     const mode = options.mode ?? "auto";
-    if (mode === "pageindex" || options.docPath && existsSync28(options.docPath)) {
+    if (mode === "pageindex" || options.docPath && existsSync29(options.docPath)) {
       try {
         const docs = listPageIndexes(memoryDir, options.project);
         if (docs.length > 0) {
@@ -16670,8 +16963,8 @@ class RetrievalEngine {
         }
       } catch {}
     }
-    const treeDir = join25(memoryDir, "tree");
-    const hasTree = existsSync28(treeDir);
+    const treeDir = join26(memoryDir, "tree");
+    const hasTree = existsSync29(treeDir);
     const allEntries = list(store);
     if (mode === "tree" || mode === "auto" && hasTree && allEntries.length >= 500) {
       try {
@@ -16709,7 +17002,7 @@ class RetrievalEngine {
       } catch {}
     }
     const vecPath = indexFilePath(memoryDir);
-    const hasVec = existsSync28(vecPath);
+    const hasVec = existsSync29(vecPath);
     if (mode === "hybrid" || mode === "auto" && hasVec && allEntries.length > 100) {
       try {
         const hybridResults = hybridSearch(store, memoryDir, query, {
@@ -26405,8 +26698,8 @@ var init_loops = __esm(() => {
 });
 
 // src/distill.ts
-import { existsSync as existsSync29, mkdirSync as mkdirSync17, writeFileSync as writeFileSync15 } from "node:fs";
-import { join as join26 } from "node:path";
+import { existsSync as existsSync30, mkdirSync as mkdirSync18, writeFileSync as writeFileSync16 } from "node:fs";
+import { join as join27 } from "node:path";
 function fixTokens(e) {
   const bag = tokenBag(e.title, 2);
   mergeBag(bag, tokenBag((e.tags ?? []).join(" "), 2));
@@ -26417,7 +26710,7 @@ function distillSkills(store, workspaceRoot, options = {}) {
   const report = { created: [], skippedExisting: [], clustersBelowThreshold: 0 };
   const fixes = list(store).filter((e) => e.status === "confirmed" && e.type === "fix").sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at));
   const clusters = clusterByTokenOverlap(fixes, fixTokens, 0.5);
-  const skillsDir = options.skillsDir ?? join26(workspaceRoot, ".agents", "skills");
+  const skillsDir = options.skillsDir ?? join27(workspaceRoot, ".agents", "skills");
   for (const cluster of clusters) {
     if (cluster.length < minCount) {
       report.clustersBelowThreshold++;
@@ -26425,9 +26718,9 @@ function distillSkills(store, workspaceRoot, options = {}) {
     }
     const topic = dominantTopicTokens(cluster.map((e) => e.title));
     const slug = slugifyId(topic.join("-") || "skill");
-    const dir = join26(skillsDir, slug);
+    const dir = join27(skillsDir, slug);
     const memberIds = cluster.map((e) => e.id);
-    if (existsSync29(dir)) {
+    if (existsSync30(dir)) {
       report.skippedExisting.push({ slug, members: memberIds });
       continue;
     }
@@ -26437,10 +26730,10 @@ function distillSkills(store, workspaceRoot, options = {}) {
       throw new Error(`Secret detected in generated SKILL.md for '${slug}': ${secrets.join(", ")}`);
     }
     if (!options.dryRun) {
-      mkdirSync17(dir, { recursive: true });
-      writeFileSync15(join26(dir, "SKILL.md"), md, "utf8");
+      mkdirSync18(dir, { recursive: true });
+      writeFileSync16(join27(dir, "SKILL.md"), md, "utf8");
     }
-    report.created.push({ slug, path: join26(dir, "SKILL.md"), members: memberIds });
+    report.created.push({ slug, path: join27(dir, "SKILL.md"), members: memberIds });
   }
   return report;
 }
@@ -26778,14 +27071,14 @@ var init_schema2 = __esm(() => {
 });
 
 // src/settings/loader.ts
-import { existsSync as existsSync30, mkdirSync as mkdirSync18, readFileSync as readFileSync24, writeFileSync as writeFileSync16 } from "node:fs";
-import { join as join27 } from "node:path";
+import { existsSync as existsSync31, mkdirSync as mkdirSync19, readFileSync as readFileSync25, writeFileSync as writeFileSync17 } from "node:fs";
+import { join as join28 } from "node:path";
 function getSettingsFilePath(memoryDir) {
-  return join27(memoryDir, "settings.json");
+  return join28(memoryDir, "settings.json");
 }
 function loadSettings(memoryDir) {
   const filePath = getSettingsFilePath(memoryDir);
-  if (!existsSync30(filePath)) {
+  if (!existsSync31(filePath)) {
     return {
       version: 1,
       global: JSON.parse(JSON.stringify(DEFAULT_SETTINGS)),
@@ -26793,7 +27086,7 @@ function loadSettings(memoryDir) {
     };
   }
   try {
-    const raw = readFileSync24(filePath, "utf8");
+    const raw = readFileSync25(filePath, "utf8");
     const parsed = JSON.parse(raw);
     return {
       version: parsed.version || 1,
@@ -26809,9 +27102,9 @@ function loadSettings(memoryDir) {
   }
 }
 function saveSettings(store, memoryDir) {
-  mkdirSync18(memoryDir, { recursive: true });
+  mkdirSync19(memoryDir, { recursive: true });
   const filePath = getSettingsFilePath(memoryDir);
-  writeFileSync16(filePath, JSON.stringify(store, null, 2), "utf8");
+  writeFileSync17(filePath, JSON.stringify(store, null, 2), "utf8");
 }
 function getSettings(memoryDir) {
   return loadSettings(memoryDir).global;
@@ -26927,17 +27220,17 @@ __export(exports_plasticity, {
   recordCoActivation: () => recordCoActivation,
   saveHebbianGraph: () => saveHebbianGraph
 });
-import { existsSync as existsSync31, readFileSync as readFileSync25, writeFileSync as writeFileSync17 } from "node:fs";
-import { join as join28 } from "node:path";
+import { existsSync as existsSync32, readFileSync as readFileSync26, writeFileSync as writeFileSync18 } from "node:fs";
+import { join as join29 } from "node:path";
 function getPlasticityPath(memoryDir) {
-  return join28(memoryDir, "hebbian-plasticity.json");
+  return join29(memoryDir, "hebbian-plasticity.json");
 }
 function loadHebbianGraph(memoryDir) {
   const p = getPlasticityPath(memoryDir);
-  if (!existsSync31(p))
+  if (!existsSync32(p))
     return {};
   try {
-    return JSON.parse(readFileSync25(p, "utf8"));
+    return JSON.parse(readFileSync26(p, "utf8"));
   } catch {
     return {};
   }
@@ -26945,7 +27238,7 @@ function loadHebbianGraph(memoryDir) {
 function saveHebbianGraph(memoryDir, graph) {
   const p = getPlasticityPath(memoryDir);
   try {
-    writeFileSync17(p, JSON.stringify(graph, null, 2), "utf8");
+    writeFileSync18(p, JSON.stringify(graph, null, 2), "utf8");
   } catch {}
 }
 function recordCoActivation(memoryIds, memoryDir) {
@@ -27036,8 +27329,8 @@ __export(exports_drift, {
   scanCodeDriftFromDiff: () => scanCodeDriftFromDiff
 });
 import { execSync as execSync3 } from "node:child_process";
-import { existsSync as existsSync32 } from "node:fs";
-import { join as join29, isAbsolute as isAbsolute2 } from "node:path";
+import { existsSync as existsSync33 } from "node:fs";
+import { join as join30, isAbsolute as isAbsolute2 } from "node:path";
 function scanCodeDriftFromDiff(entries, changedFiles, workspaceRoot) {
   const root = workspaceRoot || process.cwd();
   const normalizedChanged = new Set(changedFiles.map((f) => f.trim().replace(/^[\.\/]+/, "")).filter(Boolean));
@@ -27051,8 +27344,8 @@ function scanCodeDriftFromDiff(entries, changedFiles, workspaceRoot) {
       const norm = p.trim().replace(/^[\.\/]+/, "");
       const matched = Array.from(normalizedChanged).find((cf) => cf === norm || cf.endsWith(`/${norm}`) || norm.endsWith(`/${cf}`));
       if (matched) {
-        const fullPath = isAbsolute2(p) ? p : join29(root, p);
-        const exists = existsSync32(fullPath);
+        const fullPath = isAbsolute2(p) ? p : join30(root, p);
+        const exists = existsSync33(fullPath);
         drifted.push({
           memoryId: entry.id,
           title: entry.title,
@@ -27798,6 +28091,12 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
               recordCoActivation2(formatted.entries.map((e) => e.entry.id), activeMemoryDir);
             } catch {}
           }
+          if (activeMemoryDir) {
+            try {
+              const { harvestAllAgentTranscripts: harvestAllAgentTranscripts2 } = await Promise.resolve().then(() => (init_harvester(), exports_harvester));
+              harvestAllAgentTranscripts2(activeStore, { memoryDir: activeMemoryDir, maxFiles: 3 });
+            } catch {}
+          }
           let finalMarkdown = formatted.markdown;
           if (a.compress === true) {
             const { compressPromptContext: compressPromptContext2 } = await Promise.resolve().then(() => exports_compress);
@@ -27890,9 +28189,18 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
           }
         }
         case "memory_harvest": {
+          if (a.all === true || a.auto === true || !a.text) {
+            const { harvestAllAgentTranscripts: harvestAllAgentTranscripts2 } = await Promise.resolve().then(() => (init_harvester(), exports_harvester));
+            const harvestRes = harvestAllAgentTranscripts2(activeStore, {
+              memoryDir: activeMemoryDir,
+              confirmed: a.confirmed === true,
+              project: a.project ? String(a.project) : undefined
+            });
+            return toolResult(harvestRes);
+          }
           const created = harvestMemories(activeStore, {
             text: String(a.text),
-            project: String(a.project),
+            project: String(a.project || "default"),
             confirmed: a.confirmed === true
           });
           return toolResult({ harvested_count: created.length, entries: created });
@@ -28314,8 +28622,8 @@ __export(exports_daemon, {
   startHub: () => startHub
 });
 import { createServer as createServer2 } from "node:http";
-import { existsSync as existsSync33 } from "node:fs";
-import { join as join30 } from "node:path";
+import { existsSync as existsSync34 } from "node:fs";
+import { join as join31 } from "node:path";
 import { watch } from "node:fs";
 function startHub(port, memoryDir) {
   const clients = new Set;
@@ -28381,7 +28689,7 @@ data: ${JSON.stringify(event)}
     return clients.size;
   }
   if (memoryDir) {
-    const memoriesDir = join30(memoryDir, "memories");
+    const memoriesDir = join31(memoryDir, "memories");
     const armDebounced = (type2) => {
       if (debounceTimer)
         clearTimeout(debounceTimer);
@@ -28390,11 +28698,11 @@ data: ${JSON.stringify(event)}
       }, DEBOUNCE_MS);
     };
     try {
-      if (existsSync33(memoriesDir)) {
+      if (existsSync34(memoriesDir)) {
         watchers.push(watch(memoriesDir, () => armDebounced("memory.changed")));
       }
-      const currentMd = join30(memoryDir, "CURRENT.md");
-      if (existsSync33(currentMd)) {
+      const currentMd = join31(memoryDir, "CURRENT.md");
+      if (existsSync34(currentMd)) {
         watchers.push(watch(currentMd, () => armDebounced("constraints.changed")));
       }
     } catch {}
@@ -28427,19 +28735,19 @@ var DEBOUNCE_MS = 300;
 var init_daemon = () => {};
 
 // src/cli/ecosystem.ts
-import { join as join31 } from "node:path";
-import { existsSync as existsSync34, mkdirSync as mkdirSync19, writeFileSync as writeFileSync18, readFileSync as readFileSync26 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
+import { join as join32 } from "node:path";
+import { existsSync as existsSync35, mkdirSync as mkdirSync20, writeFileSync as writeFileSync19, readFileSync as readFileSync27 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
 function ensureProjectAgentInstructions(targetDir) {
-  const agentsMdPath = join31(targetDir, "AGENTS.md");
-  if (existsSync34(agentsMdPath)) {
+  const agentsMdPath = join32(targetDir, "AGENTS.md");
+  if (existsSync35(agentsMdPath)) {
     try {
-      const existing = readFileSync26(agentsMdPath, "utf8");
+      const existing = readFileSync27(agentsMdPath, "utf8");
       if (existing.includes("<!-- agentmemory:start -->")) {
         const updated = existing.replace(/<!-- agentmemory:start -->[\s\S]*?<!-- agentmemory:end -->/, MUSE_MEMORY_DIRECTIVE);
-        writeFileSync18(agentsMdPath, updated, "utf8");
+        writeFileSync19(agentsMdPath, updated, "utf8");
       } else if (!existing.includes("<!-- musememory:start -->") && !existing.includes("Muse Memory")) {
-        writeFileSync18(agentsMdPath, `${existing.trim()}
+        writeFileSync19(agentsMdPath, `${existing.trim()}
 
 ${MUSE_MEMORY_DIRECTIVE}
 `, "utf8");
@@ -28450,23 +28758,23 @@ ${MUSE_MEMORY_DIRECTIVE}
 
 ${MUSE_MEMORY_DIRECTIVE}
 `;
-    writeFileSync18(agentsMdPath, initialContent, "utf8");
+    writeFileSync19(agentsMdPath, initialContent, "utf8");
   }
 }
 async function handleInstallCommand({ positional, flags }) {
   const isGlobal = flags["global"] === "true" || flags["g"] === "true";
-  const targetDir = positional[0] ? join31(process.cwd(), positional[0]) : process.cwd();
-  const memoryDir = isGlobal ? getGlobalMemoryDir() : join31(targetDir, ".memory");
+  const targetDir = positional[0] ? join32(process.cwd(), positional[0]) : process.cwd();
+  const memoryDir = isGlobal ? getGlobalMemoryDir() : join32(targetDir, ".memory");
   const globalDir = getGlobalMemoryDir();
-  mkdirSync19(join31(memoryDir, "memories"), { recursive: true });
-  mkdirSync19(join31(globalDir, "memories"), { recursive: true });
-  const currentPath = join31(memoryDir, "CURRENT.md");
-  if (!existsSync34(currentPath)) {
-    writeFileSync18(currentPath, `# Active Project Constraints
+  mkdirSync20(join32(memoryDir, "memories"), { recursive: true });
+  mkdirSync20(join32(globalDir, "memories"), { recursive: true });
+  const currentPath = join32(memoryDir, "CURRENT.md");
+  if (!existsSync35(currentPath)) {
+    writeFileSync19(currentPath, `# Active Project Constraints
 `, "utf8");
   }
   const globalUserPath = userFilePath(globalDir);
-  if (!existsSync34(globalUserPath)) {
+  if (!existsSync35(globalUserPath)) {
     const { promptSingleSelect: promptSingleSelect2 } = await Promise.resolve().then(() => (init_prompt(), exports_prompt));
     const archetypeOptions = [
       { id: "developer", label: "Software Engineer / Developer", hint: "Code-first, direct, strict typing" },
@@ -28482,13 +28790,13 @@ async function handleInstallCommand({ positional, flags }) {
   if (!isGlobal) {
     ensureProjectAgentInstructions(targetDir);
   }
-  const globalAgentsMd = join31(homedir6(), ".agents", "AGENTS.md");
-  if (existsSync34(globalAgentsMd)) {
+  const globalAgentsMd = join32(homedir7(), ".agents", "AGENTS.md");
+  if (existsSync35(globalAgentsMd)) {
     try {
-      const existing = readFileSync26(globalAgentsMd, "utf8");
+      const existing = readFileSync27(globalAgentsMd, "utf8");
       if (existing.includes("<!-- agentmemory:start -->")) {
         const updated = existing.replace(/<!-- agentmemory:start -->[\s\S]*?<!-- agentmemory:end -->/, MUSE_MEMORY_DIRECTIVE);
-        writeFileSync18(globalAgentsMd, updated, "utf8");
+        writeFileSync19(globalAgentsMd, updated, "utf8");
       }
     } catch {}
   }
@@ -28549,11 +28857,11 @@ async function handleInstallCommand({ positional, flags }) {
   return 0;
 }
 async function promptOrNotifyGitHook(targetDir, autoInstall = false) {
-  const gitDir = join31(targetDir, ".git");
-  if (!existsSync34(gitDir))
+  const gitDir = join32(targetDir, ".git");
+  if (!existsSync35(gitDir))
     return false;
-  const hookPath = join31(gitDir, "hooks", "pre-commit");
-  const isInstalled = existsSync34(hookPath) && readFileSync26(hookPath, "utf8").includes("memory harvest-auto");
+  const hookPath = join32(gitDir, "hooks", "pre-commit");
+  const isInstalled = existsSync35(hookPath) && readFileSync27(hookPath, "utf8").includes("memory harvest-auto");
   if (isInstalled)
     return true;
   if (autoInstall) {
@@ -28609,7 +28917,7 @@ async function handleUninstallCommand({ positional, flags }) {
       action: async () => {
         if (purge) {
           const ctx = requireRoot(flags);
-          if (ctx && existsSync34(ctx.memoryDir) && !dryRun) {
+          if (ctx && existsSync35(ctx.memoryDir) && !dryRun) {
             const { rmSync: rmSync3 } = await import("node:fs");
             rmSync3(ctx.memoryDir, { recursive: true, force: true });
           }
@@ -28641,13 +28949,13 @@ async function handleUninstallCommand({ positional, flags }) {
 }
 async function handleInitCommand({ positional, flags }) {
   const isGlobal = flags["global"] === "true";
-  const targetDir = positional[0] ? join31(process.cwd(), positional[0]) : process.cwd();
+  const targetDir = positional[0] ? join32(process.cwd(), positional[0]) : process.cwd();
   const memoryDirName = flags["legacy"] === "true" ? ".musememory" : ".memory";
-  const memoryDir = isGlobal ? getGlobalMemoryDir() : join31(targetDir, memoryDirName);
-  mkdirSync19(join31(memoryDir, "memories"), { recursive: true });
-  const currentPath = join31(memoryDir, "CURRENT.md");
-  if (!existsSync34(currentPath)) {
-    writeFileSync18(currentPath, `# Active Project Constraints
+  const memoryDir = isGlobal ? getGlobalMemoryDir() : join32(targetDir, memoryDirName);
+  mkdirSync20(join32(memoryDir, "memories"), { recursive: true });
+  const currentPath = join32(memoryDir, "CURRENT.md");
+  if (!existsSync35(currentPath)) {
+    writeFileSync19(currentPath, `# Active Project Constraints
 `, "utf8");
   }
   if (!isGlobal) {
@@ -28823,6 +29131,13 @@ async function handleUiCommand({ flags }) {
   if (!ctx)
     return 1;
   const port = flags["port"] ? parseInt(flags["port"], 10) : 2222;
+  try {
+    const { harvestAllAgentTranscripts: harvestAllAgentTranscripts2 } = await Promise.resolve().then(() => (init_harvester(), exports_harvester));
+    const harvestRes = harvestAllAgentTranscripts2(ctx.store, { memoryDir: ctx.memoryDir });
+    if (harvestRes.harvestedFilesCount > 0) {
+      console.log(`[UI Auto-Sync] Distilled ${harvestRes.memoriesImported} new memories from ${harvestRes.harvestedFilesCount} agent transcript(s).`);
+    }
+  } catch {}
   const { startUiServer: startUiServer2 } = await Promise.resolve().then(() => (init_ui(), exports_ui));
   const srv = await startUiServer2({
     port,
@@ -28931,8 +29246,8 @@ var init_ecosystem = __esm(() => {
 });
 
 // src/agentcontract.ts
-import { existsSync as existsSync35 } from "node:fs";
-import { join as join32 } from "node:path";
+import { existsSync as existsSync36 } from "node:fs";
+import { join as join33 } from "node:path";
 function parseAgentMemoryContract(markdown) {
   if (!markdown || !markdown.startsWith("---"))
     return null;
@@ -28964,17 +29279,17 @@ function parseAgentMemoryContract(markdown) {
 function resolveAgentFile(nameOrPath, workspaceRoot) {
   if (!nameOrPath)
     return null;
-  if (existsSync35(nameOrPath))
+  if (existsSync36(nameOrPath))
     return nameOrPath;
   const candidates = [
-    join32(workspaceRoot, ".agents", `${nameOrPath}.md`),
-    join32(workspaceRoot, ".memory", "agents", `${nameOrPath}.md`)
+    join33(workspaceRoot, ".agents", `${nameOrPath}.md`),
+    join33(workspaceRoot, ".memory", "agents", `${nameOrPath}.md`)
   ];
   const home = process.env.HOME;
   if (home)
-    candidates.push(join32(home, ".config", "opencode", "agents", `${nameOrPath}.md`));
+    candidates.push(join33(home, ".config", "opencode", "agents", `${nameOrPath}.md`));
   for (const c of candidates) {
-    if (existsSync35(c))
+    if (existsSync36(c))
       return c;
   }
   return null;
@@ -28984,8 +29299,8 @@ var init_agentcontract = __esm(() => {
 });
 
 // src/cli/retrieval.ts
-import { existsSync as existsSync36, readFileSync as readFileSync27 } from "node:fs";
-import { join as join33 } from "node:path";
+import { existsSync as existsSync37, readFileSync as readFileSync28 } from "node:fs";
+import { join as join34 } from "node:path";
 async function handleContextCommand({ positional, flags }) {
   let agentTypes;
   let agentTags;
@@ -28993,7 +29308,7 @@ async function handleContextCommand({ positional, flags }) {
     const file = resolveAgentFile(flags["for-agent"], flags["dir"] ?? process.cwd());
     if (!file)
       return usageError(`--for-agent: cannot resolve agent '${flags["for-agent"]}'`);
-    const contract = parseAgentMemoryContract(readFileSync27(file, "utf8"));
+    const contract = parseAgentMemoryContract(readFileSync28(file, "utf8"));
     if (contract) {
       agentTypes = contract.types;
       agentTags = contract.tags;
@@ -29133,7 +29448,7 @@ async function handleHarvestCommand({ positional, flags }) {
   const project = flags["project"];
   if (!project)
     return usageError("harvest requires --project");
-  const rawText = existsSync36(target) ? readFileSync27(target, "utf8") : target;
+  const rawText = existsSync37(target) ? readFileSync28(target, "utf8") : target;
   const created = harvestMemories(ctx.store, {
     text: rawText,
     project,
@@ -29169,8 +29484,8 @@ async function handleSearchTranscriptCommand({ positional, flags }) {
   const filePath = positional[1];
   if (!query)
     return usageError("search-transcript requires <query> [file.jsonl]");
-  const targetFile = filePath ? filePath.startsWith("/") ? filePath : join33(process.cwd(), filePath) : join33(process.cwd(), "transcript.jsonl");
-  if (!existsSync36(targetFile)) {
+  const targetFile = filePath ? filePath.startsWith("/") ? filePath : join34(process.cwd(), filePath) : join34(process.cwd(), "transcript.jsonl");
+  if (!existsSync37(targetFile)) {
     return fail(`error: transcript file not found: ${targetFile}`);
   }
   const windowSize = flags["window"] ? parseInt(flags["window"], 10) : 2;
@@ -29186,7 +29501,7 @@ async function handleReindexCommand({ flags }) {
   const { rebuildIndex: rebuildIndex2, saveIndex: saveIndex2 } = await Promise.resolve().then(() => (init_vector(), exports_vector));
   const index = rebuildIndex2(ctx.store);
   saveIndex2(index, ctx.memoryDir);
-  console.log(`indexed ${Object.keys(index.entries).length} entries -> ${join33(ctx.memoryDir, "index.json")}`);
+  console.log(`indexed ${Object.keys(index.entries).length} entries -> ${join34(ctx.memoryDir, "index.json")}`);
   return 0;
 }
 async function handleHookCommand({ positional, flags }) {
@@ -29577,7 +29892,7 @@ var init_entities2 = __esm(() => {
 });
 
 // src/cli/settings.ts
-import { writeFileSync as writeFileSync19, readFileSync as readFileSync28 } from "node:fs";
+import { writeFileSync as writeFileSync20, readFileSync as readFileSync29 } from "node:fs";
 function handleSettingsCommand(parsed) {
   const ctx = requireRoot(parsed.flags);
   if (!ctx)
@@ -29659,7 +29974,7 @@ function handleSettingsCommand(parsed) {
     const out = parsed.flags.out;
     const json2 = exportSettings(memoryDir);
     if (out) {
-      writeFileSync19(out, json2, "utf8");
+      writeFileSync20(out, json2, "utf8");
       console.log(`Exported settings to ${out}`);
     } else {
       console.log(json2);
@@ -29673,7 +29988,7 @@ function handleSettingsCommand(parsed) {
       return 2;
     }
     try {
-      const raw = readFileSync28(file, "utf8");
+      const raw = readFileSync29(file, "utf8");
       importSettings(memoryDir, raw);
       console.log(`Successfully imported settings from ${file}`);
       return 0;
@@ -29696,16 +30011,16 @@ var init_nudge = __esm(() => {
 });
 
 // src/routines.ts
-import { readFileSync as readFileSync29, existsSync as existsSync37 } from "node:fs";
-import { join as join34 } from "node:path";
+import { readFileSync as readFileSync30, existsSync as existsSync38 } from "node:fs";
+import { join as join35 } from "node:path";
 function routinesPath(memoryDir) {
-  return join34(memoryDir, "routines.yaml");
+  return join35(memoryDir, "routines.yaml");
 }
 function loadRoutines(memoryDir) {
   const p = routinesPath(memoryDir);
-  if (!existsSync37(p))
+  if (!existsSync38(p))
     return { routines: {} };
-  const doc2 = yaml.load(readFileSync29(p, "utf8"), { schema: yaml.JSON_SCHEMA }) ?? {};
+  const doc2 = yaml.load(readFileSync30(p, "utf8"), { schema: yaml.JSON_SCHEMA }) ?? {};
   const routines = doc2.routines ?? {};
   for (const [name, r] of Object.entries(routines)) {
     if (!r || typeof r.schedule !== "string" || !r.schedule.trim()) {
@@ -29743,7 +30058,7 @@ var init_routines = __esm(() => {
 });
 
 // src/cli/lifecycle.ts
-import { writeFileSync as writeFileSync20, readFileSync as readFileSync30, existsSync as existsSync38 } from "node:fs";
+import { writeFileSync as writeFileSync21, readFileSync as readFileSync31, existsSync as existsSync39 } from "node:fs";
 async function handleProposeCommand({ positional, flags }) {
   const ctx = requireRoot(flags);
   if (!ctx)
@@ -29892,7 +30207,7 @@ async function handleExportCommand({ flags }) {
   const snapshot = exportSnapshot(ctx.store);
   const outPath = flags["out"];
   if (outPath) {
-    writeFileSync20(outPath, JSON.stringify(snapshot, null, 2), "utf8");
+    writeFileSync21(outPath, JSON.stringify(snapshot, null, 2), "utf8");
     console.log(`exported ${snapshot.total} memories to ${outPath}`);
   } else {
     console.log(JSON.stringify(snapshot, null, 2));
@@ -29906,9 +30221,9 @@ async function handleImportCommand({ positional, flags }) {
   const file = positional[0];
   if (!file)
     return usageError("import requires <file.json>");
-  if (!existsSync38(file))
+  if (!existsSync39(file))
     return fail(`error: file ${file} does not exist`);
-  const raw = JSON.parse(readFileSync30(file, "utf8"));
+  const raw = JSON.parse(readFileSync31(file, "utf8"));
   const res = importSnapshot(ctx.store, raw, { overwrite: flags["overwrite"] === "true" });
   if (res.errors.length > 0) {
     console.error(`import encountered errors:`);
@@ -30316,6 +30631,9 @@ async function main(argv) {
       return handleSearchTranscriptCommand(parsed);
     case "harvest":
       return handleHarvestCommand(parsed);
+    case "learn":
+    case "sync-chats":
+      return handleLearnCommand(parsed);
     case "harvest-auto":
       return handleHarvestAutoCommand(parsed);
     case "hook":
@@ -30449,6 +30767,7 @@ Ecosystem, Migration & Connectivity:
   agents / detect-agents        Scan workstation for 80+ coding agent platforms
   detect                        Scan machine for 24+ external memory formats
   migrate [--from P] [--all]    Ingest external memories with state preservation & secret scrubbing
+  learn / sync-chats [--confirm] Auto-discover and harvest memories from all agent chats across machine
   harvest <file|text> --project P Distill conversation transcripts into structured memory units
   harvest-auto [--from <glob>] [--project P] Harvest inbox transcripts as candidates and archive them
   hook install --git            Install the harvester as a git pre-commit hook (never clobbers)
@@ -30465,6 +30784,7 @@ var init_cli = __esm(() => {
   init_shared();
   init_ecosystem();
   init_upgrade();
+  init_harvester();
   init_retrieval3();
   init_persona();
   init_wiki2();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "musememory",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "Autonomous, self-organizing cognitive memory system for AI agents and agency networks",
   "main": "dist/index.js",
   "type": "module",