musememory 2.2.0 → 2.3.0

package/dist/index.js

@@ -4594,6 +4594,18 @@ function formatPromptContext(store, memoryDir, query = "", options = {}) {
     }
     parts.push("");
   }
+  const currentData = memoryDir ? parseCurrentFile(memoryDir) : null;
+  if (currentData?.workstreams && currentData.workstreams.length > 0) {
+    const activeWs = currentData.workstreams.filter((w) => w.status === "IN-PROGRESS" || w.status === "BLOCKED");
+    if (activeWs.length > 0) {
+      parts.push("### Active Concurrent Agent Workstreams (CURRENT.md)");
+      for (const w of activeWs) {
+        const scope = w.targetScope ? ` | Target: \`${w.targetScope}\`` : "";
+        parts.push(`- Agent \`${w.agent}\` [${w.status}]: ${w.task}${scope} (Active: ${w.lastActive})`);
+      }
+      parts.push("");
+    }
+  }
   const handoff = memoryDir ? getSessionHandoff(memoryDir) : null;
   if (handoff && (handoff.status === "IN-PROGRESS" || handoff.task || handoff.lastQuery)) {
     parts.push("### Active In-Flight Context & Session Handoff (CURRENT.md)");
@@ -4891,38 +4903,83 @@ function currentFilePath(memoryDir) {
 function parseCurrentFile(memoryDir) {
   const p = currentFilePath(memoryDir);
   if (!existsSync6(p))
-    return { constraints: [], handoff: null };
+    return { constraints: [], handoff: null, workstreams: [] };
   const raw = readFileSync5(p, "utf8");
   const lines = raw.split(`
 `);
   const constraints = [];
+  const workstreams = [];
   let inConstraintsSection = false;
   let inHandoffSection = false;
+  let inWorkstreamsSection = false;
   const handoffLines = [];
   for (const line of lines) {
     const trimmed = line.trim();
-    if (trimmed.startsWith("## Active Working Invariants") || trimmed.startsWith("## Active Constraints")) {
+    if (trimmed.startsWith("## Active Working Invariants") || trimmed.startsWith("## Active Working Constraints") || trimmed.startsWith("## Active Constraints") || trimmed.startsWith("## \uD83D\uDD12 Active Working Invariants")) {
       inConstraintsSection = true;
       inHandoffSection = false;
+      inWorkstreamsSection = false;
+      continue;
+    }
+    if (trimmed.startsWith("## \uD83E\uDD16 Active Concurrent Agent Workstreams") || trimmed.startsWith("## Concurrent Agent Workstreams") || trimmed.startsWith("## Active Workstreams")) {
+      inConstraintsSection = false;
+      inHandoffSection = false;
+      inWorkstreamsSection = true;
       continue;
     }
-    if (trimmed.startsWith("## Active Work In Progress") || trimmed.startsWith("## In-Flight Session State") || trimmed.startsWith("## Session Handoff")) {
+    if (trimmed.startsWith("## Active Work In Progress") || trimmed.startsWith("## In-Flight Session State") || trimmed.startsWith("## Session Handoff") || trimmed.startsWith("## ⚡ Active Work In Progress")) {
       inConstraintsSection = false;
       inHandoffSection = true;
+      inWorkstreamsSection = false;
       continue;
     }
-    if (trimmed.startsWith("# ")) {
+    if (trimmed.startsWith("# ") || trimmed.startsWith("> ") || trimmed.startsWith("---")) {
       continue;
     }
-    if (inHandoffSection) {
-      handoffLines.push(line);
+    if (inWorkstreamsSection) {
+      if (trimmed.startsWith("##")) {
+        inWorkstreamsSection = false;
+      } else if (trimmed.startsWith("|")) {
+        const cells = trimmed.split("|").map((c) => c.trim()).filter((_, idx, arr) => idx > 0 && idx < arr.length - 1);
+        if (cells.length >= 3 && !cells[0].includes("---") && !cells[1].toLowerCase().includes("status")) {
+          const agent = cells[0].replace(/[`*]/g, "").trim();
+          const statusRaw = cells[1].replace(/[\[\]`*]/g, "").trim().toUpperCase();
+          const status = statusRaw === "COMPLETED" || statusRaw === "BLOCKED" || statusRaw === "WAITING_REVIEW" ? statusRaw : "IN-PROGRESS";
+          const task = cells[2].trim();
+          const scope = cells[3] ? cells[3].replace(/[`*()]/g, "").trim() : undefined;
+          const lastActive = cells[4] ? cells[4].trim() : new Date().toISOString();
+          if (agent && task) {
+            workstreams.push({
+              agent,
+              status,
+              task,
+              targetScope: scope && scope !== "all" ? scope : undefined,
+              lastActive
+            });
+          }
+        }
+      }
+    } else if (inHandoffSection) {
+      if (trimmed.startsWith("##")) {
+        inHandoffSection = false;
+      } else {
+        handoffLines.push(line);
+      }
     } else if (inConstraintsSection) {
-      if (trimmed.length > 0 && !trimmed.startsWith("#") && !trimmed.startsWith("*(") && !trimmed.startsWith("(*")) {
-        constraints.push(trimmed.replace(/^-\s+/, ""));
+      if (trimmed.startsWith("##")) {
+        inConstraintsSection = false;
+      } else if (trimmed.length > 0 && !trimmed.startsWith("#") && !trimmed.startsWith("*(") && !trimmed.startsWith("(*")) {
+        const cleaned = trimmed.replace(/^-\s+/, "");
+        if (isValidConstraintLine(cleaned)) {
+          constraints.push(cleaned);
+        }
       }
-    } else if (!inConstraintsSection && !inHandoffSection) {
-      if (trimmed.length > 0 && !trimmed.startsWith("#") && !trimmed.startsWith("*(") && !trimmed.startsWith("(*")) {
-        constraints.push(trimmed.replace(/^-\s+/, ""));
+    } else if (!inConstraintsSection && !inHandoffSection && !inWorkstreamsSection) {
+      const hasSections = lines.some((l) => l.trim().startsWith("## "));
+      if (!hasSections && trimmed.length > 0 && !trimmed.startsWith("#") && !trimmed.startsWith("*(") && !trimmed.startsWith("(*") && !trimmed.startsWith("|")) {
+        if (isValidConstraintLine(trimmed)) {
+          constraints.push(trimmed.replace(/^-\s+/, ""));
+        }
       }
     }
   }
@@ -4978,14 +5035,22 @@ function parseCurrentFile(memoryDir) {
       };
     }
   }
-  return { constraints, handoff };
+  return { constraints, handoff, workstreams };
 }
 function writeCurrentFile(memoryDir, data) {
   const p = currentFilePath(memoryDir);
   mkdirSync5(memoryDir, { recursive: true });
-  const parts = [`# Active Project Constraints & In-Flight Context
-`];
-  parts.push("## Active Working Invariants & Hard Constraints");
+  const parts = [
+    `# Active Project Constraints & In-Flight Context
+`,
+    "> **Operational Guidelines**:",
+    "> - **For Humans**: Single-pane executive summary of active hard constraints and in-flight agent tasks. Zero verbose logs or transient filler.",
+    `> - **For AI Agents**: Mandatory grounding rules (never violate active constraints) and concurrent workstream awareness (check what other agents are touching before editing files).
+`,
+    `---
+`
+  ];
+  parts.push("## \uD83D\uDD12 Active Working Invariants & Hard Constraints");
   if (data.constraints.length === 0) {
     parts.push(`*(No active hard constraints)*
 `);
@@ -4995,8 +5060,19 @@ function writeCurrentFile(memoryDir, data) {
     }
     parts.push("");
   }
+  if (data.workstreams && data.workstreams.length > 0) {
+    parts.push("## \uD83E\uDD16 Active Concurrent Agent Workstreams");
+    parts.push("| Agent / Session ID | Status | Active Task | Target Scope / Files | Last Active |");
+    parts.push("| :--- | :--- | :--- | :--- | :--- |");
+    for (const ws of data.workstreams) {
+      const statusTag = `[${ws.status || "IN-PROGRESS"}]`;
+      const scope = ws.targetScope ? `\`${ws.targetScope}\`` : "*(all)*";
+      parts.push(`| \`${ws.agent}\` | ${statusTag} | ${ws.task} | ${scope} | ${ws.lastActive} |`);
+    }
+    parts.push("");
+  }
   if (data.handoff) {
-    parts.push("## Active Work In Progress (Real-Time Session Handoff)");
+    parts.push("## ⚡ Active Work In Progress (Real-Time Session Handoff)");
     parts.push(`- **Status**: [${data.handoff.status}]`);
     if (data.handoff.agent)
       parts.push(`- **Active Agent**: ${data.handoff.agent}`);
@@ -5042,12 +5118,61 @@ function updateSessionHandoff(memoryDir, update) {
     progress: progressMerged,
     discoveries: discoveriesMerged
   };
+  const workstreams = current.workstreams ? [...current.workstreams] : [];
+  if (updated.agent && (updated.task || updated.lastQuery)) {
+    const wsIdx = workstreams.findIndex((w) => updated.sessionId && w.sessionId === updated.sessionId || w.agent.toLowerCase() === updated.agent.toLowerCase());
+    const wsEntry = {
+      agent: updated.agent,
+      sessionId: updated.sessionId,
+      task: updated.task || updated.lastQuery || "Active task",
+      status: updated.status || "IN-PROGRESS",
+      lastActive: now,
+      lastInstruction: updated.lastQuery
+    };
+    if (wsIdx >= 0) {
+      workstreams[wsIdx] = { ...workstreams[wsIdx], ...wsEntry };
+    } else {
+      workstreams.push(wsEntry);
+    }
+  }
   writeCurrentFile(memoryDir, {
     constraints: current.constraints,
-    handoff: updated
+    handoff: updated,
+    workstreams
   });
   return updated;
 }
+function registerAgentWorkstream(memoryDir, workstream) {
+  const current = parseCurrentFile(memoryDir);
+  const now = new Date().toISOString();
+  const workstreams = current.workstreams ? [...current.workstreams] : [];
+  const entry = {
+    agent: workstream.agent,
+    sessionId: workstream.sessionId,
+    task: workstream.task,
+    targetScope: workstream.targetScope,
+    status: workstream.status || "IN-PROGRESS",
+    lastActive: workstream.lastActive || now,
+    lastInstruction: workstream.lastInstruction
+  };
+  const idx = workstreams.findIndex((w) => entry.sessionId && w.sessionId === entry.sessionId || w.agent.toLowerCase() === entry.agent.toLowerCase());
+  if (idx >= 0) {
+    workstreams[idx] = { ...workstreams[idx], ...entry, lastActive: now };
+  } else {
+    workstreams.push(entry);
+  }
+  const nowMs = Date.now();
+  const pruned = workstreams.filter((w) => {
+    if (w.status === "COMPLETED") {
+      const activeMs = Date.parse(w.lastActive) || 0;
+      return nowMs - activeMs < 48 * 3600 * 1000;
+    }
+    return true;
+  });
+  current.workstreams = pruned;
+  writeCurrentFile(memoryDir, current);
+  return pruned;
+}
 function getSessionHandoff(memoryDir) {
   return parseCurrentFile(memoryDir).handoff;
 }
@@ -5062,6 +5187,15 @@ function markSessionCompleted(memoryDir, summary) {
   if (summary) {
     current.handoff.task = `[COMPLETED] ${summary}`;
   }
+  if (current.workstreams && current.handoff.agent) {
+    const ws = current.workstreams.find((w) => w.agent.toLowerCase() === current.handoff.agent.toLowerCase());
+    if (ws) {
+      ws.status = "COMPLETED";
+      ws.lastActive = now;
+      if (summary)
+        ws.task = `[COMPLETED] ${summary}`;
+    }
+  }
   writeCurrentFile(memoryDir, current);
 }
 function getCurrent2(memoryDir) {
@@ -5079,6 +5213,27 @@ function setCurrent(memoryDir, text, project = "default") {
   }
   return current.constraints;
 }
+function isValidConstraintLine(text) {
+  const trimmed = text.trim();
+  if (trimmed.length < 5 || trimmed.length > 300)
+    return false;
+  if (trimmed.includes(`
+`))
+    return false;
+  if (/expect\(/i.test(trimmed) || /Ran\s+\d+\s+tests/i.test(trimmed))
+    return false;
+  if (trimmed.startsWith("Showing lines") || trimmed.startsWith("Created At:") || trimmed.startsWith("File Path:"))
+    return false;
+  if (trimmed.startsWith("MODEL PLANNER_RESPONSE") || trimmed.startsWith("</SYSTEM_MESSAGE>"))
+    return false;
+  if (trimmed.includes("<truncated") || trimmed.includes("User: That worked"))
+    return false;
+  if (trimmed.startsWith("total ") || /^\d+:\s+/.test(trimmed) || /^\d+\s*\|\s*/.test(trimmed))
+    return false;
+  if (trimmed.startsWith("The following code has been modified") || trimmed.startsWith("The above content does NOT"))
+    return false;
+  return true;
+}
 function syncConstraints(memoryDir, store, pruneContents = []) {
   const entries = list(store);
   const activeConstraintMemories = entries.filter((e) => e.type === "constraint" && (e.status === "active" || e.status === "confirmed"));
@@ -5090,24 +5245,42 @@ Stale:`)[0].split(`
 Superseded:`)[0].trim()).filter(Boolean);
   const current = parseCurrentFile(memoryDir);
   const keptManual = [];
+  const seenNorms = new Set;
   for (const c of current.constraints) {
+    if (!isValidConstraintLine(c))
+      continue;
     if (pruneContents.some((p) => c.includes(p)))
       continue;
     if (inactiveConstraintContents.some((ic) => ic.length > 0 && (c.includes(ic) || ic.includes(c))))
       continue;
+    const norm = c.toLowerCase().replace(/[^a-z0-9]/g, "");
+    if (seenNorms.has(norm))
+      continue;
+    seenNorms.add(norm);
     keptManual.push(c);
   }
   const resultConstraints = [...keptManual];
   for (const m of activeConstraintMemories) {
     const rawContent = m.content.trim();
-    if (!resultConstraints.some((c) => c.includes(rawContent))) {
-      const stamp = `[${m.created_at || new Date().toISOString()}] (${m.project}) ${rawContent}`;
+    if (rawContent.length < 5)
+      continue;
+    let constraintText = rawContent;
+    if (rawContent.includes(`
+`) || rawContent.length > 300) {
+      const firstLine = rawContent.split(`
+`)[0].trim().replace(/^[-*#0-9.:\s|]+/, "");
+      constraintText = firstLine.length >= 10 && firstLine.length <= 300 ? firstLine : m.title.replace(/^[-*#0-9.:\s|]+/, "").slice(0, 200).trim();
+    }
+    const norm = constraintText.toLowerCase().replace(/[^a-z0-9]/g, "");
+    if (constraintText.length >= 5 && isValidConstraintLine(constraintText) && !resultConstraints.some((c) => c.toLowerCase().replace(/[^a-z0-9]/g, "").includes(norm))) {
+      const stamp = `[${m.created_at || new Date().toISOString()}] (${m.project}) ${constraintText}`;
       resultConstraints.push(stamp);
     }
   }
   writeCurrentFile(memoryDir, {
     constraints: resultConstraints,
-    handoff: current.handoff
+    handoff: current.handoff,
+    workstreams: current.workstreams
   });
   return resultConstraints;
 }
@@ -5303,6 +5476,9 @@ class WorkspaceGovernor {
   static checkpointSession(memoryDir, update) {
     return updateSessionHandoff(memoryDir, update);
   }
+  static registerWorkstream(memoryDir, workstream) {
+    return registerAgentWorkstream(memoryDir, workstream);
+  }
   static completeSession(memoryDir, summary) {
     markSessionCompleted(memoryDir, summary);
   }
@@ -5720,6 +5896,8 @@ function openDatabase(dbPath) {
     rawDb = new Database(dbPath, { create: true });
     rawDb.run("PRAGMA journal_mode = WAL;");
     rawDb.run("PRAGMA synchronous = NORMAL;");
+    rawDb.run("PRAGMA busy_timeout = 5000;");
+    rawDb.run("PRAGMA foreign_keys = ON;");
     rawDb.run("PRAGMA cache_size = -64000;");
     rawDb.run("PRAGMA mmap_size = 268435456;");
     rawDb.run("PRAGMA temp_store = MEMORY;");
@@ -5758,6 +5936,8 @@ function openDatabase(dbPath) {
     rawDb = new DatabaseSync(dbPath);
     rawDb.exec("PRAGMA journal_mode = WAL;");
     rawDb.exec("PRAGMA synchronous = NORMAL;");
+    rawDb.exec("PRAGMA busy_timeout = 5000;");
+    rawDb.exec("PRAGMA foreign_keys = ON;");
     rawDb.exec("PRAGMA cache_size = -64000;");
     rawDb.exec("PRAGMA mmap_size = 268435456;");
     rawDb.exec("PRAGMA temp_store = MEMORY;");
@@ -6709,19 +6889,52 @@ function list(store, filters) {
     if (cached)
       return cached;
   }
-  const ids = listIds(store);
-  const entries = ids.map((id) => get(store, id)).filter((e) => e !== null);
-  let filtered = entries;
-  if (filters?.project)
-    filtered = filtered.filter((e) => e.project === filters.project);
-  if (filters?.type)
-    filtered = filtered.filter((e) => e.type === filters.type);
-  if (filters?.status)
-    filtered = filtered.filter((e) => e.status === filters.status);
+  let entries = [];
+  if (store.db) {
+    entries = listMemories(store.db, filters);
+    if (existsSync10(store.dir)) {
+      const dbIds = new Set(entries.map((e) => e.id));
+      const diskFiles = readdirSync2(store.dir);
+      for (const f of diskFiles) {
+        if (f.endsWith(".yaml")) {
+          const diskId = f.slice(0, -5);
+          if (!dbIds.has(diskId)) {
+            const externalEntry = get(store, diskId);
+            if (externalEntry) {
+              try {
+                insertOrReplaceMemory(store.db, externalEntry);
+              } catch {}
+              let matches = true;
+              if (filters?.project && externalEntry.project !== filters.project)
+                matches = false;
+              if (filters?.type && externalEntry.type !== filters.type)
+                matches = false;
+              if (filters?.status && externalEntry.status !== filters.status)
+                matches = false;
+              if (matches)
+                entries.push(externalEntry);
+            }
+          }
+        }
+      }
+    }
+  } else {
+    const ids = listIds(store);
+    entries = ids.map((id) => get(store, id)).filter((e) => e !== null);
+    if (filters?.project)
+      entries = entries.filter((e) => e.project === filters.project);
+    if (filters?.type)
+      entries = entries.filter((e) => e.type === filters.type);
+    if (filters?.status)
+      entries = entries.filter((e) => e.status === filters.status);
+  }
   if (store.cache) {
-    store.cache.setQuery(cacheKey, filtered, undefined, dirMtime);
+    store.cache.setQuery(cacheKey, entries, undefined, dirMtime);
+    for (const e of entries) {
+      store.cache.setEntry(e);
+    }
   }
-  return filtered;
+  return entries;
 }
 function extractEntryText(entry) {
   const parts = [
@@ -6756,7 +6969,9 @@ function save(store, entry, options = {}) {
     try {
       mtimeMs = statSync(file).mtimeMs;
     } catch {}
-  } catch {}
+  } catch (err) {
+    console.warn(`[WARN] Dual-write YAML failed for memory '${entry.id}':`, err instanceof Error ? err.message : String(err));
+  }
   if (store.cache) {
     store.cache.setEntry(entry, undefined, mtimeMs);
   }
@@ -20574,77 +20789,97 @@ async function reconcileCodeAnchors(store, options = {}) {
   let repairedEntriesCount = 0;
   let staleEntriesCount = 0;
   const details = [];
-  for (const entry of entries) {
-    if (!entry.anchors || entry.anchors.length === 0)
-      continue;
-    totalAuditedEntries++;
-    const survivingAnchors = [];
-    const entryOrphaned = [];
-    const entryDrifted = [];
-    const actionsTaken = [];
-    let entryModified = false;
-    for (const anchor of entry.anchors) {
-      totalAnchors++;
-      const verification = verifyCodeAnchor(root, anchor);
-      if (verification.status === "valid") {
-        validCount++;
-        survivingAnchors.push(anchor);
-      } else if (verification.status === "drifted") {
-        driftedCount++;
-        entryDrifted.push(`${anchor.file_path}${anchor.symbol_name ? `::${anchor.symbol_name}` : ""}`);
-        if (updateHashes && verification.current_hash) {
-          if (!dryRun) {
-            anchor.structural_hash = verification.current_hash;
-            anchor.verified_at = new Date().toISOString();
+  const inTx = !dryRun && !!store.db;
+  if (inTx) {
+    try {
+      store.db.exec("BEGIN TRANSACTION;");
+    } catch {}
+  }
+  try {
+    for (const entry of entries) {
+      if (!entry.anchors || entry.anchors.length === 0)
+        continue;
+      totalAuditedEntries++;
+      const survivingAnchors = [];
+      const entryOrphaned = [];
+      const entryDrifted = [];
+      const actionsTaken = [];
+      let entryModified = false;
+      for (const anchor of entry.anchors) {
+        totalAnchors++;
+        const verification = verifyCodeAnchor(root, anchor);
+        if (verification.status === "valid") {
+          validCount++;
+          survivingAnchors.push(anchor);
+        } else if (verification.status === "drifted") {
+          driftedCount++;
+          entryDrifted.push(`${anchor.file_path}${anchor.symbol_name ? `::${anchor.symbol_name}` : ""}`);
+          if (updateHashes && verification.current_hash) {
+            if (!dryRun) {
+              anchor.structural_hash = verification.current_hash;
+              anchor.verified_at = new Date().toISOString();
+            }
+            entryModified = true;
+            actionsTaken.push(`Updated structural hash for drifted anchor '${anchor.id}'`);
           }
-          entryModified = true;
-          actionsTaken.push(`Updated structural hash for drifted anchor '${anchor.id}'`);
-        }
-        survivingAnchors.push(anchor);
-      } else {
-        orphanedCount++;
-        entryOrphaned.push(`${anchor.file_path}${anchor.symbol_name ? `::${anchor.symbol_name}` : ""}`);
-        if (prune) {
-          entryModified = true;
-          prunedAnchorsCount++;
-          actionsTaken.push(`Pruned orphaned anchor '${anchor.id}' (${verification.drift_details || "code deleted"})`);
-        } else {
           survivingAnchors.push(anchor);
+        } else {
+          orphanedCount++;
+          entryOrphaned.push(`${anchor.file_path}${anchor.symbol_name ? `::${anchor.symbol_name}` : ""}`);
+          if (prune) {
+            entryModified = true;
+            prunedAnchorsCount++;
+            actionsTaken.push(`Pruned orphaned anchor '${anchor.id}' (${verification.drift_details || "code deleted"})`);
+          } else {
+            survivingAnchors.push(anchor);
+          }
         }
       }
-    }
-    if (prune && entryModified) {
-      if ((!survivingAnchors || survivingAnchors.length === 0) && markStale2 && entry.status === "confirmed") {
-        staleEntriesCount++;
-        actionsTaken.push(`Marked memory '${entry.id}' as stale (all code anchors orphaned)`);
-      }
-      if (!dryRun) {
-        entry.anchors = survivingAnchors.length > 0 ? survivingAnchors : undefined;
-        if ((!entry.anchors || entry.anchors.length === 0) && markStale2 && entry.status === "confirmed") {
-          entry.status = "stale";
-          entry.stale_reason = "All associated code anchors were orphaned and pruned";
+      if (prune && entryModified) {
+        if ((!survivingAnchors || survivingAnchors.length === 0) && markStale2 && entry.status === "confirmed") {
+          staleEntriesCount++;
+          actionsTaken.push(`Marked memory '${entry.id}' as stale (all code anchors orphaned)`);
         }
-        entry.updated_at = new Date().toISOString();
-        save(store, entry);
+        if (!dryRun) {
+          entry.anchors = survivingAnchors.length > 0 ? survivingAnchors : undefined;
+          if ((!entry.anchors || entry.anchors.length === 0) && markStale2 && entry.status === "confirmed") {
+            entry.status = "stale";
+            entry.stale_reason = "All associated code anchors were orphaned and pruned";
+          }
+          entry.updated_at = new Date().toISOString();
+          save(store, entry);
+        }
+        repairedEntriesCount++;
+      } else if (updateHashes && entryModified) {
+        if (!dryRun) {
+          entry.anchors = survivingAnchors.length > 0 ? survivingAnchors : undefined;
+          entry.updated_at = new Date().toISOString();
+          save(store, entry);
+        }
+        repairedEntriesCount++;
       }
-      repairedEntriesCount++;
-    } else if (updateHashes && entryModified) {
-      if (!dryRun) {
-        entry.anchors = survivingAnchors.length > 0 ? survivingAnchors : undefined;
-        entry.updated_at = new Date().toISOString();
-        save(store, entry);
+      if (entryOrphaned.length > 0 || entryDrifted.length > 0 || actionsTaken.length > 0) {
+        details.push({
+          entryId: entry.id,
+          title: entry.title,
+          actionsTaken,
+          orphanedAnchors: entryOrphaned,
+          driftedAnchors: entryDrifted
+        });
       }
-      repairedEntriesCount++;
     }
-    if (entryOrphaned.length > 0 || entryDrifted.length > 0 || actionsTaken.length > 0) {
-      details.push({
-        entryId: entry.id,
-        title: entry.title,
-        actionsTaken,
-        orphanedAnchors: entryOrphaned,
-        driftedAnchors: entryDrifted
-      });
+    if (inTx) {
+      try {
+        store.db.exec("COMMIT;");
+      } catch {}
+    }
+  } catch (err) {
+    if (inTx) {
+      try {
+        store.db.exec("ROLLBACK;");
+      } catch {}
     }
+    throw err;
   }
   if (!dryRun && store.memoryDir && (prunedAnchorsCount > 0 || staleEntriesCount > 0)) {
     recordAuditEvent(store.memoryDir, {
@@ -21969,6 +22204,253 @@ var init_mesh = __esm(() => {
   init_contracts();
 });
 
+// src/optimize.ts
+var exports_optimize = {};
+__export(exports_optimize, {
+  isJunkFragment: () => isJunkFragment,
+  isTestNoise: () => isTestNoise,
+  maybeAutoOptimize: () => maybeAutoOptimize,
+  optimizeStore: () => optimizeStore,
+  readOptimizationMetadata: () => readOptimizationMetadata,
+  shouldAutoOptimize: () => shouldAutoOptimize,
+  touchActivity: () => touchActivity,
+  writeOptimizationMetadata: () => writeOptimizationMetadata
+});
+import { existsSync as existsSync39, readFileSync as readFileSync33, writeFileSync as writeFileSync19, statSync as statSync14 } from "node:fs";
+import { join as join36 } from "node:path";
+function getMetaPath(memoryDir) {
+  return join36(memoryDir, META_FILE_NAME);
+}
+function readOptimizationMetadata(memoryDir) {
+  const metaPath = getMetaPath(memoryDir);
+  if (!existsSync39(metaPath)) {
+    return {
+      last_optimized_at: new Date(0).toISOString(),
+      last_activity_at: new Date().toISOString(),
+      total_optimizations: 0
+    };
+  }
+  try {
+    const raw = readFileSync33(metaPath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return {
+      last_optimized_at: new Date(0).toISOString(),
+      last_activity_at: new Date().toISOString(),
+      total_optimizations: 0
+    };
+  }
+}
+function writeOptimizationMetadata(memoryDir, meta) {
+  const metaPath = getMetaPath(memoryDir);
+  try {
+    writeFileSync19(metaPath, JSON.stringify(meta, null, 2), "utf8");
+  } catch {}
+}
+function touchActivity(memoryDir) {
+  try {
+    const meta = readOptimizationMetadata(memoryDir);
+    meta.last_activity_at = new Date().toISOString();
+    writeOptimizationMetadata(memoryDir, meta);
+  } catch {}
+}
+function shouldAutoOptimize(memoryDir, options = {}) {
+  const meta = readOptimizationMetadata(memoryDir);
+  const now = Date.now();
+  const daysThreshold = options.daysIntervalThreshold ?? 7;
+  const daysMs = daysThreshold * 24 * 60 * 60 * 1000;
+  const hoursThreshold = options.inactivityHoursThreshold ?? 48;
+  const hoursMs = hoursThreshold * 60 * 60 * 1000;
+  const lastOpt = Date.parse(meta.last_optimized_at) || 0;
+  const lastAct = Date.parse(meta.last_activity_at) || now;
+  if (now - lastOpt >= daysMs) {
+    return {
+      shouldRun: true,
+      reason: `Scheduled ${daysThreshold}-day cadence reached (${Math.round((now - lastOpt) / (24 * 3600 * 1000))}d since last run)`
+    };
+  }
+  if (now - lastAct >= hoursMs && now - lastOpt >= hoursMs) {
+    return {
+      shouldRun: true,
+      reason: `Inactivity threshold reached (${Math.round((now - lastAct) / (3600 * 1000))}h idle)`
+    };
+  }
+  return { shouldRun: false };
+}
+function isTestNoise(entry) {
+  if (entry.status === "confirmed" && entry.verification?.level === "user-confirmed") {
+    return false;
+  }
+  const text = `${entry.title} ${entry.content}`;
+  return /error:\s*expect\(/i.test(text) || /expect\([^)]+\)\.toBe/i.test(text) || /expect\([^)]+\)\.toEqual/i.test(text) || /expect\([^)]+\)\.toBeGreaterThan/i.test(text) || /expect\(received\)/i.test(text) || /at\s+<anonymous>\s+\([^)]+\.test\.(ts|js)/i.test(text) || /Ran\s+\d+\s+tests\s+across/i.test(text) || /\.test\.(ts|js):\d+:\d+/i.test(text) || /TypeError:\s*store\./i.test(text) || /AssertionError:/i.test(text) || /✗\s+Universal Agent Transcript/i.test(text) || /\b\d+\s+pass\s+\d+\s+fail\b/i.test(text) || /✓\s+[^\n]+\[\d+\.?\d*ms\]/i.test(text);
+}
+function isJunkFragment(entry) {
+  const title = (entry.title || "").trim();
+  const content = (entry.content || "").trim();
+  if (content.length <= 5 && (/^['"]?[0-9]+['"]?$/.test(title) || title === "+" || title === "-" || title === "|" || title === ">-")) {
+    return true;
+  }
+  if (content.includes("The following code has been modified") || content.includes("The above content does NOT show the entire file contents") || content.includes("MODEL PLANNER_RESPONSE") || content.includes("</SYSTEM_MESSAGE>") || content.split(`
+`).length > 50 && content.includes("Completed At:") || content.includes("<truncated") || content.includes("expect(") && /expect\([^)]+\)\.toBe/i.test(content)) {
+    return true;
+  }
+  if (entry.status === "confirmed")
+    return false;
+  if (title === "1" || title === "+" || title === "-" || title === "|" || title === ">-") {
+    return true;
+  }
+  if (/^['"]?[0-9]+['"]?$/.test(title)) {
+    return true;
+  }
+  if (content.length < 15) {
+    return true;
+  }
+  if (content.includes("create mode 100644") || content.includes("File Path: `file://") || content.includes("Showing lines ")) {
+    return true;
+  }
+  return false;
+}
+function optimizeStore(store, options = {}) {
+  const startTime = Date.now();
+  const memoryDir = options.memoryDir || store.memoryDir || ".memory";
+  if (!options.force) {
+    const autoCheck = shouldAutoOptimize(memoryDir, {
+      inactivityHoursThreshold: options.inactivityHoursThreshold,
+      daysIntervalThreshold: options.daysIntervalThreshold
+    });
+    if (!autoCheck.shouldRun) {
+      return {
+        timestamp: new Date().toISOString(),
+        totalBefore: 0,
+        totalAfter: 0,
+        prunedNoise: 0,
+        prunedJunk: 0,
+        prunedDuplicates: 0,
+        totalPruned: 0,
+        spaceReclaimedBytes: 0,
+        vacuumExecuted: false,
+        skippedReason: "Optimization thresholds not met (7-day cadence or 48-hour inactivity)",
+        durationMs: Date.now() - startTime
+      };
+    }
+  }
+  const allEntries = list(store, options.project ? { project: options.project } : undefined);
+  const totalBefore = allEntries.length;
+  const getDbSize = () => {
+    try {
+      const dbPath = join36(memoryDir, "memory.db");
+      if (existsSync39(dbPath)) {
+        return statSync14(dbPath).size;
+      }
+    } catch {}
+    return 0;
+  };
+  const dbSizeBefore = getDbSize();
+  const toDeleteNoise = [];
+  const toDeleteJunk = [];
+  const toDeleteDuplicates = [];
+  const seenHashes = new Map;
+  for (const entry of allEntries) {
+    if (entry.status !== "confirmed" && isTestNoise(entry)) {
+      toDeleteNoise.push(entry.id);
+      continue;
+    }
+    if (isJunkFragment(entry)) {
+      toDeleteJunk.push(entry.id);
+      continue;
+    }
+    if (entry.status === "candidate") {
+      const normKey = `${normalizeText(entry.title)}|${normalizeText(entry.content.slice(0, 120))}`;
+      if (seenHashes.has(normKey)) {
+        toDeleteDuplicates.push(entry.id);
+      } else {
+        seenHashes.set(normKey, entry.id);
+      }
+    }
+  }
+  const totalPruned = toDeleteNoise.length + toDeleteJunk.length + toDeleteDuplicates.length;
+  if (!options.dryRun) {
+    if (store.db) {
+      try {
+        store.db.exec("BEGIN TRANSACTION;");
+      } catch {}
+    }
+    for (const id of toDeleteNoise) {
+      deleteEntry(store, id, "Automated optimize: pruned test assertion noise");
+    }
+    for (const id of toDeleteJunk) {
+      deleteEntry(store, id, "Automated optimize: pruned junk fragment");
+    }
+    for (const id of toDeleteDuplicates) {
+      deleteEntry(store, id, "Automated optimize: pruned duplicate candidate");
+    }
+    if (store.db) {
+      try {
+        store.db.exec("COMMIT;");
+      } catch {}
+    }
+    if (store.db) {
+      try {
+        store.db.exec("VACUUM;");
+        store.db.exec("PRAGMA optimize;");
+      } catch {}
+    }
+    try {
+      syncConstraints(memoryDir, store);
+    } catch {}
+  }
+  const dbSizeAfter = getDbSize();
+  const spaceReclaimedBytes = Math.max(0, dbSizeBefore - dbSizeAfter);
+  const remainingEntries = list(store, options.project ? { project: options.project } : undefined);
+  const totalAfter = options.dryRun ? totalBefore - totalPruned : remainingEntries.length;
+  const report = {
+    timestamp: new Date().toISOString(),
+    totalBefore,
+    totalAfter,
+    prunedNoise: toDeleteNoise.length,
+    prunedJunk: toDeleteJunk.length,
+    prunedDuplicates: toDeleteDuplicates.length,
+    totalPruned,
+    spaceReclaimedBytes,
+    vacuumExecuted: !options.dryRun && !!store.db,
+    durationMs: Date.now() - startTime
+  };
+  if (!options.dryRun) {
+    recordAuditEvent(memoryDir, {
+      operation: "optimize",
+      entry_id: "store",
+      project: options.project || "all",
+      actor: "system:optimizer",
+      reason: `Optimized store: pruned ${totalPruned} items, reclaimed ${spaceReclaimedBytes} bytes`
+    });
+    const meta = readOptimizationMetadata(memoryDir);
+    meta.last_optimized_at = report.timestamp;
+    meta.last_activity_at = report.timestamp;
+    meta.total_optimizations = (meta.total_optimizations || 0) + 1;
+    meta.last_report = report;
+    writeOptimizationMetadata(memoryDir, meta);
+  }
+  return report;
+}
+function maybeAutoOptimize(store, memoryDir) {
+  const dir = memoryDir || store.memoryDir || ".memory";
+  const check = shouldAutoOptimize(dir);
+  if (!check.shouldRun)
+    return null;
+  try {
+    return optimizeStore(store, { memoryDir: dir, force: true });
+  } catch {
+    return null;
+  }
+}
+var META_FILE_NAME = "optimization_meta.json";
+var init_optimize = __esm(() => {
+  init_store();
+  init_dedup();
+  init_audit();
+  init_governor();
+});
+
 // src/ui.ts
 var exports_ui = {};
 __export(exports_ui, {
@@ -22268,6 +22750,42 @@ function startUiServer(opts) {
         }
         return;
       }
+      if (pathname === "/api/optimize" && req.method === "POST") {
+        try {
+          const { optimizeStore: optimizeStore2 } = await Promise.resolve().then(() => (init_optimize(), exports_optimize));
+          const body = await parseJsonBody(req);
+          const report = optimizeStore2(opts.store, {
+            memoryDir: opts.memoryDir,
+            project: body.project ? String(body.project) : undefined,
+            dryRun: body.dryRun === true,
+            force: body.force !== false
+          });
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ success: true, report }));
+        } catch (err) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: String(err) }));
+        }
+        return;
+      }
+      if (pathname === "/api/optimize/status" && req.method === "GET") {
+        try {
+          const { readOptimizationMetadata: readOptimizationMetadata2, shouldAutoOptimize: shouldAutoOptimize2 } = await Promise.resolve().then(() => (init_optimize(), exports_optimize));
+          const meta = readOptimizationMetadata2(opts.memoryDir);
+          const autoCheck = shouldAutoOptimize2(opts.memoryDir);
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            success: true,
+            meta,
+            shouldAutoOptimize: autoCheck.shouldRun,
+            autoOptimizeReason: autoCheck.reason
+          }));
+        } catch (err) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: String(err) }));
+        }
+        return;
+      }
       const workspaceRoot = opts.store.layout?.root || getStorageLayout(opts.memoryDir).root;
       if (pathname === "/api/health" && req.method === "GET") {
         try {
@@ -22769,6 +23287,10 @@ var MAX_BODY_SIZE, EMBEDDED_HTML = `<!DOCTYPE html>
         <span class="refresh-icon" id="refreshIcon">\uD83D\uDD04</span>
         <span id="refreshLabel">Refresh</span>
       </button>
+      <button class="btn-icon btn-optimize" id="optimizeBtn" onclick="optimizeStoreDashboard()" title="Clean test noise, prune junk, deduplicate candidates, and defragment SQLite storage">
+        <span class="optimize-icon" id="optimizeIcon">⚡</span>
+        <span id="optimizeLabel">Optimize</span>
+      </button>
       <div class="status-badge"><div class="status-dot"></div>[LIVE] Active</div>
       <button class="btn-icon" onclick="exportDataHtml()">⬇ Export HTML</button>
     </div>
@@ -23230,6 +23752,40 @@ var MAX_BODY_SIZE, EMBEDDED_HTML = `<!DOCTYPE html>
       }
     }
 
+    async function optimizeStoreDashboard() {
+      const icon = document.getElementById('optimizeIcon');
+      const label = document.getElementById('optimizeLabel');
+      const btn = document.getElementById('optimizeBtn');
+      if (icon) icon.classList.add('spinning');
+      if (label) label.textContent = 'Optimizing...';
+      if (btn) btn.disabled = true;
+
+      try {
+        const res = await fetch('/api/optimize', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ force: true }),
+        });
+        const data = await res.json();
+        if (!data.success) throw new Error(data.error || 'Optimization failed');
+        const rep = data.report;
+        await loadData();
+        const formatBytes = (b) => {
+          if (b >= 1024 * 1024) return (b / (1024 * 1024)).toFixed(1) + ' MB';
+          if (b >= 1024) return (b / 1024).toFixed(1) + ' KB';
+          return b + ' B';
+        };
+        const spaceMsg = rep.spaceReclaimedBytes > 0 ? ' Reclaimed ' + formatBytes(rep.spaceReclaimedBytes) + '.' : '';
+        flash('⚡ Optimization Complete! Pruned ' + rep.totalPruned + ' items (' + rep.prunedNoise + ' noise, ' + rep.prunedJunk + ' junk, ' + rep.prunedDuplicates + ' dupes).' + spaceMsg);
+      } catch (err) {
+        flash('Optimization failed: ' + (err && err.message ? err.message : String(err)), true);
+      } finally {
+        if (icon) icon.classList.remove('spinning');
+        if (label) label.textContent = 'Optimize';
+        if (btn) btn.disabled = false;
+      }
+    }
+
     async function loadData() {
       try {
         if (window.STANDALONE_DATA) {
@@ -32537,8 +33093,8 @@ var init_loops = __esm(() => {
 });
 
 // src/distill.ts
-import { existsSync as existsSync39, mkdirSync as mkdirSync21, writeFileSync as writeFileSync19 } from "node:fs";
-import { join as join36 } from "node:path";
+import { existsSync as existsSync40, mkdirSync as mkdirSync21, writeFileSync as writeFileSync20 } from "node:fs";
+import { join as join37 } from "node:path";
 function fixTokens(e) {
   const bag = tokenBag(e.title, 2);
   mergeBag(bag, tokenBag((e.tags ?? []).join(" "), 2));
@@ -32549,7 +33105,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 ?? join36(workspaceRoot, ".agents", "skills");
+  const skillsDir = options.skillsDir ?? join37(workspaceRoot, ".agents", "skills");
   for (const cluster of clusters) {
     if (cluster.length < minCount) {
       report.clustersBelowThreshold++;
@@ -32557,9 +33113,9 @@ function distillSkills(store, workspaceRoot, options = {}) {
     }
     const topic = dominantTopicTokens(cluster.map((e) => e.title));
     const slug = slugifyId(topic.join("-") || "skill");
-    const dir = join36(skillsDir, slug);
+    const dir = join37(skillsDir, slug);
     const memberIds = cluster.map((e) => e.id);
-    if (existsSync39(dir)) {
+    if (existsSync40(dir)) {
       report.skippedExisting.push({ slug, members: memberIds });
       continue;
     }
@@ -32570,9 +33126,9 @@ function distillSkills(store, workspaceRoot, options = {}) {
     }
     if (!options.dryRun) {
       mkdirSync21(dir, { recursive: true });
-      writeFileSync19(join36(dir, "SKILL.md"), md, "utf8");
+      writeFileSync20(join37(dir, "SKILL.md"), md, "utf8");
     }
-    report.created.push({ slug, path: join36(dir, "SKILL.md"), members: memberIds });
+    report.created.push({ slug, path: join37(dir, "SKILL.md"), members: memberIds });
   }
   return report;
 }
@@ -32622,18 +33178,18 @@ __export(exports_provenance, {
   loadSources: () => loadSources,
   saveSources: () => saveSources
 });
-import { existsSync as existsSync40, readFileSync as readFileSync33, writeFileSync as writeFileSync20, mkdirSync as mkdirSync22 } from "node:fs";
-import { join as join37 } from "node:path";
+import { existsSync as existsSync41, readFileSync as readFileSync34, writeFileSync as writeFileSync21, mkdirSync as mkdirSync22 } from "node:fs";
+import { join as join38 } from "node:path";
 function getSourcesFilePath(memoryDir) {
-  return join37(memoryDir, "sources.json");
+  return join38(memoryDir, "sources.json");
 }
 function loadSources(memoryDir) {
   const filePath = getSourcesFilePath(memoryDir);
-  if (!existsSync40(filePath)) {
+  if (!existsSync41(filePath)) {
     return [];
   }
   try {
-    const raw = readFileSync33(filePath, "utf-8");
+    const raw = readFileSync34(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed : [];
   } catch {
@@ -32643,7 +33199,7 @@ function loadSources(memoryDir) {
 function saveSources(memoryDir, sources) {
   mkdirSync22(memoryDir, { recursive: true });
   const filePath = getSourcesFilePath(memoryDir);
-  writeFileSync20(filePath, JSON.stringify(sources, null, 2), "utf-8");
+  writeFileSync21(filePath, JSON.stringify(sources, null, 2), "utf-8");
 }
 function addSource(memoryDir, input) {
   const textToScan = `${input.title}
@@ -32710,18 +33266,18 @@ __export(exports_claims, {
   recordClaim: () => recordClaim,
   saveClaims: () => saveClaims
 });
-import { existsSync as existsSync41, readFileSync as readFileSync34, writeFileSync as writeFileSync21, mkdirSync as mkdirSync23 } from "node:fs";
-import { join as join38 } from "node:path";
+import { existsSync as existsSync42, readFileSync as readFileSync35, writeFileSync as writeFileSync22, mkdirSync as mkdirSync23 } from "node:fs";
+import { join as join39 } from "node:path";
 function getClaimsFilePath(memoryDir) {
-  return join38(memoryDir, "claims.json");
+  return join39(memoryDir, "claims.json");
 }
 function loadClaims(memoryDir) {
   const filePath = getClaimsFilePath(memoryDir);
-  if (!existsSync41(filePath)) {
+  if (!existsSync42(filePath)) {
     return [];
   }
   try {
-    const raw = readFileSync34(filePath, "utf-8");
+    const raw = readFileSync35(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed : [];
   } catch {
@@ -32731,7 +33287,7 @@ function loadClaims(memoryDir) {
 function saveClaims(memoryDir, claims) {
   mkdirSync23(memoryDir, { recursive: true });
   const filePath = getClaimsFilePath(memoryDir);
-  writeFileSync21(filePath, JSON.stringify(claims, null, 2), "utf-8");
+  writeFileSync22(filePath, JSON.stringify(claims, null, 2), "utf-8");
 }
 function recordClaim(memoryDir, input) {
   const textToScan = `${input.claim}
@@ -32876,8 +33432,8 @@ ${result.stderr}`.trim().slice(0, 2000)
   return result;
 }
 function verifyStrictIntegrity(store, memoryDir, workspaceRoot, options = {}) {
-  const { existsSync: existsSync42, readFileSync: readFileSync35, readdirSync: readdirSync16 } = __require("node:fs");
-  const { join: join39 } = __require("node:path");
+  const { existsSync: existsSync43, readFileSync: readFileSync36, readdirSync: readdirSync16 } = __require("node:fs");
+  const { join: join40 } = __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));
@@ -32895,15 +33451,15 @@ ${(e.tags ?? []).join(" ")}`;
       secretErrors.push(`Secret detected in memory ${e.id}: ${found.join(", ")}`);
     }
   }
-  const currentPath = join39(memoryDir, "CURRENT.md");
-  if (existsSync42(currentPath)) {
-    const found = scanSecrets2(readFileSync35(currentPath, "utf-8"));
+  const currentPath = join40(memoryDir, "CURRENT.md");
+  if (existsSync43(currentPath)) {
+    const found = scanSecrets2(readFileSync36(currentPath, "utf-8"));
     if (found.length > 0)
       secretErrors.push(`Secret detected in CURRENT.md: ${found.join(", ")}`);
   }
-  const userPath = join39(memoryDir, "USER.md");
-  if (existsSync42(userPath)) {
-    const found = scanSecrets2(readFileSync35(userPath, "utf-8"));
+  const userPath = join40(memoryDir, "USER.md");
+  if (existsSync43(userPath)) {
+    const found = scanSecrets2(readFileSync36(userPath, "utf-8"));
     if (found.length > 0)
       secretErrors.push(`Secret detected in USER.md: ${found.join(", ")}`);
   }
@@ -32972,12 +33528,12 @@ ${(e.tags ?? []).join(" ")}`;
     errors: claimErrors.length > 0 ? claimErrors : undefined
   });
   const wikiErrors = [];
-  const wikiDir = join39(memoryDir, "wiki");
-  if (existsSync42(wikiDir)) {
+  const wikiDir = join40(memoryDir, "wiki");
+  if (existsSync43(wikiDir)) {
     let collectSlugs = function(dir) {
       const items = readdirSync16(dir, { withFileTypes: true });
       for (const it of items) {
-        const full = join39(dir, it.name);
+        const full = join40(dir, it.name);
         if (it.isDirectory()) {
           collectSlugs(full);
         } else if (it.name.endsWith(".md")) {
@@ -32989,11 +33545,11 @@ ${(e.tags ?? []).join(" ")}`;
     }, scanWikilinks = function(dir) {
       const items = readdirSync16(dir, { withFileTypes: true });
       for (const it of items) {
-        const full = join39(dir, it.name);
+        const full = join40(dir, it.name);
         if (it.isDirectory()) {
           scanWikilinks(full);
         } else if (it.name.endsWith(".md")) {
-          const content = readFileSync35(full, "utf-8");
+          const content = readFileSync36(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();
@@ -33260,14 +33816,14 @@ var init_schema2 = __esm(() => {
 });
 
 // src/settings/loader.ts
-import { existsSync as existsSync42, mkdirSync as mkdirSync24, readFileSync as readFileSync35, writeFileSync as writeFileSync22 } from "node:fs";
-import { join as join39 } from "node:path";
+import { existsSync as existsSync43, mkdirSync as mkdirSync24, readFileSync as readFileSync36, writeFileSync as writeFileSync23 } from "node:fs";
+import { join as join40 } from "node:path";
 function getSettingsFilePath(memoryDir) {
-  return join39(memoryDir, "settings.json");
+  return join40(memoryDir, "settings.json");
 }
 function loadSettings(memoryDir) {
   const filePath = getSettingsFilePath(memoryDir);
-  if (!existsSync42(filePath)) {
+  if (!existsSync43(filePath)) {
     return {
       version: 1,
       global: JSON.parse(JSON.stringify(DEFAULT_SETTINGS)),
@@ -33275,7 +33831,7 @@ function loadSettings(memoryDir) {
     };
   }
   try {
-    const raw = readFileSync35(filePath, "utf8");
+    const raw = readFileSync36(filePath, "utf8");
     const parsed = JSON.parse(raw);
     return {
       version: parsed.version || 1,
@@ -33293,7 +33849,7 @@ function loadSettings(memoryDir) {
 function saveSettings(store, memoryDir) {
   mkdirSync24(memoryDir, { recursive: true });
   const filePath = getSettingsFilePath(memoryDir);
-  writeFileSync22(filePath, JSON.stringify(store, null, 2), "utf8");
+  writeFileSync23(filePath, JSON.stringify(store, null, 2), "utf8");
 }
 function getSettings(memoryDir) {
   return loadSettings(memoryDir).global;
@@ -33401,10 +33957,10 @@ var init_settings2 = __esm(() => {
 });
 
 // src/learning/observation.ts
-import { existsSync as existsSync43, readFileSync as readFileSync36, appendFileSync as appendFileSync2, writeFileSync as writeFileSync23, mkdirSync as mkdirSync25 } from "node:fs";
-import { join as join40 } from "node:path";
+import { existsSync as existsSync44, readFileSync as readFileSync37, appendFileSync as appendFileSync2, writeFileSync as writeFileSync24, mkdirSync as mkdirSync25 } from "node:fs";
+import { join as join41 } from "node:path";
 function observationsFilePath(memoryDir) {
-  return join40(memoryDir, "observations.jsonl");
+  return join41(memoryDir, "observations.jsonl");
 }
 function recordObservation(store, obs) {
   if (!obs.raw || !obs.raw.trim()) {
@@ -33416,7 +33972,7 @@ function recordObservation(store, obs) {
   }
   const memoryDir = store.memoryDir || store.dir;
   const filePath = observationsFilePath(memoryDir);
-  if (!existsSync43(memoryDir)) {
+  if (!existsSync44(memoryDir)) {
     mkdirSync25(memoryDir, { recursive: true });
   }
   const id = `obs_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
@@ -33437,9 +33993,9 @@ function recordObservation(store, obs) {
 function listObservations(store, options) {
   const memoryDir = store.memoryDir || store.dir;
   const filePath = observationsFilePath(memoryDir);
-  if (!existsSync43(filePath))
+  if (!existsSync44(filePath))
     return [];
-  const lines = readFileSync36(filePath, "utf8").split(`
+  const lines = readFileSync37(filePath, "utf8").split(`
 `).filter((l) => l.trim().length > 0);
   const results = [];
   for (const line of lines) {
@@ -33459,9 +34015,9 @@ function listObservations(store, options) {
 function markObservationProcessed(store, observationId, extractedCandidateId) {
   const memoryDir = store.memoryDir || store.dir;
   const filePath = observationsFilePath(memoryDir);
-  if (!existsSync43(filePath))
+  if (!existsSync44(filePath))
     return false;
-  const lines = readFileSync36(filePath, "utf8").split(`
+  const lines = readFileSync37(filePath, "utf8").split(`
 `).filter((l) => l.trim().length > 0);
   let updated = false;
   const newLines = [];
@@ -33480,7 +34036,7 @@ function markObservationProcessed(store, observationId, extractedCandidateId) {
     }
   }
   if (updated) {
-    writeFileSync23(filePath, `${newLines.join(`
+    writeFileSync24(filePath, `${newLines.join(`
 `)}
 `, "utf8");
   }
@@ -33781,8 +34337,8 @@ var init_bidirectional = __esm(() => {
 });
 
 // src/intelligence/impact.ts
-import { existsSync as existsSync44, readdirSync as readdirSync16, readFileSync as readFileSync37 } from "node:fs";
-import { join as join41, basename as basename2 } from "node:path";
+import { existsSync as existsSync45, readdirSync as readdirSync16, readFileSync as readFileSync38 } from "node:fs";
+import { join as join42, basename as basename2 } from "node:path";
 async function analyzeMemoryCodeImpact(store, options) {
   const root = options.workspaceRoot || store.dir || process.cwd();
   const targetFile = options.filePath;
@@ -33838,11 +34394,19 @@ async function analyzeMemoryCodeImpact(store, options) {
   }));
   const allAdrs = listAdrs(store);
   const matchedAdrs = [];
+  const normTarget = targetFile.toLowerCase().replace(/^[./\\]+/, "");
   const fileBase = basename2(targetFile).toLowerCase();
+  const symbolRegex = targetSymbol && targetSymbol.length > 2 ? new RegExp(`\\b${targetSymbol.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&")}\\b`, "i") : null;
+  const pathRegex = fileBase.length > 3 && fileBase !== "index.ts" && fileBase !== "index.js" ? new RegExp(`\\b${fileBase.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&")}\\b`, "i") : null;
   for (const adr of allAdrs) {
-    const text = `${adr.title} ${adr.content}`.toLowerCase();
-    const hasAnchor = adr.anchors?.some((a) => a.file_path.toLowerCase().includes(fileBase) || targetSymbol && a.symbol_name?.toLowerCase() === targetSymbol.toLowerCase());
-    if (hasAnchor || text.includes(fileBase) || targetSymbol && text.includes(targetSymbol.toLowerCase())) {
+    const text = `${adr.title} ${adr.content}`;
+    const hasAnchor = adr.anchors?.some((a) => {
+      const aPath = a.file_path.toLowerCase().replace(/^[./\\]+/, "");
+      return aPath === normTarget || aPath.endsWith("/" + fileBase) || targetSymbol && a.symbol_name?.toLowerCase() === targetSymbol.toLowerCase();
+    });
+    const matchesSymbol = symbolRegex ? symbolRegex.test(text) : false;
+    const matchesPath = pathRegex ? pathRegex.test(text) : false;
+    if (hasAnchor || matchesSymbol || matchesPath) {
       matchedAdrs.push({
         id: adr.id,
         title: adr.title,
@@ -33852,10 +34416,10 @@ async function analyzeMemoryCodeImpact(store, options) {
     }
   }
   const activeConstraints = memoryRes.constraints.map((c) => c.title);
-  const currentMdPath = join41(store.memoryDir || join41(root, ".memory"), "CURRENT.md");
-  if (existsSync44(currentMdPath)) {
+  const currentMdPath = join42(store.memoryDir || join42(root, ".memory"), "CURRENT.md");
+  if (existsSync45(currentMdPath)) {
     try {
-      const currentContent = readFileSync37(currentMdPath, "utf8");
+      const currentContent = readFileSync38(currentMdPath, "utf8");
       const lines = currentContent.split(`
 `);
       for (const line of lines) {
@@ -33875,14 +34439,14 @@ async function analyzeMemoryCodeImpact(store, options) {
     totalMemoryEntities: linkedMemories.length + matchedAdrs.length + negativeWarnings.length + activeConstraints.length
   };
   const relatedDocs = [];
-  const docsDir = join41(root, "docs");
-  if (existsSync44(docsDir)) {
+  const docsDir = join42(root, "docs");
+  if (existsSync45(docsDir)) {
     try {
       const docFiles = readdirSync16(docsDir, { recursive: true });
       for (const df of docFiles) {
         if (typeof df === "string" && (df.endsWith(".md") || df.endsWith(".mdx"))) {
-          const fullPath = join41(docsDir, df);
-          const content = readFileSync37(fullPath, "utf8").toLowerCase();
+          const fullPath = join42(docsDir, df);
+          const content = readFileSync38(fullPath, "utf8").toLowerCase();
           if (content.includes(fileBase) || targetSymbol && content.includes(targetSymbol.toLowerCase())) {
             relatedDocs.push(`docs/${df}`);
           }
@@ -33890,10 +34454,10 @@ async function analyzeMemoryCodeImpact(store, options) {
       }
     } catch {}
   }
-  const readmePath = join41(root, "README.md");
-  if (existsSync44(readmePath)) {
+  const readmePath = join42(root, "README.md");
+  if (existsSync45(readmePath)) {
     try {
-      const readmeContent = readFileSync37(readmePath, "utf8").toLowerCase();
+      const readmeContent = readFileSync38(readmePath, "utf8").toLowerCase();
       if (readmeContent.includes(fileBase) || targetSymbol && readmeContent.includes(targetSymbol.toLowerCase())) {
         relatedDocs.push("README.md");
       }
@@ -34058,8 +34622,8 @@ var init_intelligence = __esm(() => {
   init_impact();
 });
 // src/compaction/engine.ts
-import { existsSync as existsSync45, writeFileSync as writeFileSync24, mkdirSync as mkdirSync26 } from "node:fs";
-import { join as join42 } from "node:path";
+import { existsSync as existsSync46, writeFileSync as writeFileSync25, mkdirSync as mkdirSync26 } from "node:fs";
+import { join as join43 } from "node:path";
 function evaluateContextUsage(usedTokens, maxTokens = DEFAULT_CONTEXT_MAX_TOKENS) {
   const usagePercent = Math.round(usedTokens / maxTokens * 100);
   const thresholdExceeded = usagePercent >= COMPACTION_THRESHOLD_PERCENT;
@@ -34151,12 +34715,12 @@ function generateSessionHandoff(memoryDir, invariants, options) {
   if (!invariants.highLevelGoal || !invariants.nextConcreteTask) {
     throw new Error("Cannot generate handoff: highLevelGoal and nextConcreteTask are mandatory");
   }
-  if (!existsSync45(memoryDir)) {
+  if (!existsSync46(memoryDir)) {
     mkdirSync26(memoryDir, { recursive: true });
   }
-  const currentMdPath = join42(memoryDir, "CURRENT.md");
+  const currentMdPath = join43(memoryDir, "CURRENT.md");
   const markdownContent = renderCurrentMdContent(invariants, options);
-  writeFileSync24(currentMdPath, markdownContent, "utf8");
+  writeFileSync25(currentMdPath, markdownContent, "utf8");
   recordAuditEvent(memoryDir, {
     operation: "checkpoint",
     entry_id: "CURRENT.md",
@@ -34295,28 +34859,38 @@ var init_harvester2 = __esm(() => {
 });
 
 // src/compaction/pr-context.ts
-import { execSync as execSync3 } from "node:child_process";
-import { existsSync as existsSync46, readFileSync as readFileSync38 } from "node:fs";
-import { join as join43, basename as basename3 } from "node:path";
+import { execFileSync } from "node:child_process";
+import { existsSync as existsSync47, readFileSync as readFileSync39 } from "node:fs";
+import { join as join44, basename as basename3 } from "node:path";
 async function generatePrContext(store, options = {}) {
   const root = options.workspaceRoot || store.dir || process.cwd();
-  const base = options.baseBranch || "main";
+  const rawBase = options.baseBranch || "main";
+  const safeBase = /^[a-zA-Z0-9._\/-]+$/.test(rawBase) ? rawBase : "main";
   let changedFiles = [];
   try {
-    const diffCmd = `git diff --name-only ${base}...HEAD`;
-    const stdout = execSync3(diffCmd, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    const stdout = execFileSync("git", ["diff", "--name-only", `${safeBase}...HEAD`], {
+      cwd: root,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
     changedFiles = stdout.split(`
 `).map((f) => f.trim()).filter(Boolean);
   } catch {
     try {
-      const diffCmd = `git diff --name-only HEAD~1`;
-      const stdout = execSync3(diffCmd, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+      const stdout = execFileSync("git", ["diff", "--name-only", "HEAD~1"], {
+        cwd: root,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+      });
       changedFiles = stdout.split(`
 `).map((f) => f.trim()).filter(Boolean);
     } catch {
       try {
-        const diffCmd = `git status --porcelain`;
-        const stdout = execSync3(diffCmd, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        const stdout = execFileSync("git", ["status", "--porcelain"], {
+          cwd: root,
+          encoding: "utf8",
+          stdio: ["ignore", "pipe", "ignore"]
+        });
         changedFiles = stdout.split(`
 `).map((l) => l.slice(3).trim()).filter(Boolean);
       } catch {
@@ -34358,10 +34932,10 @@ async function generatePrContext(store, options = {}) {
     } catch {}
   }
   const activeConstraints = [];
-  const currentMdPath = join43(store.memoryDir || join43(root, ".memory"), "CURRENT.md");
-  if (existsSync46(currentMdPath)) {
+  const currentMdPath = join44(store.memoryDir || join44(root, ".memory"), "CURRENT.md");
+  if (existsSync47(currentMdPath)) {
     try {
-      const lines = readFileSync38(currentMdPath, "utf8").split(`
+      const lines = readFileSync39(currentMdPath, "utf8").split(`
 `);
       for (const line of lines) {
         const trimmed = line.trim();
@@ -34472,7 +35046,7 @@ async function generatePrContext(store, options = {}) {
   return {
     title: prTitle,
     bodyMarkdown: md,
-    baseBranch: base,
+    baseBranch: safeBase,
     changedFiles,
     anchorsTouched: totalAnchorsTouched,
     adrsInvolved,
@@ -34514,8 +35088,6 @@ var init_anchors = __esm(() => {
   init_resolver();
 });
 // src/orchestrator/context.ts
-import { existsSync as existsSync47, readFileSync as readFileSync39 } from "node:fs";
-import { join as join44 } from "node:path";
 function estimateTokens(text) {
   return Math.max(1, Math.ceil(text.length / 4));
 }
@@ -34542,18 +35114,29 @@ async function resolveMuseContext(store, workspaceRoot, input) {
   const compositeQuery = queryParts.join(" ") || "active constraints and architecture";
   const activeConstraints = [];
   if (store.memoryDir) {
-    const currentPath = join44(store.memoryDir, "CURRENT.md");
-    if (existsSync47(currentPath)) {
-      const currentMd = readFileSync39(currentPath, "utf8");
-      const constraintMatch = currentMd.match(/## Active Working Constraints & Open Loops([\s\S]*?)(?:##|$)/);
-      if (constraintMatch && constraintMatch[1].trim()) {
+    try {
+      const currentData = parseCurrentFile(store.memoryDir);
+      if (currentData.constraints.length > 0) {
         activeConstraints.push({
           id: "current_md_constraints",
           title: "Session Working Constraints",
-          content: constraintMatch[1].trim()
+          content: currentData.constraints.join(`
+`)
         });
       }
-    }
+      if (currentData.workstreams && currentData.workstreams.length > 0) {
+        const activeWs = currentData.workstreams.filter((w) => w.status === "IN-PROGRESS" || w.status === "BLOCKED");
+        if (activeWs.length > 0) {
+          const wsSummary = activeWs.map((w) => `- Agent \`${w.agent}\` [${w.status}]: ${w.task}${w.targetScope ? ` (Scope: ${w.targetScope})` : ""}`).join(`
+`);
+          activeConstraints.push({
+            id: "concurrent_workstreams",
+            title: "Active Concurrent Agent Workstreams",
+            content: wsSummary
+          });
+        }
+      }
+    } catch {}
   }
   const allEntries = list(store);
   const constraintEntries = allEntries.filter((e) => (e.type === "constraint" || e.temporal_mode === "timeless") && e.status !== "archived" && e.status !== "superseded" && e.status !== "rejected");
@@ -34669,6 +35252,7 @@ ${c.content}`);
 var init_context = __esm(() => {
   init_store();
   init_ranking();
+  init_governor();
 });
 
 // src/orchestrator/profiles.ts
@@ -34807,7 +35391,7 @@ var init_orchestrator = __esm(() => {
 });
 
 // src/prompts.ts
-import { existsSync as existsSync48, readFileSync as readFileSync40, writeFileSync as writeFileSync25, mkdirSync as mkdirSync27, readdirSync as readdirSync17 } from "node:fs";
+import { existsSync as existsSync48, readFileSync as readFileSync40, writeFileSync as writeFileSync26, mkdirSync as mkdirSync27, readdirSync as readdirSync17 } from "node:fs";
 import { join as join45 } from "node:path";
 function getPromptsDir(memoryDir) {
   if (!memoryDir)
@@ -34996,7 +35580,7 @@ Period: {{period}}
 });
 
 // src/compounding/temporal.ts
-import { existsSync as existsSync49, readFileSync as readFileSync41, writeFileSync as writeFileSync26, mkdirSync as mkdirSync28 } from "node:fs";
+import { existsSync as existsSync49, readFileSync as readFileSync41, writeFileSync as writeFileSync27, mkdirSync as mkdirSync28 } from "node:fs";
 import { join as join46 } from "node:path";
 function getPeriodKey(dateInput, period) {
   const date4 = typeof dateInput === "string" ? new Date(dateInput) : dateInput;
@@ -35066,7 +35650,7 @@ function compileHotCache(store, memoryDir) {
 `;
   const hotPath = join46(memoryDir, "HOT.md");
   mkdirSync28(memoryDir, { recursive: true });
-  writeFileSync26(hotPath, hotContent, "utf-8");
+  writeFileSync27(hotPath, hotContent, "utf-8");
   return hotPath;
 }
 function rollupTemporal(store, options) {
@@ -35120,7 +35704,7 @@ function rollupTemporal(store, options) {
   const rollupDir = join46(memoryDir, "wiki", "rollups");
   mkdirSync28(rollupDir, { recursive: true });
   const filePath = join46(rollupDir, `${periodKey}.md`);
-  writeFileSync26(filePath, lines.join(`
+  writeFileSync27(filePath, lines.join(`
 `) + `
 `, "utf-8");
   const hotMdPath = compileHotCache(store, memoryDir);
@@ -35137,7 +35721,7 @@ var init_temporal = __esm(() => {
 });
 
 // src/iterations.ts
-import { existsSync as existsSync50, readFileSync as readFileSync42, appendFileSync as appendFileSync3, writeFileSync as writeFileSync27, mkdirSync as mkdirSync29 } from "node:fs";
+import { existsSync as existsSync50, readFileSync as readFileSync42, appendFileSync as appendFileSync3, writeFileSync as writeFileSync28, mkdirSync as mkdirSync29 } from "node:fs";
 import { join as join47 } from "node:path";
 function getIterationsFilePath(memoryDir) {
   return join47(memoryDir, "iterations.jsonl");
@@ -35180,7 +35764,7 @@ function listIterations(memoryDir) {
 function clearIterations(memoryDir) {
   const filePath = getIterationsFilePath(memoryDir);
   if (existsSync50(filePath)) {
-    writeFileSync27(filePath, "", "utf-8");
+    writeFileSync28(filePath, "", "utf-8");
   }
 }
 function detectIterationStatus(memoryDir) {
@@ -35241,7 +35825,7 @@ __export(exports_plasticity, {
   recordCoActivation: () => recordCoActivation,
   saveHebbianGraph: () => saveHebbianGraph
 });
-import { existsSync as existsSync51, readFileSync as readFileSync43, writeFileSync as writeFileSync28 } from "node:fs";
+import { existsSync as existsSync51, readFileSync as readFileSync43, writeFileSync as writeFileSync29 } from "node:fs";
 import { join as join48 } from "node:path";
 function getPlasticityPath(memoryDir) {
   return join48(memoryDir, "hebbian-plasticity.json");
@@ -35259,7 +35843,7 @@ function loadHebbianGraph(memoryDir) {
 function saveHebbianGraph(memoryDir, graph) {
   const p = getPlasticityPath(memoryDir);
   try {
-    writeFileSync28(p, JSON.stringify(graph, null, 2), "utf8");
+    writeFileSync29(p, JSON.stringify(graph, null, 2), "utf8");
   } catch {}
 }
 function recordCoActivation(memoryIds, memoryDir) {
@@ -35349,7 +35933,7 @@ __export(exports_drift, {
   scanCodeDrift: () => scanCodeDrift,
   scanCodeDriftFromDiff: () => scanCodeDriftFromDiff
 });
-import { execSync as execSync4 } from "node:child_process";
+import { execSync as execSync3 } from "node:child_process";
 import { existsSync as existsSync52 } from "node:fs";
 import { join as join49, isAbsolute as isAbsolute2 } from "node:path";
 function scanCodeDriftFromDiff(entries, changedFiles, workspaceRoot) {
@@ -35390,7 +35974,7 @@ function scanCodeDriftFromDiff(entries, changedFiles, workspaceRoot) {
 function getGitChangedFiles(workspaceRoot) {
   const root = workspaceRoot || process.cwd();
   try {
-    const stdout = execSync4("git status --porcelain", {
+    const stdout = execSync3("git status --porcelain", {
       cwd: root,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
@@ -35407,7 +35991,7 @@ function getGitChangedFiles(workspaceRoot) {
         files.push(filePath);
     }
     try {
-      const diffOut = execSync4("git diff --name-only HEAD", {
+      const diffOut = execSync3("git diff --name-only HEAD", {
         cwd: root,
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"]
@@ -38079,7 +38663,7 @@ var init_daemon = () => {};
 
 // src/cli/ecosystem.ts
 import { join as join51 } from "node:path";
-import { existsSync as existsSync54, mkdirSync as mkdirSync30, writeFileSync as writeFileSync29, readFileSync as readFileSync44 } from "node:fs";
+import { existsSync as existsSync54, mkdirSync as mkdirSync30, writeFileSync as writeFileSync30, readFileSync as readFileSync44 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
 function ensureProjectAgentInstructions(targetDir) {
   const agentsMdPath = join51(targetDir, "AGENTS.md");
@@ -38088,9 +38672,9 @@ function ensureProjectAgentInstructions(targetDir) {
       const existing = readFileSync44(agentsMdPath, "utf8");
       if (existing.includes("<!-- agentmemory:start -->")) {
         const updated = existing.replace(/<!-- agentmemory:start -->[\s\S]*?<!-- agentmemory:end -->/, MUSE_MEMORY_DIRECTIVE);
-        writeFileSync29(agentsMdPath, updated, "utf8");
+        writeFileSync30(agentsMdPath, updated, "utf8");
       } else if (!existing.includes("<!-- musememory:start -->") && !existing.includes("Muse Memory")) {
-        writeFileSync29(agentsMdPath, `${existing.trim()}
+        writeFileSync30(agentsMdPath, `${existing.trim()}
 
 ${MUSE_MEMORY_DIRECTIVE}
 `, "utf8");
@@ -38101,7 +38685,7 @@ ${MUSE_MEMORY_DIRECTIVE}
 
 ${MUSE_MEMORY_DIRECTIVE}
 `;
-    writeFileSync29(agentsMdPath, initialContent, "utf8");
+    writeFileSync30(agentsMdPath, initialContent, "utf8");
   }
 }
 async function handleInstallCommand({ positional, flags }) {
@@ -38113,7 +38697,7 @@ async function handleInstallCommand({ positional, flags }) {
   mkdirSync30(join51(globalDir, "memories"), { recursive: true });
   const currentPath = join51(memoryDir, "CURRENT.md");
   if (!existsSync54(currentPath)) {
-    writeFileSync29(currentPath, `# Active Project Constraints
+    writeFileSync30(currentPath, `# Active Project Constraints
 `, "utf8");
   }
   const globalUserPath = userFilePath(globalDir);
@@ -38139,7 +38723,7 @@ async function handleInstallCommand({ positional, flags }) {
       const existing = readFileSync44(globalAgentsMd, "utf8");
       if (existing.includes("<!-- agentmemory:start -->")) {
         const updated = existing.replace(/<!-- agentmemory:start -->[\s\S]*?<!-- agentmemory:end -->/, MUSE_MEMORY_DIRECTIVE);
-        writeFileSync29(globalAgentsMd, updated, "utf8");
+        writeFileSync30(globalAgentsMd, updated, "utf8");
       }
     } catch {}
   }
@@ -38298,7 +38882,7 @@ async function handleInitCommand({ positional, flags }) {
   mkdirSync30(join51(memoryDir, "memories"), { recursive: true });
   const currentPath = join51(memoryDir, "CURRENT.md");
   if (!existsSync54(currentPath)) {
-    writeFileSync29(currentPath, `# Active Project Constraints
+    writeFileSync30(currentPath, `# Active Project Constraints
 `, "utf8");
   }
   if (!isGlobal) {
@@ -39261,7 +39845,7 @@ var init_entities2 = __esm(() => {
 });
 
 // src/cli/settings.ts
-import { writeFileSync as writeFileSync30, readFileSync as readFileSync46 } from "node:fs";
+import { writeFileSync as writeFileSync31, readFileSync as readFileSync46 } from "node:fs";
 function handleSettingsCommand(parsed) {
   const ctx = requireRoot(parsed.flags);
   if (!ctx)
@@ -39343,7 +39927,7 @@ function handleSettingsCommand(parsed) {
     const out = parsed.flags.out;
     const json2 = exportSettings(memoryDir);
     if (out) {
-      writeFileSync30(out, json2, "utf8");
+      writeFileSync31(out, json2, "utf8");
       console.log(`Exported settings to ${out}`);
     } else {
       console.log(json2);
@@ -39427,7 +40011,7 @@ var init_routines = __esm(() => {
 });
 
 // src/cli/lifecycle.ts
-import { writeFileSync as writeFileSync31, readFileSync as readFileSync48, existsSync as existsSync58 } from "node:fs";
+import { writeFileSync as writeFileSync32, readFileSync as readFileSync48, existsSync as existsSync58 } from "node:fs";
 async function handleProposeCommand({ positional, flags }) {
   const ctx = requireRoot(flags);
   if (!ctx)
@@ -39576,7 +40160,7 @@ async function handleExportCommand({ flags }) {
   const snapshot = exportSnapshot(ctx.store);
   const outPath = flags["out"];
   if (outPath) {
-    writeFileSync31(outPath, JSON.stringify(snapshot, null, 2), "utf8");
+    writeFileSync32(outPath, JSON.stringify(snapshot, null, 2), "utf8");
     console.log(`exported ${snapshot.total} memories to ${outPath}`);
   } else {
     console.log(JSON.stringify(snapshot, null, 2));
@@ -39776,6 +40360,58 @@ async function handleConsolidateCommand({ flags }) {
   }
   return 0;
 }
+async function handleOptimizeCommand({ flags }) {
+  const ctx = requireRoot(flags);
+  if (!ctx)
+    return 1;
+  const isDryRun = flags["dry-run"] === "true";
+  const force = flags["force"] !== "false";
+  const project = flags["project"];
+  console.log(`
+====================================================`);
+  console.log(`  ⚡ Muse Memory Optimizer ${isDryRun ? "(DRY-RUN)" : ""}`);
+  console.log(`====================================================`);
+  if (project)
+    console.log(`Scope: Project '${project}'`);
+  console.log(`Store: ${ctx.memoryDir}
+`);
+  const report = optimizeStore(ctx.store, {
+    project,
+    dryRun: isDryRun,
+    force,
+    memoryDir: ctx.memoryDir
+  });
+  if (report.skippedReason) {
+    console.log(`ℹ️  Optimization skipped: ${report.skippedReason}`);
+    console.log(`Tip: Pass --force to run immediately regardless of cadence.`);
+    return 0;
+  }
+  const formatBytes = (bytes) => {
+    if (bytes >= 1024 * 1024)
+      return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+    if (bytes >= 1024)
+      return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${bytes} B`;
+  };
+  console.log(`Results:`);
+  console.log(`  - Pruned Test Noise:     ${report.prunedNoise} items`);
+  console.log(`  - Pruned Junk Fragments: ${report.prunedJunk} items`);
+  console.log(`  - Pruned Duplicates:     ${report.prunedDuplicates} items`);
+  console.log(`  -----------------------------------------`);
+  console.log(`  - Total Items Pruned:    ${report.totalPruned} items`);
+  console.log(`  - Total Before:          ${report.totalBefore} items`);
+  console.log(`  - Total After:           ${report.totalAfter} items`);
+  if (report.spaceReclaimedBytes > 0) {
+    console.log(`  - Storage Reclaimed:     ${formatBytes(report.spaceReclaimedBytes)}`);
+  }
+  if (report.vacuumExecuted) {
+    console.log(`  - SQLite Vacuum:         Executed (Defragmented)`);
+  }
+  console.log(`  - Duration:              ${report.durationMs}ms
+`);
+  console.log(`✅ Optimization successfully completed.`);
+  return 0;
+}
 async function handleTraceCommand({ positional, flags }) {
   const ctx = requireRoot(flags);
   if (!ctx)
@@ -39946,6 +40582,7 @@ var init_lifecycle = __esm(() => {
   init_store();
   init_retrieval();
   init_consolidate();
+  init_optimize();
   init_trace();
   init_loops();
   init_nudge();
@@ -40249,8 +40886,9 @@ async function runMemoryBenchmark(store, options = {}) {
   const iterations = options.iterations || 30;
   const testQuery = options.query || "authentication architecture security";
   const tokenBudget = options.tokenBudget || 1500;
-  const allEntries = list(store);
   const coldStartT0 = performance.now();
+  const coldStore = openStore(store.memoryDir || store.dir);
+  const allEntries = list(coldStore);
   const entriesCount = allEntries.length;
   const cold_startup_ms = Math.round((performance.now() - coldStartT0) * 100) / 100;
   const hotSamplesUs = [];
@@ -40473,10 +41111,11 @@ async function handleReconcileCommand(parsed) {
     return 1;
   }
   const { root, store } = ctx;
-  const prune = parsed.flags["prune"] === "true" || parsed.flags["p"] === "true";
-  const markStale2 = parsed.flags["mark-stale"] === "true" || parsed.flags["stale"] === "true";
-  const updateHashes = parsed.flags["update-hashes"] === "true";
-  const dryRun = parsed.flags["dry-run"] === "true" || !prune && !markStale2 && !updateHashes;
+  const isTrue = (val) => val === true || val === "true" || val === "";
+  const prune = isTrue(parsed.flags["prune"]) || isTrue(parsed.flags["p"]);
+  const markStale2 = isTrue(parsed.flags["mark-stale"]) || isTrue(parsed.flags["stale"]);
+  const updateHashes = isTrue(parsed.flags["update-hashes"]);
+  const dryRun = isTrue(parsed.flags["dry-run"]) || !prune && !markStale2 && !updateHashes;
   const { reconcileCodeAnchors: reconcileCodeAnchors2, formatReconcileReport: formatReconcileReport2 } = await Promise.resolve().then(() => (init_health(), exports_health));
   const report = await reconcileCodeAnchors2(store, {
     prune,
@@ -40557,9 +41196,9 @@ async function handlePrContextCommand(parsed) {
   });
   const outFile = parsed.flags["out"];
   if (outFile) {
-    const { writeFileSync: writeFileSync32 } = await import("node:fs");
+    const { writeFileSync: writeFileSync33 } = await import("node:fs");
     const { resolve: resolve4 } = await import("node:path");
-    writeFileSync32(resolve4(root, outFile), result.bodyMarkdown, "utf8");
+    writeFileSync33(resolve4(root, outFile), result.bodyMarkdown, "utf8");
     console.log(`[+] Wrote PR context description to ${outFile}`);
     return 0;
   }
@@ -40579,7 +41218,7 @@ var init_health2 = __esm(() => {
 });
 
 // src/cli/sync.ts
-import { writeFileSync as writeFileSync32, readFileSync as readFileSync49 } from "node:fs";
+import { writeFileSync as writeFileSync33, readFileSync as readFileSync49 } from "node:fs";
 import { resolve as resolve4 } from "node:path";
 async function handleSyncCommand(parsed) {
   const ctx = requireRoot(parsed.flags);
@@ -40596,7 +41235,7 @@ async function handleSyncCommand(parsed) {
     });
     if (parsed.flags.out) {
       const outPath = resolve4(process.cwd(), parsed.flags.out);
-      writeFileSync32(outPath, JSON.stringify(packet2, null, 2), "utf-8");
+      writeFileSync33(outPath, JSON.stringify(packet2, null, 2), "utf-8");
       console.log(`\x1B[32m✓ Broadcast packet saved to '${outPath}' (${packet2.payload.memories.length} memories)\x1B[0m`);
     } else {
       console.log(JSON.stringify(packet2, null, 2));
@@ -40942,6 +41581,8 @@ async function main(argv) {
       return handleStaleCommand(parsed);
     case "consolidate":
       return handleConsolidateCommand(parsed);
+    case "optimize":
+      return handleOptimizeCommand(parsed);
     case "trace":
       return handleTraceCommand(parsed);
     case "loops":
@@ -41024,6 +41665,7 @@ Core Memory Lifecycle Commands:
   stats                         Display total memory counts and status/type distribution
   stale [--days N]              List entries exceeding staleness policy
   consolidate [--project P] [--dry-run]  Cluster confirmed memories into scene rollups
+  optimize [--dry-run] [--project P] [--force] Prune test noise, junk, duplicates & vacuum SQLite DB
   trace <id> [--depth N]        Walk causal graph pathways from an entry (default depth 5)
   loops                         Prioritized open-loop report: git state, stale candidates, constraints
   nudge                         Proactive attention list: overdue/due-soon entries, stale-by-policy, open loops