musememory 1.9.0 → 1.11.0

package/dist/index.js

@@ -68,6 +68,13 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/secrets.ts
+var exports_secrets = {};
+__export(exports_secrets, {
+  SECRET_RULES: () => SECRET_RULES,
+  hasSecret: () => hasSecret,
+  redactSecrets: () => redactSecrets,
+  scanSecrets: () => scanSecrets
+});
 function scanSecrets(text) {
   if (!text || typeof text !== "string")
     return [];
@@ -79,6 +86,11 @@ function scanSecrets(text) {
   }
   return matches;
 }
+function hasSecret(text) {
+  if (!text || typeof text !== "string")
+    return false;
+  return SECRET_RULES.some((rule) => rule.pattern.test(text));
+}
 function redactSecrets(text) {
   if (!text || typeof text !== "string")
     return text;
@@ -4857,7 +4869,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 +4895,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 +4913,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";
@@ -5265,6 +5304,30 @@ var sqliteDriver = "none";
 var init_sqlite = () => {};
 
 // src/store.ts
+var exports_store = {};
+__export(exports_store, {
+  addConstraint: () => addConstraint,
+  confirm: () => confirm,
+  deleteEntry: () => deleteEntry,
+  extractEntryText: () => extractEntryText,
+  fileForId: () => fileForId,
+  get: () => get2,
+  getStorageLayout: () => getStorageLayout,
+  harvestMemories: () => harvestMemories,
+  link: () => link2,
+  list: () => list,
+  listIds: () => listIds,
+  makeId: () => makeId,
+  markStale: () => markStale,
+  markSuperseded: () => markSuperseded,
+  nowIso: () => nowIso2,
+  openStore: () => openStore,
+  propose: () => propose,
+  reject: () => reject,
+  save: () => save,
+  slugifyId: () => slugifyId,
+  supersede: () => supersede
+});
 import { resolve } from "node:path";
 import { readdirSync as readdirSync2, readFileSync as readFileSync8, writeFileSync as writeFileSync5, renameSync, unlinkSync, mkdirSync as mkdirSync7, existsSync as existsSync10 } from "node:fs";
 import { join as join7 } from "node:path";
@@ -9031,18 +9094,48 @@ var init_hook = __esm(() => {
 // src/cli/upgrade.ts
 var exports_upgrade = {};
 __export(exports_upgrade, {
+  DEFAULT_PANDA_FRAMES: () => DEFAULT_PANDA_FRAMES,
   detectPackageManager: () => detectPackageManager,
   executePackageUpgrade: () => executePackageUpgrade,
+  formatPandaProgressBar: () => formatPandaProgressBar,
   formatProgressBar: () => formatProgressBar,
   getLatestNpmVersion: () => getLatestNpmVersion,
   getUpgradeMilestones: () => getUpgradeMilestones,
   handleUpgradeCommand: () => handleUpgradeCommand,
   playGamifiedLoader: () => playGamifiedLoader,
+  playPandaLoader: () => playPandaLoader,
   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 formatPandaProgressBar(percent, width = 20, options = {}) {
+  const p = Math.max(0, Math.min(100, percent));
+  const trailChar = options.trailChar ?? "━";
+  const trackChar = options.trackChar ?? "─";
+  const target = options.target;
+  const frame = options.frame ?? 0;
+  let pandaChar = "ʕ•ᴥ•ʔ";
+  if (Array.isArray(options.panda) && options.panda.length > 0) {
+    pandaChar = options.panda[frame % options.panda.length];
+  } else if (typeof options.panda === "string") {
+    pandaChar = options.panda;
+  }
+  const pos = Math.round(p / 100 * width);
+  const trail = trailChar.repeat(pos);
+  let empty = "";
+  if (target) {
+    if (pos >= width) {
+      empty = target;
+    } else {
+      const remaining = width - pos;
+      empty = trackChar.repeat(remaining) + target;
+    }
+  } else {
+    empty = trackChar.repeat(Math.max(0, width - pos));
+  }
+  return `[${trail}${pandaChar}${empty}] ${Math.round(p)}%`;
+}
 function formatProgressBar(percent, width = 20) {
   const p = Math.max(0, Math.min(100, percent));
   const filledCount = Math.round(p / 100 * width);
@@ -9123,36 +9216,110 @@ function getUpgradeMilestones() {
     }
   ];
 }
-async function playGamifiedLoader(steps, options = {}) {
-  const isTTY = process.stdout.isTTY;
+async function playPandaLoader(steps, options = {}) {
+  const stream = options.stream ?? process.stdout;
+  const isTTY = options.isTTY ?? (typeof stream.isTTY === "boolean" ? stream.isTTY : process.stdout.isTTY ?? false);
+  const width = options.width ?? 20;
   const total = steps.length;
-  console.log(`
-┌──────────────────────────────────────────────────────────────────┐`);
-  console.log(`│  \uD83E\uDDE0 MUSE MEMORY · ${options.title || "SYSTEM LEVEL-UP & RECOVERY MATRIX"}  │`);
-  console.log(`└──────────────────────────────────────────────────────────────────┘
-`);
+  const tickIntervalMs = options.tickIntervalMs ?? 60;
+  const target = options.target;
+  const panda = options.panda ?? DEFAULT_PANDA_FRAMES;
+  const cleanTitle = options.title || "SYSTEM LEVEL-UP & RECOVERY MATRIX";
+  const titleLine = `
+┌──────────────────────────────────────────────────────────────────┐
+│  \uD83E\uDDE0 MUSE MEMORY · ${cleanTitle.padEnd(46)}│
+└──────────────────────────────────────────────────────────────────┘
+`;
+  stream.write(titleLine);
+  let frameIndex = 0;
+  let currentPercent = 0;
   for (let i = 0;i < total; i++) {
     const step = steps[i];
-    const percent = Math.round((i + 1) / total * 100);
-    const bar = formatProgressBar(percent, 24);
+    const targetPercent = Math.round((i + 1) / total * 100);
+    const stepStartPercent = Math.round(i / total * 100);
+    currentPercent = stepStartPercent;
+    let timer = null;
     if (isTTY) {
-      process.stdout.write(`  ${bar} ⚡ LEVEL ${step.level}: ${step.title}...\r`);
+      timer = setInterval(() => {
+        frameIndex++;
+        if (currentPercent < targetPercent - 1) {
+          currentPercent += Math.max(0.5, (targetPercent - currentPercent) * 0.15);
+        }
+        const bar2 = formatPandaProgressBar(Math.round(currentPercent), width, {
+          panda,
+          frame: frameIndex,
+          target,
+          trailChar: options.trailChar,
+          trackChar: options.trackChar
+        });
+        stream.write(`\r\x1B[K  ${bar2} \uD83D\uDC3E [${i + 1}/${total}] ${step.title}...`);
+      }, tickIntervalMs);
+      const bar = formatPandaProgressBar(stepStartPercent, width, {
+        panda,
+        frame: frameIndex,
+        target,
+        trailChar: options.trailChar,
+        trackChar: options.trackChar
+      });
+      stream.write(`\r\x1B[K  ${bar} \uD83D\uDC3E [${i + 1}/${total}] ${step.title}...`);
     } else {
-      console.log(`  ${bar} ⚡ LEVEL ${step.level}: ${step.title}`);
+      const bar = formatPandaProgressBar(targetPercent, width, {
+        panda,
+        frame: i,
+        target,
+        trailChar: options.trailChar,
+        trackChar: options.trackChar
+      });
+      stream.write(`  ${bar} \uD83D\uDC3E [${i + 1}/${total}] ${step.title}
+`);
     }
     try {
       await step.action();
     } catch (err) {
-      console.log(`
-  [!] Warning during step "${step.title}": ${err.message || err}`);
+      if (timer)
+        clearInterval(timer);
+      if (isTTY) {
+        stream.write(`
+  [!] Warning during step "${step.title}": ${err.message || err}
+`);
+      } else {
+        stream.write(`  [!] Warning during step "${step.title}": ${err.message || err}
+`);
+      }
+    } finally {
+      if (timer)
+        clearInterval(timer);
     }
     if (isTTY) {
-      await new Promise((r) => setTimeout(r, 60));
-      process.stdout.write(`  ${bar} ✓ LEVEL ${step.level}: ${step.title} [OK]
-`);
+      currentPercent = targetPercent;
+      frameIndex++;
+      const bar = formatPandaProgressBar(targetPercent, width, {
+        panda,
+        frame: frameIndex,
+        target,
+        trailChar: options.trailChar,
+        trackChar: options.trackChar
+      });
+      stream.write(`\r\x1B[K  ${bar} ✓ [${i + 1}/${total}] ${step.title} [OK]`);
+      await new Promise((r) => setTimeout(r, 40));
     }
   }
-  console.log();
+  const finalBar = formatPandaProgressBar(100, width, {
+    panda,
+    frame: frameIndex,
+    target: target ?? "\uD83C\uDF8B",
+    trailChar: options.trailChar,
+    trackChar: options.trackChar
+  });
+  if (isTTY) {
+    stream.write(`\r\x1B[K  ${finalBar} ✨ [${total}/${total}] Complete!
+
+`);
+  } else {
+    stream.write(`  ${finalBar} ✨ [${total}/${total}] Complete!
+
+`);
+  }
 }
 async function repairInstallation(options = {}) {
   const root = options.workspaceRoot || process.cwd();
@@ -9311,12 +9478,20 @@ async function handleUpgradeCommand({ flags }) {
 `);
   return 0;
 }
+var DEFAULT_PANDA_FRAMES, playGamifiedLoader;
 var init_upgrade = __esm(() => {
   init_root();
   init_user();
   init_connect();
   init_graph();
   init_hook();
+  DEFAULT_PANDA_FRAMES = [
+    "ʕ•ᴥ•ʔ",
+    "ʕ •ᴥ•ʔ",
+    "ʕ-ᴥ-ʔ",
+    "ʕ•ᴥ•ʔﾉ"
+  ];
+  playGamifiedLoader = playPandaLoader;
 });
 
 // node_modules/ajv/dist/compile/codegen/code.js
@@ -15746,19 +15921,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 +16197,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 +16221,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 +16244,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 +16282,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 +16344,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 +16381,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 +16491,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 +16500,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 +16518,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 +16579,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 +16591,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 +16744,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 +16794,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 +16875,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 +16953,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 +17019,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 +17049,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 +17058,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 +17078,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 +17111,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 +17150,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, {
@@ -16765,6 +17206,8 @@ var init_retrieval2 = __esm(() => {
 });
 
 // src/snapshot.ts
+import { existsSync as existsSync30, readFileSync as readFileSync25, writeFileSync as writeFileSync16, mkdirSync as mkdirSync18, readdirSync as readdirSync11 } from "node:fs";
+import { join as join27, relative as relative2 } from "node:path";
 function exportSnapshot(store) {
   const entries = list(store);
   return {
@@ -16813,6 +17256,106 @@ function importSnapshot(store, snapshot, options = {}) {
   }
   return { imported, skipped, errors };
 }
+function freezeExecutionSnapshot(options) {
+  const { workspaceRoot, memoryDir } = options;
+  const runId = options.runId ?? `run_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+  const timestamp2 = new Date().toISOString();
+  let task = options.task;
+  if (existsSync30(task)) {
+    try {
+      task = readFileSync25(task, "utf-8").trim();
+    } catch {}
+  }
+  let gitCommit;
+  try {
+    const { execSync: execSync3 } = __require("node:child_process");
+    gitCommit = execSync3("git rev-parse HEAD", { cwd: workspaceRoot, stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+  } catch {
+    gitCommit = undefined;
+  }
+  const currentPath = join27(memoryDir, "CURRENT.md");
+  let constraints = [];
+  if (existsSync30(currentPath)) {
+    const currentContent = readFileSync25(currentPath, "utf-8");
+    constraints = currentContent.split(`
+`).map((l) => l.trim()).filter((l) => l.startsWith("- ") || l.startsWith("* ")).map((l) => l.replace(/^[-*]\s+/, ""));
+  }
+  const { createHash: createHash3 } = __require("node:crypto");
+  const entries = options.store ? list(options.store) : [];
+  const memory_hashes = entries.map((e) => {
+    const contentToHash = `${e.id}
+${e.title}
+${e.content}
+${e.status}
+${e.type ?? ""}`;
+    const hash = createHash3("sha256").update(contentToHash).digest("hex");
+    return {
+      id: e.id,
+      title: e.title,
+      type: e.type,
+      hash
+    };
+  });
+  const file_inventory = [];
+  function scanDir(dir, base) {
+    if (!existsSync30(dir))
+      return;
+    const items = readdirSync11(dir, { withFileTypes: true });
+    for (const item of items) {
+      if (item.name === "node_modules" || item.name === ".git" || item.name === ".memory")
+        continue;
+      const fullPath = join27(dir, item.name);
+      const relPath = relative2(base, fullPath);
+      if (item.isDirectory()) {
+        scanDir(fullPath, base);
+      } else {
+        file_inventory.push(relPath);
+      }
+    }
+  }
+  scanDir(workspaceRoot, workspaceRoot);
+  const snapshot = {
+    run_id: runId,
+    task,
+    timestamp: timestamp2,
+    git_commit: gitCommit,
+    constraints,
+    memory_hashes,
+    file_inventory,
+    metadata: options.metadata
+  };
+  const safeRunId = runId.replace(/[^a-zA-Z0-9_\-\.]/g, "_");
+  const runDir = join27(memoryDir, "runs", safeRunId);
+  mkdirSync18(runDir, { recursive: true });
+  writeFileSync16(join27(runDir, "snapshot.json"), JSON.stringify(snapshot, null, 2), "utf-8");
+  return snapshot;
+}
+function loadExecutionSnapshot(memoryDir, runId) {
+  const safeRunId = runId.replace(/[^a-zA-Z0-9_\-\.]/g, "_");
+  const snapshotPath = join27(memoryDir, "runs", safeRunId, "snapshot.json");
+  if (!existsSync30(snapshotPath))
+    return null;
+  try {
+    return JSON.parse(readFileSync25(snapshotPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function listExecutionSnapshots(memoryDir) {
+  const runsDir = join27(memoryDir, "runs");
+  if (!existsSync30(runsDir))
+    return [];
+  const entries = readdirSync11(runsDir, { withFileTypes: true });
+  const snapshots = [];
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const snap = loadExecutionSnapshot(memoryDir, entry.name);
+      if (snap)
+        snapshots.push(snap);
+    }
+  }
+  return snapshots.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+}
 var init_snapshot = __esm(() => {
   init_store();
   init_schema();
@@ -26405,8 +26948,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 existsSync31, mkdirSync as mkdirSync19, writeFileSync as writeFileSync17 } from "node:fs";
+import { join as join28 } from "node:path";
 function fixTokens(e) {
   const bag = tokenBag(e.title, 2);
   mergeBag(bag, tokenBag((e.tags ?? []).join(" "), 2));
@@ -26417,7 +26960,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 ?? join28(workspaceRoot, ".agents", "skills");
   for (const cluster of clusters) {
     if (cluster.length < minCount) {
       report.clustersBelowThreshold++;
@@ -26425,9 +26968,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 = join28(skillsDir, slug);
     const memberIds = cluster.map((e) => e.id);
-    if (existsSync29(dir)) {
+    if (existsSync31(dir)) {
       report.skippedExisting.push({ slug, members: memberIds });
       continue;
     }
@@ -26437,10 +26980,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");
+      mkdirSync19(dir, { recursive: true });
+      writeFileSync17(join28(dir, "SKILL.md"), md, "utf8");
     }
-    report.created.push({ slug, path: join26(dir, "SKILL.md"), members: memberIds });
+    report.created.push({ slug, path: join28(dir, "SKILL.md"), members: memberIds });
   }
   return report;
 }
@@ -26479,6 +27022,183 @@ var init_distill = __esm(() => {
   init_consolidate();
 });
 
+// src/provenance.ts
+var exports_provenance = {};
+__export(exports_provenance, {
+  addSource: () => addSource,
+  findSources: () => findSources,
+  getSource: () => getSource,
+  getSourcesFilePath: () => getSourcesFilePath,
+  listSources: () => listSources,
+  loadSources: () => loadSources,
+  saveSources: () => saveSources
+});
+import { existsSync as existsSync32, readFileSync as readFileSync26, writeFileSync as writeFileSync18, mkdirSync as mkdirSync20 } from "node:fs";
+import { join as join29 } from "node:path";
+function getSourcesFilePath(memoryDir) {
+  return join29(memoryDir, "sources.json");
+}
+function loadSources(memoryDir) {
+  const filePath = getSourcesFilePath(memoryDir);
+  if (!existsSync32(filePath)) {
+    return [];
+  }
+  try {
+    const raw = readFileSync26(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function saveSources(memoryDir, sources) {
+  mkdirSync20(memoryDir, { recursive: true });
+  const filePath = getSourcesFilePath(memoryDir);
+  writeFileSync18(filePath, JSON.stringify(sources, null, 2), "utf-8");
+}
+function addSource(memoryDir, input) {
+  const textToScan = `${input.title}
+${input.url}
+${input.excerpt ?? ""}
+${input.author ?? ""}`;
+  const secrets = scanSecrets(textToScan);
+  if (secrets.length > 0) {
+    throw new Error(`Vibeguard: Detected secret in source data: ${secrets.join(", ")}`);
+  }
+  const sources = loadSources(memoryDir);
+  const id = input.id ?? `src_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+  const retrieved_at = input.retrieved_at ?? new Date().toISOString();
+  const sourceEntry = {
+    id,
+    url: input.url,
+    title: input.title,
+    source_type: input.source_type ?? "documentation",
+    excerpt: input.excerpt,
+    author: input.author,
+    retrieved_at,
+    metadata: input.metadata
+  };
+  const existingIdx = sources.findIndex((s) => s.id === id);
+  if (existingIdx >= 0) {
+    sources[existingIdx] = sourceEntry;
+  } else {
+    sources.push(sourceEntry);
+  }
+  saveSources(memoryDir, sources);
+  return sourceEntry;
+}
+function getSource(memoryDir, id) {
+  const sources = loadSources(memoryDir);
+  return sources.find((s) => s.id === id) ?? null;
+}
+function listSources(memoryDir, filter) {
+  let sources = loadSources(memoryDir);
+  if (filter?.source_type) {
+    const st = filter.source_type.toLowerCase();
+    sources = sources.filter((s) => s.source_type.toLowerCase() === st);
+  }
+  if (filter?.query && filter.query.trim()) {
+    const q = filter.query.toLowerCase().trim();
+    sources = sources.filter((s) => s.title.toLowerCase().includes(q) || s.url.toLowerCase().includes(q) || s.excerpt && s.excerpt.toLowerCase().includes(q) || s.author && s.author.toLowerCase().includes(q));
+  }
+  return sources;
+}
+function findSources(memoryDir, query) {
+  return listSources(memoryDir, { query });
+}
+var init_provenance = __esm(() => {
+  init_secrets();
+});
+
+// src/claims.ts
+var exports_claims = {};
+__export(exports_claims, {
+  findClaims: () => findClaims,
+  getClaim: () => getClaim,
+  getClaimsFilePath: () => getClaimsFilePath,
+  listClaims: () => listClaims,
+  loadClaims: () => loadClaims,
+  recordClaim: () => recordClaim,
+  saveClaims: () => saveClaims
+});
+import { existsSync as existsSync33, readFileSync as readFileSync27, writeFileSync as writeFileSync19, mkdirSync as mkdirSync21 } from "node:fs";
+import { join as join30 } from "node:path";
+function getClaimsFilePath(memoryDir) {
+  return join30(memoryDir, "claims.json");
+}
+function loadClaims(memoryDir) {
+  const filePath = getClaimsFilePath(memoryDir);
+  if (!existsSync33(filePath)) {
+    return [];
+  }
+  try {
+    const raw = readFileSync27(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function saveClaims(memoryDir, claims) {
+  mkdirSync21(memoryDir, { recursive: true });
+  const filePath = getClaimsFilePath(memoryDir);
+  writeFileSync19(filePath, JSON.stringify(claims, null, 2), "utf-8");
+}
+function recordClaim(memoryDir, input) {
+  const textToScan = `${input.claim}
+${input.notes ?? ""}`;
+  const secrets = scanSecrets(textToScan);
+  if (secrets.length > 0) {
+    throw new Error(`Vibeguard: Detected secret in claim: ${secrets.join(", ")}`);
+  }
+  const claims = loadClaims(memoryDir);
+  const id = input.id ?? `clm_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+  const created_at = input.created_at ?? new Date().toISOString();
+  const claimEntry = {
+    id,
+    claim: input.claim,
+    confidence_tag: input.confidence_tag ?? "INFER",
+    source_ids: input.source_ids ?? [],
+    memory_ids: input.memory_ids ?? [],
+    notes: input.notes,
+    created_at,
+    verified: input.verified ?? false
+  };
+  const existingIdx = claims.findIndex((c) => c.id === id);
+  if (existingIdx >= 0) {
+    claims[existingIdx] = claimEntry;
+  } else {
+    claims.push(claimEntry);
+  }
+  saveClaims(memoryDir, claims);
+  return claimEntry;
+}
+function getClaim(memoryDir, id) {
+  const claims = loadClaims(memoryDir);
+  return claims.find((c) => c.id === id) ?? null;
+}
+function listClaims(memoryDir, filter) {
+  let claims = loadClaims(memoryDir);
+  if (filter?.confidence_tag) {
+    const tag = filter.confidence_tag.toUpperCase();
+    claims = claims.filter((c) => c.confidence_tag.toUpperCase() === tag);
+  }
+  if (filter?.verified !== undefined) {
+    claims = claims.filter((c) => !!c.verified === filter.verified);
+  }
+  if (filter?.query && filter.query.trim()) {
+    const q = filter.query.toLowerCase().trim();
+    claims = claims.filter((c) => c.claim.toLowerCase().includes(q) || c.notes && c.notes.toLowerCase().includes(q));
+  }
+  return claims;
+}
+function findClaims(memoryDir, query) {
+  return listClaims(memoryDir, { query });
+}
+var init_claims = __esm(() => {
+  init_secrets();
+});
+
 // src/verify.ts
 import { execFile } from "node:child_process";
 function runCommand(command, cwd, timeoutSec) {
@@ -26565,41 +27285,213 @@ ${result.stderr}`.trim().slice(0, 2000)
   }
   return result;
 }
-var init_verify = __esm(() => {
-  init_store();
-  init_audit();
-});
-
-// src/sessions.ts
-var init_sessions = __esm(() => {
-  init_governor();
-});
-// src/entities/index.ts
-var init_entities = __esm(() => {
-  init_extractor();
-});
-// src/pageindex/index.ts
-var init_pageindex = __esm(() => {
-  init_engine2();
-});
-// src/settings/defaults.ts
-var DEFAULT_SETTINGS;
-var init_defaults = __esm(() => {
-  DEFAULT_SETTINGS = {
-    version: 1,
-    retrieval: {
-      defaultMode: "hybrid",
-      defaultTokenBudget: 2000,
-      defaultDisclosureDepth: "L2",
-      treeMaxDepth: 5,
-      enableLLMReasoning: false,
-      hybridVectorWeight: 0.5,
-      hybridTreeWeight: 0.5
-    },
-    wiki: {
-      autoCompile: false,
-      compileIntervalMinutes: 60,
-      minClusterSize: 3,
+function verifyStrictIntegrity(store, memoryDir, workspaceRoot, options = {}) {
+  const { existsSync: existsSync34, readFileSync: readFileSync28, readdirSync: readdirSync12 } = __require("node:fs");
+  const { join: join31 } = __require("node:path");
+  const { scanSecrets: scanSecrets2 } = (init_secrets(), __toCommonJS(exports_secrets));
+  const { list: list2 } = (init_store(), __toCommonJS(exports_store));
+  const { loadSources: loadSources2 } = (init_provenance(), __toCommonJS(exports_provenance));
+  const { loadClaims: loadClaims2 } = (init_claims(), __toCommonJS(exports_claims));
+  const checks4 = [];
+  const entries = list2(store);
+  const entryMap = new Map(entries.map((e) => [e.id, e]));
+  const secretErrors = [];
+  for (const e of entries) {
+    const text = `${e.title}
+${e.content}
+${(e.tags ?? []).join(" ")}`;
+    const found = scanSecrets2(text);
+    if (found.length > 0) {
+      secretErrors.push(`Secret detected in memory ${e.id}: ${found.join(", ")}`);
+    }
+  }
+  const currentPath = join31(memoryDir, "CURRENT.md");
+  if (existsSync34(currentPath)) {
+    const found = scanSecrets2(readFileSync28(currentPath, "utf-8"));
+    if (found.length > 0)
+      secretErrors.push(`Secret detected in CURRENT.md: ${found.join(", ")}`);
+  }
+  const userPath = join31(memoryDir, "USER.md");
+  if (existsSync34(userPath)) {
+    const found = scanSecrets2(readFileSync28(userPath, "utf-8"));
+    if (found.length > 0)
+      secretErrors.push(`Secret detected in USER.md: ${found.join(", ")}`);
+  }
+  checks4.push({
+    name: "zero_secret_leakage",
+    passed: secretErrors.length === 0,
+    message: secretErrors.length === 0 ? "Zero secret credentials detected" : `Found ${secretErrors.length} leaked secret(s)`,
+    errors: secretErrors.length > 0 ? secretErrors : undefined
+  });
+  const refErrors = [];
+  for (const e of entries) {
+    if (e.supersedes) {
+      const targets = Array.isArray(e.supersedes) ? e.supersedes : [e.supersedes];
+      for (const t of targets) {
+        if (t && !entryMap.has(t)) {
+          refErrors.push(`Entry ${e.id} references non-existent supersedes ID: ${t}`);
+        }
+      }
+    }
+    if (e.superseded_by) {
+      const targets = Array.isArray(e.superseded_by) ? e.superseded_by : [e.superseded_by];
+      for (const t of targets) {
+        if (t && !entryMap.has(t)) {
+          refErrors.push(`Entry ${e.id} references non-existent superseded_by ID: ${t}`);
+        }
+      }
+    }
+    if (e.related_memory_ids) {
+      for (const r of e.related_memory_ids) {
+        if (!entryMap.has(r)) {
+          refErrors.push(`Entry ${e.id} references non-existent related memory ID: ${r}`);
+        }
+      }
+    }
+  }
+  checks4.push({
+    name: "referential_integrity",
+    passed: refErrors.length === 0,
+    message: refErrors.length === 0 ? "All graph links resolve cleanly" : `Found ${refErrors.length} broken reference(s)`,
+    errors: refErrors.length > 0 ? refErrors : undefined
+  });
+  const claimErrors = [];
+  const sources = loadSources2(memoryDir);
+  const sourceIds = new Set(sources.map((s) => s.id));
+  const claims = loadClaims2(memoryDir);
+  for (const c of claims) {
+    if (c.source_ids) {
+      for (const sid of c.source_ids) {
+        if (!sourceIds.has(sid)) {
+          claimErrors.push(`Claim ${c.id} references missing source ID: ${sid}`);
+        }
+      }
+    }
+    if (c.memory_ids) {
+      for (const mid of c.memory_ids) {
+        if (!entryMap.has(mid)) {
+          claimErrors.push(`Claim ${c.id} references missing memory ID: ${mid}`);
+        }
+      }
+    }
+  }
+  checks4.push({
+    name: "claim_sources",
+    passed: claimErrors.length === 0,
+    message: claimErrors.length === 0 ? "All claims mapped to valid sources" : `Found ${claimErrors.length} unmapped claim reference(s)`,
+    errors: claimErrors.length > 0 ? claimErrors : undefined
+  });
+  const wikiErrors = [];
+  const wikiDir = join31(memoryDir, "wiki");
+  if (existsSync34(wikiDir)) {
+    let collectSlugs = function(dir) {
+      const items = readdirSync12(dir, { withFileTypes: true });
+      for (const it of items) {
+        const full = join31(dir, it.name);
+        if (it.isDirectory()) {
+          collectSlugs(full);
+        } else if (it.name.endsWith(".md")) {
+          knownSlugs.add(it.name.replace(/\.md$/, "").toLowerCase());
+          const { relative: relative3 } = __require("node:path");
+          knownSlugs.add(relative3(wikiDir, full).replace(/\.md$/, "").toLowerCase());
+        }
+      }
+    }, scanWikilinks = function(dir) {
+      const items = readdirSync12(dir, { withFileTypes: true });
+      for (const it of items) {
+        const full = join31(dir, it.name);
+        if (it.isDirectory()) {
+          scanWikilinks(full);
+        } else if (it.name.endsWith(".md")) {
+          const content = readFileSync28(full, "utf-8");
+          const matches = content.matchAll(/\[\[([a-zA-Z0-9_\-\./ ]+?)(?:\|[^\r\n\]]+)?\]\]/g);
+          for (const m of matches) {
+            const rawTarget = m[1].trim().toLowerCase();
+            if (!rawTarget || rawTarget.startsWith("type:") || rawTarget.startsWith("tag:") || rawTarget.length <= 1) {
+              continue;
+            }
+            if (!knownSlugs.has(rawTarget)) {
+              wikiErrors.push(`Wikilink [[${m[1]}]] in ${it.name} does not resolve to any wiki page.`);
+            }
+          }
+        }
+      }
+    };
+    const knownSlugs = new Set;
+    collectSlugs(wikiDir);
+    for (const id of entryMap.keys()) {
+      knownSlugs.add(id.toLowerCase());
+    }
+    scanWikilinks(wikiDir);
+  }
+  checks4.push({
+    name: "wikilink_resolution",
+    passed: wikiErrors.length === 0,
+    message: wikiErrors.length === 0 ? "All wikilinks resolve cleanly" : `Found ${wikiErrors.length} broken wikilink(s)`,
+    errors: wikiErrors.length > 0 ? wikiErrors : undefined
+  });
+  const candidateErrors = [];
+  const maxDays = options.maxCandidateDays ?? 90;
+  const cutoff = Date.now() - maxDays * 86400000;
+  for (const e of entries) {
+    if (e.status === "candidate") {
+      const created = new Date(e.created_at).getTime();
+      if (!isNaN(created) && created < cutoff) {
+        candidateErrors.push(`Candidate memory ${e.id} ("${e.title}") has been orphaned for > ${maxDays} days without review.`);
+      }
+    }
+  }
+  checks4.push({
+    name: "candidate_retention",
+    passed: candidateErrors.length === 0,
+    message: candidateErrors.length === 0 ? "No orphaned candidates" : `Found ${candidateErrors.length} orphaned candidate(s)`,
+    errors: candidateErrors.length > 0 ? candidateErrors : undefined
+  });
+  const failedChecks = checks4.filter((c) => !c.passed).length;
+  const passedChecks = checks4.filter((c) => c.passed).length;
+  return {
+    ok: failedChecks === 0,
+    totalChecks: checks4.length,
+    passedChecks,
+    failedChecks,
+    checks: checks4
+  };
+}
+var init_verify = __esm(() => {
+  init_store();
+  init_audit();
+});
+
+// src/sessions.ts
+var init_sessions = __esm(() => {
+  init_governor();
+});
+// src/entities/index.ts
+var init_entities = __esm(() => {
+  init_extractor();
+});
+// src/pageindex/index.ts
+var init_pageindex = __esm(() => {
+  init_engine2();
+});
+// src/settings/defaults.ts
+var DEFAULT_SETTINGS;
+var init_defaults = __esm(() => {
+  DEFAULT_SETTINGS = {
+    version: 1,
+    retrieval: {
+      defaultMode: "hybrid",
+      defaultTokenBudget: 2000,
+      defaultDisclosureDepth: "L2",
+      treeMaxDepth: 5,
+      enableLLMReasoning: false,
+      hybridVectorWeight: 0.5,
+      hybridTreeWeight: 0.5
+    },
+    wiki: {
+      autoCompile: false,
+      compileIntervalMinutes: 60,
+      minClusterSize: 3,
       clusteringThreshold: 0.5,
       conceptOverlapThreshold: 0.3,
       includeTypes: ["fix", "decision", "architecture", "operation", "failure", "constraint", "preference", "discovery"],
@@ -26778,14 +27670,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 existsSync34, mkdirSync as mkdirSync22, readFileSync as readFileSync28, writeFileSync as writeFileSync20 } from "node:fs";
+import { join as join31 } from "node:path";
 function getSettingsFilePath(memoryDir) {
-  return join27(memoryDir, "settings.json");
+  return join31(memoryDir, "settings.json");
 }
 function loadSettings(memoryDir) {
   const filePath = getSettingsFilePath(memoryDir);
-  if (!existsSync30(filePath)) {
+  if (!existsSync34(filePath)) {
     return {
       version: 1,
       global: JSON.parse(JSON.stringify(DEFAULT_SETTINGS)),
@@ -26793,7 +27685,7 @@ function loadSettings(memoryDir) {
     };
   }
   try {
-    const raw = readFileSync24(filePath, "utf8");
+    const raw = readFileSync28(filePath, "utf8");
     const parsed = JSON.parse(raw);
     return {
       version: parsed.version || 1,
@@ -26809,9 +27701,9 @@ function loadSettings(memoryDir) {
   }
 }
 function saveSettings(store, memoryDir) {
-  mkdirSync18(memoryDir, { recursive: true });
+  mkdirSync22(memoryDir, { recursive: true });
   const filePath = getSettingsFilePath(memoryDir);
-  writeFileSync16(filePath, JSON.stringify(store, null, 2), "utf8");
+  writeFileSync20(filePath, JSON.stringify(store, null, 2), "utf8");
 }
 function getSettings(memoryDir) {
   return loadSettings(memoryDir).global;
@@ -26918,6 +27810,510 @@ var init_settings2 = __esm(() => {
   init_settings();
 });
 
+// src/prompts.ts
+import { existsSync as existsSync35, readFileSync as readFileSync29, writeFileSync as writeFileSync21, mkdirSync as mkdirSync23, readdirSync as readdirSync12 } from "node:fs";
+import { join as join32 } from "node:path";
+function getPromptsDir(memoryDir) {
+  if (!memoryDir)
+    return null;
+  return join32(memoryDir, "prompts");
+}
+function listPrompts(memoryDir) {
+  const promptMap = new Map;
+  for (const bp of BUILTIN_PROMPTS) {
+    promptMap.set(bp.name, bp);
+  }
+  const dir = getPromptsDir(memoryDir);
+  if (dir && existsSync35(dir)) {
+    const files = readdirSync12(dir).filter((f) => f.endsWith(".md"));
+    for (const file of files) {
+      const name = file.replace(/\.md$/, "");
+      const fullPath = join32(dir, file);
+      try {
+        const raw = readFileSync29(fullPath, "utf-8");
+        const parsed = parsePromptFile(name, raw);
+        promptMap.set(name, parsed);
+      } catch {}
+    }
+  }
+  return Array.from(promptMap.values());
+}
+function getPrompt(memoryDir, name) {
+  const safeName = name.replace(/[^a-zA-Z0-9_\-\.]/g, "_");
+  const dir = getPromptsDir(memoryDir);
+  if (dir) {
+    const filePath = join32(dir, `${safeName}.md`);
+    if (existsSync35(filePath)) {
+      try {
+        const raw = readFileSync29(filePath, "utf-8");
+        return parsePromptFile(name, raw);
+      } catch {}
+    }
+  }
+  return BUILTIN_PROMPTS.find((p) => p.name === name) ?? null;
+}
+function parsePromptFile(name, content) {
+  if (content.startsWith("---")) {
+    const parts = content.split("---");
+    if (parts.length >= 3) {
+      const yamlBlock = parts[1];
+      const template = parts.slice(2).join("---").trim();
+      let title = name;
+      let description = "";
+      const variables = [];
+      const tags = [];
+      for (const line of yamlBlock.split(`
+`)) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("title:"))
+          title = trimmed.replace("title:", "").trim();
+        if (trimmed.startsWith("description:"))
+          description = trimmed.replace("description:", "").trim();
+        if (trimmed.startsWith("variables:")) {
+          const match = trimmed.match(/\[(.*?)\]/);
+          if (match) {
+            variables.push(...match[1].split(",").map((v) => v.trim()).filter(Boolean));
+          }
+        }
+        if (trimmed.startsWith("tags:")) {
+          const match = trimmed.match(/\[(.*?)\]/);
+          if (match) {
+            tags.push(...match[1].split(",").map((t) => t.trim()).filter(Boolean));
+          }
+        }
+      }
+      return {
+        name,
+        title,
+        description,
+        template,
+        variables: variables.length > 0 ? variables : undefined,
+        tags: tags.length > 0 ? tags : undefined
+      };
+    }
+  }
+  return {
+    name,
+    title: name,
+    description: "",
+    template: content.trim()
+  };
+}
+function renderPrompt(memoryDir, name, args = {}, contextData = {}) {
+  const prompt = getPrompt(memoryDir, name);
+  if (!prompt) {
+    throw new Error(`Prompt template "${name}" not found`);
+  }
+  let text = prompt.template;
+  const nowStr = args.date ?? new Date().toISOString().split("T")[0];
+  text = text.replace(/\{\{date\}\}/g, nowStr);
+  text = text.replace(/\{\{focus\}\}/g, args.focus ?? "General Development");
+  text = text.replace(/\{\{project\}\}/g, args.project ?? "core");
+  text = text.replace(/\{\{target\}\}/g, args.target ?? "release");
+  text = text.replace(/\{\{period\}\}/g, args.period ?? "current sprint");
+  if (memoryDir) {
+    const currentPath = join32(memoryDir, "CURRENT.md");
+    let currentConstraints = "*(None recorded)*";
+    if (existsSync35(currentPath)) {
+      currentConstraints = readFileSync29(currentPath, "utf-8").trim();
+    }
+    text = text.replace(/\{\{current_constraints\}\}/g, currentConstraints);
+    text = text.replace(/\{\{overdue_items\}\}/g, contextData.overdue_items ?? "*(No overdue items)*");
+    text = text.replace(/\{\{recent_discoveries\}\}/g, contextData.recent_discoveries ?? "*(None recorded)*");
+    text = text.replace(/\{\{arch_memories\}\}/g, contextData.arch_memories ?? "*(See .memory/memories/)*");
+  }
+  for (const [key, val] of Object.entries(args)) {
+    const regex = new RegExp(`\\{\\{${key}\\}\\}`, "g");
+    text = text.replace(regex, val);
+  }
+  return text;
+}
+var BUILTIN_PROMPTS;
+var init_prompts = __esm(() => {
+  BUILTIN_PROMPTS = [
+    {
+      name: "morning-standup",
+      title: "Morning Cognitive Standup & Invariant Briefing",
+      description: "Gathers overdue items, active constraints, and recent session discoveries.",
+      variables: ["date", "focus"],
+      tags: ["standup", "planning", "governance"],
+      template: `### Morning Cognitive Standup Briefing
+Date: {{date}}
+Focus: {{focus}}
+
+#### 1. Active Working Constraints (CURRENT.md)
+{{current_constraints}}
+
+#### 2. Overdue & Due-Soon Action Items
+{{overdue_items}}
+
+#### 3. Recent Discoveries & Fixes
+{{recent_discoveries}}
+
+#### Strategic Question:
+What is the highest-leverage task to execute today that satisfies all active invariants?`
+    },
+    {
+      name: "drift-audit",
+      title: "CodeGraph AST Drift Audit",
+      description: "Compares CodeGraph AST symbols against confirmed architectural memories.",
+      variables: ["project"],
+      tags: ["ast", "drift", "audit"],
+      template: `### AST Symbol Drift Audit
+Project: {{project}}
+
+#### 1. Confirmed Architectural Memories & Referenced Symbols
+{{arch_memories}}
+
+#### 2. AST Drift Status
+Scan workspace codebase symbols against memory references. Flag any symbols that were renamed, deleted, or signature-changed without corresponding memory updates.`
+    },
+    {
+      name: "pre-publish-audit",
+      title: "Pre-Publish & Delivery Gate Audit",
+      description: "Scans diffs for secrets, unverified claims, and broken references.",
+      variables: ["target"],
+      tags: ["security", "claims", "verification"],
+      template: `### Pre-Publish Delivery Gate Audit
+Target: {{target}}
+
+1. **Vibeguard Secret Check**: Zero API keys, private tokens, or connection strings in code or documentation.
+2. **Claim Ledger Verification**: All claims tagged with [RAW], [FETCH], [SEARCH], or [INFER] must have valid source references.
+3. **Wikilink & Reference Integrity**: Verify that all interlinked concepts and memory IDs resolve cleanly.
+4. **Test Suite Status**: Confirm all unit and integration tests pass with 0 failures.`
+    },
+    {
+      name: "sprint-compounding",
+      title: "Sprint Knowledge Compounding & Wiki Synthesis",
+      description: "Clusters candidate memories and triggers wiki compilation.",
+      variables: ["period"],
+      tags: ["compounding", "wiki", "synthesis"],
+      template: `### Sprint Knowledge Compounding
+Period: {{period}}
+
+1. Review candidate memories and cluster related insights.
+2. Promote verified candidates to confirmed status.
+3. Mark superseded and decaying entries as stale.
+4. Compile Obsidian-compatible wiki concept pages and update .memory/HOT.md working memory cache.`
+    }
+  ];
+});
+
+// src/compounding/temporal.ts
+import { existsSync as existsSync36, readFileSync as readFileSync30, writeFileSync as writeFileSync22, mkdirSync as mkdirSync24 } from "node:fs";
+import { join as join33 } from "node:path";
+function getPeriodKey(dateInput, period) {
+  const date4 = typeof dateInput === "string" ? new Date(dateInput) : dateInput;
+  const year = date4.getUTCFullYear();
+  const month = date4.getUTCMonth() + 1;
+  if (period === "month") {
+    return `${year}-${String(month).padStart(2, "0")}`;
+  }
+  if (period === "quarter") {
+    const q = Math.ceil(month / 3);
+    return `${year}-Q${q}`;
+  }
+  const target = new Date(date4.valueOf());
+  const dayNr = (date4.getUTCDay() + 6) % 7;
+  target.setUTCDate(target.getUTCDate() - dayNr + 3);
+  const firstThursday = target.valueOf();
+  target.setUTCMonth(0, 1);
+  if (target.getUTCDay() !== 4) {
+    target.setUTCMonth(0, 1 + (4 - target.getUTCDay() + 7) % 7);
+  }
+  const weekNumber = 1 + Math.ceil((firstThursday - target.valueOf()) / 604800000);
+  return `${year}-W${String(weekNumber).padStart(2, "0")}`;
+}
+function compileHotCache(store, memoryDir) {
+  const currentPath = join33(memoryDir, "CURRENT.md");
+  let constraintsBlock = "*(No active constraints)*";
+  if (existsSync36(currentPath)) {
+    constraintsBlock = readFileSync30(currentPath, "utf-8").trim();
+  }
+  const entries = list(store);
+  const confirmed = entries.filter((e) => e.status === "confirmed" || e.status === "active");
+  const archEntries = confirmed.filter((e) => e.type === "architecture").slice(0, 5);
+  const fixEntries = confirmed.filter((e) => e.type === "fix").slice(0, 5);
+  const prefEntries = confirmed.filter((e) => e.type === "preference").slice(0, 5);
+  const lines = [
+    "# HOT Working Memory Cache",
+    `> **Last Compiled**: ${new Date().toISOString()}`,
+    "",
+    "## 1. Active Constraints & Invariants (CURRENT.md)",
+    constraintsBlock,
+    "",
+    "## 2. Key Architecture Invariants"
+  ];
+  if (archEntries.length === 0) {
+    lines.push("*(No confirmed architectural memories)*");
+  } else {
+    for (const e of archEntries) {
+      lines.push(`- **${e.title}** (\`${e.id}\`): ${e.content.slice(0, 140)}...`);
+    }
+  }
+  lines.push("", "## 3. High-Priority Fixes & Workarounds");
+  if (fixEntries.length === 0) {
+    lines.push("*(No confirmed bug fixes)*");
+  } else {
+    for (const e of fixEntries) {
+      lines.push(`- **${e.title}** (\`${e.id}\`): ${e.content.slice(0, 140)}...`);
+    }
+  }
+  if (prefEntries.length > 0) {
+    lines.push("", "## 4. Key Developer Preferences");
+    for (const e of prefEntries) {
+      lines.push(`- **${e.title}**: ${e.content.slice(0, 140)}...`);
+    }
+  }
+  const hotContent = lines.join(`
+`) + `
+`;
+  const hotPath = join33(memoryDir, "HOT.md");
+  mkdirSync24(memoryDir, { recursive: true });
+  writeFileSync22(hotPath, hotContent, "utf-8");
+  return hotPath;
+}
+function rollupTemporal(store, options) {
+  const { memoryDir, period } = options;
+  const targetDate = options.date ?? new Date;
+  const periodKey = getPeriodKey(targetDate, period);
+  let entries = list(store).filter((e) => e.status === "confirmed" || e.status === "active" || e.status === "candidate");
+  if (options.project) {
+    entries = entries.filter((e) => e.project === options.project);
+  }
+  const arch = entries.filter((e) => e.type === "architecture");
+  const fixes = entries.filter((e) => e.type === "fix");
+  const decisions = entries.filter((e) => e.type === "decision");
+  const discoveries = entries.filter((e) => e.type === "discovery");
+  const periodLabel = period === "week" ? "Weekly Synthesis" : period === "month" ? "Monthly Synthesis" : "Quarterly Synthesis";
+  const lines = [
+    `# ${periodLabel}: ${periodKey}`,
+    `> **Compounding Window**: ${periodKey} | **Evaluated Memories**: ${entries.length} | **Generated**: ${new Date().toISOString()}`,
+    "",
+    "## \uD83C\uDFDB️ System Architecture & Invariants"
+  ];
+  if (arch.length === 0) {
+    lines.push("*(No architectural changes in this period)*");
+  } else {
+    for (const a of arch) {
+      lines.push(`- **${a.title}** (\`${a.id}\`) [${a.status}]`);
+      lines.push(`  ${a.content}`);
+    }
+  }
+  lines.push("", "## \uD83D\uDEE0️ Resolved Fixes & Incident Workarounds");
+  if (fixes.length === 0) {
+    lines.push("*(No fixes recorded in this period)*");
+  } else {
+    for (const f of fixes) {
+      lines.push(`- **${f.title}** (\`${f.id}\`)`);
+      lines.push(`  ${f.content}`);
+    }
+  }
+  lines.push("", "## \uD83D\uDCA1 Key Decisions & Discoveries");
+  const combined = [...decisions, ...discoveries];
+  if (combined.length === 0) {
+    lines.push("*(No new decisions or discoveries)*");
+  } else {
+    for (const d of combined) {
+      lines.push(`- **${d.title}** (\`${d.id}\`)`);
+      lines.push(`  ${d.content}`);
+    }
+  }
+  const summary = `Compiled ${entries.length} memories into ${periodKey} rollup.`;
+  lines.push("", "---", `*Generated by Muse Memory Temporal Compounding Engine*`);
+  const rollupDir = join33(memoryDir, "wiki", "rollups");
+  mkdirSync24(rollupDir, { recursive: true });
+  const filePath = join33(rollupDir, `${periodKey}.md`);
+  writeFileSync22(filePath, lines.join(`
+`) + `
+`, "utf-8");
+  const hotMdPath = compileHotCache(store, memoryDir);
+  return {
+    filePath,
+    periodKey,
+    summary,
+    entriesCount: entries.length,
+    hotMdPath
+  };
+}
+var init_temporal = __esm(() => {
+  init_store();
+});
+
+// src/iterations.ts
+import { existsSync as existsSync37, readFileSync as readFileSync31, appendFileSync as appendFileSync2, writeFileSync as writeFileSync23, mkdirSync as mkdirSync25 } from "node:fs";
+import { join as join34 } from "node:path";
+function getIterationsFilePath(memoryDir) {
+  return join34(memoryDir, "iterations.jsonl");
+}
+function recordIteration(memoryDir, input) {
+  const textToScan = `${input.largest_fix_identified}
+${input.test_results}`;
+  const secrets = scanSecrets(textToScan);
+  if (secrets.length > 0) {
+    throw new Error(`Vibeguard: Detected secret in iteration record: ${secrets.join(", ")}`);
+  }
+  const entry = {
+    iteration_index: input.iteration_index,
+    critic_verdict: input.critic_verdict,
+    largest_fix_identified: input.largest_fix_identified,
+    test_results: input.test_results,
+    diff_hash: input.diff_hash,
+    timestamp: input.timestamp ?? new Date().toISOString(),
+    metadata: input.metadata
+  };
+  mkdirSync25(memoryDir, { recursive: true });
+  const filePath = getIterationsFilePath(memoryDir);
+  appendFileSync2(filePath, JSON.stringify(entry) + `
+`, "utf-8");
+  return entry;
+}
+function listIterations(memoryDir) {
+  const filePath = getIterationsFilePath(memoryDir);
+  if (!existsSync37(filePath)) {
+    return [];
+  }
+  try {
+    const raw = readFileSync31(filePath, "utf-8");
+    return raw.split(`
+`).map((l) => l.trim()).filter(Boolean).map((l) => JSON.parse(l));
+  } catch {
+    return [];
+  }
+}
+function clearIterations(memoryDir) {
+  const filePath = getIterationsFilePath(memoryDir);
+  if (existsSync37(filePath)) {
+    writeFileSync23(filePath, "", "utf-8");
+  }
+}
+function detectIterationStatus(memoryDir) {
+  const iterations = listIterations(memoryDir);
+  if (iterations.length === 0) {
+    return {
+      totalIterations: 0,
+      isPlateaued: false,
+      isRegressed: false,
+      consecutiveFailures: 0,
+      recommendation: "No active iteration loops recorded."
+    };
+  }
+  const last = iterations[iterations.length - 1];
+  let consecutiveFailures = 0;
+  for (let i = iterations.length - 1;i >= 0; i--) {
+    if (iterations[i].critic_verdict !== "pass") {
+      consecutiveFailures++;
+    } else {
+      break;
+    }
+  }
+  const isRegressed = last.critic_verdict === "regressed";
+  let isPlateaued = last.critic_verdict === "plateaued" || consecutiveFailures >= 3;
+  if (!isPlateaued && iterations.length >= 2) {
+    const prev = iterations[iterations.length - 2];
+    if (last.diff_hash && prev.diff_hash && last.diff_hash === prev.diff_hash) {
+      isPlateaued = true;
+    }
+  }
+  let recommendation = "Proceed with next improvement iteration.";
+  if (isRegressed) {
+    recommendation = "Revert last change immediately: regression detected in test results.";
+  } else if (isPlateaued) {
+    recommendation = "Halt iteration loop: Plateau detected (no improvement or repeated state). Human review required.";
+  } else if (last.critic_verdict === "pass") {
+    recommendation = "Loop passed: All criteria and tests verified. Ready to ship.";
+  }
+  return {
+    totalIterations: iterations.length,
+    lastVerdict: last.critic_verdict,
+    isPlateaued,
+    isRegressed,
+    consecutiveFailures,
+    recommendation
+  };
+}
+var init_iterations = __esm(() => {
+  init_secrets();
+});
+
+// src/retrieval/tiered.ts
+function queryTieredContext(store, memoryDir, query = "", options = {}) {
+  const tier = options.tier ?? 2;
+  if (tier === 2) {
+    return formatPromptContext(store, memoryDir, query, options);
+  }
+  const queryResult = queryContext(store, query, options);
+  const constraints = memoryDir ? syncConstraints(memoryDir, store) : [];
+  const userProfile = getUserProfile(memoryDir, { query });
+  const coreBlock = formatCoreBlock(memoryDir);
+  if (tier === 0) {
+    const parts2 = [];
+    parts2.push("### Memory Manifest (Tier 0)");
+    if (queryResult.results.length === 0) {
+      parts2.push("*(No matching memories)*");
+    } else {
+      for (const item of queryResult.results) {
+        const t = item.entry.type ? `[${item.entry.type}] ` : "";
+        parts2.push(`- \`${item.entry.id}\` ${t}${item.entry.title}`);
+      }
+    }
+    const markdown2 = parts2.join(`
+`);
+    const totalTokensUsed2 = Math.ceil(markdown2.length / 4);
+    return {
+      markdown: markdown2,
+      entries: queryResult.results,
+      totalTokensUsed: totalTokensUsed2,
+      constraints,
+      userProfile
+    };
+  }
+  const parts = [];
+  if (userProfile) {
+    parts.push("### User Profile & Preferences (USER.md)");
+    parts.push(userProfile);
+    parts.push("");
+  }
+  if (coreBlock) {
+    parts.push("### Core Memory (CORE.md)");
+    parts.push(coreBlock);
+    parts.push("");
+  }
+  if (constraints.length > 0) {
+    parts.push("### Active Working Constraints (CURRENT.md)");
+    for (const c of constraints) {
+      parts.push(`- ${c}`);
+    }
+    parts.push("");
+  }
+  parts.push("### Domain Routing Invariants (Tier 1)");
+  if (queryResult.results.length === 0) {
+    parts.push("*(No matching invariant routes)*");
+  } else {
+    for (const item of queryResult.results) {
+      const t = item.entry.type ? `[${item.entry.type}] ` : "";
+      const tags = item.entry.tags && item.entry.tags.length > 0 ? ` (tags: ${item.entry.tags.join(", ")})` : "";
+      parts.push(`- \`${item.entry.id}\` ${t}${item.entry.title}${tags}`);
+    }
+  }
+  const markdown = parts.join(`
+`);
+  const totalTokensUsed = Math.ceil(markdown.length / 4);
+  return {
+    markdown,
+    entries: queryResult.results,
+    totalTokensUsed,
+    constraints,
+    userProfile
+  };
+}
+var init_tiered = __esm(() => {
+  init_retrieval();
+  init_governor();
+  init_user();
+  init_core();
+});
+
 // src/plasticity.ts
 var exports_plasticity = {};
 __export(exports_plasticity, {
@@ -26927,17 +28323,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 existsSync38, readFileSync as readFileSync32, writeFileSync as writeFileSync24 } from "node:fs";
+import { join as join35 } from "node:path";
 function getPlasticityPath(memoryDir) {
-  return join28(memoryDir, "hebbian-plasticity.json");
+  return join35(memoryDir, "hebbian-plasticity.json");
 }
 function loadHebbianGraph(memoryDir) {
   const p = getPlasticityPath(memoryDir);
-  if (!existsSync31(p))
+  if (!existsSync38(p))
     return {};
   try {
-    return JSON.parse(readFileSync25(p, "utf8"));
+    return JSON.parse(readFileSync32(p, "utf8"));
   } catch {
     return {};
   }
@@ -26945,7 +28341,7 @@ function loadHebbianGraph(memoryDir) {
 function saveHebbianGraph(memoryDir, graph) {
   const p = getPlasticityPath(memoryDir);
   try {
-    writeFileSync17(p, JSON.stringify(graph, null, 2), "utf8");
+    writeFileSync24(p, JSON.stringify(graph, null, 2), "utf8");
   } catch {}
 }
 function recordCoActivation(memoryIds, memoryDir) {
@@ -27036,8 +28432,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 existsSync39 } from "node:fs";
+import { join as join36, 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 +28447,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 : join36(root, p);
+        const exists = existsSync39(fullPath);
         drifted.push({
           memoryId: entry.id,
           title: entry.title,
@@ -27126,12 +28522,13 @@ var init_drift = __esm(() => {
 // src/mcp.ts
 var exports_mcp = {};
 __export(exports_mcp, {
+  createServer: () => createServer2,
   runMcpServer: () => runMcpServer
 });
 import { basename } from "node:path";
-async function runMcpServer() {
-  const targetDir = process.env.MUSE_MEMORY_PROJECT_DIR || process.env.PROJECT_ROOT || process.cwd();
-  const { root, memoryDir } = findOrCreateProjectRoot(targetDir);
+function createServer2(targetDir) {
+  const resolvedTarget = targetDir || process.env.MUSE_MEMORY_PROJECT_DIR || process.env.PROJECT_ROOT || process.cwd();
+  const { root, memoryDir } = findOrCreateProjectRoot(resolvedTarget);
   const store = openStore(memoryDir);
   function resolveStoreForRequest(a) {
     const dir = a?.dir || a?.workspace || a?.project_dir || a?.cwd;
@@ -27179,7 +28576,8 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
             type: { type: "string" },
             status: { type: "string" },
             verified: { type: "boolean" },
-            depth: { type: "string", enum: ["L1", "L2", "L3"], description: "Progressive disclosure tier: L1 = id+title lines, L2 = title+content+tags (default), L3 = full raw entry" }
+            depth: { type: "string", enum: ["L1", "L2", "L3"], description: "Progressive disclosure tier: L1 = id+title lines, L2 = title+content+tags (default), L3 = full raw entry" },
+            tier: { type: "number", description: "Deterministic retrieval tier: 0 (manifest index), 1 (routing set), 2 (bounded bodies, default)" }
           }
         }
       },
@@ -27646,97 +29044,265 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
         }
       },
       {
-        name: "memory_entities_search",
-        description: "List extracted entities by type or project",
+        name: "memory_entities_search",
+        description: "List extracted entities by type or project",
+        inputSchema: {
+          type: "object",
+          properties: {
+            type: { type: "string", enum: ["person", "product", "organization", "file", "concept"], description: "Filter by entity type" },
+            project: { type: "string", description: "Filter by project" }
+          }
+        }
+      },
+      {
+        name: "memory_pageindex_index",
+        description: "Build a PageIndex-style hierarchical tree index from document/text for reasoning-based retrieval",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: { type: "string", description: "Document text content (max 10MB)" },
+            project: { type: "string", description: "Project to associate the index with" },
+            title: { type: "string", description: "Optional title for the index" },
+            maxDepth: { type: "number", description: "Max tree depth (default: 5)" },
+            dryRun: { type: "boolean", description: "Preview without persisting" }
+          },
+          required: ["content", "project"]
+        }
+      },
+      {
+        name: "memory_pageindex_search",
+        description: "Search a PageIndex tree index with reasoning-based retrieval",
+        inputSchema: {
+          type: "object",
+          properties: {
+            indexId: { type: "string", description: "Tree index ID to search" },
+            query: { type: "string", description: "Search query" },
+            project: { type: "string", description: "Project scope" },
+            tokenBudget: { type: "number", description: "Maximum token budget" },
+            maxDepth: { type: "number", description: "Max search depth" }
+          },
+          required: ["indexId", "query"]
+        }
+      },
+      {
+        name: "memory_pageindex_import",
+        description: "Import PageIndex search results/insights as memory entries",
+        inputSchema: {
+          type: "object",
+          properties: {
+            indexId: { type: "string", description: "Tree index ID" },
+            query: { type: "string", description: "Search query" },
+            project: { type: "string", description: "Project scope" },
+            type: { type: "string", description: "Memory type (default: discovery)" },
+            confirmed: { type: "boolean", description: "Auto-confirm imported entries" }
+          },
+          required: ["indexId", "query", "project"]
+        }
+      },
+      {
+        name: "memory_disconnect_pageindex",
+        description: "Disconnect PageIndex MCP tools and remove associated indexes",
+        inputSchema: {
+          type: "object",
+          properties: {
+            indexId: { type: "string", description: "Specific index to remove, or omit for all" },
+            project: { type: "string", description: "Project scope" }
+          }
+        }
+      },
+      {
+        name: "memory_settings_get",
+        description: "Read unified global or project configuration settings",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Optional project scope override" }
+          }
+        }
+      },
+      {
+        name: "memory_settings_set",
+        description: "Update unified global or project configuration settings",
+        inputSchema: {
+          type: "object",
+          properties: {
+            settings: { type: "object", description: "Settings object to merge" },
+            project: { type: "string", description: "Optional project scope override" }
+          },
+          required: ["settings"]
+        }
+      },
+      {
+        name: "memory_drift",
+        description: "Scan the local Git workspace for modified or deleted code files and AST symbols referenced by memories. Flags drifted memories for re-verification or supersession.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            dir: { type: "string", description: "Optional project workspace directory path" }
+          }
+        }
+      },
+      {
+        name: "memory_compress",
+        description: "Compress formatted prompt context losslessly, stripping header whitespace and boilerplate while preserving all architectural facts.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            text: { type: "string", description: "Markdown prompt context to compress" },
+            level: { type: "string", enum: ["light", "aggressive"], description: "Compression aggressiveness level" }
+          },
+          required: ["text"]
+        }
+      },
+      {
+        name: "memory_source_add",
+        description: "Record external documentation, research paper, RFC, or URL into the provenance Source Ledger",
+        inputSchema: {
+          type: "object",
+          properties: {
+            url: { type: "string" },
+            title: { type: "string" },
+            source_type: { type: "string", description: "Source classification: primary | secondary | documentation | rfc | repo | article" },
+            excerpt: { type: "string", description: "Key quote or summary excerpt from source" },
+            author: { type: "string", description: "Author or organization" },
+            dir: { type: "string", description: "Optional project workspace directory path" }
+          },
+          required: ["url", "title"]
+        }
+      },
+      {
+        name: "memory_source_list",
+        description: "List recorded external sources in the Source Ledger",
+        inputSchema: {
+          type: "object",
+          properties: {
+            source_type: { type: "string" },
+            query: { type: "string" },
+            dir: { type: "string", description: "Optional project workspace directory path" }
+          }
+        }
+      },
+      {
+        name: "memory_claim_record",
+        description: "Record an evidence-backed claim into the Claim Ledger connected to sources and confidence tags ([RAW], [FETCH], [SEARCH], [INFER])",
+        inputSchema: {
+          type: "object",
+          properties: {
+            claim: { type: "string" },
+            confidence_tag: { type: "string", enum: ["RAW", "FETCH", "SEARCH", "INFER"], description: "Confidence level: RAW (locally verified), FETCH (authoritative URL), SEARCH (synthesized search), INFER (agent deduction)" },
+            source_ids: { type: "array", items: { type: "string" } },
+            memory_ids: { type: "array", items: { type: "string" } },
+            notes: { type: "string" },
+            verified: { type: "boolean" },
+            dir: { type: "string", description: "Optional project workspace directory path" }
+          },
+          required: ["claim"]
+        }
+      },
+      {
+        name: "memory_claim_list",
+        description: "List recorded claims in the Claim Ledger",
+        inputSchema: {
+          type: "object",
+          properties: {
+            confidence_tag: { type: "string", enum: ["RAW", "FETCH", "SEARCH", "INFER"] },
+            query: { type: "string" },
+            verified: { type: "boolean" },
+            dir: { type: "string", description: "Optional project workspace directory path" }
+          }
+        }
+      },
+      {
+        name: "memory_freeze_run",
+        description: "Capture an immutable execution snapshot (active task, file inventory, git SHA, CURRENT constraints, memory SHA-256 hashes) in .memory/runs/<run-id>/",
         inputSchema: {
           type: "object",
           properties: {
-            type: { type: "string", enum: ["person", "product", "organization", "file", "concept"], description: "Filter by entity type" },
-            project: { type: "string", description: "Filter by project" }
-          }
+            task: { type: "string", description: "Task description or path to task markdown file" },
+            run_id: { type: "string", description: "Optional unique run identifier" },
+            dir: { type: "string", description: "Optional project workspace directory path" }
+          },
+          required: ["task"]
         }
       },
       {
-        name: "memory_pageindex_index",
-        description: "Build a PageIndex-style hierarchical tree index from document/text for reasoning-based retrieval",
+        name: "memory_freeze_list",
+        description: "List recorded frozen execution snapshots in .memory/runs/",
         inputSchema: {
           type: "object",
           properties: {
-            content: { type: "string", description: "Document text content (max 10MB)" },
-            project: { type: "string", description: "Project to associate the index with" },
-            title: { type: "string", description: "Optional title for the index" },
-            maxDepth: { type: "number", description: "Max tree depth (default: 5)" },
-            dryRun: { type: "boolean", description: "Preview without persisting" }
-          },
-          required: ["content", "project"]
+            dir: { type: "string", description: "Optional project workspace directory path" }
+          }
         }
       },
       {
-        name: "memory_pageindex_search",
-        description: "Search a PageIndex tree index with reasoning-based retrieval",
+        name: "memory_prompt_list",
+        description: "List available structured prompt templates in .memory/prompts/",
         inputSchema: {
           type: "object",
           properties: {
-            indexId: { type: "string", description: "Tree index ID to search" },
-            query: { type: "string", description: "Search query" },
-            project: { type: "string", description: "Project scope" },
-            tokenBudget: { type: "number", description: "Maximum token budget" },
-            maxDepth: { type: "number", description: "Max search depth" }
-          },
-          required: ["indexId", "query"]
+            dir: { type: "string", description: "Optional project workspace directory path" }
+          }
         }
       },
       {
-        name: "memory_pageindex_import",
-        description: "Import PageIndex search results/insights as memory entries",
+        name: "memory_prompt_get",
+        description: "Get prompt template by name",
         inputSchema: {
           type: "object",
           properties: {
-            indexId: { type: "string", description: "Tree index ID" },
-            query: { type: "string", description: "Search query" },
-            project: { type: "string", description: "Project scope" },
-            type: { type: "string", description: "Memory type (default: discovery)" },
-            confirmed: { type: "boolean", description: "Auto-confirm imported entries" }
+            name: { type: "string" },
+            dir: { type: "string", description: "Optional project workspace directory path" }
           },
-          required: ["indexId", "query", "project"]
+          required: ["name"]
         }
       },
       {
-        name: "memory_disconnect_pageindex",
-        description: "Disconnect PageIndex MCP tools and remove associated indexes",
+        name: "memory_prompt_run",
+        description: "Render prompt template with variable substitution and live memory context injection",
         inputSchema: {
           type: "object",
           properties: {
-            indexId: { type: "string", description: "Specific index to remove, or omit for all" },
-            project: { type: "string", description: "Project scope" }
-          }
+            name: { type: "string" },
+            args: { type: "object", description: "Key-value pairs for prompt template variables" },
+            dir: { type: "string", description: "Optional project workspace directory path" }
+          },
+          required: ["name"]
         }
       },
       {
-        name: "memory_settings_get",
-        description: "Read unified global or project configuration settings",
+        name: "memory_rollup",
+        description: "Multi-scale temporal compounding: aggregate atomic memories into weekly, monthly, or quarterly synthesis wiki pages and update HOT.md cache",
         inputSchema: {
           type: "object",
           properties: {
-            project: { type: "string", description: "Optional project scope override" }
-          }
+            period: { type: "string", enum: ["week", "month", "quarter"] },
+            date: { type: "string", description: "Optional target date (YYYY-MM-DD)" },
+            project: { type: "string" },
+            dir: { type: "string", description: "Optional project workspace directory path" }
+          },
+          required: ["period"]
         }
       },
       {
-        name: "memory_settings_set",
-        description: "Update unified global or project configuration settings",
+        name: "memory_loop_record",
+        description: "Record an iteration round in the multi-agent Gauntlet Iteration Ledger (.memory/iterations.jsonl)",
         inputSchema: {
           type: "object",
           properties: {
-            settings: { type: "object", description: "Settings object to merge" },
-            project: { type: "string", description: "Optional project scope override" }
+            iteration_index: { type: "number" },
+            critic_verdict: { type: "string", enum: ["pass", "fail", "regressed", "plateaued"] },
+            largest_fix_identified: { type: "string" },
+            test_results: { type: "string" },
+            diff_hash: { type: "string" },
+            dir: { type: "string", description: "Optional project workspace directory path" }
           },
-          required: ["settings"]
+          required: ["iteration_index", "critic_verdict", "largest_fix_identified", "test_results"]
         }
       },
       {
-        name: "memory_drift",
-        description: "Scan the local Git workspace for modified or deleted code files and AST symbols referenced by memories. Flags drifted memories for re-verification or supersession.",
+        name: "memory_loop_status",
+        description: "Inspect multi-round iteration status, plateau warnings, and regression signals",
         inputSchema: {
           type: "object",
           properties: {
@@ -27745,15 +29311,14 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
         }
       },
       {
-        name: "memory_compress",
-        description: "Compress formatted prompt context losslessly, stripping header whitespace and boilerplate while preserving all architectural facts.",
+        name: "memory_verify_strict",
+        description: "Execute Strict Integrity & Health Gate: audits zero secrets, referential link integrity, wikilinks, orphaned candidates, and claim sources",
         inputSchema: {
           type: "object",
           properties: {
-            text: { type: "string", description: "Markdown prompt context to compress" },
-            level: { type: "string", enum: ["light", "aggressive"], description: "Compression aggressiveness level" }
-          },
-          required: ["text"]
+            max_candidate_days: { type: "number" },
+            dir: { type: "string", description: "Optional project workspace directory path" }
+          }
         }
       }
     ]
@@ -27782,7 +29347,17 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
               });
             } catch {}
           }
-          const formatted = formatPromptContext(activeStore, activeMemoryDir, queryStr, {
+          const tierOpt = typeof a.tier === "number" ? a.tier : undefined;
+          const formatted = tierOpt !== undefined ? queryTieredContext(activeStore, activeMemoryDir, queryStr, {
+            limit: typeof a.limit === "number" ? a.limit : 5,
+            tokenBudget: typeof a.token_budget === "number" ? a.token_budget : undefined,
+            project: a.project ? String(a.project) : undefined,
+            includeSuperseded: false,
+            type: a.type ? String(a.type) : undefined,
+            status: a.status ? String(a.status) : undefined,
+            verified: a.verified === true,
+            tier: tierOpt
+          }) : formatPromptContext(activeStore, activeMemoryDir, queryStr, {
             limit: typeof a.limit === "number" ? a.limit : 5,
             tokenBudget: typeof a.token_budget === "number" ? a.token_budget : undefined,
             project: a.project ? String(a.project) : undefined,
@@ -27798,6 +29373,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 +29471,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 });
@@ -28250,6 +29840,99 @@ Path: ${item.path}`,
           const result = compressPromptContext2(text, { level });
           return toolResult(result);
         }
+        case "memory_source_add": {
+          const source = addSource(activeMemoryDir, {
+            url: String(a.url),
+            title: String(a.title),
+            source_type: a.source_type ? String(a.source_type) : undefined,
+            excerpt: a.excerpt ? String(a.excerpt) : undefined,
+            author: a.author ? String(a.author) : undefined
+          });
+          return toolResult(source);
+        }
+        case "memory_source_list": {
+          const sources = listSources(activeMemoryDir, {
+            query: a.query ? String(a.query) : undefined,
+            source_type: a.source_type ? String(a.source_type) : undefined
+          });
+          return toolResult(sources);
+        }
+        case "memory_claim_record": {
+          const claim = recordClaim(activeMemoryDir, {
+            claim: String(a.claim),
+            confidence_tag: a.confidence_tag,
+            source_ids: Array.isArray(a.source_ids) ? a.source_ids.map(String) : undefined,
+            memory_ids: Array.isArray(a.memory_ids) ? a.memory_ids.map(String) : undefined,
+            notes: a.notes ? String(a.notes) : undefined,
+            verified: a.verified === true
+          });
+          return toolResult(claim);
+        }
+        case "memory_claim_list": {
+          const claims = listClaims(activeMemoryDir, {
+            confidence_tag: a.confidence_tag ? String(a.confidence_tag) : undefined,
+            query: a.query ? String(a.query) : undefined,
+            verified: typeof a.verified === "boolean" ? a.verified : undefined
+          });
+          return toolResult(claims);
+        }
+        case "memory_freeze_run": {
+          const snapshot = freezeExecutionSnapshot({
+            workspaceRoot: activeRoot,
+            memoryDir: activeMemoryDir,
+            task: String(a.task),
+            runId: a.run_id ? String(a.run_id) : undefined,
+            store: activeStore
+          });
+          return toolResult(snapshot);
+        }
+        case "memory_freeze_list": {
+          const snapshots = listExecutionSnapshots(activeMemoryDir);
+          return toolResult(snapshots);
+        }
+        case "memory_prompt_list": {
+          const prompts = listPrompts(activeMemoryDir);
+          return toolResult(prompts);
+        }
+        case "memory_prompt_get": {
+          const prompt = getPrompt(activeMemoryDir, String(a.name));
+          if (!prompt)
+            return toolError(`Prompt template "${a.name}" not found`);
+          return toolResult(prompt);
+        }
+        case "memory_prompt_run": {
+          const rendered = renderPrompt(activeMemoryDir, String(a.name), a.args ?? {});
+          return toolResult({ rendered });
+        }
+        case "memory_rollup": {
+          const res = rollupTemporal(activeStore, {
+            memoryDir: activeMemoryDir,
+            period: a.period ?? "week",
+            date: a.date ? String(a.date) : undefined,
+            project: a.project ? String(a.project) : undefined
+          });
+          return toolResult(res);
+        }
+        case "memory_loop_record": {
+          const entry = recordIteration(activeMemoryDir, {
+            iteration_index: Number(a.iteration_index) || 1,
+            critic_verdict: String(a.critic_verdict),
+            largest_fix_identified: String(a.largest_fix_identified),
+            test_results: String(a.test_results),
+            diff_hash: a.diff_hash ? String(a.diff_hash) : undefined
+          });
+          return toolResult(entry);
+        }
+        case "memory_loop_status": {
+          const status = detectIterationStatus(activeMemoryDir);
+          return toolResult(status);
+        }
+        case "memory_verify_strict": {
+          const report = verifyStrictIntegrity(activeStore, activeMemoryDir, activeRoot, {
+            maxCandidateDays: typeof a.max_candidate_days === "number" ? a.max_candidate_days : undefined
+          });
+          return toolResult(report);
+        }
         default:
           return toolError(`unknown tool ${name}`);
       }
@@ -28257,6 +29940,10 @@ Path: ${item.path}`,
       return toolError(err instanceof Error ? err.message : String(err));
     }
   });
+  return server;
+}
+async function runMcpServer() {
+  const server = createServer2();
   const transport = new StdioServerTransport;
   await server.connect(transport);
   process.stdin.resume();
@@ -28306,6 +29993,14 @@ var init_mcp = __esm(() => {
   init_entities();
   init_pageindex();
   init_settings2();
+  init_provenance();
+  init_claims();
+  init_snapshot();
+  init_prompts();
+  init_temporal();
+  init_iterations();
+  init_verify();
+  init_tiered();
 });
 
 // src/daemon.ts
@@ -28313,15 +30008,15 @@ var exports_daemon = {};
 __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 { createServer as createServer3 } from "node:http";
+import { existsSync as existsSync40 } from "node:fs";
+import { join as join37 } from "node:path";
 import { watch } from "node:fs";
 function startHub(port, memoryDir) {
   const clients = new Set;
   const watchers = [];
   let debounceTimer = null;
-  const server = createServer2((req, res) => {
+  const server = createServer3((req, res) => {
     if (req.method === "GET" && req.url?.startsWith("/events")) {
       res.writeHead(200, {
         "content-type": "text/event-stream",
@@ -28381,7 +30076,7 @@ data: ${JSON.stringify(event)}
     return clients.size;
   }
   if (memoryDir) {
-    const memoriesDir = join30(memoryDir, "memories");
+    const memoriesDir = join37(memoryDir, "memories");
     const armDebounced = (type2) => {
       if (debounceTimer)
         clearTimeout(debounceTimer);
@@ -28390,17 +30085,17 @@ data: ${JSON.stringify(event)}
       }, DEBOUNCE_MS);
     };
     try {
-      if (existsSync33(memoriesDir)) {
+      if (existsSync40(memoriesDir)) {
         watchers.push(watch(memoriesDir, () => armDebounced("memory.changed")));
       }
-      const currentMd = join30(memoryDir, "CURRENT.md");
-      if (existsSync33(currentMd)) {
+      const currentMd = join37(memoryDir, "CURRENT.md");
+      if (existsSync40(currentMd)) {
         watchers.push(watch(currentMd, () => armDebounced("constraints.changed")));
       }
     } catch {}
   }
   return new Promise((resolve3) => {
-    server.listen(port, () => {
+    server.listen(port, "127.0.0.1", () => {
       const address = server.address();
       const actualPort = typeof address === "object" && address ? address.port : port;
       resolve3({
@@ -28427,19 +30122,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 join38 } from "node:path";
+import { existsSync as existsSync41, mkdirSync as mkdirSync26, writeFileSync as writeFileSync25, readFileSync as readFileSync33 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
 function ensureProjectAgentInstructions(targetDir) {
-  const agentsMdPath = join31(targetDir, "AGENTS.md");
-  if (existsSync34(agentsMdPath)) {
+  const agentsMdPath = join38(targetDir, "AGENTS.md");
+  if (existsSync41(agentsMdPath)) {
     try {
-      const existing = readFileSync26(agentsMdPath, "utf8");
+      const existing = readFileSync33(agentsMdPath, "utf8");
       if (existing.includes("<!-- agentmemory:start -->")) {
         const updated = existing.replace(/<!-- agentmemory:start -->[\s\S]*?<!-- agentmemory:end -->/, MUSE_MEMORY_DIRECTIVE);
-        writeFileSync18(agentsMdPath, updated, "utf8");
+        writeFileSync25(agentsMdPath, updated, "utf8");
       } else if (!existing.includes("<!-- musememory:start -->") && !existing.includes("Muse Memory")) {
-        writeFileSync18(agentsMdPath, `${existing.trim()}
+        writeFileSync25(agentsMdPath, `${existing.trim()}
 
 ${MUSE_MEMORY_DIRECTIVE}
 `, "utf8");
@@ -28450,23 +30145,23 @@ ${MUSE_MEMORY_DIRECTIVE}
 
 ${MUSE_MEMORY_DIRECTIVE}
 `;
-    writeFileSync18(agentsMdPath, initialContent, "utf8");
+    writeFileSync25(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] ? join38(process.cwd(), positional[0]) : process.cwd();
+  const memoryDir = isGlobal ? getGlobalMemoryDir() : join38(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
+  mkdirSync26(join38(memoryDir, "memories"), { recursive: true });
+  mkdirSync26(join38(globalDir, "memories"), { recursive: true });
+  const currentPath = join38(memoryDir, "CURRENT.md");
+  if (!existsSync41(currentPath)) {
+    writeFileSync25(currentPath, `# Active Project Constraints
 `, "utf8");
   }
   const globalUserPath = userFilePath(globalDir);
-  if (!existsSync34(globalUserPath)) {
+  if (!existsSync41(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 +30177,13 @@ async function handleInstallCommand({ positional, flags }) {
   if (!isGlobal) {
     ensureProjectAgentInstructions(targetDir);
   }
-  const globalAgentsMd = join31(homedir6(), ".agents", "AGENTS.md");
-  if (existsSync34(globalAgentsMd)) {
+  const globalAgentsMd = join38(homedir7(), ".agents", "AGENTS.md");
+  if (existsSync41(globalAgentsMd)) {
     try {
-      const existing = readFileSync26(globalAgentsMd, "utf8");
+      const existing = readFileSync33(globalAgentsMd, "utf8");
       if (existing.includes("<!-- agentmemory:start -->")) {
         const updated = existing.replace(/<!-- agentmemory:start -->[\s\S]*?<!-- agentmemory:end -->/, MUSE_MEMORY_DIRECTIVE);
-        writeFileSync18(globalAgentsMd, updated, "utf8");
+        writeFileSync25(globalAgentsMd, updated, "utf8");
       }
     } catch {}
   }
@@ -28549,11 +30244,11 @@ async function handleInstallCommand({ positional, flags }) {
   return 0;
 }
 async function promptOrNotifyGitHook(targetDir, autoInstall = false) {
-  const gitDir = join31(targetDir, ".git");
-  if (!existsSync34(gitDir))
+  const gitDir = join38(targetDir, ".git");
+  if (!existsSync41(gitDir))
     return false;
-  const hookPath = join31(gitDir, "hooks", "pre-commit");
-  const isInstalled = existsSync34(hookPath) && readFileSync26(hookPath, "utf8").includes("memory harvest-auto");
+  const hookPath = join38(gitDir, "hooks", "pre-commit");
+  const isInstalled = existsSync41(hookPath) && readFileSync33(hookPath, "utf8").includes("memory harvest-auto");
   if (isInstalled)
     return true;
   if (autoInstall) {
@@ -28609,7 +30304,7 @@ async function handleUninstallCommand({ positional, flags }) {
       action: async () => {
         if (purge) {
           const ctx = requireRoot(flags);
-          if (ctx && existsSync34(ctx.memoryDir) && !dryRun) {
+          if (ctx && existsSync41(ctx.memoryDir) && !dryRun) {
             const { rmSync: rmSync3 } = await import("node:fs");
             rmSync3(ctx.memoryDir, { recursive: true, force: true });
           }
@@ -28641,13 +30336,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] ? join38(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() : join38(targetDir, memoryDirName);
+  mkdirSync26(join38(memoryDir, "memories"), { recursive: true });
+  const currentPath = join38(memoryDir, "CURRENT.md");
+  if (!existsSync41(currentPath)) {
+    writeFileSync25(currentPath, `# Active Project Constraints
 `, "utf8");
   }
   if (!isGlobal) {
@@ -28823,6 +30518,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 +30633,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 existsSync42 } from "node:fs";
+import { join as join39 } from "node:path";
 function parseAgentMemoryContract(markdown) {
   if (!markdown || !markdown.startsWith("---"))
     return null;
@@ -28964,17 +30666,17 @@ function parseAgentMemoryContract(markdown) {
 function resolveAgentFile(nameOrPath, workspaceRoot) {
   if (!nameOrPath)
     return null;
-  if (existsSync35(nameOrPath))
+  if (existsSync42(nameOrPath))
     return nameOrPath;
   const candidates = [
-    join32(workspaceRoot, ".agents", `${nameOrPath}.md`),
-    join32(workspaceRoot, ".memory", "agents", `${nameOrPath}.md`)
+    join39(workspaceRoot, ".agents", `${nameOrPath}.md`),
+    join39(workspaceRoot, ".memory", "agents", `${nameOrPath}.md`)
   ];
   const home = process.env.HOME;
   if (home)
-    candidates.push(join32(home, ".config", "opencode", "agents", `${nameOrPath}.md`));
+    candidates.push(join39(home, ".config", "opencode", "agents", `${nameOrPath}.md`));
   for (const c of candidates) {
-    if (existsSync35(c))
+    if (existsSync42(c))
       return c;
   }
   return null;
@@ -28984,8 +30686,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 existsSync43, readFileSync as readFileSync34 } from "node:fs";
+import { join as join40 } from "node:path";
 async function handleContextCommand({ positional, flags }) {
   let agentTypes;
   let agentTags;
@@ -28993,7 +30695,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(readFileSync34(file, "utf8"));
     if (contract) {
       agentTypes = contract.types;
       agentTags = contract.tags;
@@ -29011,6 +30713,26 @@ async function handleContextCommand({ positional, flags }) {
   if (depth && depth !== "L1" && depth !== "L2" && depth !== "L3") {
     return usageError("--depth must be one of L1|L2|L3");
   }
+  if (flags["tier"] !== undefined) {
+    const tierNum = parseInt(flags["tier"], 10);
+    if (tierNum !== 0 && tierNum !== 1 && tierNum !== 2) {
+      return usageError("--tier must be 0, 1, or 2");
+    }
+    const tiered = queryTieredContext(ctx.store, ctx.memoryDir, query, {
+      limit,
+      tokenBudget: tokenBudget ?? (flags["budget"] ? parseInt(flags["budget"], 10) : undefined),
+      project: flags["project"],
+      includeSuperseded: false,
+      type: flags["type"],
+      types: agentTypes,
+      tags: agentTags,
+      status: flags["status"],
+      verified: flags["verified"] === "true",
+      tier: tierNum
+    });
+    console.log(tiered.markdown);
+    return 0;
+  }
   if (depth) {
     const formatted = formatPromptContext(ctx.store, ctx.memoryDir, query, {
       limit,
@@ -29133,7 +30855,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 = existsSync43(target) ? readFileSync34(target, "utf8") : target;
   const created = harvestMemories(ctx.store, {
     text: rawText,
     project,
@@ -29169,8 +30891,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 : join40(process.cwd(), filePath) : join40(process.cwd(), "transcript.jsonl");
+  if (!existsSync43(targetFile)) {
     return fail(`error: transcript file not found: ${targetFile}`);
   }
   const windowSize = flags["window"] ? parseInt(flags["window"], 10) : 2;
@@ -29186,7 +30908,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 -> ${join40(ctx.memoryDir, "index.json")}`);
   return 0;
 }
 async function handleHookCommand({ positional, flags }) {
@@ -29220,6 +30942,7 @@ async function handleHarvestAutoCommand({ flags }) {
 }
 var init_retrieval3 = __esm(() => {
   init_retrieval();
+  init_tiered();
   init_vector();
   init_retrieval2();
   init_harvest();
@@ -29577,7 +31300,7 @@ var init_entities2 = __esm(() => {
 });
 
 // src/cli/settings.ts
-import { writeFileSync as writeFileSync19, readFileSync as readFileSync28 } from "node:fs";
+import { writeFileSync as writeFileSync26, readFileSync as readFileSync35 } from "node:fs";
 function handleSettingsCommand(parsed) {
   const ctx = requireRoot(parsed.flags);
   if (!ctx)
@@ -29659,7 +31382,7 @@ function handleSettingsCommand(parsed) {
     const out = parsed.flags.out;
     const json2 = exportSettings(memoryDir);
     if (out) {
-      writeFileSync19(out, json2, "utf8");
+      writeFileSync26(out, json2, "utf8");
       console.log(`Exported settings to ${out}`);
     } else {
       console.log(json2);
@@ -29673,7 +31396,7 @@ function handleSettingsCommand(parsed) {
       return 2;
     }
     try {
-      const raw = readFileSync28(file, "utf8");
+      const raw = readFileSync35(file, "utf8");
       importSettings(memoryDir, raw);
       console.log(`Successfully imported settings from ${file}`);
       return 0;
@@ -29696,16 +31419,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 readFileSync36, existsSync as existsSync44 } from "node:fs";
+import { join as join41 } from "node:path";
 function routinesPath(memoryDir) {
-  return join34(memoryDir, "routines.yaml");
+  return join41(memoryDir, "routines.yaml");
 }
 function loadRoutines(memoryDir) {
   const p = routinesPath(memoryDir);
-  if (!existsSync37(p))
+  if (!existsSync44(p))
     return { routines: {} };
-  const doc2 = yaml.load(readFileSync29(p, "utf8"), { schema: yaml.JSON_SCHEMA }) ?? {};
+  const doc2 = yaml.load(readFileSync36(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 +31466,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 writeFileSync27, readFileSync as readFileSync37, existsSync as existsSync45 } from "node:fs";
 async function handleProposeCommand({ positional, flags }) {
   const ctx = requireRoot(flags);
   if (!ctx)
@@ -29892,7 +31615,7 @@ async function handleExportCommand({ flags }) {
   const snapshot = exportSnapshot(ctx.store);
   const outPath = flags["out"];
   if (outPath) {
-    writeFileSync20(outPath, JSON.stringify(snapshot, null, 2), "utf8");
+    writeFileSync27(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 +31629,9 @@ async function handleImportCommand({ positional, flags }) {
   const file = positional[0];
   if (!file)
     return usageError("import requires <file.json>");
-  if (!existsSync38(file))
+  if (!existsSync45(file))
     return fail(`error: file ${file} does not exist`);
-  const raw = JSON.parse(readFileSync30(file, "utf8"));
+  const raw = JSON.parse(readFileSync37(file, "utf8"));
   const res = importSnapshot(ctx.store, raw, { overwrite: flags["overwrite"] === "true" });
   if (res.errors.length > 0) {
     console.error(`import encountered errors:`);
@@ -30198,9 +31921,31 @@ async function handleVerifyCommand({ positional, flags }) {
   const ctx = requireRoot(flags);
   if (!ctx)
     return 1;
+  if (flags["strict"] === "true" || positional[0] === "--strict" || flags["all"] === "true") {
+    const report = verifyStrictIntegrity(ctx.store, ctx.memoryDir, ctx.root);
+    console.log(`=== Muse Memory Strict Integrity Audit ===`);
+    for (const c of report.checks) {
+      const statusIcon = c.passed ? "✓" : "✗";
+      console.log(`${statusIcon} ${c.name}: ${c.message}`);
+      if (c.errors && c.errors.length > 0) {
+        for (const err of c.errors) {
+          console.error(`  - ${err}`);
+        }
+      }
+    }
+    if (report.ok) {
+      console.log(`
+[pass] Strict Verification Passed (${report.passedChecks}/${report.totalChecks} gates clean)`);
+      return 0;
+    } else {
+      console.error(`
+[fail] Strict Verification Failed (${report.failedChecks}/${report.totalChecks} gates violated)`);
+      return 1;
+    }
+  }
   const id = positional[0];
   if (!id)
-    return usageError("verify requires <id>");
+    return usageError("verify requires <id> or --strict");
   const timeout = flags["timeout"] ? parseInt(flags["timeout"], 10) : undefined;
   const result = await verifyEntry(ctx.store, ctx.root, ctx.memoryDir, id, { timeout });
   if (result.stdout?.trim())
@@ -30253,6 +31998,275 @@ var init_lifecycle = __esm(() => {
   init_shared();
 });
 
+// src/cli/evolution.ts
+async function handleSourceCommand({ positional, flags }) {
+  const ctx = requireRoot(flags);
+  if (!ctx)
+    return 1;
+  const sub = positional[0] ?? "list";
+  if (sub === "add") {
+    const url = positional[1];
+    if (!url)
+      return usageError("source add requires <url>");
+    const title = flags["title"] || positional[2] || url;
+    try {
+      const source = addSource(ctx.memoryDir, {
+        url,
+        title,
+        source_type: flags["type"] || "documentation",
+        excerpt: flags["excerpt"],
+        author: flags["author"]
+      });
+      console.log(`Recorded source ${source.id}: "${source.title}" (${source.url})`);
+      return 0;
+    } catch (err) {
+      console.error(`Error adding source: ${err instanceof Error ? err.message : String(err)}`);
+      return 1;
+    }
+  }
+  if (sub === "show" || sub === "get") {
+    const id = positional[1];
+    if (!id)
+      return usageError("source show requires <id>");
+    const source = getSource(ctx.memoryDir, id);
+    if (!source) {
+      console.error(`Source ${id} not found`);
+      return 1;
+    }
+    console.log(JSON.stringify(source, null, 2));
+    return 0;
+  }
+  const query = flags["query"] || (sub === "find" ? positional[1] : undefined);
+  const sources = listSources(ctx.memoryDir, {
+    source_type: flags["type"],
+    query
+  });
+  if (sources.length === 0) {
+    console.log("*(No sources found)*");
+    return 0;
+  }
+  console.log(`Found ${sources.length} source(s):`);
+  for (const s of sources) {
+    console.log(`- [${s.id}] (${s.source_type}) ${s.title} — ${s.url}`);
+    if (s.excerpt)
+      console.log(`  "${s.excerpt}"`);
+  }
+  return 0;
+}
+async function handleClaimCommand({ positional, flags }) {
+  const ctx = requireRoot(flags);
+  if (!ctx)
+    return 1;
+  const sub = positional[0] ?? "list";
+  if (sub === "record" || sub === "add") {
+    const claimText = positional.slice(1).join(" ") || flags["claim"];
+    if (!claimText || !claimText.trim())
+      return usageError("claim record requires <claim text>");
+    const sourceIds = flags["sources"] || flags["source_ids"] ? (flags["sources"] || flags["source_ids"]).split(",").map((s) => s.trim()).filter(Boolean) : undefined;
+    const memoryIds = flags["memories"] || flags["memory_ids"] ? (flags["memories"] || flags["memory_ids"]).split(",").map((s) => s.trim()).filter(Boolean) : undefined;
+    try {
+      const claim = recordClaim(ctx.memoryDir, {
+        claim: claimText.trim(),
+        confidence_tag: flags["confidence"] || "INFER",
+        source_ids: sourceIds,
+        memory_ids: memoryIds,
+        notes: flags["notes"],
+        verified: flags["verified"] === "true"
+      });
+      console.log(`Recorded claim ${claim.id} [${claim.confidence_tag}]: "${claim.claim}"`);
+      return 0;
+    } catch (err) {
+      console.error(`Error recording claim: ${err instanceof Error ? err.message : String(err)}`);
+      return 1;
+    }
+  }
+  if (sub === "show" || sub === "get") {
+    const id = positional[1];
+    if (!id)
+      return usageError("claim show requires <id>");
+    const claim = getClaim(ctx.memoryDir, id);
+    if (!claim) {
+      console.error(`Claim ${id} not found`);
+      return 1;
+    }
+    console.log(JSON.stringify(claim, null, 2));
+    return 0;
+  }
+  const query = flags["query"] || (sub === "find" ? positional[1] : undefined);
+  const claims = listClaims(ctx.memoryDir, {
+    confidence_tag: flags["confidence"],
+    query
+  });
+  if (claims.length === 0) {
+    console.log("*(No claims found)*");
+    return 0;
+  }
+  console.log(`Found ${claims.length} claim(s):`);
+  for (const c of claims) {
+    const sources = c.source_ids && c.source_ids.length > 0 ? ` (sources: ${c.source_ids.join(", ")})` : "";
+    console.log(`- [${c.id}] [${c.confidence_tag}] ${c.claim}${sources}`);
+  }
+  return 0;
+}
+async function handleFreezeCommand({ positional, flags }) {
+  const ctx = requireRoot(flags);
+  if (!ctx)
+    return 1;
+  const sub = positional[0];
+  if (sub === "list") {
+    const snapshots = listExecutionSnapshots(ctx.memoryDir);
+    console.log(`Found ${snapshots.length} execution snapshot(s):`);
+    for (const s of snapshots) {
+      console.log(`- [${s.run_id}] (${s.timestamp}) ${s.task.slice(0, 60)}...`);
+    }
+    return 0;
+  }
+  if (sub === "show") {
+    const runId = positional[1];
+    if (!runId)
+      return usageError("freeze show requires <run-id>");
+    const snap2 = loadExecutionSnapshot(ctx.memoryDir, runId);
+    if (!snap2) {
+      console.error(`Snapshot ${runId} not found`);
+      return 1;
+    }
+    console.log(JSON.stringify(snap2, null, 2));
+    return 0;
+  }
+  const task = flags["task"] || positional.join(" ");
+  if (!task || !task.trim()) {
+    return usageError("freeze requires --task <task.md|text>");
+  }
+  const snap = freezeExecutionSnapshot({
+    workspaceRoot: ctx.root,
+    memoryDir: ctx.memoryDir,
+    task: task.trim(),
+    runId: flags["run-id"],
+    store: ctx.store
+  });
+  console.log(`Frozen execution snapshot [${snap.run_id}] with ${snap.memory_hashes.length} memories and ${snap.file_inventory.length} workspace files.`);
+  return 0;
+}
+async function handlePromptCommand({ positional, flags }) {
+  const ctx = requireRoot(flags);
+  const memoryDir = ctx?.memoryDir;
+  const sub = positional[0] ?? "list";
+  if (sub === "list") {
+    const prompts = listPrompts(memoryDir);
+    console.log(`Available Prompt Templates (${prompts.length}):`);
+    for (const p of prompts) {
+      console.log(`- **${p.name}**: ${p.title} — ${p.description}`);
+    }
+    return 0;
+  }
+  if (sub === "show") {
+    const name = positional[1];
+    if (!name)
+      return usageError("prompt show requires <name>");
+    const prompt = getPrompt(memoryDir, name);
+    if (!prompt) {
+      console.error(`Prompt template "${name}" not found`);
+      return 1;
+    }
+    console.log(JSON.stringify(prompt, null, 2));
+    return 0;
+  }
+  if (sub === "run") {
+    const name = positional[1];
+    if (!name)
+      return usageError("prompt run requires <name>");
+    const args = {};
+    if (flags["args"]) {
+      for (const pair of flags["args"].split(",")) {
+        const [k, v] = pair.split("=");
+        if (k && v)
+          args[k.trim()] = v.trim();
+      }
+    }
+    try {
+      const rendered = renderPrompt(memoryDir, name, args);
+      console.log(rendered);
+      return 0;
+    } catch (err) {
+      console.error(`Error running prompt: ${err instanceof Error ? err.message : String(err)}`);
+      return 1;
+    }
+  }
+  return usageError("prompt command requires list|show|run");
+}
+async function handleRollupCommand({ positional, flags }) {
+  const ctx = requireRoot(flags);
+  if (!ctx)
+    return 1;
+  const period = flags["period"] || positional[0] || "week";
+  if (period !== "week" && period !== "month" && period !== "quarter") {
+    return usageError("--period must be week, month, or quarter");
+  }
+  try {
+    const res = rollupTemporal(ctx.store, {
+      memoryDir: ctx.memoryDir,
+      period,
+      date: flags["date"],
+      project: flags["project"]
+    });
+    const periodLabel = period === "week" ? "weekly" : period === "month" ? "monthly" : "quarterly";
+    console.log(`Compiled ${periodLabel} rollup (${res.periodKey}) to ${res.filePath} (${res.entriesCount} memories).`);
+    return 0;
+  } catch (err) {
+    console.error(`Error during rollup: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+}
+async function handleLoopCommand({ positional, flags }) {
+  const ctx = requireRoot(flags);
+  if (!ctx)
+    return 1;
+  const sub = positional[0] ?? "status";
+  if (sub === "record" || sub === "add") {
+    const index = parseInt(flags["index"] ?? positional[1] ?? "1", 10) || 1;
+    const verdict = flags["verdict"] || "fail";
+    const fix = flags["fix"] || positional.slice(2).join(" ") || "No description";
+    const tests = flags["tests"] || "Unspecified";
+    try {
+      const entry = recordIteration(ctx.memoryDir, {
+        iteration_index: index,
+        critic_verdict: verdict,
+        largest_fix_identified: fix,
+        test_results: tests,
+        diff_hash: flags["diff-hash"] || flags["diff_hash"]
+      });
+      console.log(`Recorded iteration #${entry.iteration_index} [${entry.critic_verdict}]: ${entry.largest_fix_identified}`);
+      return 0;
+    } catch (err) {
+      console.error(`Error recording iteration: ${err instanceof Error ? err.message : String(err)}`);
+      return 1;
+    }
+  }
+  if (sub === "clear") {
+    clearIterations(ctx.memoryDir);
+    console.log("Cleared iteration ledger.");
+    return 0;
+  }
+  const status = detectIterationStatus(ctx.memoryDir);
+  console.log(`Iteration Loop Status:
+- Total iterations: ${status.totalIterations}
+- Last verdict: ${status.lastVerdict ?? "none"}
+- Consecutive failures: ${status.consecutiveFailures}
+- Plateau detected: ${status.isPlateaued ? "YES" : "No"}
+- Regression detected: ${status.isRegressed ? "YES" : "No"}
+- Recommendation: ${status.recommendation}`);
+  return 0;
+}
+var init_evolution = __esm(() => {
+  init_shared();
+  init_provenance();
+  init_claims();
+  init_snapshot();
+  init_prompts();
+  init_temporal();
+  init_iterations();
+});
+
 // src/cli.ts
 var exports_cli = {};
 __export(exports_cli, {
@@ -30316,6 +32330,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":
@@ -30388,6 +32405,22 @@ async function main(argv) {
       return handleEntitiesCommand(parsed);
     case "settings":
       return handleSettingsCommand(parsed);
+    case "source":
+    case "sources":
+      return handleSourceCommand(parsed);
+    case "claim":
+    case "claims":
+      return handleClaimCommand(parsed);
+    case "freeze":
+      return handleFreezeCommand(parsed);
+    case "prompt":
+    case "prompts":
+      return handlePromptCommand(parsed);
+    case "rollup":
+      return handleRollupCommand(parsed);
+    case "loop":
+    case "iterations":
+      return handleLoopCommand(parsed);
     default:
       console.error(`Error: unknown command "${cmd}"`);
       return 2;
@@ -30423,11 +32456,19 @@ Core Memory Lifecycle Commands:
   routine run <name>            Execute a routine's steps from .memory/routines.yaml
   routine install [name]        Print crontab line(s) for routines (user installs; no system mutation)
   distill [--min-count N] [--dry-run]  Distill recurring fix patterns into .agents/skills/ folders
-  verify <id> [--timeout S]     Execute a fix entry's test_command; exit 0 promotes + independently verifies
+  verify <id> [--timeout S] [--strict] Execute test_command or run full strict integrity gate
   briefing [--limit N]          Executive summary of active and stale memories
 
+Evidence, Provenance & Cognitive Governance:
+  source [add|list|show]        Manage external documentation and URLs in provenance Source Ledger
+  claim [record|list|show]      Record verifiable claims with confidence tags ([RAW], [FETCH], [SEARCH], [INFER])
+  freeze --task <task> [--run-id R] Capture immutable execution snapshot with file inventory & sha-256 hashes
+  prompt [list|show|run <name>] Manage and run structured prompt templates with live context injection
+  rollup --period week|month|quarter Multi-scale temporal compounding & HOT.md working cache generation
+  loop [record|status|clear]    Gauntlet iteration ledger & plateau/regression detector
+
 Context & Retrieval Commands:
-  context [query] [--limit N] [--token-budget N] [--depth L1|L2|L3] Top-ranked prompt injection context
+  context [query] [--limit N] [--token-budget N] [--depth L1|L2|L3] [--tier 0|1|2] Top-ranked prompt context
   search <query> [--limit N] [--token-budget N] [--hybrid] [--tree] Scored token retrieval (hybrid: vector+BM25, tree: hierarchical reasoning)
   reindex                       Rebuild the local vector index (.memory/index.json) for hybrid search
   recall [query]                Search active/confirmed memories with filters
@@ -30449,6 +32490,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,12 +32507,14 @@ var init_cli = __esm(() => {
   init_shared();
   init_ecosystem();
   init_upgrade();
+  init_harvester();
   init_retrieval3();
   init_persona();
   init_wiki2();
   init_entities2();
   init_settings3();
   init_lifecycle();
+  init_evolution();
 });
 
 // bin/memory.ts