musememory 1.8.0 → 1.10.0

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";
@@ -9028,6 +9055,297 @@ var init_hook = __esm(() => {
   init_audit();
 });
 
+// src/cli/upgrade.ts
+var exports_upgrade = {};
+__export(exports_upgrade, {
+  detectPackageManager: () => detectPackageManager,
+  executePackageUpgrade: () => executePackageUpgrade,
+  formatProgressBar: () => formatProgressBar,
+  getLatestNpmVersion: () => getLatestNpmVersion,
+  getUpgradeMilestones: () => getUpgradeMilestones,
+  handleUpgradeCommand: () => handleUpgradeCommand,
+  playGamifiedLoader: () => playGamifiedLoader,
+  repairInstallation: () => repairInstallation
+});
+import { execSync as execSync2 } from "node:child_process";
+import { existsSync as existsSync22, mkdirSync as mkdirSync13, writeFileSync as writeFileSync11 } from "node:fs";
+import { join as join19 } from "node:path";
+function formatProgressBar(percent, width = 20) {
+  const p = Math.max(0, Math.min(100, percent));
+  const filledCount = Math.round(p / 100 * width);
+  const emptyCount = Math.max(0, width - filledCount);
+  const filled = "█".repeat(filledCount);
+  const empty = "░".repeat(emptyCount);
+  return `[${filled}${empty}] ${Math.round(p)}%`;
+}
+function detectPackageManager() {
+  try {
+    if (typeof process.isBun !== "undefined" || process.versions.bun) {
+      return "bun";
+    }
+  } catch {}
+  try {
+    execSync2("bun --version", { stdio: "ignore" });
+    return "bun";
+  } catch {}
+  try {
+    execSync2("pnpm --version", { stdio: "ignore" });
+    return "pnpm";
+  } catch {}
+  try {
+    execSync2("yarn --version", { stdio: "ignore" });
+    return "yarn";
+  } catch {}
+  return "npm";
+}
+async function getLatestNpmVersion(packageName = "musememory") {
+  try {
+    const res = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(3000)
+    });
+    if (res.ok) {
+      const data = await res.json();
+      if (data && typeof data.version === "string") {
+        return data.version;
+      }
+    }
+  } catch {}
+  try {
+    const out = execSync2(`npm show ${packageName} version`, {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (out && !out.includes("error"))
+      return out;
+  } catch {}
+  return null;
+}
+function getUpgradeMilestones() {
+  return [
+    {
+      level: 1,
+      stage: "LEVEL 1 [\uD83D\uDEE1️ Vibeguard Pre-Flight Check]",
+      description: "Auditing environment credentials & storage integrity"
+    },
+    {
+      level: 2,
+      stage: "LEVEL 2 [\uD83D\uDCE6 Package Manager Synchronization]",
+      description: "Querying package registry and pulling latest release binaries"
+    },
+    {
+      level: 3,
+      stage: "LEVEL 3 [\uD83E\uDDE0 Synaptic Database & Schema Alignment]",
+      description: "Validating SQLite tables, CURRENT.md constraints & USER.md profiles"
+    },
+    {
+      level: 4,
+      stage: "LEVEL 4 [\uD83E\uDD16 80+ Agent Auto-Wiring Matrix]",
+      description: "Scanning workstation platforms and auto-wiring newly detected agents"
+    },
+    {
+      level: 5,
+      stage: "LEVEL 5 [✨ Cognitive Ascendance Complete]",
+      description: "Upgraded to latest version! All agent skills synchronized"
+    }
+  ];
+}
+async function playGamifiedLoader(steps, options = {}) {
+  const isTTY = process.stdout.isTTY;
+  const total = steps.length;
+  console.log(`
+┌──────────────────────────────────────────────────────────────────┐`);
+  console.log(`│  \uD83E\uDDE0 MUSE MEMORY · ${options.title || "SYSTEM LEVEL-UP & RECOVERY MATRIX"}  │`);
+  console.log(`└──────────────────────────────────────────────────────────────────┘
+`);
+  for (let i = 0;i < total; i++) {
+    const step = steps[i];
+    const percent = Math.round((i + 1) / total * 100);
+    const bar = formatProgressBar(percent, 24);
+    if (isTTY) {
+      process.stdout.write(`  ${bar} ⚡ LEVEL ${step.level}: ${step.title}...\r`);
+    } else {
+      console.log(`  ${bar} ⚡ LEVEL ${step.level}: ${step.title}`);
+    }
+    try {
+      await step.action();
+    } catch (err) {
+      console.log(`
+  [!] Warning during step "${step.title}": ${err.message || err}`);
+    }
+    if (isTTY) {
+      await new Promise((r) => setTimeout(r, 60));
+      process.stdout.write(`  ${bar} ✓ LEVEL ${step.level}: ${step.title} [OK]
+`);
+    }
+  }
+  console.log();
+}
+async function repairInstallation(options = {}) {
+  const root = options.workspaceRoot || process.cwd();
+  const isGlobal = options.global === true;
+  const memoryDir = options.memoryDir || (isGlobal ? getGlobalMemoryDir() : resolveMemoryDir({ root }));
+  const actionsTaken = [];
+  const memoriesDir = join19(memoryDir, "memories");
+  if (!existsSync22(memoriesDir)) {
+    mkdirSync13(memoriesDir, { recursive: true });
+    actionsTaken.push(`Created missing memories directory: ${memoriesDir}`);
+  }
+  const currentPath = join19(memoryDir, "CURRENT.md");
+  if (!existsSync22(currentPath)) {
+    writeFileSync11(currentPath, `# Active Project Constraints
+
+- [ ] Initial session constraints initialized.
+`, "utf8");
+    actionsTaken.push(`Recovered missing CURRENT.md at ${currentPath}`);
+  }
+  const uPath = userFilePath(memoryDir);
+  if (!existsSync22(uPath)) {
+    initUserProfile(memoryDir, "developer", false, !isGlobal);
+    actionsTaken.push(`Recovered missing USER.md profile at ${uPath}`);
+  }
+  let agentsConnected = 0;
+  if (!options.skipAgentConnect) {
+    try {
+      const reports = connectAgent("all", undefined, { dryRun: false, force: false });
+      agentsConnected = reports.filter((r) => r.updated || r.installed).length;
+      if (agentsConnected > 0) {
+        actionsTaken.push(`Auto-wired ${agentsConnected} detected agent platform(s)`);
+      }
+    } catch {}
+  }
+  if (!isGlobal && existsSync22(root)) {
+    try {
+      const index = indexGraph(root, memoryDir);
+      if (index.symbolCount > 0) {
+        actionsTaken.push(`Indexed ${index.symbolCount} AST symbols from ${index.provider}`);
+      }
+    } catch {}
+    if (existsSync22(join19(root, ".git"))) {
+      try {
+        const hookRes = installGitHook(root);
+        if (hookRes.installed) {
+          actionsTaken.push(`Installed Git pre-commit transcript harvester hook`);
+        }
+      } catch {}
+    }
+  }
+  return {
+    repaired: true,
+    actionsTaken,
+    agentsConnected,
+    memoryDir
+  };
+}
+function executePackageUpgrade(pm, dryRun = false) {
+  let cmd = "";
+  switch (pm) {
+    case "bun":
+      cmd = "bun add -g musememory@latest";
+      break;
+    case "pnpm":
+      cmd = "pnpm add -g musememory@latest";
+      break;
+    case "yarn":
+      cmd = "yarn global add musememory@latest";
+      break;
+    default:
+      cmd = "npm install -g musememory@latest";
+      break;
+  }
+  if (!dryRun) {
+    try {
+      execSync2(cmd, { stdio: "inherit" });
+    } catch (err) {
+      throw new Error(`Failed running upgrade command "${cmd}": ${err.message || err}`);
+    }
+  }
+  return cmd;
+}
+async function handleUpgradeCommand({ flags }) {
+  const isGlobal = flags["global"] === "true" || flags["g"] === "true";
+  const dryRun = flags["dry-run"] === "true";
+  const force = flags["force"] === "true";
+  const checkOnly = flags["check"] === "true";
+  const pm = detectPackageManager();
+  const currentVersion = "1.8.0";
+  console.log(`[Upgrade] Checking for updates (detected package manager: ${pm})...`);
+  const latestVersion = await getLatestNpmVersion();
+  if (latestVersion) {
+    console.log(`  * Installed version: v${currentVersion}`);
+    console.log(`  * Latest release:    v${latestVersion}`);
+  }
+  if (checkOnly) {
+    if (latestVersion && latestVersion !== currentVersion) {
+      console.log(`
+\uD83D\uDCA1 Update available: v${currentVersion} ➔ v${latestVersion}`);
+      console.log(`   Run 'memory upgrade' or '${pm === "bun" ? "bun add -g" : "npm install -g"} musememory@latest' to update.`);
+    } else {
+      console.log(`
+✓ Muse Memory is up to date (v${currentVersion}).`);
+    }
+    return 0;
+  }
+  let repairInfo;
+  const steps = [
+    {
+      level: 1,
+      title: "Vibeguard Security & Credential Audit",
+      action: async () => {}
+    },
+    {
+      level: 2,
+      title: `Package Manager Sync (${pm})`,
+      action: async () => {
+        if (!dryRun) {
+          executePackageUpgrade(pm, dryRun);
+        }
+      }
+    },
+    {
+      level: 3,
+      title: "Synaptic Storage & Schema Alignment",
+      action: async () => {
+        repairInfo = await repairInstallation({ global: isGlobal });
+      }
+    },
+    {
+      level: 4,
+      title: "80+ Agent Platforms & Skills Auto-Wiring",
+      action: async () => {}
+    },
+    {
+      level: 5,
+      title: "Cognitive Ascendance Complete",
+      action: async () => {}
+    }
+  ];
+  await playGamifiedLoader(steps, { title: "SYSTEM LEVEL-UP & UPGRADE MATRIX" });
+  console.log(`\uD83C\uDFC6 [LEVEL-UP COMPLETE] Muse Memory is now fully armed and up to date!`);
+  if (repairInfo && repairInfo.actionsTaken.length > 0) {
+    console.log(`
+\uD83D\uDD27 Self-Healing Actions Applied:`);
+    for (const act of repairInfo.actionsTaken) {
+      console.log(`  ✓ ${act}`);
+    }
+  }
+  console.log(`
+\uD83D\uDE80 Available Upgrade Commands for Reference:`);
+  console.log(`  • Bun:   bun add -g musememory@latest`);
+  console.log(`  • NPM:   npm install -g musememory@latest`);
+  console.log(`  • NPX:   npx musememory@latest`);
+  console.log(`  • Auto:  memory upgrade
+`);
+  return 0;
+}
+var init_upgrade = __esm(() => {
+  init_root();
+  init_user();
+  init_connect();
+  init_graph();
+  init_hook();
+});
+
 // node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS(function(exports) {
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -15329,8 +15647,8 @@ var require_ajv = __commonJS(function(exports, module) {
 });
 
 // src/schema.ts
-import { existsSync as existsSync22, readFileSync as readFileSync18 } from "node:fs";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync23, readFileSync as readFileSync19 } from "node:fs";
+import { join as join20 } from "node:path";
 function getValidator() {
   if (cachedValidate)
     return cachedValidate;
@@ -15341,14 +15659,14 @@ function getValidator() {
     return !Number.isNaN(Date.parse(value));
   });
   const candidates = [
-    join19(import.meta.dir, "..", "schema.json"),
-    join19(import.meta.dir, "schema.json"),
-    join19(process.cwd(), "schema.json")
+    join20(import.meta.dir, "..", "schema.json"),
+    join20(import.meta.dir, "schema.json"),
+    join20(process.cwd(), "schema.json")
   ];
   let schemaContent = null;
   for (const p of candidates) {
-    if (existsSync22(p)) {
-      schemaContent = readFileSync18(p, "utf8");
+    if (existsSync23(p)) {
+      schemaContent = readFileSync19(p, "utf8");
       break;
     }
   }
@@ -15455,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 existsSync23, statSync as statSync8, readFileSync as readFileSync19 } from "node:fs";
-import { join as join20 } 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 || join20(home, ".memory");
-  const isInitialized = existsSync23(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;
@@ -15485,10 +16049,10 @@ async function runDoctor(targetDir, options = {}) {
   let secretLeaksCount = 0;
   let brokenLinksCount = 0;
   if (isInitialized) {
-    const currentPath = join20(storagePath, "CURRENT.md");
-    if (existsSync23(currentPath)) {
+    const currentPath = join22(storagePath, "CURRENT.md");
+    if (existsSync25(currentPath)) {
       currentMdExists = true;
-      const content = readFileSync19(currentPath, "utf8");
+      const content = readFileSync21(currentPath, "utf8");
       currentMdLines = content.split(`
 `).filter((l) => l.trim().length > 0).length;
     }
@@ -15509,21 +16073,21 @@ async function runDoctor(targetDir, options = {}) {
       valid = false;
     }
   }
-  const auditPath = join20(storagePath, "audit.jsonl");
+  const auditPath = join22(storagePath, "audit.jsonl");
   let auditExists = false;
   let auditCount = 0;
   let auditSize = 0;
   let lastEvent;
-  if (existsSync23(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 = readFileSync19(auditPath, "utf8");
+      const raw = readFileSync21(auditPath, "utf8");
       auditCount = raw.split(`
 `).filter((l) => l.trim().length > 0).length;
     } catch {}
@@ -15532,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 {
@@ -15565,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,
@@ -15622,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) {
@@ -15649,27 +16233,27 @@ var init_doctor = __esm(() => {
 });
 
 // src/retrieval/tree-index.ts
-import { existsSync as existsSync24, readFileSync as readFileSync20, writeFileSync as writeFileSync11, mkdirSync as mkdirSync13, rmSync } from "node:fs";
-import { join as join21 } 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 join21(memoryDir, "tree-index");
+  return join23(memoryDir, "tree-index");
 }
 function partitionDir(idxDir, project, type2) {
-  return join21(idxDir, project, type2);
+  return join23(idxDir, project, type2);
 }
 function shardFilePath(pDir, shardId) {
-  return join21(pDir, `${shardId}.json`);
+  return join23(pDir, `${shardId}.json`);
 }
 function partitionIndexFilePath(pDir) {
-  return join21(pDir, "index.json");
+  return join23(pDir, "index.json");
 }
 function globalIndexFilePath(idxDir) {
-  return join21(idxDir, "index.json");
+  return join23(idxDir, "index.json");
 }
 function nowIso3() {
   return new Date().toISOString();
@@ -15759,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");
-  mkdirSync13(indexDir(memoryDir), { recursive: true });
+  mkdirSync15(indexDir(memoryDir), { recursive: true });
   if (allMemories.length === 0) {
     const emptyIndex = {
       version: 1,
@@ -15768,7 +16352,7 @@ function buildTreeIndex(store, memoryDir, config = {}) {
       totalMemories: 0,
       builtAt: nowIso3()
     };
-    writeFileSync11(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;
@@ -15786,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);
-    mkdirSync13(pDir, { recursive: true });
+    mkdirSync15(pDir, { recursive: true });
     const maxShardSize = cfg.shardThreshold || 1e4;
     const finalShards = [];
     const memoryChunks = [];
@@ -15847,9 +16431,9 @@ function buildTreeIndex(store, memoryDir, config = {}) {
     partitions[`${project}|${type2}`] = partition;
     totalIndexNodes += partitionNodes;
     totalIndexMemories += partitionMemories;
-    writeFileSync11(partitionIndexFilePath(pDir), JSON.stringify(partition, null, 2), "utf8");
+    writeFileSync13(partitionIndexFilePath(pDir), JSON.stringify(partition, null, 2), "utf8");
     for (const shard of finalShards) {
-      writeFileSync11(shardFilePath(pDir, shard.id), JSON.stringify(shard, null, 2), "utf8");
+      writeFileSync13(shardFilePath(pDir, shard.id), JSON.stringify(shard, null, 2), "utf8");
     }
   }
   const index = {
@@ -15859,15 +16443,15 @@ function buildTreeIndex(store, memoryDir, config = {}) {
     totalMemories: totalIndexMemories,
     builtAt: nowIso3()
   };
-  writeFileSync11(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 (!existsSync24(path))
+  if (!existsSync26(path))
     return null;
   try {
-    const data = JSON.parse(readFileSync20(path, "utf8"));
+    const data = JSON.parse(readFileSync22(path, "utf8"));
     return data.version === 1 ? data : null;
   } catch {
     return null;
@@ -16012,10 +16596,10 @@ __export(exports_vector, {
   saveIndex: () => saveIndex,
   termFrequencies: () => termFrequencies
 });
-import { existsSync as existsSync25, readFileSync as readFileSync21, writeFileSync as writeFileSync12, mkdirSync as mkdirSync14 } from "node:fs";
-import { join as join22 } 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 join22(memoryDir, "index.json");
+  return join24(memoryDir, "index.json");
 }
 function hashTrigram(tri) {
   let h = 2166136261;
@@ -16062,16 +16646,16 @@ function rebuildIndex(store) {
   return index;
 }
 function saveIndex(index, memoryDir) {
-  if (!existsSync25(memoryDir))
-    mkdirSync14(memoryDir, { recursive: true });
-  writeFileSync12(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 (!existsSync25(p))
+  if (!existsSync27(p))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync21(p, "utf8"));
+    const parsed = JSON.parse(readFileSync23(p, "utf8"));
     return parsed.version === 1 ? parsed : null;
   } catch {
     return null;
@@ -16143,8 +16727,8 @@ var init_vector = __esm(() => {
 });
 
 // src/pageindex/engine.ts
-import { existsSync as existsSync26, mkdirSync as mkdirSync15, readFileSync as readFileSync22, writeFileSync as writeFileSync13, rmSync as rmSync2, readdirSync as readdirSync9 } from "node:fs";
-import { join as join23 } 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);
 }
@@ -16221,9 +16805,9 @@ function buildPageIndex(content, options) {
     root: rootNode
   };
   if (options.memoryDir && !options.dryRun) {
-    const dir = join23(options.memoryDir, "pageindex", project);
-    mkdirSync15(dir, { recursive: true });
-    writeFileSync13(join23(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;
 }
@@ -16287,29 +16871,29 @@ function searchPageIndex(doc, options) {
   };
 }
 function loadPageIndex(memoryDir, project, indexId) {
-  const filePath = join23(memoryDir, "pageindex", project, `${indexId}.json`);
-  if (!existsSync26(filePath))
+  const filePath = join25(memoryDir, "pageindex", project, `${indexId}.json`);
+  if (!existsSync28(filePath))
     return null;
   try {
-    return JSON.parse(readFileSync22(filePath, "utf8"));
+    return JSON.parse(readFileSync24(filePath, "utf8"));
   } catch {
     return null;
   }
 }
 function listPageIndexes(memoryDir, project) {
-  const base = join23(memoryDir, "pageindex");
-  if (!existsSync26(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 = join23(base, p);
-    if (!existsSync26(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(readFileSync22(join23(pDir, f), "utf8")));
+          results.push(JSON.parse(readFileSync24(join25(pDir, f), "utf8")));
         } catch {}
       }
     }
@@ -16317,8 +16901,8 @@ function listPageIndexes(memoryDir, project) {
   return results;
 }
 function deletePageIndex(memoryDir, project, indexId) {
-  const base = join23(memoryDir, "pageindex");
-  if (!existsSync26(base))
+  const base = join25(memoryDir, "pageindex");
+  if (!existsSync28(base))
     return { deletedCount: 0 };
   let count = 0;
   if (!project && !indexId) {
@@ -16326,14 +16910,14 @@ function deletePageIndex(memoryDir, project, indexId) {
     return { deletedCount: 1 };
   }
   if (project && !indexId) {
-    const pDir = join23(base, project);
-    if (existsSync26(pDir)) {
+    const pDir = join25(base, project);
+    if (existsSync28(pDir)) {
       rmSync2(pDir, { recursive: true, force: true });
       count++;
     }
   } else if (project && indexId) {
-    const file = join23(base, project, `${indexId}.json`);
-    if (existsSync26(file)) {
+    const file = join25(base, project, `${indexId}.json`);
+    if (existsSync28(file)) {
       rmSync2(file, { force: true });
       count++;
     }
@@ -16346,13 +16930,13 @@ var init_engine2 = __esm(() => {
 });
 
 // src/retrieval/engine.ts
-import { existsSync as existsSync27 } from "node:fs";
-import { join as join24 } 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 && existsSync27(options.docPath)) {
+    if (mode === "pageindex" || options.docPath && existsSync29(options.docPath)) {
       try {
         const docs = listPageIndexes(memoryDir, options.project);
         if (docs.length > 0) {
@@ -16379,8 +16963,8 @@ class RetrievalEngine {
         }
       } catch {}
     }
-    const treeDir = join24(memoryDir, "tree");
-    const hasTree = existsSync27(treeDir);
+    const treeDir = join26(memoryDir, "tree");
+    const hasTree = existsSync29(treeDir);
     const allEntries = list(store);
     if (mode === "tree" || mode === "auto" && hasTree && allEntries.length >= 500) {
       try {
@@ -16418,7 +17002,7 @@ class RetrievalEngine {
       } catch {}
     }
     const vecPath = indexFilePath(memoryDir);
-    const hasVec = existsSync27(vecPath);
+    const hasVec = existsSync29(vecPath);
     if (mode === "hybrid" || mode === "auto" && hasVec && allEntries.length > 100) {
       try {
         const hybridResults = hybridSearch(store, memoryDir, query, {
@@ -26114,8 +26698,8 @@ var init_loops = __esm(() => {
 });
 
 // src/distill.ts
-import { existsSync as existsSync28, mkdirSync as mkdirSync16, writeFileSync as writeFileSync14 } from "node:fs";
-import { join as join25 } 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));
@@ -26126,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 ?? join25(workspaceRoot, ".agents", "skills");
+  const skillsDir = options.skillsDir ?? join27(workspaceRoot, ".agents", "skills");
   for (const cluster of clusters) {
     if (cluster.length < minCount) {
       report.clustersBelowThreshold++;
@@ -26134,9 +26718,9 @@ function distillSkills(store, workspaceRoot, options = {}) {
     }
     const topic = dominantTopicTokens(cluster.map((e) => e.title));
     const slug = slugifyId(topic.join("-") || "skill");
-    const dir = join25(skillsDir, slug);
+    const dir = join27(skillsDir, slug);
     const memberIds = cluster.map((e) => e.id);
-    if (existsSync28(dir)) {
+    if (existsSync30(dir)) {
       report.skippedExisting.push({ slug, members: memberIds });
       continue;
     }
@@ -26146,10 +26730,10 @@ function distillSkills(store, workspaceRoot, options = {}) {
       throw new Error(`Secret detected in generated SKILL.md for '${slug}': ${secrets.join(", ")}`);
     }
     if (!options.dryRun) {
-      mkdirSync16(dir, { recursive: true });
-      writeFileSync14(join25(dir, "SKILL.md"), md, "utf8");
+      mkdirSync18(dir, { recursive: true });
+      writeFileSync16(join27(dir, "SKILL.md"), md, "utf8");
     }
-    report.created.push({ slug, path: join25(dir, "SKILL.md"), members: memberIds });
+    report.created.push({ slug, path: join27(dir, "SKILL.md"), members: memberIds });
   }
   return report;
 }
@@ -26487,14 +27071,14 @@ var init_schema2 = __esm(() => {
 });
 
 // src/settings/loader.ts
-import { existsSync as existsSync29, mkdirSync as mkdirSync17, readFileSync as readFileSync23, writeFileSync as writeFileSync15 } from "node:fs";
-import { join as join26 } 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 join26(memoryDir, "settings.json");
+  return join28(memoryDir, "settings.json");
 }
 function loadSettings(memoryDir) {
   const filePath = getSettingsFilePath(memoryDir);
-  if (!existsSync29(filePath)) {
+  if (!existsSync31(filePath)) {
     return {
       version: 1,
       global: JSON.parse(JSON.stringify(DEFAULT_SETTINGS)),
@@ -26502,7 +27086,7 @@ function loadSettings(memoryDir) {
     };
   }
   try {
-    const raw = readFileSync23(filePath, "utf8");
+    const raw = readFileSync25(filePath, "utf8");
     const parsed = JSON.parse(raw);
     return {
       version: parsed.version || 1,
@@ -26518,9 +27102,9 @@ function loadSettings(memoryDir) {
   }
 }
 function saveSettings(store, memoryDir) {
-  mkdirSync17(memoryDir, { recursive: true });
+  mkdirSync19(memoryDir, { recursive: true });
   const filePath = getSettingsFilePath(memoryDir);
-  writeFileSync15(filePath, JSON.stringify(store, null, 2), "utf8");
+  writeFileSync17(filePath, JSON.stringify(store, null, 2), "utf8");
 }
 function getSettings(memoryDir) {
   return loadSettings(memoryDir).global;
@@ -26636,17 +27220,17 @@ __export(exports_plasticity, {
   recordCoActivation: () => recordCoActivation,
   saveHebbianGraph: () => saveHebbianGraph
 });
-import { existsSync as existsSync30, readFileSync as readFileSync24, writeFileSync as writeFileSync16 } from "node:fs";
-import { join as join27 } 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 join27(memoryDir, "hebbian-plasticity.json");
+  return join29(memoryDir, "hebbian-plasticity.json");
 }
 function loadHebbianGraph(memoryDir) {
   const p = getPlasticityPath(memoryDir);
-  if (!existsSync30(p))
+  if (!existsSync32(p))
     return {};
   try {
-    return JSON.parse(readFileSync24(p, "utf8"));
+    return JSON.parse(readFileSync26(p, "utf8"));
   } catch {
     return {};
   }
@@ -26654,7 +27238,7 @@ function loadHebbianGraph(memoryDir) {
 function saveHebbianGraph(memoryDir, graph) {
   const p = getPlasticityPath(memoryDir);
   try {
-    writeFileSync16(p, JSON.stringify(graph, null, 2), "utf8");
+    writeFileSync18(p, JSON.stringify(graph, null, 2), "utf8");
   } catch {}
 }
 function recordCoActivation(memoryIds, memoryDir) {
@@ -26744,9 +27328,9 @@ __export(exports_drift, {
   scanCodeDrift: () => scanCodeDrift,
   scanCodeDriftFromDiff: () => scanCodeDriftFromDiff
 });
-import { execSync as execSync2 } from "node:child_process";
-import { existsSync as existsSync31 } from "node:fs";
-import { join as join28, isAbsolute as isAbsolute2 } from "node:path";
+import { execSync as execSync3 } from "node:child_process";
+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));
@@ -26760,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 : join28(root, p);
-        const exists = existsSync31(fullPath);
+        const fullPath = isAbsolute2(p) ? p : join30(root, p);
+        const exists = existsSync33(fullPath);
         drifted.push({
           memoryId: entry.id,
           title: entry.title,
@@ -26785,7 +27369,7 @@ function scanCodeDriftFromDiff(entries, changedFiles, workspaceRoot) {
 function getGitChangedFiles(workspaceRoot) {
   const root = workspaceRoot || process.cwd();
   try {
-    const stdout = execSync2("git status --porcelain", {
+    const stdout = execSync3("git status --porcelain", {
       cwd: root,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
@@ -26802,7 +27386,7 @@ function getGitChangedFiles(workspaceRoot) {
         files.push(filePath);
     }
     try {
-      const diffOut = execSync2("git diff --name-only HEAD", {
+      const diffOut = execSync3("git diff --name-only HEAD", {
         cwd: root,
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"]
@@ -27507,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);
@@ -27599,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 });
@@ -28023,8 +28622,8 @@ __export(exports_daemon, {
   startHub: () => startHub
 });
 import { createServer as createServer2 } from "node:http";
-import { existsSync as existsSync32 } from "node:fs";
-import { join as join29 } 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;
@@ -28090,7 +28689,7 @@ data: ${JSON.stringify(event)}
     return clients.size;
   }
   if (memoryDir) {
-    const memoriesDir = join29(memoryDir, "memories");
+    const memoriesDir = join31(memoryDir, "memories");
     const armDebounced = (type2) => {
       if (debounceTimer)
         clearTimeout(debounceTimer);
@@ -28099,11 +28698,11 @@ data: ${JSON.stringify(event)}
       }, DEBOUNCE_MS);
     };
     try {
-      if (existsSync32(memoriesDir)) {
+      if (existsSync34(memoriesDir)) {
         watchers.push(watch(memoriesDir, () => armDebounced("memory.changed")));
       }
-      const currentMd = join29(memoryDir, "CURRENT.md");
-      if (existsSync32(currentMd)) {
+      const currentMd = join31(memoryDir, "CURRENT.md");
+      if (existsSync34(currentMd)) {
         watchers.push(watch(currentMd, () => armDebounced("constraints.changed")));
       }
     } catch {}
@@ -28136,19 +28735,19 @@ var DEBOUNCE_MS = 300;
 var init_daemon = () => {};
 
 // src/cli/ecosystem.ts
-import { join as join30 } from "node:path";
-import { existsSync as existsSync33, mkdirSync as mkdirSync18, writeFileSync as writeFileSync17, readFileSync as readFileSync25 } 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 = join30(targetDir, "AGENTS.md");
-  if (existsSync33(agentsMdPath)) {
+  const agentsMdPath = join32(targetDir, "AGENTS.md");
+  if (existsSync35(agentsMdPath)) {
     try {
-      const existing = readFileSync25(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);
-        writeFileSync17(agentsMdPath, updated, "utf8");
+        writeFileSync19(agentsMdPath, updated, "utf8");
       } else if (!existing.includes("<!-- musememory:start -->") && !existing.includes("Muse Memory")) {
-        writeFileSync17(agentsMdPath, `${existing.trim()}
+        writeFileSync19(agentsMdPath, `${existing.trim()}
 
 ${MUSE_MEMORY_DIRECTIVE}
 `, "utf8");
@@ -28159,23 +28758,23 @@ ${MUSE_MEMORY_DIRECTIVE}
 
 ${MUSE_MEMORY_DIRECTIVE}
 `;
-    writeFileSync17(agentsMdPath, initialContent, "utf8");
+    writeFileSync19(agentsMdPath, initialContent, "utf8");
   }
 }
 async function handleInstallCommand({ positional, flags }) {
   const isGlobal = flags["global"] === "true" || flags["g"] === "true";
-  const targetDir = positional[0] ? join30(process.cwd(), positional[0]) : process.cwd();
-  const memoryDir = isGlobal ? getGlobalMemoryDir() : join30(targetDir, ".memory");
+  const targetDir = positional[0] ? join32(process.cwd(), positional[0]) : process.cwd();
+  const memoryDir = isGlobal ? getGlobalMemoryDir() : join32(targetDir, ".memory");
   const globalDir = getGlobalMemoryDir();
-  mkdirSync18(join30(memoryDir, "memories"), { recursive: true });
-  mkdirSync18(join30(globalDir, "memories"), { recursive: true });
-  const currentPath = join30(memoryDir, "CURRENT.md");
-  if (!existsSync33(currentPath)) {
-    writeFileSync17(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 (!existsSync33(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" },
@@ -28191,45 +28790,78 @@ async function handleInstallCommand({ positional, flags }) {
   if (!isGlobal) {
     ensureProjectAgentInstructions(targetDir);
   }
-  const globalAgentsMd = join30(homedir6(), ".agents", "AGENTS.md");
-  if (existsSync33(globalAgentsMd)) {
+  const globalAgentsMd = join32(homedir7(), ".agents", "AGENTS.md");
+  if (existsSync35(globalAgentsMd)) {
     try {
-      const existing = readFileSync25(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);
-        writeFileSync17(globalAgentsMd, updated, "utf8");
+        writeFileSync19(globalAgentsMd, updated, "utf8");
       }
     } catch {}
   }
+  const { playGamifiedLoader: playGamifiedLoader2 } = await Promise.resolve().then(() => (init_upgrade(), exports_upgrade));
+  let reports = [];
+  let detected = [];
+  const installSteps = [
+    {
+      level: 1,
+      title: "Storage Layout & Memory Directory Scaffold",
+      action: async () => {}
+    },
+    {
+      level: 2,
+      title: "80+ Coding Agent Auto-Wiring Matrix",
+      action: async () => {
+        const { connectAgent: connectAgent2 } = await Promise.resolve().then(() => (init_connect(), exports_connect));
+        reports = connectAgent2("all", undefined, { dryRun: false, force: false });
+      }
+    },
+    {
+      level: 3,
+      title: "External Memory Provider Probe (24+ Formats)",
+      action: async () => {
+        detected = detectProviders(targetDir).filter((p) => p.detected);
+      }
+    },
+    {
+      level: 4,
+      title: "Git Pre-Commit Harvester Verification",
+      action: async () => {
+        if (!isGlobal) {
+          await promptOrNotifyGitHook(targetDir, flags["auto"] === "true" || flags["yes"] === "true");
+        }
+      }
+    },
+    {
+      level: 5,
+      title: "Cognitive Onboarding Ready",
+      action: async () => {}
+    }
+  ];
   console.log(`[+] Initialized Muse Memory in ${memoryDir}`);
-  const { connectAgent: connectAgent2 } = await Promise.resolve().then(() => (init_connect(), exports_connect));
-  const reports = connectAgent2("all", undefined, { dryRun: false, force: false });
+  await playGamifiedLoader2(installSteps, { title: "AUTONOMOUS ONBOARDING MATRIX" });
   if (reports.length > 0) {
-    console.log(`
-[+] Auto-wired ${reports.length} detected coding agent(s) with zero permissions:`);
+    console.log(`[+] Auto-wired ${reports.length} detected coding agent(s) with zero permissions:`);
     for (const r of reports) {
       console.log(`  * ${r.agentName}: ${r.message}`);
     }
   }
-  const detected = detectProviders(targetDir).filter((p) => p.detected);
   if (detected.length > 0) {
     console.log(`
 [!] Detected ${detected.length} external memory provider(s): ${detected.map((d) => d.name).join(", ")}`);
     console.log(`   -> Run 'memory migrate' to auto-import legacy memories.`);
   }
-  if (!isGlobal) {
-    await promptOrNotifyGitHook(targetDir, flags["auto"] === "true" || flags["yes"] === "true");
-  }
   console.log(`
-[OK] Muse Memory is ready! Use 'memory doctor' to verify system health.`);
+[OK] Muse Memory is initialized and ready! Use 'memory doctor' to verify health.`);
   return 0;
 }
 async function promptOrNotifyGitHook(targetDir, autoInstall = false) {
-  const gitDir = join30(targetDir, ".git");
-  if (!existsSync33(gitDir))
+  const gitDir = join32(targetDir, ".git");
+  if (!existsSync35(gitDir))
     return false;
-  const hookPath = join30(gitDir, "hooks", "pre-commit");
-  const isInstalled = existsSync33(hookPath) && readFileSync25(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) {
@@ -28255,44 +28887,75 @@ async function handleDoctorCommand({ positional, flags }) {
   return report.validation.valid ? 0 : 1;
 }
 async function handleUninstallCommand({ positional, flags }) {
+  const { playGamifiedLoader: playGamifiedLoader2 } = await Promise.resolve().then(() => (init_upgrade(), exports_upgrade));
   const { disconnectAllAgents: disconnectAllAgents2, disconnectSingleAgent: disconnectSingleAgent2 } = await Promise.resolve().then(() => (init_connect(), exports_connect));
   const agent = positional[0];
   const purge = flags["purge"] === "true";
   const dryRun = flags["dry-run"] === "true";
+  let unwiredReports = [];
+  const uninstallSteps = [
+    {
+      level: 1,
+      title: "Agent Platform Discovery & Configuration Lock",
+      action: async () => {}
+    },
+    {
+      level: 2,
+      title: `Unwiring Agent Platforms (${agent || "all"})`,
+      action: async () => {
+        if (agent && agent !== "all") {
+          const report = disconnectSingleAgent2(agent, undefined, { dryRun });
+          unwiredReports = [report];
+        } else {
+          unwiredReports = disconnectAllAgents2(undefined, { dryRun });
+        }
+      }
+    },
+    {
+      level: 3,
+      title: purge ? "Purging Memory Store (.memory/)" : "Preserving Cognitive Memory Store (.memory/)",
+      action: async () => {
+        if (purge) {
+          const ctx = requireRoot(flags);
+          if (ctx && existsSync35(ctx.memoryDir) && !dryRun) {
+            const { rmSync: rmSync3 } = await import("node:fs");
+            rmSync3(ctx.memoryDir, { recursive: true, force: true });
+          }
+        }
+      }
+    },
+    {
+      level: 4,
+      title: "Clean Teardown Verification",
+      action: async () => {}
+    }
+  ];
   console.log(`[CLEAN] Running Muse Memory Uninstaller${dryRun ? " [DRY RUN]" : ""}...`);
-  if (agent && agent !== "all") {
-    const report = disconnectSingleAgent2(agent, undefined, { dryRun });
-    console.log(`  * ${report.agentName}: ${report.message}`);
-  } else {
-    const reports = disconnectAllAgents2(undefined, { dryRun });
-    console.log(`
-[+] Unwired ${reports.length} coding agent(s):`);
-    for (const r of reports) {
+  await playGamifiedLoader2(uninstallSteps, { title: `SYSTEM UNINSTALL MATRIX${dryRun ? " [DRY RUN]" : ""}` });
+  if (unwiredReports.length > 0) {
+    console.log(`[+] Unwired ${unwiredReports.length} coding agent(s):`);
+    for (const r of unwiredReports) {
       console.log(`  * ${r.agentName}: ${r.message}`);
     }
   }
   if (purge) {
-    const ctx = requireRoot(flags);
-    if (ctx && existsSync33(ctx.memoryDir) && !dryRun) {
-      const { rmSync: rmSync3 } = await import("node:fs");
-      rmSync3(ctx.memoryDir, { recursive: true, force: true });
-      console.log(`  [PURGED] Memory directory removed: ${ctx.memoryDir}`);
-    }
+    console.log(`
+[PURGED] Memory directory removed successfully.`);
   } else {
     console.log(`
-[INFO] Memory files preserved in .memory/. Use 'memory uninstall --purge' to remove data.`);
+[INFO] Memory files preserved in .memory/. (Use 'memory uninstall --purge' to remove data).`);
   }
   return 0;
 }
 async function handleInitCommand({ positional, flags }) {
   const isGlobal = flags["global"] === "true";
-  const targetDir = positional[0] ? join30(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() : join30(targetDir, memoryDirName);
-  mkdirSync18(join30(memoryDir, "memories"), { recursive: true });
-  const currentPath = join30(memoryDir, "CURRENT.md");
-  if (!existsSync33(currentPath)) {
-    writeFileSync17(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) {
@@ -28468,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,
@@ -28576,8 +29246,8 @@ var init_ecosystem = __esm(() => {
 });
 
 // src/agentcontract.ts
-import { existsSync as existsSync34 } from "node:fs";
-import { join as join31 } 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;
@@ -28609,17 +29279,17 @@ function parseAgentMemoryContract(markdown) {
 function resolveAgentFile(nameOrPath, workspaceRoot) {
   if (!nameOrPath)
     return null;
-  if (existsSync34(nameOrPath))
+  if (existsSync36(nameOrPath))
     return nameOrPath;
   const candidates = [
-    join31(workspaceRoot, ".agents", `${nameOrPath}.md`),
-    join31(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(join31(home, ".config", "opencode", "agents", `${nameOrPath}.md`));
+    candidates.push(join33(home, ".config", "opencode", "agents", `${nameOrPath}.md`));
   for (const c of candidates) {
-    if (existsSync34(c))
+    if (existsSync36(c))
       return c;
   }
   return null;
@@ -28629,8 +29299,8 @@ var init_agentcontract = __esm(() => {
 });
 
 // src/cli/retrieval.ts
-import { existsSync as existsSync35, readFileSync as readFileSync26 } from "node:fs";
-import { join as join32 } 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;
@@ -28638,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(readFileSync26(file, "utf8"));
+    const contract = parseAgentMemoryContract(readFileSync28(file, "utf8"));
     if (contract) {
       agentTypes = contract.types;
       agentTags = contract.tags;
@@ -28778,7 +29448,7 @@ async function handleHarvestCommand({ positional, flags }) {
   const project = flags["project"];
   if (!project)
     return usageError("harvest requires --project");
-  const rawText = existsSync35(target) ? readFileSync26(target, "utf8") : target;
+  const rawText = existsSync37(target) ? readFileSync28(target, "utf8") : target;
   const created = harvestMemories(ctx.store, {
     text: rawText,
     project,
@@ -28814,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 : join32(process.cwd(), filePath) : join32(process.cwd(), "transcript.jsonl");
-  if (!existsSync35(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;
@@ -28831,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 -> ${join32(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 }) {
@@ -29222,7 +29892,7 @@ var init_entities2 = __esm(() => {
 });
 
 // src/cli/settings.ts
-import { writeFileSync as writeFileSync18, readFileSync as readFileSync27 } from "node:fs";
+import { writeFileSync as writeFileSync20, readFileSync as readFileSync29 } from "node:fs";
 function handleSettingsCommand(parsed) {
   const ctx = requireRoot(parsed.flags);
   if (!ctx)
@@ -29304,7 +29974,7 @@ function handleSettingsCommand(parsed) {
     const out = parsed.flags.out;
     const json2 = exportSettings(memoryDir);
     if (out) {
-      writeFileSync18(out, json2, "utf8");
+      writeFileSync20(out, json2, "utf8");
       console.log(`Exported settings to ${out}`);
     } else {
       console.log(json2);
@@ -29318,7 +29988,7 @@ function handleSettingsCommand(parsed) {
       return 2;
     }
     try {
-      const raw = readFileSync27(file, "utf8");
+      const raw = readFileSync29(file, "utf8");
       importSettings(memoryDir, raw);
       console.log(`Successfully imported settings from ${file}`);
       return 0;
@@ -29341,16 +30011,16 @@ var init_nudge = __esm(() => {
 });
 
 // src/routines.ts
-import { readFileSync as readFileSync28, existsSync as existsSync36 } from "node:fs";
-import { join as join33 } from "node:path";
+import { readFileSync as readFileSync30, existsSync as existsSync38 } from "node:fs";
+import { join as join35 } from "node:path";
 function routinesPath(memoryDir) {
-  return join33(memoryDir, "routines.yaml");
+  return join35(memoryDir, "routines.yaml");
 }
 function loadRoutines(memoryDir) {
   const p = routinesPath(memoryDir);
-  if (!existsSync36(p))
+  if (!existsSync38(p))
     return { routines: {} };
-  const doc2 = yaml.load(readFileSync28(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()) {
@@ -29388,7 +30058,7 @@ var init_routines = __esm(() => {
 });
 
 // src/cli/lifecycle.ts
-import { writeFileSync as writeFileSync19, readFileSync as readFileSync29, existsSync as existsSync37 } 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)
@@ -29537,7 +30207,7 @@ async function handleExportCommand({ flags }) {
   const snapshot = exportSnapshot(ctx.store);
   const outPath = flags["out"];
   if (outPath) {
-    writeFileSync19(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));
@@ -29551,9 +30221,9 @@ async function handleImportCommand({ positional, flags }) {
   const file = positional[0];
   if (!file)
     return usageError("import requires <file.json>");
-  if (!existsSync37(file))
+  if (!existsSync39(file))
     return fail(`error: file ${file} does not exist`);
-  const raw = JSON.parse(readFileSync29(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:`);
@@ -29918,6 +30588,9 @@ async function main(argv) {
   switch (cmd) {
     case "install":
       return handleInstallCommand(parsed);
+    case "upgrade":
+    case "update":
+      return handleUpgradeCommand(parsed);
     case "doctor":
       return handleDoctorCommand(parsed);
     case "uninstall":
@@ -29958,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":
@@ -30043,6 +30719,7 @@ Usage:
 
 Core Memory Lifecycle Commands:
   install [dir]                 Run interactive onboarding wizard & auto-wire installed agents
+  upgrade / update [--check]    Auto-fetch latest release, self-heal, and sync agent platforms
   doctor [dir]                  Run comprehensive ecosystem health diagnostic
   uninstall [agent] [--purge]   Disconnect agents and optionally purge .memory data
   init [dir]                    Initialize .memory/ in workspace or current dir
@@ -30090,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)
@@ -30105,6 +30783,8 @@ Ecosystem, Migration & Connectivity:
 var init_cli = __esm(() => {
   init_shared();
   init_ecosystem();
+  init_upgrade();
+  init_harvester();
   init_retrieval3();
   init_persona();
   init_wiki2();