musememory 1.10.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;
@@ -5292,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";
@@ -9058,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);
@@ -9150,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();
@@ -9338,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
@@ -17058,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 {
@@ -17106,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();
@@ -26698,8 +26948,8 @@ var init_loops = __esm(() => {
 });
 
 // src/distill.ts
-import { existsSync as existsSync30, mkdirSync as mkdirSync18, writeFileSync as writeFileSync16 } from "node:fs";
-import { join as join27 } 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));
@@ -26710,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 ?? join27(workspaceRoot, ".agents", "skills");
+  const skillsDir = options.skillsDir ?? join28(workspaceRoot, ".agents", "skills");
   for (const cluster of clusters) {
     if (cluster.length < minCount) {
       report.clustersBelowThreshold++;
@@ -26718,9 +26968,9 @@ function distillSkills(store, workspaceRoot, options = {}) {
     }
     const topic = dominantTopicTokens(cluster.map((e) => e.title));
     const slug = slugifyId(topic.join("-") || "skill");
-    const dir = join27(skillsDir, slug);
+    const dir = join28(skillsDir, slug);
     const memberIds = cluster.map((e) => e.id);
-    if (existsSync30(dir)) {
+    if (existsSync31(dir)) {
       report.skippedExisting.push({ slug, members: memberIds });
       continue;
     }
@@ -26730,10 +26980,10 @@ function distillSkills(store, workspaceRoot, options = {}) {
       throw new Error(`Secret detected in generated SKILL.md for '${slug}': ${secrets.join(", ")}`);
     }
     if (!options.dryRun) {
-      mkdirSync18(dir, { recursive: true });
-      writeFileSync16(join27(dir, "SKILL.md"), md, "utf8");
+      mkdirSync19(dir, { recursive: true });
+      writeFileSync17(join28(dir, "SKILL.md"), md, "utf8");
     }
-    report.created.push({ slug, path: join27(dir, "SKILL.md"), members: memberIds });
+    report.created.push({ slug, path: join28(dir, "SKILL.md"), members: memberIds });
   }
   return report;
 }
@@ -26772,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) {
@@ -26858,6 +27285,178 @@ ${result.stderr}`.trim().slice(0, 2000)
   }
   return result;
 }
+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();
@@ -27071,14 +27670,14 @@ var init_schema2 = __esm(() => {
 });
 
 // src/settings/loader.ts
-import { existsSync as existsSync31, mkdirSync as mkdirSync19, readFileSync as readFileSync25, writeFileSync as writeFileSync17 } from "node:fs";
-import { join as join28 } 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 join28(memoryDir, "settings.json");
+  return join31(memoryDir, "settings.json");
 }
 function loadSettings(memoryDir) {
   const filePath = getSettingsFilePath(memoryDir);
-  if (!existsSync31(filePath)) {
+  if (!existsSync34(filePath)) {
     return {
       version: 1,
       global: JSON.parse(JSON.stringify(DEFAULT_SETTINGS)),
@@ -27086,7 +27685,7 @@ function loadSettings(memoryDir) {
     };
   }
   try {
-    const raw = readFileSync25(filePath, "utf8");
+    const raw = readFileSync28(filePath, "utf8");
     const parsed = JSON.parse(raw);
     return {
       version: parsed.version || 1,
@@ -27102,9 +27701,9 @@ function loadSettings(memoryDir) {
   }
 }
 function saveSettings(store, memoryDir) {
-  mkdirSync19(memoryDir, { recursive: true });
+  mkdirSync22(memoryDir, { recursive: true });
   const filePath = getSettingsFilePath(memoryDir);
-  writeFileSync17(filePath, JSON.stringify(store, null, 2), "utf8");
+  writeFileSync20(filePath, JSON.stringify(store, null, 2), "utf8");
 }
 function getSettings(memoryDir) {
   return loadSettings(memoryDir).global;
@@ -27211,88 +27810,592 @@ var init_settings2 = __esm(() => {
   init_settings();
 });
 
-// src/plasticity.ts
-var exports_plasticity = {};
-__export(exports_plasticity, {
-  getAssociatedMemories: () => getAssociatedMemories,
-  getHebbianAssociationWeight: () => getHebbianAssociationWeight,
-  loadHebbianGraph: () => loadHebbianGraph,
-  recordCoActivation: () => recordCoActivation,
-  saveHebbianGraph: () => saveHebbianGraph
-});
-import { existsSync as existsSync32, readFileSync as readFileSync26, writeFileSync as writeFileSync18 } from "node:fs";
-import { join as join29 } from "node:path";
-function getPlasticityPath(memoryDir) {
-  return join29(memoryDir, "hebbian-plasticity.json");
-}
-function loadHebbianGraph(memoryDir) {
-  const p = getPlasticityPath(memoryDir);
-  if (!existsSync32(p))
-    return {};
-  try {
-    return JSON.parse(readFileSync26(p, "utf8"));
-  } catch {
-    return {};
+// 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 saveHebbianGraph(memoryDir, graph) {
-  const p = getPlasticityPath(memoryDir);
-  try {
-    writeFileSync18(p, JSON.stringify(graph, null, 2), "utf8");
-  } catch {}
+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 recordCoActivation(memoryIds, memoryDir) {
-  const ids = Array.from(new Set(memoryIds.filter(Boolean)));
-  if (ids.length < 2)
-    return;
-  const graph = loadHebbianGraph(memoryDir);
-  const now = new Date().toISOString();
-  for (let i = 0;i < ids.length; i++) {
-    const src = ids[i];
-    if (!graph[src])
-      graph[src] = {};
-    for (let j = 0;j < ids.length; j++) {
-      if (i === j)
-        continue;
-      const tgt = ids[j];
-      const existing = graph[src][tgt];
-      const prevWeight = existing ? existing.weight : 0;
-      const prevCount = existing ? existing.count : 0;
-      const newWeight = Math.min(1, Math.round((prevWeight + 0.05) * 1000) / 1000);
-      graph[src][tgt] = {
-        weight: newWeight,
-        count: prevCount + 1,
-        lastActivated: now
+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
       };
     }
   }
-  saveHebbianGraph(memoryDir, graph);
-}
-function getHebbianAssociationWeight(sourceId, targetId, memoryDir) {
-  const graph = loadHebbianGraph(memoryDir);
-  return graph[sourceId]?.[targetId]?.weight ?? 0;
+  return {
+    name,
+    title: name,
+    description: "",
+    template: content.trim()
+  };
 }
-function getAssociatedMemories(sourceId, memoryDir) {
-  const graph = loadHebbianGraph(memoryDir);
-  const targets = graph[sourceId];
-  if (!targets)
-    return [];
-  return Object.entries(targets).map(([targetId, edge]) => ({
-    targetId,
-    weight: edge.weight,
-    count: edge.count
-  })).sort((a, b) => b.weight - a.weight);
+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 init_plasticity = () => {};
-
-// src/compress.ts
-var exports_compress = {};
-__export(exports_compress, {
-  compressPromptContext: () => compressPromptContext,
-  estimateTokens: () => estimateTokens
+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.`
+    }
+  ];
 });
-function estimateTokens(text) {
-  if (!text || text.trim().length === 0)
+
+// 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, {
+  getAssociatedMemories: () => getAssociatedMemories,
+  getHebbianAssociationWeight: () => getHebbianAssociationWeight,
+  loadHebbianGraph: () => loadHebbianGraph,
+  recordCoActivation: () => recordCoActivation,
+  saveHebbianGraph: () => saveHebbianGraph
+});
+import { existsSync as existsSync38, readFileSync as readFileSync32, writeFileSync as writeFileSync24 } from "node:fs";
+import { join as join35 } from "node:path";
+function getPlasticityPath(memoryDir) {
+  return join35(memoryDir, "hebbian-plasticity.json");
+}
+function loadHebbianGraph(memoryDir) {
+  const p = getPlasticityPath(memoryDir);
+  if (!existsSync38(p))
+    return {};
+  try {
+    return JSON.parse(readFileSync32(p, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveHebbianGraph(memoryDir, graph) {
+  const p = getPlasticityPath(memoryDir);
+  try {
+    writeFileSync24(p, JSON.stringify(graph, null, 2), "utf8");
+  } catch {}
+}
+function recordCoActivation(memoryIds, memoryDir) {
+  const ids = Array.from(new Set(memoryIds.filter(Boolean)));
+  if (ids.length < 2)
+    return;
+  const graph = loadHebbianGraph(memoryDir);
+  const now = new Date().toISOString();
+  for (let i = 0;i < ids.length; i++) {
+    const src = ids[i];
+    if (!graph[src])
+      graph[src] = {};
+    for (let j = 0;j < ids.length; j++) {
+      if (i === j)
+        continue;
+      const tgt = ids[j];
+      const existing = graph[src][tgt];
+      const prevWeight = existing ? existing.weight : 0;
+      const prevCount = existing ? existing.count : 0;
+      const newWeight = Math.min(1, Math.round((prevWeight + 0.05) * 1000) / 1000);
+      graph[src][tgt] = {
+        weight: newWeight,
+        count: prevCount + 1,
+        lastActivated: now
+      };
+    }
+  }
+  saveHebbianGraph(memoryDir, graph);
+}
+function getHebbianAssociationWeight(sourceId, targetId, memoryDir) {
+  const graph = loadHebbianGraph(memoryDir);
+  return graph[sourceId]?.[targetId]?.weight ?? 0;
+}
+function getAssociatedMemories(sourceId, memoryDir) {
+  const graph = loadHebbianGraph(memoryDir);
+  const targets = graph[sourceId];
+  if (!targets)
+    return [];
+  return Object.entries(targets).map(([targetId, edge]) => ({
+    targetId,
+    weight: edge.weight,
+    count: edge.count
+  })).sort((a, b) => b.weight - a.weight);
+}
+var init_plasticity = () => {};
+
+// src/compress.ts
+var exports_compress = {};
+__export(exports_compress, {
+  compressPromptContext: () => compressPromptContext,
+  estimateTokens: () => estimateTokens
+});
+function estimateTokens(text) {
+  if (!text || text.trim().length === 0)
     return 0;
   return Math.max(1, Math.ceil(text.length / 4));
 }
@@ -27329,8 +28432,8 @@ __export(exports_drift, {
   scanCodeDriftFromDiff: () => scanCodeDriftFromDiff
 });
 import { execSync as execSync3 } from "node:child_process";
-import { existsSync as existsSync33 } from "node:fs";
-import { join as join30, isAbsolute as isAbsolute2 } from "node:path";
+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));
@@ -27344,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 : join30(root, p);
-        const exists = existsSync33(fullPath);
+        const fullPath = isAbsolute2(p) ? p : join36(root, p);
+        const exists = existsSync39(fullPath);
         drifted.push({
           memoryId: entry.id,
           title: entry.title,
@@ -27419,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;
@@ -27472,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)" }
           }
         }
       },
@@ -28048,6 +29153,173 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
           },
           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: {
+            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_freeze_list",
+        description: "List recorded frozen execution snapshots in .memory/runs/",
+        inputSchema: {
+          type: "object",
+          properties: {
+            dir: { type: "string", description: "Optional project workspace directory path" }
+          }
+        }
+      },
+      {
+        name: "memory_prompt_list",
+        description: "List available structured prompt templates in .memory/prompts/",
+        inputSchema: {
+          type: "object",
+          properties: {
+            dir: { type: "string", description: "Optional project workspace directory path" }
+          }
+        }
+      },
+      {
+        name: "memory_prompt_get",
+        description: "Get prompt template by name",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            dir: { type: "string", description: "Optional project workspace directory path" }
+          },
+          required: ["name"]
+        }
+      },
+      {
+        name: "memory_prompt_run",
+        description: "Render prompt template with variable substitution and live memory context injection",
+        inputSchema: {
+          type: "object",
+          properties: {
+            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_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: {
+            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_loop_record",
+        description: "Record an iteration round in the multi-agent Gauntlet Iteration Ledger (.memory/iterations.jsonl)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            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: ["iteration_index", "critic_verdict", "largest_fix_identified", "test_results"]
+        }
+      },
+      {
+        name: "memory_loop_status",
+        description: "Inspect multi-round iteration status, plateau warnings, and regression signals",
+        inputSchema: {
+          type: "object",
+          properties: {
+            dir: { type: "string", description: "Optional project workspace directory path" }
+          }
+        }
+      },
+      {
+        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: {
+            max_candidate_days: { type: "number" },
+            dir: { type: "string", description: "Optional project workspace directory path" }
+          }
+        }
       }
     ]
   }));
@@ -28075,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,
@@ -28558,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}`);
       }
@@ -28565,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();
@@ -28614,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
@@ -28621,15 +30008,15 @@ var exports_daemon = {};
 __export(exports_daemon, {
   startHub: () => startHub
 });
-import { createServer as createServer2 } from "node:http";
-import { existsSync as existsSync34 } from "node:fs";
-import { join as join31 } 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",
@@ -28689,7 +30076,7 @@ data: ${JSON.stringify(event)}
     return clients.size;
   }
   if (memoryDir) {
-    const memoriesDir = join31(memoryDir, "memories");
+    const memoriesDir = join37(memoryDir, "memories");
     const armDebounced = (type2) => {
       if (debounceTimer)
         clearTimeout(debounceTimer);
@@ -28698,17 +30085,17 @@ data: ${JSON.stringify(event)}
       }, DEBOUNCE_MS);
     };
     try {
-      if (existsSync34(memoriesDir)) {
+      if (existsSync40(memoriesDir)) {
         watchers.push(watch(memoriesDir, () => armDebounced("memory.changed")));
       }
-      const currentMd = join31(memoryDir, "CURRENT.md");
-      if (existsSync34(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({
@@ -28735,19 +30122,19 @@ var DEBOUNCE_MS = 300;
 var init_daemon = () => {};
 
 // src/cli/ecosystem.ts
-import { join as join32 } from "node:path";
-import { existsSync as existsSync35, mkdirSync as mkdirSync20, writeFileSync as writeFileSync19, readFileSync as readFileSync27 } from "node:fs";
+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 = join32(targetDir, "AGENTS.md");
-  if (existsSync35(agentsMdPath)) {
+  const agentsMdPath = join38(targetDir, "AGENTS.md");
+  if (existsSync41(agentsMdPath)) {
     try {
-      const existing = readFileSync27(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);
-        writeFileSync19(agentsMdPath, updated, "utf8");
+        writeFileSync25(agentsMdPath, updated, "utf8");
       } else if (!existing.includes("<!-- musememory:start -->") && !existing.includes("Muse Memory")) {
-        writeFileSync19(agentsMdPath, `${existing.trim()}
+        writeFileSync25(agentsMdPath, `${existing.trim()}
 
 ${MUSE_MEMORY_DIRECTIVE}
 `, "utf8");
@@ -28758,23 +30145,23 @@ ${MUSE_MEMORY_DIRECTIVE}
 
 ${MUSE_MEMORY_DIRECTIVE}
 `;
-    writeFileSync19(agentsMdPath, initialContent, "utf8");
+    writeFileSync25(agentsMdPath, initialContent, "utf8");
   }
 }
 async function handleInstallCommand({ positional, flags }) {
   const isGlobal = flags["global"] === "true" || flags["g"] === "true";
-  const targetDir = positional[0] ? join32(process.cwd(), positional[0]) : process.cwd();
-  const memoryDir = isGlobal ? getGlobalMemoryDir() : join32(targetDir, ".memory");
+  const targetDir = positional[0] ? join38(process.cwd(), positional[0]) : process.cwd();
+  const memoryDir = isGlobal ? getGlobalMemoryDir() : join38(targetDir, ".memory");
   const globalDir = getGlobalMemoryDir();
-  mkdirSync20(join32(memoryDir, "memories"), { recursive: true });
-  mkdirSync20(join32(globalDir, "memories"), { recursive: true });
-  const currentPath = join32(memoryDir, "CURRENT.md");
-  if (!existsSync35(currentPath)) {
-    writeFileSync19(currentPath, `# Active Project Constraints
+  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 (!existsSync35(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" },
@@ -28790,13 +30177,13 @@ async function handleInstallCommand({ positional, flags }) {
   if (!isGlobal) {
     ensureProjectAgentInstructions(targetDir);
   }
-  const globalAgentsMd = join32(homedir7(), ".agents", "AGENTS.md");
-  if (existsSync35(globalAgentsMd)) {
+  const globalAgentsMd = join38(homedir7(), ".agents", "AGENTS.md");
+  if (existsSync41(globalAgentsMd)) {
     try {
-      const existing = readFileSync27(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);
-        writeFileSync19(globalAgentsMd, updated, "utf8");
+        writeFileSync25(globalAgentsMd, updated, "utf8");
       }
     } catch {}
   }
@@ -28857,11 +30244,11 @@ async function handleInstallCommand({ positional, flags }) {
   return 0;
 }
 async function promptOrNotifyGitHook(targetDir, autoInstall = false) {
-  const gitDir = join32(targetDir, ".git");
-  if (!existsSync35(gitDir))
+  const gitDir = join38(targetDir, ".git");
+  if (!existsSync41(gitDir))
     return false;
-  const hookPath = join32(gitDir, "hooks", "pre-commit");
-  const isInstalled = existsSync35(hookPath) && readFileSync27(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) {
@@ -28917,7 +30304,7 @@ async function handleUninstallCommand({ positional, flags }) {
       action: async () => {
         if (purge) {
           const ctx = requireRoot(flags);
-          if (ctx && existsSync35(ctx.memoryDir) && !dryRun) {
+          if (ctx && existsSync41(ctx.memoryDir) && !dryRun) {
             const { rmSync: rmSync3 } = await import("node:fs");
             rmSync3(ctx.memoryDir, { recursive: true, force: true });
           }
@@ -28949,13 +30336,13 @@ async function handleUninstallCommand({ positional, flags }) {
 }
 async function handleInitCommand({ positional, flags }) {
   const isGlobal = flags["global"] === "true";
-  const targetDir = positional[0] ? join32(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() : join32(targetDir, memoryDirName);
-  mkdirSync20(join32(memoryDir, "memories"), { recursive: true });
-  const currentPath = join32(memoryDir, "CURRENT.md");
-  if (!existsSync35(currentPath)) {
-    writeFileSync19(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) {
@@ -29246,8 +30633,8 @@ var init_ecosystem = __esm(() => {
 });
 
 // src/agentcontract.ts
-import { existsSync as existsSync36 } from "node:fs";
-import { join as join33 } 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;
@@ -29279,17 +30666,17 @@ function parseAgentMemoryContract(markdown) {
 function resolveAgentFile(nameOrPath, workspaceRoot) {
   if (!nameOrPath)
     return null;
-  if (existsSync36(nameOrPath))
+  if (existsSync42(nameOrPath))
     return nameOrPath;
   const candidates = [
-    join33(workspaceRoot, ".agents", `${nameOrPath}.md`),
-    join33(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(join33(home, ".config", "opencode", "agents", `${nameOrPath}.md`));
+    candidates.push(join39(home, ".config", "opencode", "agents", `${nameOrPath}.md`));
   for (const c of candidates) {
-    if (existsSync36(c))
+    if (existsSync42(c))
       return c;
   }
   return null;
@@ -29299,8 +30686,8 @@ var init_agentcontract = __esm(() => {
 });
 
 // src/cli/retrieval.ts
-import { existsSync as existsSync37, readFileSync as readFileSync28 } from "node:fs";
-import { join as join34 } 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;
@@ -29308,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(readFileSync28(file, "utf8"));
+    const contract = parseAgentMemoryContract(readFileSync34(file, "utf8"));
     if (contract) {
       agentTypes = contract.types;
       agentTags = contract.tags;
@@ -29326,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,
@@ -29448,7 +30855,7 @@ async function handleHarvestCommand({ positional, flags }) {
   const project = flags["project"];
   if (!project)
     return usageError("harvest requires --project");
-  const rawText = existsSync37(target) ? readFileSync28(target, "utf8") : target;
+  const rawText = existsSync43(target) ? readFileSync34(target, "utf8") : target;
   const created = harvestMemories(ctx.store, {
     text: rawText,
     project,
@@ -29484,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 : join34(process.cwd(), filePath) : join34(process.cwd(), "transcript.jsonl");
-  if (!existsSync37(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;
@@ -29501,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 -> ${join34(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 }) {
@@ -29535,6 +30942,7 @@ async function handleHarvestAutoCommand({ flags }) {
 }
 var init_retrieval3 = __esm(() => {
   init_retrieval();
+  init_tiered();
   init_vector();
   init_retrieval2();
   init_harvest();
@@ -29892,7 +31300,7 @@ var init_entities2 = __esm(() => {
 });
 
 // src/cli/settings.ts
-import { writeFileSync as writeFileSync20, readFileSync as readFileSync29 } from "node:fs";
+import { writeFileSync as writeFileSync26, readFileSync as readFileSync35 } from "node:fs";
 function handleSettingsCommand(parsed) {
   const ctx = requireRoot(parsed.flags);
   if (!ctx)
@@ -29974,7 +31382,7 @@ function handleSettingsCommand(parsed) {
     const out = parsed.flags.out;
     const json2 = exportSettings(memoryDir);
     if (out) {
-      writeFileSync20(out, json2, "utf8");
+      writeFileSync26(out, json2, "utf8");
       console.log(`Exported settings to ${out}`);
     } else {
       console.log(json2);
@@ -29988,7 +31396,7 @@ function handleSettingsCommand(parsed) {
       return 2;
     }
     try {
-      const raw = readFileSync29(file, "utf8");
+      const raw = readFileSync35(file, "utf8");
       importSettings(memoryDir, raw);
       console.log(`Successfully imported settings from ${file}`);
       return 0;
@@ -30011,16 +31419,16 @@ var init_nudge = __esm(() => {
 });
 
 // src/routines.ts
-import { readFileSync as readFileSync30, existsSync as existsSync38 } from "node:fs";
-import { join as join35 } from "node:path";
+import { readFileSync as readFileSync36, existsSync as existsSync44 } from "node:fs";
+import { join as join41 } from "node:path";
 function routinesPath(memoryDir) {
-  return join35(memoryDir, "routines.yaml");
+  return join41(memoryDir, "routines.yaml");
 }
 function loadRoutines(memoryDir) {
   const p = routinesPath(memoryDir);
-  if (!existsSync38(p))
+  if (!existsSync44(p))
     return { routines: {} };
-  const doc2 = yaml.load(readFileSync30(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()) {
@@ -30058,7 +31466,7 @@ var init_routines = __esm(() => {
 });
 
 // src/cli/lifecycle.ts
-import { writeFileSync as writeFileSync21, readFileSync as readFileSync31, existsSync as existsSync39 } 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)
@@ -30207,7 +31615,7 @@ async function handleExportCommand({ flags }) {
   const snapshot = exportSnapshot(ctx.store);
   const outPath = flags["out"];
   if (outPath) {
-    writeFileSync21(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));
@@ -30221,9 +31629,9 @@ async function handleImportCommand({ positional, flags }) {
   const file = positional[0];
   if (!file)
     return usageError("import requires <file.json>");
-  if (!existsSync39(file))
+  if (!existsSync45(file))
     return fail(`error: file ${file} does not exist`);
-  const raw = JSON.parse(readFileSync31(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:`);
@@ -30513,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())
@@ -30568,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, {
@@ -30706,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;
@@ -30741,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
@@ -30791,6 +32514,7 @@ var init_cli = __esm(() => {
   init_entities2();
   init_settings3();
   init_lifecycle();
+  init_evolution();
 });
 
 // bin/memory.ts