musememory 2.2.0 → 2.2.1

package/.agents/context/current.md

@@ -1,7 +1,7 @@
 # 📍 Current Shipped State & Active Invariants
 
-> **Version**: `v2.1.0`  
-> **Status**: Production Release (P2P Sync, Studio, and Monorepo Mesh)
+> **Version**: `v2.2.1`  
+> **Status**: Production Release (Hardened v2.2 with Linus-Style Code Review Bug Fixes)
 
 ---
 
@@ -34,6 +34,11 @@
 25. **Cross-Agent Knowledge Sync & P2P Gossip Protocol (R14)**: Portable sealed `SyncPacket` with SHA-256 integrity, vector clock causal ordering, bidirectional shared pool drop-directory gossip exchange, deduplication, Vibeguard secret scrubbing, and semantic contradiction tagging with mutual `conflict_ids`.
 26. **Full Web Observability Studio & Interactive Visual Dashboard (R15)**: Integrated web studio served over local HTTP (`memory studio`), featuring a 5-pillar health scorecard, overall letter grade, prioritized remediation action checklist, ADR registry with code-to-doc drift inspector, autonomous "Why" reasoner, bug friction clusters heatmap, debt hotspots, and live P2P mesh topology visualizer.
 27. **Multi-Repo & Monorepo Cross-Project Mesh (R16)**: Automatic workspace detection across pnpm, npm, bun, lerna, and multi-repo sibling groups; cross-project memory querying with origin package provenance; cross-package contract and entrypoint export auditing; explicit mesh linking (`mesh_links.json`); and shared invariant propagation across the entire mesh.
+28. **Unified Code & Memory Impact Analysis**: Pre-flight blast radius analysis evaluating AST callers, test suites, governing ADRs, negative warnings, and risk levels (`memory code-impact` / `muse_code_impact`).
+29. **PR & Change Context Generator**: Automatically turns git diffs into rich, memory-grounded GitHub PR descriptions linking touched anchors and active constraints (`memory pr-context` / `muse_pr_context`).
+30. **Interactive Code Anchor Reconciler**: Audits and repairs code anchors across memories, pruning dead references and updating structural hashes (`memory reconcile` / `muse_reconcile_anchors`).
+31. **Latency & Quality Telemetry Suite**: Benchmarks microsecond hot caches, FTS5 BM25 search, knapsack token packing, and ROI in a clean ASCII scoreboard (`memory benchmark`).
+32. **Linus-Style Architectural Hardening (v2.2.1)**: Elimination of shell command injection via `execFileSync`, concurrency-safe `PRAGMA busy_timeout = 5000` on SQLite WAL mode, O(N) stat storm elimination in `list(store)`, structured warnings on YAML dual-write failures, and tightened word-boundary/code-anchor ADR matching.
 
 ---
 

package/README.md

@@ -24,60 +24,34 @@
 
 ---
 
-## 🚀 What's New in v2.2.0, v2.1.0 & v2.0.0 (Impact Analysis, PR Context, Reconciler & Telemetry)
-
-### 💥 v2.2.0 Flagship Additions: Code Impact, PR Context & Cognitive Governance
-- **💥 Unified Code & Memory Impact Analysis (`memory code-impact`)**:
-  - Synthesizes AST code callers, affected test suites, linked memories, living ADRs, negative anti-patterns, and active constraints.
-  - Computes a composite Risk Score (0–100) and Risk Level (`LOW`, `MEDIUM`, `HIGH`, `CRITICAL`) with pre-flight actionable recommendations before modifying code.
-  - Available via CLI `memory code-impact <file> [--symbol <name>]` and MCP tool `muse_code_impact`.
-- **📋 PR & Change Context Generator (`memory pr-context`)**:
-  - Automatically analyzes git diff against base branch, linking touched code anchors, respected ADRs, active project constraints, and blast radius.
-  - Generates rich GitHub-ready Markdown pull request descriptions with verification checklists and merge promotion proposals.
-  - Available via CLI `memory pr-context [--base main] [--out <file>]` and MCP tool `muse_pr_context`.
-- **⚓ Interactive Code Anchor Reconciler (`memory reconcile`)**:
-  - Audits code anchors across memories, pruning dead anchors, refreshing structural hashes for drifted code, and marking abandoned memories stale.
-  - Supports `--dry-run`, `--prune`, `--mark-stale`, `--update-hashes`, and MCP tool `muse_reconcile_anchors`.
-- **⚡ Repeatable Speed, Quality & ROI Benchmark Suite (`memory benchmark`)**:
-  - Measures microsecond in-process cache reads (P50 < 4µs), SQLite FTS5 BM25 search, knapsack token packing, contradiction rates, and compression ratios in a clean ASCII scoreboard.
-- **🧠 Complete Agent Skills Roster for v2.0–v2.2**:
-  - Added `.agents/skills/muse-health`, `muse-drift`, `muse-why`, `muse-sync`, and `muse-mesh`.
-
-### 🌟 v2.1.0 Flagship Additions: Multi-Agent & Mesh Orchestration
-- **🤝 Cross-Agent Knowledge Sync & P2P Gossip Protocol (R14)**:
-  - Cryptographically sealed, portable `SyncPacket` engine with whole-packet SHA-256 integrity verification and vector clock causal ordering.
-  - Zero-daemon shared filesystem gossip pool (`.memory/sync_pool/`) allowing autonomous subagent teams (frontend, backend, test) to exchange insights asynchronously.
-  - Ingestion deduplication, inline Vibeguard secret scrubbing, and semantic contradiction tagging with mutual `conflict_ids`.
-  - CLI `memory sync` command suite & 4 MCP tools (`muse_sync_broadcast`, `muse_sync_ingest`, `muse_sync_status`, `muse_sync_pool`).
-- **🌐 Full Web Observability Studio (`memory studio`) (R15)**:
-  - Embedded zero-dependency visual web dashboard (`memory studio` or `memory ui`) with interactive control plane.
-  - Live 5-pillar health scorecard (A–F letter grade, PASS/WARN/FAIL gate status, and prioritized remediation checklist).
-  - Interactive ADR registry and bidirectional documentation $\longleftrightarrow$ code drift inspector.
-  - Historical "Why" reasoner query interface, recurring bug friction heatmap, and debt scanner.
-  - Real-time P2P gossip mesh status and interactive broadcast/shared pool sync controls.
-- **🕸️ Multi-Repo & Monorepo Cross-Project Mesh (R16)**:
-  - Passive automatic monorepo discovery across `pnpm`, `npm`, `bun`, `lerna`, and multi-repo sibling directories.
-  - Cross-project memory query resolver (`resolveMeshMemories`) with origin package provenance tags (`[mesh:@scope/package]`).
-  - Shared invariant and working constraint propagation (`propagateConstraintToMesh`) broadcasting critical security rules across all packages.
-  - Cross-package dependency contract and entrypoint export auditor (`auditMeshContracts`) validating cross-package imports and cross-repo code anchors.
-  - CLI `memory mesh` suite & 4 MCP tools (`muse_mesh_status`, `muse_mesh_query`, `muse_mesh_audit`, `muse_mesh_link`).
-
-### 🧠 v2.0.0 Major Cognitive Overhaul:
-- **🏥 Unified 5-Pillar Project Health Gate (`memory health` / `muse_health`)**: Single-call architectural audit across Store Integrity, Code Anchors, Doc-Code Alignment, Negative Sentry, and Technical Debt.
-- **🤔 Autonomous Engineering Cognition & "Why" Reasoner (`muse_why`)**: Reconstructs historical code evolution through past bug workarounds, accepted trade-offs, and timeless rules before refactoring.
-- **🏛️ First-Class Architecture Decision Records (`memory adr` / `memory_adr_record`)**: Living, queryable ADR entities with options considered, consequences, native code anchors, and supersession lineage.
-- **🔄 Bidirectional Documentation $\longleftrightarrow$ Code Drift Engine (`memory_drift_audit`)**: Continuously verifies alignment across 6 states (`DOCUMENTED`, `IMPLEMENTED`, `PARTIAL`, `CONFLICTING`, `STALE`, `MISSING`).
-- **🎯 Flagship Unified Context Orchestrator (`muse_context`)**: Single-call fused context injection with knapsack token budget packing.
-- **⚙️ Task-Focused MCP Profiles**: Dynamic role-based tool filtering (`core`, `coding`, `debugging`, `review`, `architecture`, `maintenance`).
-- **⚓ Native Structural Code Anchors (`src/anchors/`)**: Line-independent structural SHA-256 hashing insensitive to spacing/comments.
-- **🪜 Scoped Promotion & Extended Archival Lifecycle (`src/promotion/`)**: 3-tier promotion ladder (`local` $\rightarrow$ `project` $\rightarrow$ `global`), 5× repeated success policy, universal generalization, and `active` $\rightarrow$ `cold` $\rightarrow$ `dormant` $\rightarrow$ `archived` lifecycle with query rehydration.
-- **⚡ Hot Query Cache & SQLite WAL Optimization**: Microsecond memory lookups and high-throughput concurrent I/O.
+## 🚀 What's New
+
+### v2.2.0
+- **Unified Code & Memory Impact Analysis**: Pre-flight blast radius analysis evaluating AST callers, test suites, governing ADRs, negative warnings, and risk levels (`memory code-impact` / `muse_code_impact`).
+- **PR & Change Context Generator**: Automatically turns git diffs into rich, memory-grounded GitHub PR descriptions linking touched anchors and active constraints (`memory pr-context` / `muse_pr_context`).
+- **Interactive Code Anchor Reconciler**: Audits and repairs code anchors across memories, pruning dead references and updating structural hashes (`memory reconcile` / `muse_reconcile_anchors`).
+- **Latency & Quality Telemetry Suite**: Benchmarks microsecond hot caches, FTS5 BM25 search, knapsack token packing, and ROI in a clean ASCII scoreboard (`memory benchmark`).
+- **Expanded Agent Skills**: Shipped turnkey skills for `muse-health`, `muse-drift`, `muse-why`, `muse-sync`, and `muse-mesh`.
+
+### v2.1.0
+- **Cross-Agent Knowledge Sync & P2P Gossip Protocol**: Sealed portable `SyncPacket` engine with SHA-256 integrity and zero-daemon shared filesystem gossip pool (`memory sync` / `muse_sync_*`).
+- **Web Observability Studio**: Embedded visual dashboard (`memory studio` / `memory ui`) with interactive 5-pillar health, ADR registry, code drift inspector, and sync controls.
+- **Monorepo & Multi-Repo Mesh**: Automatic workspace discovery (pnpm, npm, bun, lerna) with cross-project memory queries and shared constraint propagation (`memory mesh` / `muse_mesh_*`).
+
+### v2.0.0
+- **5-Pillar Project Health Gate**: Architectural health gate evaluating store integrity, code anchors, doc-code alignment, negative sentry, and technical debt (`memory health` / `muse_health`).
+- **Cognitive "Why" Reasoner**: Reconstructs historical code evolution, bug workarounds, and trade-offs before refactoring (`muse_why`).
+- **Living Architecture Decision Records (ADRs)**: Queryable ADRs with options, consequences, native code anchors, and supersession lineage (`memory adr` / `memory_adr_record`).
+- **Doc ⟷ Code Drift Engine**: Continuously audits documentation against AST code implementations across 6 drift states (`memory drift` / `memory_drift_audit`).
+- **Unified Context Orchestrator & MCP Profiles**: Single-call fused context injection with knapsack token packing (`muse_context`) and task-specific tool profiles.
+- **Native Structural Code Anchors**: Line-independent structural SHA-256 hashing for files, symbols, and routes.
+- **Scoped Promotion & Archival Lifecycle**: 3-tier promotion ladder (`local` → `project` → `global`) and cold/dormant/archived storage tiers.
 
 ---
 
 ## 📑 Table of Contents
 
-- [🚀 What's New in v2.1.0 & v2.0.0](#-whats-new-in-v210--v200-autonomous-cognitive-engine-p2p-sync--monorepo-mesh)
+- [🚀 What's New](#-whats-new)
 - [💡 What is Muse Memory? (TL;DR)](#-what-is-muse-memory-tldr)
 - [✨ Key Feature Highlights](#-key-feature-highlights)
 - [⚡ Quick Start & Installation](#-quick-start--installation)

package/dist/index.js

@@ -5720,6 +5720,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 +5760,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 +6713,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 +6793,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 +20613,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, {
@@ -33838,11 +33897,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,
@@ -34295,28 +34362,38 @@ var init_harvester2 = __esm(() => {
 });
 
 // src/compaction/pr-context.ts
-import { execSync as execSync3 } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import { existsSync as existsSync46, readFileSync as readFileSync38 } from "node:fs";
 import { join as join43, 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 {
@@ -34472,7 +34549,7 @@ async function generatePrContext(store, options = {}) {
   return {
     title: prTitle,
     bodyMarkdown: md,
-    baseBranch: base,
+    baseBranch: safeBase,
     changedFiles,
     anchorsTouched: totalAnchorsTouched,
     adrsInvolved,
@@ -35349,7 +35426,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 +35467,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 +35484,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"]
@@ -40249,8 +40326,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 +40551,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,

package/package.json

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