musememory 3.0.2 → 3.2.0

package/dist/index.js

@@ -4480,7 +4480,7 @@ function searchMemoriesFts(db, query, filters) {
   sql += ` ORDER BY rank ASC`;
   const targetLimit = filters?.limit;
   if (targetLimit) {
-    const shouldOverfetch = filters?.overfetch !== false && !filters?.includeSuperseded && !filters?.status;
+    const shouldOverfetch = filters?.overfetch !== false && !filters?.status && (!filters?.includeSuperseded || !filters?.includeConflicted);
     const fetchLimit = shouldOverfetch ? Math.min(500, Math.max(targetLimit * 2, targetLimit + 10)) : targetLimit;
     sql += ` LIMIT ?`;
     params.push(fetchLimit);
@@ -4495,6 +4495,10 @@ function searchMemoriesFts(db, query, filters) {
         hidden_count++;
         continue;
       }
+      if (!filters?.includeConflicted && !filters?.status && entry.status === "conflicted") {
+        hidden_count++;
+        continue;
+      }
       activeHits.push({ entry, rank: r.rank });
     }
     const finalHits = targetLimit ? activeHits.slice(0, targetLimit) : activeHits;
@@ -4601,6 +4605,29 @@ function findConflictBetween(db, memoryA, memoryB) {
     return null;
   return rowToConflictRecord(row);
 }
+function listConflictsFromDb(db, options) {
+  let sql = `SELECT * FROM conflicts`;
+  const conditions = [];
+  const params = [];
+  if (options?.status) {
+    conditions.push(`status = ?`);
+    params.push(options.status);
+  }
+  if (options?.memoryId) {
+    conditions.push(`(memory_a_id = ? OR memory_b_id = ?)`);
+    params.push(options.memoryId, options.memoryId);
+  }
+  if (conditions.length > 0) {
+    sql += ` WHERE ` + conditions.join(" AND ");
+  }
+  sql += ` ORDER BY detected_at DESC`;
+  if (options?.limit && options.limit > 0) {
+    sql += ` LIMIT ?`;
+    params.push(options.limit);
+  }
+  const rows = db.query(sql).all(params);
+  return rows.map(rowToConflictRecord);
+}
 function insertFactProvenance(db, record) {
   try {
     const scope = record.scope ?? "global";
@@ -7559,6 +7586,10 @@ function queryContext(store, query = "", options = {}) {
         hidden_count++;
         return false;
       }
+      if (!options.includeConflicted && options.status !== "conflicted" && e.status === "conflicted") {
+        hidden_count++;
+        return false;
+      }
       if (!options.includeArchived && options.status !== "archived" && e.status === "archived") {
         hidden_count++;
         return false;
@@ -7840,7 +7871,7 @@ function searchTemporal(store, query, atTime, options = {}) {
   };
 }
 function formatPromptContext(store, memoryDir, query = "", options = {}) {
-  const cacheKey = store.cache ? `ctx:${query}:${options.project || ""}:${options.depth || "L2"}:${options.limit ?? 5}:${options.tokenBudget ?? ""}:${options.type || ""}:${options.status || ""}:${options.verified ? "1" : "0"}:${options.minVeracity ?? ""}:${options.as_of || ""}:${options.includeSuperseded ? "1" : "0"}:${options.includeArchived ? "1" : "0"}:${options.includeUntrusted ? "1" : "0"}:${options.types?.join(",") || ""}:${options.tags?.join(",") || ""}` : undefined;
+  const cacheKey = store.cache ? `ctx:${query}:${options.project || ""}:${options.depth || "L2"}:${options.limit ?? 5}:${options.tokenBudget ?? ""}:${options.type || ""}:${options.status || ""}:${options.verified ? "1" : "0"}:${options.minVeracity ?? ""}:${options.as_of || ""}:${options.includeSuperseded ? "1" : "0"}:${options.includeConflicted ? "1" : "0"}:${options.includeArchived ? "1" : "0"}:${options.includeUntrusted ? "1" : "0"}:${options.types?.join(",") || ""}:${options.tags?.join(",") || ""}` : undefined;
   if (cacheKey && store.cache) {
     const cached = store.cache.getContext(cacheKey);
     if (cached) {
@@ -10305,6 +10336,166 @@ var init_embedders = __esm(() => {
   init_schema();
 });
 
+// src/quality/scope.ts
+function canonicalizeScope(scope) {
+  if (!scope)
+    return "";
+  const norm = scope.toLowerCase().trim().replace(/[-_]+/g, " ").replace(/\s+/g, " ");
+  if (SCOPE_ALIASES[norm])
+    return SCOPE_ALIASES[norm];
+  const tokens = norm.split(" ").filter(Boolean);
+  if (tokens.length > 1) {
+    const mapped = tokens.map((token) => SCOPE_ALIASES[token]);
+    if (mapped.every((value) => value && value === mapped[0]))
+      return mapped[0];
+  }
+  return norm;
+}
+function extractTrailingScope(text, fromIndex) {
+  const rest = text.slice(fromIndex);
+  const defaultMatch = rest.match(/^[\s,;:()\-]*(?:by\s+default)\b/i);
+  if (defaultMatch)
+    return canonicalizeScope("default");
+  const prepMatch = rest.match(/^[\s,;:()\-]*(?:only\s+)?(instead\s+of|within|throughout|during|while|when|before|after|under|across|between|in|on|at|for|per)\b/i);
+  if (!prepMatch)
+    return;
+  const afterPrep = rest.slice(prepMatch[0].length);
+  const tokens = afterPrep.split(/[^A-Za-z0-9_\-\/]+/).filter(Boolean);
+  if (tokens.length === 0)
+    return;
+  const phrase = [];
+  for (const token of tokens) {
+    if (phrase.length >= SCOPE_MAX_TOKENS)
+      break;
+    const lower = token.toLowerCase();
+    if (phrase.length > 0 && SCOPE_BOUNDARY_TOKENS.has(lower))
+      break;
+    phrase.push(token);
+  }
+  if (phrase.length === 0)
+    return;
+  return canonicalizeScope(phrase.join(" "));
+}
+function extractLeadingScope(clause) {
+  const re = /\b(?:only\s+)?(instead\s+of|within|during|while|when|before|after|under|across|between|in|on|at|for|per)\s+([^,;.]{1,40}),/gi;
+  let last;
+  let match;
+  while ((match = re.exec(clause)) !== null) {
+    const tokens = match[2].split(/[^A-Za-z0-9_\-/]+/).filter(Boolean);
+    if (tokens.length === 0)
+      continue;
+    const phrase = [];
+    for (const token of tokens) {
+      if (phrase.length >= SCOPE_MAX_TOKENS)
+        break;
+      if (phrase.length > 0 && SCOPE_BOUNDARY_TOKENS.has(token.toLowerCase()))
+        break;
+      phrase.push(token);
+    }
+    if (phrase.length === 0)
+      continue;
+    last = canonicalizeScope(phrase.join(" "));
+  }
+  return last;
+}
+function isStrongScope(scope) {
+  if (!scope)
+    return false;
+  const norm = canonicalizeScope(scope);
+  if (STRONG_SCOPES.has(norm))
+    return true;
+  return /^(tier|level|stage|phase|version|v)\s*\d+$/.test(norm);
+}
+function scopesAreCompatible(scopeA, scopeB) {
+  const a = scopeA ? canonicalizeScope(scopeA) : "";
+  const b = scopeB ? canonicalizeScope(scopeB) : "";
+  if (!a && !b)
+    return true;
+  if (!a || !b)
+    return false;
+  return a === b;
+}
+var SCOPE_ALIASES, SCOPE_BOUNDARY_TOKENS, SCOPE_MAX_TOKENS = 3, STRONG_SCOPES;
+var init_scope = __esm(() => {
+  SCOPE_ALIASES = {
+    prod: "production",
+    production: "production",
+    dev: "development",
+    development: "development",
+    test: "testing",
+    testing: "testing",
+    qa: "testing",
+    staging: "staging",
+    stage: "staging",
+    analytics: "analytics",
+    warehouse: "analytics",
+    olap: "analytics",
+    macos: "desktop",
+    desktop: "desktop",
+    mobile: "mobile",
+    ios: "mobile",
+    android: "mobile",
+    frontend: "frontend",
+    backend: "backend",
+    localhost: "local",
+    local: "local",
+    ci: "ci",
+    cd: "ci",
+    container: "container",
+    docker: "container",
+    browser: "browser",
+    server: "server",
+    client: "client"
+  };
+  SCOPE_BOUNDARY_TOKENS = new Set([
+    "and",
+    "but",
+    "or",
+    "so",
+    "because",
+    "since",
+    "unless",
+    "which",
+    "that",
+    "who",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "to",
+    "as",
+    "if",
+    "then",
+    "otherwise",
+    "however",
+    "meanwhile",
+    "also",
+    "both",
+    "either",
+    "neither"
+  ]);
+  STRONG_SCOPES = new Set([
+    "production",
+    "development",
+    "testing",
+    "staging",
+    "analytics",
+    "desktop",
+    "mobile",
+    "frontend",
+    "backend",
+    "local",
+    "ci",
+    "container",
+    "browser",
+    "server",
+    "client",
+    "default"
+  ]);
+});
+
 // src/quality/invalidation.ts
 function normalizeTerm(term) {
   if (!term)
@@ -10315,10 +10506,6 @@ function canonicalizeRelation(rel) {
   const norm = normalizeTerm(rel);
   return RELATION_ALIASES[norm] || norm;
 }
-function canonicalizeScope(scope) {
-  const norm = normalizeTerm(scope);
-  return SCOPE_ALIASES[norm] || norm;
-}
 function extractFactTriples(entry) {
   if (entry.triples && Array.isArray(entry.triples) && entry.triples.length > 0) {
     return entry.triples.map((t) => ({
@@ -10331,32 +10518,32 @@ function extractFactTriples(entry) {
   const triples = [];
   const text = `${entry.title} ${entry.content}`;
   const lowerText = text.toLowerCase();
-  let detectedScope;
+  let tagScope;
   if (entry.tags) {
     for (const tag of entry.tags) {
       if (tag.startsWith("scope:")) {
-        detectedScope = canonicalizeScope(tag.replace("scope:", ""));
+        tagScope = canonicalizeScope(tag.replace("scope:", ""));
         break;
       }
     }
   }
-  if (!detectedScope) {
-    if (/\b(in\s+production|for\s+production|prod\s+server|production\s+database|production\s+environment)\b/i.test(text)) {
-      detectedScope = "production";
-    } else if (/\b(in\s+development|for\s+development|dev\s+server|development\s+environment|local\s+dev)\b/i.test(text)) {
-      detectedScope = "development";
-    } else if (/\b(for\s+analytics|analytics\s+warehouse|analytics\s+database|in\s+olap)\b/i.test(text)) {
-      detectedScope = "analytics";
-    } else if (/\b(on\s+macos|macos\s+desktop|for\s+desktop)\b/i.test(text)) {
-      detectedScope = "desktop";
-    } else if (/\b(on\s+mobile|mobile\s+ios|on\s+ios|on\s+android|mobile\s+app)\b/i.test(text)) {
-      detectedScope = "mobile";
-    } else if (/\b(in\s+staging|staging\s+environment)\b/i.test(text)) {
-      detectedScope = "staging";
-    } else if (/\b(in\s+testing|for\s+test|test\s+environment)\b/i.test(text)) {
-      detectedScope = "testing";
-    }
-  }
+  let fixedScope;
+  if (/\b(in\s+production|for\s+production|prod\s+server|production\s+database|production\s+environment)\b/i.test(text)) {
+    fixedScope = "production";
+  } else if (/\b(in\s+development|for\s+development|dev\s+server|development\s+environment|local\s+dev)\b/i.test(text)) {
+    fixedScope = "development";
+  } else if (/\b(for\s+analytics|analytics\s+warehouse|analytics\s+database|in\s+olap)\b/i.test(text)) {
+    fixedScope = "analytics";
+  } else if (/\b(on\s+macos|macos\s+desktop|for\s+desktop)\b/i.test(text)) {
+    fixedScope = "desktop";
+  } else if (/\b(on\s+mobile|mobile\s+ios|on\s+ios|on\s+android|mobile\s+app)\b/i.test(text)) {
+    fixedScope = "mobile";
+  } else if (/\b(in\s+staging|staging\s+environment)\b/i.test(text)) {
+    fixedScope = "staging";
+  } else if (/\b(in\s+testing|for\s+test|test\s+environment)\b/i.test(text)) {
+    fixedScope = "testing";
+  }
+  const scopeFor = (claimEndIndex) => tagScope ?? fixedScope ?? extractTrailingScope(text, claimEndIndex);
   const dbMatch = text.match(/\b(primary\s+database|database|warehouse|persistence|db)\b.*?uses?\s+([A-Za-z0-9_]+)/i) || text.match(/\buses?\s+(postgresql|postgres|mysql|sqlite|mongodb)\b/i);
   if (dbMatch) {
     const target = dbMatch[2] ? dbMatch[2].toLowerCase() : dbMatch[1].toLowerCase();
@@ -10364,7 +10551,7 @@ function extractFactTriples(entry) {
       entity: "database",
       relation: "database",
       target: target.startsWith("postgres") ? "postgresql" : target,
-      scope: detectedScope
+      scope: scopeFor((dbMatch.index ?? 0) + dbMatch[0].length)
     });
   }
   const portMatch = text.match(/\b(binds?\s+to\s+port|runs?\s+on\s+port|port\s+binding|port)\s+([0-9]{2,5})\b/i);
@@ -10373,7 +10560,7 @@ function extractFactTriples(entry) {
       entity: "gateway",
       relation: "port",
       target: portMatch[2],
-      scope: detectedScope
+      scope: scopeFor((portMatch.index ?? 0) + portMatch[0].length)
     });
   }
   const themeMatch = text.match(/\b(theme|mode)\b.*?\b(dark|light)\b/i) || text.match(/\bprefers?\s+(dark|light)\s+(mode|theme)?\b/i);
@@ -10383,7 +10570,7 @@ function extractFactTriples(entry) {
       entity: "user_theme",
       relation: "theme",
       target,
-      scope: detectedScope
+      scope: scopeFor((themeMatch.index ?? 0) + themeMatch[0].length)
     });
   }
   const runtimeMatch = text.match(/\b(runtime|engine)\b.*?\b(bun|node|deno)\b/i) || text.match(/\b(bun|node|deno)\s+runtime\b/i);
@@ -10393,7 +10580,7 @@ function extractFactTriples(entry) {
       entity: "runtime",
       relation: "runtime",
       target,
-      scope: detectedScope
+      scope: scopeFor((runtimeMatch.index ?? 0) + runtimeMatch[0].length)
     });
   }
   const statusMatch = text.match(/\b([A-Za-z0-9_-]+)\s+(service|feature|caching|compression|plugin)\s*(?:is\s+)?(enabled|disabled|allowed|denied|forbidden|active|inactive)\b/i);
@@ -10402,7 +10589,7 @@ function extractFactTriples(entry) {
       entity: normalizeTerm(statusMatch[1]),
       relation: "status",
       target: normalizeTerm(statusMatch[3]),
-      scope: detectedScope
+      scope: scopeFor((statusMatch.index ?? 0) + statusMatch[0].length)
     });
   }
   return triples;
@@ -10463,52 +10650,10 @@ function evaluateScopedAlignment(tripleA, tripleB) {
     reason: `Target values '${tripleA.target}' and '${tripleB.target}' are consistent`
   };
 }
-function evaluateScopedInvalidation(existing, candidate) {
-  const existingTriples = extractFactTriples(existing);
-  const candidateTriples = extractFactTriples(candidate);
-  if (existingTriples.length > 0 && candidateTriples.length > 0) {
-    let hadScopeOrEntityMismatch = false;
-    let mismatchReason = "";
-    for (const eTriple of existingTriples) {
-      for (const cTriple of candidateTriples) {
-        const alignment = evaluateScopedAlignment(eTriple, cTriple);
-        if (alignment.aligned && alignment.conflicting) {
-          return {
-            shouldInvalidate: true,
-            aligned: true,
-            conflicting: true,
-            confidence: 0.95,
-            reason: alignment.reason,
-            matchingTriples: {
-              existingTriple: eTriple,
-              candidateTriple: cTriple
-            }
-          };
-        } else if (!alignment.aligned) {
-          hadScopeOrEntityMismatch = true;
-          mismatchReason = alignment.reason || "Entity or scope mismatch";
-        }
-      }
-    }
-    if (hadScopeOrEntityMismatch) {
-      return {
-        shouldInvalidate: false,
-        aligned: false,
-        conflicting: false,
-        confidence: 0,
-        reason: mismatchReason
-      };
-    }
-  }
-  return {
-    shouldInvalidate: false,
-    aligned: false,
-    conflicting: false,
-    confidence: 0
-  };
-}
-var RELATION_ALIASES, SCOPE_ALIASES, CONFLICTING_TARGET_PAIRS;
+var RELATION_ALIASES, CONFLICTING_TARGET_PAIRS;
 var init_invalidation = __esm(() => {
+  init_scope();
+  init_scope();
   RELATION_ALIASES = {
     db: "database",
     database: "database",
@@ -10531,25 +10676,6 @@ var init_invalidation = __esm(() => {
     runtime: "runtime",
     runtime_engine: "runtime"
   };
-  SCOPE_ALIASES = {
-    prod: "production",
-    production: "production",
-    dev: "development",
-    development: "development",
-    test: "testing",
-    testing: "testing",
-    staging: "staging",
-    analytics: "analytics",
-    warehouse: "analytics",
-    olap: "analytics",
-    macos: "desktop",
-    desktop: "desktop",
-    mobile: "mobile",
-    ios: "mobile",
-    android: "mobile",
-    frontend: "frontend",
-    backend: "backend"
-  };
   CONFLICTING_TARGET_PAIRS = [
     [/\b(enable|enabled|true|allow|allowed|active)\b/i, /\b(disable|disabled|false|deny|denied|inactive|forbidden)\b/i],
     [/\b(postgres|postgresql)\b/i, /\b(mysql|sqlite|mongodb)\b/i],
@@ -10561,10 +10687,570 @@ var init_invalidation = __esm(() => {
   ];
 });
 
+// src/quality/polarity.ts
+function tokenize2(text) {
+  return text.split(/[^A-Za-z0-9_\-/]+/).filter(Boolean);
+}
+function lastClauseBoundary(text) {
+  let index = -1;
+  for (const boundary of CLAUSE_BOUNDARIES) {
+    const found = text.lastIndexOf(boundary);
+    if (found > index)
+      index = found;
+  }
+  return index;
+}
+function trimTrailing(tokens, vocab) {
+  const out = [...tokens];
+  while (out.length && vocab.has(out[out.length - 1].toLowerCase()))
+    out.pop();
+  return out;
+}
+function subjectBefore(text, claimIndex, maxTokens = 4) {
+  const before = text.slice(0, claimIndex);
+  const clause = before.slice(lastClauseBoundary(before) + 1);
+  let tokens = tokenize2(clause);
+  tokens = trimTrailing(tokens, AUXILIARY_TOKENS);
+  tokens = trimTrailing(tokens, TRAILING_VERB_TOKENS);
+  tokens = trimTrailing(tokens, TRAILING_PREPOSITION_TOKENS);
+  tokens = tokens.slice(-maxTokens);
+  tokens = tokens.filter((token) => !TECHNOLOGY_TOKENS.has(token.toLowerCase()));
+  while (tokens.length && LEADING_TRIM_TOKENS.has(tokens[0].toLowerCase()))
+    tokens.shift();
+  tokens = trimTrailing(tokens, TRAILING_PREPOSITION_TOKENS);
+  return tokens.join(" ").toLowerCase();
+}
+function objectAfter(text, fromIndex) {
+  const rest = text.slice(fromIndex);
+  const tokens = [];
+  let consumed = fromIndex;
+  const re = /[\s:,\-]*([A-Za-z0-9_\-/]+)/g;
+  let match;
+  while ((match = re.exec(rest)) !== null) {
+    const word = match[1];
+    const lower = word.toLowerCase();
+    if (tokens.length >= 4)
+      break;
+    if (tokens.length > 0 && (TRAILING_PREPOSITION_TOKENS.has(lower) || AUXILIARY_TOKENS.has(lower)))
+      break;
+    if (tokens.length === 0 && DETERMINER_TOKENS.has(lower)) {
+      consumed = fromIndex + match.index + match[0].length;
+      continue;
+    }
+    tokens.push(word);
+    consumed = fromIndex + match.index + match[0].length;
+  }
+  if (tokens.length === 0)
+    return null;
+  return { phrase: tokens.join(" ").toLowerCase(), endIndex: consumed };
+}
+function isMigrationContext(before) {
+  const tail = before.slice(-48).toLowerCase();
+  return /\b(from|migrat\w*|switch\w*|move[ds]?|chang\w*|replac\w*|instead\s+of|convert\w*|port\w*)\b[^.]{0,30}$/.test(tail);
+}
+function resolveScope(text, claimEnd, claimStart, options) {
+  const strongOnly = options?.strongOnly === true;
+  const trailing = extractTrailingScope(text, claimEnd);
+  if (trailing && (!strongOnly || isStrongScope(trailing)))
+    return trailing;
+  const before = text.slice(0, claimStart);
+  const clause = before.slice(lastClauseBoundary(before) + 1);
+  const leading = extractLeadingScope(clause);
+  if (leading && (!strongOnly || isStrongScope(leading)))
+    return leading;
+  return;
+}
+function statusClaims(text) {
+  const claims = [];
+  const adjectiveRe = new RegExp(`\\b(${STATUS_ADJECTIVES.join("|")})\\b`, "gi");
+  let match;
+  while ((match = adjectiveRe.exec(text)) !== null) {
+    const term = match[1].toLowerCase();
+    const entity = subjectBefore(text, match.index);
+    if (!entity)
+      continue;
+    const scope = resolveScope(text, match.index + match[0].length, match.index);
+    claims.push({
+      entity,
+      relation: "status",
+      target: term,
+      scope,
+      evidence: match[0]
+    });
+  }
+  const booleanRe = /\b(is|are|was|were|=|:)\s+(true|false)\b/gi;
+  while ((match = booleanRe.exec(text)) !== null) {
+    const term = match[2].toLowerCase();
+    const entity = subjectBefore(text, match.index);
+    if (!entity)
+      continue;
+    const scope = resolveScope(text, match.index + match[0].length, match.index);
+    claims.push({
+      entity,
+      relation: "status",
+      target: term,
+      scope,
+      evidence: match[0]
+    });
+  }
+  const verbRe = /\b(enables?|disables?|allows?|denies?)\b/gi;
+  while ((match = verbRe.exec(text)) !== null) {
+    const verb = match[1].toLowerCase();
+    const target = VERB_STATUS[verb];
+    if (!target)
+      continue;
+    const object = objectAfter(text, match.index + match[0].length);
+    if (!object)
+      continue;
+    const scope = resolveScope(text, object.endIndex, match.index);
+    claims.push({
+      entity: object.phrase,
+      relation: "status",
+      target,
+      scope,
+      evidence: `${match[0]} ${object.phrase}`
+    });
+  }
+  return claims;
+}
+function databaseClaims(text) {
+  const claims = [];
+  const re = /\b(postgres(?:ql)?|mysql|sqlite|mongodb)\b/gi;
+  let match;
+  while ((match = re.exec(text)) !== null) {
+    const token = match[1].toLowerCase();
+    const before = text.slice(0, match.index);
+    const after = text.slice(match.index + match[0].length);
+    if (isMigrationContext(before))
+      continue;
+    const anchored = DB_ANCHOR_BEFORE.test(before) || DB_ANCHOR_AFTER.test(after);
+    if (!anchored)
+      continue;
+    const scope = resolveScope(text, match.index + match[0].length, match.index, { strongOnly: true });
+    claims.push({
+      entity: subjectBefore(text, match.index, 3) || "database",
+      relation: "database",
+      target: DB_TARGETS[token] ?? token,
+      scope,
+      evidence: match[0]
+    });
+  }
+  return claims;
+}
+function portClaims(text) {
+  const claims = [];
+  const re = /\bport\s+(\d{2,5})\b/gi;
+  let match;
+  while ((match = re.exec(text)) !== null) {
+    const entity = subjectBefore(text, match.index, 3);
+    if (!entity)
+      continue;
+    const scope = resolveScope(text, match.index + match[0].length, match.index, { strongOnly: true });
+    claims.push({
+      entity,
+      relation: "port",
+      target: match[1],
+      scope,
+      evidence: match[0]
+    });
+  }
+  return claims;
+}
+function protocolClaims(text) {
+  const claims = [];
+  const re = /\b(rest\s+api|graphql|grpc|rest)\b/gi;
+  let match;
+  while ((match = re.exec(text)) !== null) {
+    const token = match[1].toLowerCase();
+    if (isMigrationContext(text.slice(0, match.index)))
+      continue;
+    const before = text.slice(0, match.index);
+    const clause = text.slice(lastClauseBoundary(before) + 1);
+    const clauseWithoutMatch = `${clause}${text.slice(match.index + match[0].length).split(/[.;\n]/)[0]}`;
+    if (!PROTOCOL_ANCHOR.test(clauseWithoutMatch))
+      continue;
+    const entity = subjectBefore(text, match.index, 3);
+    if (!entity)
+      continue;
+    const target = token.startsWith("rest") ? "rest" : token;
+    const scope = resolveScope(text, match.index + match[0].length, match.index, { strongOnly: true });
+    claims.push({
+      entity,
+      relation: "protocol",
+      target,
+      scope,
+      evidence: match[0]
+    });
+  }
+  return claims;
+}
+function runtimeClaims(text) {
+  const claims = [];
+  const re = /\b(bun|node|deno)\s+runtime\b/gi;
+  let match;
+  while ((match = re.exec(text)) !== null) {
+    if (isMigrationContext(text.slice(0, match.index)))
+      continue;
+    const entity = subjectBefore(text, match.index, 3);
+    if (!entity)
+      continue;
+    const scope = resolveScope(text, match.index + match[0].length, match.index, { strongOnly: true });
+    claims.push({
+      entity,
+      relation: "runtime",
+      target: match[1].toLowerCase(),
+      scope,
+      evidence: match[0]
+    });
+  }
+  return claims;
+}
+function themeClaims(text) {
+  const claims = [];
+  const re = /\b(dark|light)\s+(?:mode|theme)\b/gi;
+  let match;
+  while ((match = re.exec(text)) !== null) {
+    const entity = subjectBefore(text, match.index, 3);
+    if (!entity)
+      continue;
+    const scope = resolveScope(text, match.index + match[0].length, match.index, { strongOnly: true });
+    claims.push({
+      entity,
+      relation: "theme",
+      target: match[1].toLowerCase(),
+      scope,
+      evidence: match[0]
+    });
+  }
+  return claims;
+}
+function policyClaims(text) {
+  const claims = [];
+  const re = /\b(always|never)\b/gi;
+  let match;
+  while ((match = re.exec(text)) !== null) {
+    const object = objectAfter(text, match.index + match[0].length);
+    if (!object)
+      continue;
+    claims.push({
+      entity: object.phrase,
+      relation: "policy",
+      target: match[1].toLowerCase(),
+      scope: undefined,
+      evidence: `${match[0]} ${object.phrase}`
+    });
+  }
+  return claims;
+}
+function dedupeClaims(claims) {
+  const scopedKeys = new Set;
+  for (const claim of claims) {
+    if (claim.scope)
+      scopedKeys.add(`${claim.entity}|${claim.relation}|${claim.target}`);
+  }
+  const seen = new Set;
+  const unique = [];
+  for (const claim of claims) {
+    const key = `${claim.entity}|${claim.relation}|${claim.target}|${claim.scope ?? ""}`;
+    if (seen.has(key))
+      continue;
+    if (!claim.scope && scopedKeys.has(`${claim.entity}|${claim.relation}|${claim.target}`))
+      continue;
+    seen.add(key);
+    unique.push(claim);
+  }
+  return unique;
+}
+function extractPolarityClaims(text) {
+  if (!text)
+    return [];
+  const claims = [
+    ...statusClaims(text),
+    ...databaseClaims(text),
+    ...portClaims(text),
+    ...protocolClaims(text),
+    ...runtimeClaims(text),
+    ...themeClaims(text),
+    ...policyClaims(text)
+  ];
+  return dedupeClaims(claims);
+}
+function comparePolarityClaims(a, b) {
+  if (a.relation !== b.relation)
+    return { conflicting: false };
+  if (!a.entity || !b.entity)
+    return { conflicting: false };
+  const entityMatches = a.entity === b.entity || a.entity.includes(b.entity) || b.entity.includes(a.entity);
+  if (!entityMatches) {
+    return {
+      conflicting: false,
+      reason: `Subject mismatch: '${a.entity}' vs '${b.entity}' are different subjects`
+    };
+  }
+  if (!scopesAreCompatible(a.scope, b.scope)) {
+    return {
+      conflicting: false,
+      reason: `Distinct scopes: '${a.scope ?? "unscoped"}' vs '${b.scope ?? "unscoped"}' represent distinct contextual truths, not a contradiction`
+    };
+  }
+  if (areTargetsContradictory(a.target, b.target)) {
+    const label = RELATION_LABELS[a.relation] ?? "Contradictory claims";
+    return {
+      conflicting: true,
+      reason: `${label}: contradictory ${a.relation} values '${a.target}' vs '${b.target}' for subject '${a.entity}'${a.scope ? ` in scope '${a.scope}'` : ""}`
+    };
+  }
+  return { conflicting: false };
+}
+var DETERMINER_TOKENS, AUXILIARY_TOKENS, TRAILING_PREPOSITION_TOKENS, LEADING_TRIM_TOKENS, TRAILING_VERB_TOKENS, CLAUSE_BOUNDARIES, TECHNOLOGY_TOKENS, STATUS_ADJECTIVES, VERB_STATUS, DB_TARGETS, DB_ANCHOR_BEFORE, DB_ANCHOR_AFTER, PROTOCOL_ANCHOR, RELATION_LABELS;
+var init_polarity = __esm(() => {
+  init_invalidation();
+  init_scope();
+  DETERMINER_TOKENS = new Set([
+    "the",
+    "a",
+    "an",
+    "this",
+    "that",
+    "these",
+    "those",
+    "our",
+    "its",
+    "their",
+    "my",
+    "your",
+    "some",
+    "any",
+    "each",
+    "every",
+    "all",
+    "both",
+    "one",
+    "other",
+    "no",
+    "most",
+    "such"
+  ]);
+  AUXILIARY_TOKENS = new Set([
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "am",
+    "remains",
+    "remain",
+    "remained",
+    "stays",
+    "stay",
+    "stayed",
+    "get",
+    "gets",
+    "got",
+    "getting",
+    "should",
+    "must",
+    "needs",
+    "need",
+    "to",
+    "has",
+    "have",
+    "had",
+    "will",
+    "would",
+    "can",
+    "could",
+    "may",
+    "might",
+    "do",
+    "does",
+    "did",
+    "not",
+    "also",
+    "then",
+    "than",
+    "so",
+    "if",
+    "when",
+    "while",
+    "because",
+    "since",
+    "unless",
+    "which",
+    "that",
+    "where",
+    "how",
+    "what",
+    "why",
+    "and",
+    "or",
+    "but",
+    "there",
+    "it",
+    "its",
+    "we",
+    "you",
+    "they"
+  ]);
+  TRAILING_PREPOSITION_TOKENS = new Set([
+    "for",
+    "in",
+    "on",
+    "at",
+    "of",
+    "with",
+    "to",
+    "from",
+    "by",
+    "during",
+    "when",
+    "while",
+    "under",
+    "within",
+    "across",
+    "per",
+    "about",
+    "into",
+    "onto",
+    "via",
+    "using",
+    "after",
+    "before",
+    "since",
+    "until",
+    "against",
+    "between",
+    "among",
+    "like",
+    "as",
+    "than",
+    "and",
+    "or",
+    "but",
+    "so",
+    "because",
+    "over",
+    "under"
+  ]);
+  LEADING_TRIM_TOKENS = new Set([
+    ...DETERMINER_TOKENS,
+    "for",
+    "about",
+    "regarding",
+    "concerning",
+    "with",
+    "using",
+    "via",
+    "when",
+    "while",
+    "because",
+    "since",
+    "if"
+  ]);
+  TRAILING_VERB_TOKENS = new Set([
+    "bind",
+    "binds",
+    "binding",
+    "run",
+    "runs",
+    "running",
+    "listen",
+    "listens",
+    "listening",
+    "serve",
+    "serves",
+    "serving",
+    "use",
+    "uses",
+    "using",
+    "connect",
+    "connects",
+    "connecting",
+    "expose",
+    "exposes",
+    "exposing",
+    "prefers",
+    "prefer",
+    "prefers",
+    "target",
+    "targets",
+    "targeting",
+    "serve",
+    "serves",
+    "provide",
+    "provides",
+    "providing",
+    "keep",
+    "keeps",
+    "keeping",
+    "always",
+    "never"
+  ]);
+  CLAUSE_BOUNDARIES = [".", ";", `
+`, "!", "?", "|"];
+  TECHNOLOGY_TOKENS = new Set([
+    "postgres",
+    "postgresql",
+    "mysql",
+    "sqlite",
+    "mongodb",
+    "bun",
+    "node",
+    "deno",
+    "rest",
+    "graphql",
+    "grpc",
+    "dark",
+    "light"
+  ]);
+  STATUS_ADJECTIVES = [
+    "enabled",
+    "disabled",
+    "active",
+    "inactive",
+    "allowed",
+    "denied",
+    "forbidden"
+  ];
+  VERB_STATUS = {
+    enable: "enabled",
+    enables: "enabled",
+    disable: "disabled",
+    disables: "disabled",
+    allow: "allowed",
+    allows: "allowed",
+    deny: "denied",
+    denies: "denied"
+  };
+  DB_TARGETS = {
+    postgres: "postgresql",
+    postgresql: "postgresql",
+    mysql: "mysql",
+    sqlite: "sqlite",
+    mongodb: "mongodb"
+  };
+  DB_ANCHOR_BEFORE = /\b(?:uses?|using|use\s+of|primary\s+database|database|db|engine|store|persistence|persisted\s+(?:in|to)|backed\s+by|runs?\s+on)\b[^A-Za-z0-9]{0,30}$/i;
+  DB_ANCHOR_AFTER = /^\s*(?:is|as)\s+(?:the\s+)?(?:primary\s+)?(?:database|store|engine|db)\b/i;
+  PROTOCOL_ANCHOR = /\b(api|protocol|service|endpoint|interface|route|client|server)\b/i;
+  RELATION_LABELS = {
+    status: "Opposing configuration polarity",
+    database: "Conflicting primary database choice",
+    port: "Conflicting port binding",
+    protocol: "Conflicting communication protocol",
+    runtime: "Conflicting runtime engine",
+    theme: "Conflicting theme selection",
+    policy: "Contradictory universal policy"
+  };
+});
+
 // src/quality/contradiction.ts
 import { randomUUID } from "node:crypto";
-function detectConflict(store, candidate) {
-  const candidateText = `${candidate.title} ${candidate.content}`.toLowerCase();
+function detectConflict(store, candidate, options) {
+  const dryRun = options?.dryRun === true;
+  const candidateText = `${candidate.title || ""} ${candidate.content || ""}`;
+  const candidateClaims = extractPolarityClaims(candidateText);
   const entries = list(store, candidate.project ? { project: candidate.project } : undefined);
   for (const entry of entries) {
     if (candidate.id && entry.id === candidate.id)
@@ -10572,55 +11258,93 @@ function detectConflict(store, candidate) {
     if (entry.status !== "active" && entry.status !== "confirmed" && entry.status !== "conflicted") {
       continue;
     }
-    const scopedCheck = evaluateScopedInvalidation(entry, candidate);
-    if (scopedCheck.shouldInvalidate) {
-      const entryText = `${entry.title} ${entry.content}`.toLowerCase();
-      let pairReason = "";
-      for (const [patternA, patternB, reason] of CONTRADICTORY_PAIRS) {
-        if (patternA.test(candidateText) && patternB.test(entryText) || patternB.test(candidateText) && patternA.test(entryText)) {
-          pairReason = `${reason} between candidate and "${entry.title}" (${entry.id})`;
-          break;
+    const existingTriples = entry.triples && entry.triples.length > 0 ? extractFactTriples(entry) : [];
+    const candidateTriples = candidate.triples && candidate.triples.length > 0 ? extractFactTriples(candidate) : [];
+    if (existingTriples.length > 0 && candidateTriples.length > 0) {
+      for (const existingTriple of existingTriples) {
+        for (const candidateTriple of candidateTriples) {
+          const alignment = evaluateScopedAlignment(existingTriple, candidateTriple);
+          if (alignment.aligned && alignment.conflicting) {
+            return {
+              conflicted: true,
+              conflictingEntry: entry,
+              confidence: 0.95,
+              reason: alignment.reason,
+              dryRun
+            };
+          }
         }
       }
-      const combinedReason = pairReason ? `${pairReason}: ${scopedCheck.reason}` : scopedCheck.reason || `Scoped contradiction detected with "${entry.title}" (${entry.id})`;
-      return {
-        conflicted: true,
-        conflictingEntry: entry,
-        confidence: scopedCheck.confidence,
-        reason: combinedReason
-      };
-    }
-    if (scopedCheck.reason && !scopedCheck.aligned && !scopedCheck.shouldInvalidate) {
-      continue;
     }
-    const entryText = `${entry.title} ${entry.content}`.toLowerCase();
-    const topicSimilarity = computeJaccardSimilarity(candidate.title, entry.title);
-    if (topicSimilarity >= 0.4 || entry.type && candidate.type && entry.type === candidate.type && topicSimilarity >= 0.3) {
-      for (const [patternA, patternB, reason] of CONTRADICTORY_PAIRS) {
-        const aInCand = patternA.test(candidateText);
-        const bInCand = patternB.test(candidateText);
-        const aInEntry = patternA.test(entryText);
-        const bInEntry = patternB.test(entryText);
-        if (aInCand && bInEntry || bInCand && aInEntry) {
+    const entryText = `${entry.title || ""} ${entry.content || ""}`;
+    const entryClaims = extractPolarityClaims(entryText);
+    for (const candidateClaim of candidateClaims) {
+      for (const entryClaim of entryClaims) {
+        const comparison = comparePolarityClaims(candidateClaim, entryClaim);
+        if (comparison.conflicting) {
           return {
             conflicted: true,
             conflictingEntry: entry,
             confidence: 0.85,
-            reason: `${reason} between candidate and "${entry.title}" (${entry.id})`
+            reason: comparison.reason,
+            dryRun
           };
         }
       }
-      if (candidateText.includes("do not") && !entryText.includes("do not") && topicSimilarity > 0.6 || !candidateText.includes("do not") && entryText.includes("do not") && topicSimilarity > 0.6) {
-        return {
-          conflicted: true,
-          conflictingEntry: entry,
-          confidence: 0.8,
-          reason: `Direct negation detected on topic "${entry.title}" (${entry.id})`
-        };
+    }
+    const candidateLower = candidateText.toLowerCase();
+    const entryLower = entryText.toLowerCase();
+    const topicSimilarity = computeJaccardSimilarity(candidate.title || "", entry.title || "");
+    if (topicSimilarity > 0.6 && (candidateLower.includes("do not") && !entryLower.includes("do not") || !candidateLower.includes("do not") && entryLower.includes("do not"))) {
+      return {
+        conflicted: true,
+        conflictingEntry: entry,
+        confidence: 0.8,
+        reason: `Direct negation detected on topic "${entry.title}" (${entry.id})`,
+        dryRun
+      };
+    }
+  }
+  return { conflicted: false, confidence: 0, dryRun };
+}
+function scanPotentialConflicts(store, options) {
+  const entries = list(store, options?.project ? { project: options.project } : undefined).filter((entry) => entry.status === "active" || entry.status === "confirmed");
+  const claimsById = new Map;
+  for (const entry of entries) {
+    claimsById.set(entry.id, extractPolarityClaims(`${entry.title || ""} ${entry.content || ""}`));
+  }
+  const found = [];
+  for (let i = 0;i < entries.length; i++) {
+    for (let j = i + 1;j < entries.length; j++) {
+      const a = entries[i];
+      const b = entries[j];
+      const aClaims = claimsById.get(a.id) ?? [];
+      const bClaims = claimsById.get(b.id) ?? [];
+      let conflict = null;
+      for (const aClaim of aClaims) {
+        for (const bClaim of bClaims) {
+          const comparison = comparePolarityClaims(aClaim, bClaim);
+          if (comparison.conflicting) {
+            conflict = comparison;
+            break;
+          }
+        }
+        if (conflict)
+          break;
+      }
+      if (conflict) {
+        found.push({
+          entry_a_id: a.id,
+          entry_a_title: a.title,
+          entry_b_id: b.id,
+          entry_b_title: b.title,
+          confidence: 0.85,
+          reason: conflict.reason
+        });
       }
     }
   }
-  return { conflicted: false, confidence: 0 };
+  return options?.limit !== undefined ? found.slice(0, options.limit) : found;
 }
 function flagConflict(store, existingId, newId, reason, options) {
   const existing = get(store, existingId);
@@ -10780,22 +11504,18 @@ function resolveConflict(store, options) {
     message
   };
 }
-var CONTRADICTORY_PAIRS;
+function listConflicts(store, options) {
+  if (!store.db)
+    return [];
+  return listConflictsFromDb(store.db, options);
+}
 var init_contradiction = __esm(() => {
   init_store();
   init_audit();
   init_dedup();
   init_sqlite();
   init_invalidation();
-  CONTRADICTORY_PAIRS = [
-    [/\b(enable|enabled|true)\b/i, /\b(disable|disabled|false)\b/i, "Opposing configuration polarity"],
-    [/\b(allow|allowed)\b/i, /\b(deny|denied|disallow|disallowed|forbidden)\b/i, "Opposing permission rule"],
-    [/\b(uses?\s+postgresql|postgres)\b/i, /\b(uses?\s+mysql|uses?\s+sqlite|uses?\s+mongodb)\b/i, "Conflicting primary database choice"],
-    [/\b(port\s+3000)\b/i, /\b(port\s+8080|port\s+5000|port\s+4000)\b/i, "Conflicting port binding"],
-    [/\b(rest\s+api)\b/i, /\b(graphql\s+only|grpc\s+only)\b/i, "Conflicting communication protocol"],
-    [/\b(bun\s+runtime)\b/i, /\b(node\s+runtime\s+only|deno\s+only)\b/i, "Conflicting runtime engine"],
-    [/\b(always)\b/i, /\b(never)\b/i, "Contradictory universal policy"]
-  ];
+  init_polarity();
 });
 
 // src/quality/retention.ts
@@ -13142,6 +13862,9 @@ async function rankAndRetrieveMemories(store, query, options = {}) {
   if (!options.includeSuperseded) {
     entries = entries.filter((e) => e.status !== "superseded" && e.status !== "rejected");
   }
+  if (!options.includeConflicted) {
+    entries = entries.filter((e) => e.status !== "conflicted");
+  }
   if (options.sessionId && options.suppressReinjection !== false) {
     const filtered = defaultReinjectionTracker.filterSuppressed(options.sessionId, entries, {
       turn: options.sessionTurn,
@@ -13441,6 +14164,8 @@ function passesRowFilter(entry, o, now) {
     return false;
   if (!o.includeSuperseded && (entry.status === "superseded" || entry.status === "rejected"))
     return false;
+  if (!o.includeConflicted && entry.status === "conflicted")
+    return false;
   if (!o.includeArchived && entry.status === "archived")
     return false;
   if (!o.includeExpired && isExpired(entry, now))
@@ -13926,6 +14651,10 @@ function list(store, filters) {
   }
   return entries;
 }
+function listForProject(store, project) {
+  const trimmed = project?.trim();
+  return trimmed ? list(store, { project: trimmed }) : list(store);
+}
 function countMemories(store) {
   if (store.circuit?.isDegraded() && store.cache) {
     return store.cache.size();
@@ -14318,14 +15047,30 @@ function propose(store, opts) {
     }
   }
   if (opts.checkConflict) {
+    const conflictDryRun = opts.conflictDryRun === true;
     const conflict = detectConflict(store, {
       title: entry.title,
       content: entry.content,
       project: entry.project,
       type: entry.type,
       id: entry.id
-    });
+    }, { dryRun: conflictDryRun });
     if (conflict.conflicted && conflict.conflictingEntry) {
+      if (conflictDryRun) {
+        if (store.memoryDir) {
+          recordAuditEvent(store.memoryDir, {
+            operation: "conflict_detected_dry_run",
+            entry_id: entry.id,
+            project: entry.project,
+            details: {
+              would_conflict_with: conflict.conflictingEntry.id,
+              reason: conflict.reason || "Contradiction detected",
+              confidence: conflict.confidence
+            }
+          });
+        }
+        return entry;
+      }
       const flagged = flagConflict(store, conflict.conflictingEntry.id, entry.id, conflict.reason || "Contradiction detected");
       return flagged.incoming;
     }
@@ -18686,7 +19431,7 @@ async function getLatestNpmVersion(packageName = "musememory") {
   try {
     const res = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
       headers: { Accept: "application/json" },
-      signal: AbortSignal.timeout(3000)
+      signal: AbortSignal.timeout(2000)
     });
     if (res.ok) {
       const data = await res.json();
@@ -18698,6 +19443,7 @@ async function getLatestNpmVersion(packageName = "musememory") {
   try {
     const out = execFileSync("npm", ["show", packageName, "version"], {
       encoding: "utf8",
+      timeout: 1500,
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
     if (out && !out.includes("error"))
@@ -26181,7 +26927,6 @@ function getStandardAgentTranscriptDirs(home = homedir5()) {
     join36(home, ".local", "share", "opencode", "transcripts"),
     join36(home, ".claude", "transcripts"),
     join36(home, ".claude", "projects"),
-    join36(home, ".config", "LIFEOS", "runtime", "transcripts"),
     join36(home, ".hermes", "sessions"),
     join36(home, ".hermes", "transcripts"),
     join36(home, ".config", "goose", "sessions"),
@@ -27312,7 +28057,7 @@ var init_pack = __esm(() => {
 // src/retrieval/tree-index.ts
 import { existsSync as existsSync43, readFileSync as readFileSync37, writeFileSync as writeFileSync26, mkdirSync as mkdirSync25, rmSync } from "node:fs";
 import { join as join40 } from "node:path";
-function tokenize2(text) {
+function tokenize3(text) {
   if (!text || typeof text !== "string")
     return [];
   return text.toLowerCase().match(/[a-z0-9]+/g) ?? [];
@@ -27546,10 +28291,10 @@ function selectPartitions(index, options) {
   return result;
 }
 function scoreNode(node, query) {
-  const queryTokens = new Set(tokenize2(query));
+  const queryTokens = new Set(tokenize3(query));
   if (queryTokens.size === 0)
     return 0;
-  const haystack = tokenize2(`${node.title} ${node.summary} ${(node.metadata?.tags ?? []).join(" ")}`);
+  const haystack = tokenize3(`${node.title} ${node.summary} ${(node.metadata?.tags ?? []).join(" ")}`);
   const hay = new Set(haystack);
   let overlap = 0;
   for (const t of queryTokens)
@@ -28019,6 +28764,7 @@ class RetrievalEngine {
           limit: options.limit !== undefined ? clampLimit(options.limit, 10, 200, 1) : 10,
           project: options.project,
           includeSuperseded: options.includeSuperseded,
+          includeConflicted: options.includeConflicted,
           includeArchived: options.includeArchived,
           includeExpired: options.includeExpired,
           now: options.now
@@ -29032,8 +29778,8 @@ function attachAnchorToMemory(store, memoryId, anchor, actor = "agent", options
   }
   return entry;
 }
-function auditMemoryAnchors(store, workspaceRoot) {
-  const entries = list(store);
+function auditMemoryAnchors(store, workspaceRoot, options) {
+  const entries = listForProject(store, options?.project);
   const details = [];
   let validCount = 0;
   let driftedCount = 0;
@@ -29181,8 +29927,8 @@ function extractExportedSymbols(filePath) {
   }
   return symbols;
 }
-function detectDocumentationCodeDrift(store, workspaceRoot) {
-  const allEntries = list(store);
+function detectDocumentationCodeDrift(store, workspaceRoot, options) {
+  const allEntries = listForProject(store, options?.project);
   const items = [];
   let documentedCount = 0;
   let implementedCount = 0;
@@ -29314,7 +30060,7 @@ function scanFiles(dir, maxFiles = 50) {
   walk(dir);
   return files;
 }
-function analyzeTechnicalDebt(store, workspaceRoot) {
+function analyzeTechnicalDebt(store, workspaceRoot, options) {
   const items = [];
   const hotspotMap = new Map;
   const sourceFiles = scanFiles(workspaceRoot, 40);
@@ -29358,7 +30104,7 @@ function analyzeTechnicalDebt(store, workspaceRoot) {
       }
     }
   }
-  const allEntries = list(store);
+  const allEntries = listForProject(store, options?.project);
   for (const entry of allEntries) {
     if (entry.status === "archived" || entry.status === "superseded")
       continue;
@@ -29426,8 +30172,8 @@ function classifyBug(entry) {
   }
   return "general_bug";
 }
-function clusterRecurringBugsAndFriction(store) {
-  const entries = list(store);
+function clusterRecurringBugsAndFriction(store, options) {
+  const entries = listForProject(store, options?.project);
   const bugEntries = entries.filter((e) => e.status !== "archived" && (e.type === "fix" || e.type === "negative" || e.negative != null || e.tags?.includes("bug") || e.tags?.includes("fix") || e.tags?.includes("failure") || e.tags?.includes("error")));
   const clusterMap = new Map;
   for (const entry of bugEntries) {
@@ -29533,9 +30279,10 @@ function scoreToStatus(score) {
     return "WARN";
   return "FAIL";
 }
-function evaluateProjectHealth(store, workspaceRoot) {
+function evaluateProjectHealth(store, workspaceRoot, options) {
   const now = new Date().toISOString();
-  const entries = list(store);
+  const projectFilter = options?.project?.trim() || undefined;
+  const entries = listForProject(store, projectFilter);
   const checklist = [];
   let activeCount = 0;
   let confirmedCount = 0;
@@ -29578,7 +30325,7 @@ function evaluateProjectHealth(store, workspaceRoot) {
     },
     remediation_items: integrityRemediations
   };
-  const anchorAudit = auditMemoryAnchors(store, workspaceRoot);
+  const anchorAudit = auditMemoryAnchors(store, workspaceRoot, { project: projectFilter });
   const anchorScore = Math.round(anchorAudit.integrity_score * 100);
   const anchorRemediations = [];
   if (anchorAudit.drifted_anchors > 0) {
@@ -29601,7 +30348,7 @@ function evaluateProjectHealth(store, workspaceRoot) {
     },
     remediation_items: anchorRemediations
   };
-  const driftAudit = detectDocumentationCodeDrift(store, workspaceRoot);
+  const driftAudit = detectDocumentationCodeDrift(store, workspaceRoot, { project: projectFilter });
   const driftScore = Math.round(driftAudit.alignment_score * 100);
   const driftRemediations = [];
   if (driftAudit.missing_count > 0) {
@@ -29655,8 +30402,8 @@ function evaluateProjectHealth(store, workspaceRoot) {
     },
     remediation_items: negativeRemediations
   };
-  const debtReport = analyzeTechnicalDebt(store, workspaceRoot);
-  const bugClusters = clusterRecurringBugsAndFriction(store);
+  const debtReport = analyzeTechnicalDebt(store, workspaceRoot, { project: projectFilter });
+  const bugClusters = clusterRecurringBugsAndFriction(store, { project: projectFilter });
   const topFragility = bugClusters.length > 0 ? bugClusters[0].fragility_score : 0;
   const debtPenalty = debtReport.debt_score + Math.round(topFragility * 20);
   const debtScore = Math.max(0, Math.min(100, 100 - debtPenalty));
@@ -29682,7 +30429,16 @@ function evaluateProjectHealth(store, workspaceRoot) {
   checklist.push(...docCodeAlignmentPillar.remediation_items);
   checklist.push(...negativeAntiPatternsPillar.remediation_items);
   checklist.push(...techDebtPillar.remediation_items);
-  const projectName = entries[0]?.project || "default";
+  const projectsCovered = [
+    ...new Set(entries.map((e) => e.project).filter((p) => Boolean(p)))
+  ].sort();
+  const projectName = projectFilter ?? (projectsCovered.length === 1 ? projectsCovered[0] : "all");
+  const scope = {
+    filter: projectFilter ?? null,
+    projects: projectsCovered,
+    entry_count: entries.length,
+    code_scope: "workspace"
+  };
   let summary = `Project health evaluated with overall Grade ${overallGrade} (${overallScore}/100) — Status: ${gateStatus}.`;
   if (gateStatus === "PASS") {
     summary += " All 5 pillars meet production hardening criteria.";
@@ -29691,8 +30447,10 @@ function evaluateProjectHealth(store, workspaceRoot) {
   } else {
     summary += " Critical architectural violations or unverified contradictions must be resolved before sign-off.";
   }
+  summary += ` Scope: ${projectFilter ? `project "${projectFilter}"` : "entire store"} (${entries.length} memories across ${projectsCovered.length} project${projectsCovered.length === 1 ? "" : "s"}); code-side metrics cover the workspace.`;
   return {
     project: projectName,
+    scope,
     timestamp: now,
     overall_score: overallScore,
     overall_grade: overallGrade,
@@ -29919,10 +30677,35 @@ var init_reconcile = __esm(() => {
   init_resolver();
 });
 
+// src/health/resolve.ts
+function listProjectNames(store) {
+  return [
+    ...new Set(list(store).map((e) => e.project).filter((p) => Boolean(p)))
+  ].sort();
+}
+function resolveProjectName(store, requested) {
+  const name = requested?.trim();
+  if (!name)
+    return;
+  const projects = listProjectNames(store);
+  if (projects.includes(name))
+    return name;
+  const matches = projects.filter((p) => p.toLowerCase() === name.toLowerCase());
+  return matches.length === 1 ? matches[0] : undefined;
+}
+function formatAvailable(store) {
+  const available = listProjectNames(store);
+  return available.length > 0 ? available.join(", ") : "none";
+}
+var init_resolve = __esm(() => {
+  init_store();
+});
+
 // src/health/index.ts
 var init_health = __esm(() => {
   init_gate();
   init_reconcile();
+  init_resolve();
 });
 // src/adrs/engine.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
@@ -31290,7 +32073,18 @@ function startUiServer(opts) {
       const workspaceRoot = opts.store.layout?.root || getStorageLayout(opts.memoryDir).root;
       if (pathname === "/api/health" && req.method === "GET") {
         try {
-          const report = evaluateProjectHealth(opts.store, workspaceRoot);
+          const requestedProject = url.searchParams.get("project")?.trim() || undefined;
+          const canonicalProject = resolveProjectName(opts.store, requestedProject);
+          if (requestedProject && canonicalProject === undefined) {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+              error: `no memories for project "${requestedProject}" — available: ${formatAvailable(opts.store)}`
+            }));
+            return;
+          }
+          const report = evaluateProjectHealth(opts.store, workspaceRoot, {
+            project: canonicalProject
+          });
           res.writeHead(200, { "Content-Type": "application/json" });
           res.end(JSON.stringify(report));
         } catch (err) {
@@ -31312,7 +32106,18 @@ function startUiServer(opts) {
       }
       if (pathname === "/api/drift" && req.method === "GET") {
         try {
-          const drift = detectDocumentationCodeDrift(opts.store, workspaceRoot);
+          const requestedProject = url.searchParams.get("project")?.trim() || undefined;
+          const canonicalProject = resolveProjectName(opts.store, requestedProject);
+          if (requestedProject && canonicalProject === undefined) {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+              error: `no memories for project "${requestedProject}" — available: ${formatAvailable(opts.store)}`
+            }));
+            return;
+          }
+          const drift = detectDocumentationCodeDrift(opts.store, workspaceRoot, {
+            project: canonicalProject
+          });
           res.writeHead(200, { "Content-Type": "application/json" });
           res.end(JSON.stringify(drift));
         } catch (err) {
@@ -31340,7 +32145,18 @@ function startUiServer(opts) {
       }
       if (pathname === "/api/cognition/clusters" && req.method === "GET") {
         try {
-          const clusters = clusterRecurringBugsAndFriction(opts.store);
+          const requestedProject = url.searchParams.get("project")?.trim() || undefined;
+          const canonicalProject = resolveProjectName(opts.store, requestedProject);
+          if (requestedProject && canonicalProject === undefined) {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+              error: `no memories for project "${requestedProject}" — available: ${formatAvailable(opts.store)}`
+            }));
+            return;
+          }
+          const clusters = clusterRecurringBugsAndFriction(opts.store, {
+            project: canonicalProject
+          });
           res.writeHead(200, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ total_clusters: clusters.length, clusters }));
         } catch (err) {
@@ -31351,7 +32167,18 @@ function startUiServer(opts) {
       }
       if (pathname === "/api/cognition/debt" && req.method === "GET") {
         try {
-          const debt = analyzeTechnicalDebt(opts.store, workspaceRoot);
+          const requestedProject = url.searchParams.get("project")?.trim() || undefined;
+          const canonicalProject = resolveProjectName(opts.store, requestedProject);
+          if (requestedProject && canonicalProject === undefined) {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+              error: `no memories for project "${requestedProject}" — available: ${formatAvailable(opts.store)}`
+            }));
+            return;
+          }
+          const debt = analyzeTechnicalDebt(opts.store, workspaceRoot, {
+            project: canonicalProject
+          });
           res.writeHead(200, { "Content-Type": "application/json" });
           res.end(JSON.stringify(debt));
         } catch (err) {
@@ -31589,6 +32416,10 @@ var MAX_BODY_SIZE, EMBEDDED_HTML = `<!DOCTYPE html>
     
     /* Stats & Quick Actions */
     .header-actions { display: flex; align-items: center; gap: 12px; }
+    .scope-filter { display: flex; align-items: center; gap: 8px; }
+    .scope-filter-label { font-size: 10px; font-weight: 700; color: var(--text-dim); text-transform: uppercase; letter-spacing: 0.05em; white-space: nowrap; }
+    .scope-filter-input { width: 140px; background: #090d14; border: 1px solid var(--panel-border); border-radius: var(--radius-md); padding: 6px 10px; color: #fff; font-size: 12px; outline: none; transition: var(--transition); }
+    .scope-filter-input:focus { border-color: var(--accent); box-shadow: 0 0 0 3px var(--accent-glow); }
     .status-badge { font-size: 12px; font-weight: 600; background: rgba(16,185,129,0.12); color: var(--green); padding: 5px 12px; border-radius: var(--radius-full); border: 1px solid rgba(16,185,129,0.25); display: flex; align-items: center; gap: 6px; }
     .status-dot { width: 6px; height: 6px; border-radius: 50%; background: var(--green); box-shadow: 0 0 8px var(--green); }
     .btn-icon { background: rgba(255,255,255,0.04); border: 1px solid var(--panel-border); color: var(--text-muted); padding: 6px 12px; border-radius: var(--radius-md); font-size: 12px; font-weight: 600; cursor: pointer; transition: var(--transition); display: inline-flex; align-items: center; gap: 6px; }
@@ -31795,6 +32626,10 @@ var MAX_BODY_SIZE, EMBEDDED_HTML = `<!DOCTYPE html>
     </div>
     
     <div class="header-actions">
+      <div class="scope-filter">
+        <label class="scope-filter-label" for="projectFilter">Project Scope</label>
+        <input type="text" id="projectFilter" class="scope-filter-input" placeholder="all projects" autocomplete="off" spellcheck="false" title="Leave empty to audit the whole memory store, or enter a project name to scope the health gate, drift, bug cluster and technical debt audits." />
+      </div>
       <button class="btn-icon btn-refresh" id="refreshBtn" onclick="refreshMemories()" title="Refresh and sync active constraints, handoff state, and prior memories">
         <span class="refresh-icon" id="refreshIcon">\uD83D\uDD04</span>
         <span id="refreshLabel">Refresh</span>
@@ -31977,6 +32812,10 @@ var MAX_BODY_SIZE, EMBEDDED_HTML = `<!DOCTYPE html>
                   <span class="gate-badge gate-pass" id="healthGate">[PASS]</span>
                 </div>
                 <div style="font-size:13px; color:var(--text-muted); margin-top:3px;" id="healthSummary">Comprehensive project cognitive health evaluation.</div>
+                <div style="font-size:11px; color:var(--text-dim); margin-top:6px; display:flex; gap:14px; flex-wrap:wrap;">
+                  <span id="healthScopeProject">Project: --</span>
+                  <span id="healthScope">Scope: --</span>
+                </div>
               </div>
             </div>
             <div style="text-align:right;">
@@ -32213,6 +33052,36 @@ var MAX_BODY_SIZE, EMBEDDED_HTML = `<!DOCTYPE html>
     let searchQuery = '';
     let currentTab = 'graph';
 
+    // T-321: optional project scope for the studio's audit surfaces.
+    // An empty value means the whole store; a value scopes the health gate,
+    // drift, bug cluster and technical debt audits to that memory project.
+    // The initial value comes from the URL query string so a scoped link
+    // stays shareable and reloadable.
+    let projectScope = (new URLSearchParams(window.location.search).get('project') || '').trim();
+
+    function projectScopeQuery() {
+      return projectScope ? '?project=' + encodeURIComponent(projectScope) : '';
+    }
+
+    function syncProjectScopeUrl() {
+      try {
+        const url = new URL(window.location.href);
+        if (projectScope) url.searchParams.set('project', projectScope);
+        else url.searchParams.delete('project');
+        window.history.replaceState({}, '', url.toString());
+      } catch (err) {
+        console.error('Failed to sync project scope in URL:', err);
+      }
+    }
+
+    function applyProjectScope(value) {
+      projectScope = (value || '').trim();
+      syncProjectScopeUrl();
+      fetchHealth();
+      if (currentTab === 'adrs') fetchDrift();
+      if (currentTab === 'cognition') fetchCognition();
+    }
+
     // ---- Graph state (3D force-directed) ----
     const TYPE_COLORS = {
       fix: '#10b981',
@@ -32879,7 +33748,7 @@ var MAX_BODY_SIZE, EMBEDDED_HTML = `<!DOCTYPE html>
     // R15 Studio Loaders
     async function fetchHealth() {
       try {
-        const res = await fetch('/api/health');
+        const res = await fetch('/api/health' + projectScopeQuery());
         const data = await res.json();
         renderHealth(data);
       } catch (err) {
@@ -32887,12 +33756,25 @@ var MAX_BODY_SIZE, EMBEDDED_HTML = `<!DOCTYPE html>
       }
     }
 
+    // T-321: mirrors the CLI scope wording — "N memories across M project(s)".
+    function formatHealthScope(scope) {
+      if (!scope) return 'Scope: --';
+      const count = scope.entry_count || 0;
+      const projectCount = (scope.projects || []).length;
+      const memories = count === 1 ? 'memory' : 'memories';
+      const projects = projectCount === 1 ? 'project' : 'projects';
+      const label = scope.filter ? 'project "' + scope.filter + '"' : 'entire store';
+      return 'Scope: ' + label + ' (' + count + ' ' + memories + ' across ' + projectCount + ' ' + projects + '); code-side metrics cover the ' + (scope.code_scope || 'workspace') + '.';
+    }
+
     function renderHealth(data) {
       if (!data) return;
       const gradeEl = document.getElementById('healthGrade');
       const scoreEl = document.getElementById('healthScore');
       const gateEl = document.getElementById('healthGate');
       const summaryEl = document.getElementById('healthSummary');
+      const scopeEl = document.getElementById('healthScope');
+      const scopeProjectEl = document.getElementById('healthScopeProject');
       const grade = data.overall_grade || data.grade || '--';
       const score = data.overall_score !== undefined ? data.overall_score : (data.score || 0);
       if (gradeEl) {
@@ -32905,6 +33787,8 @@ var MAX_BODY_SIZE, EMBEDDED_HTML = `<!DOCTYPE html>
         gateEl.className = 'gate-badge gate-' + (data.gate_status || 'WARN').toLowerCase();
       }
       if (summaryEl) summaryEl.textContent = data.summary || '';
+      if (scopeEl) scopeEl.textContent = formatHealthScope(data.scope);
+      if (scopeProjectEl) scopeProjectEl.textContent = 'Project: ' + (data.project || '--');
 
       if (data.pillars) {
         const p1 = data.pillars.store_integrity || data.pillars.memory_integrity;
@@ -33007,7 +33891,7 @@ var MAX_BODY_SIZE, EMBEDDED_HTML = `<!DOCTYPE html>
 
     async function fetchDrift() {
       try {
-        const res = await fetch('/api/drift');
+        const res = await fetch('/api/drift' + projectScopeQuery());
         const drift = await res.json();
         const tbody = document.getElementById('driftTableBody');
         if (tbody) {
@@ -33065,8 +33949,8 @@ var MAX_BODY_SIZE, EMBEDDED_HTML = `<!DOCTYPE html>
     async function fetchCognition() {
       try {
         const [clustRes, debtRes] = await Promise.all([
-          fetch('/api/cognition/clusters'),
-          fetch('/api/cognition/debt')
+          fetch('/api/cognition/clusters' + projectScopeQuery()),
+          fetch('/api/cognition/debt' + projectScopeQuery())
         ]);
         const clustersData = await clustRes.json();
         const debtData = await debtRes.json();
@@ -33303,6 +34187,16 @@ var MAX_BODY_SIZE, EMBEDDED_HTML = `<!DOCTYPE html>
     setupCanvasInteractions();
     setupTimeline();
 
+    // T-321: project scope control. Seeded from the URL so a scoped link is
+    // reloadable; an empty value means the whole store.
+    const projectFilterInput = document.getElementById('projectFilter');
+    if (projectFilterInput) {
+      projectFilterInput.value = projectScope;
+      projectFilterInput.addEventListener('change', () => {
+        applyProjectScope(projectFilterInput.value);
+      });
+    }
+
     let searchDebounceTimer = null;
     document.getElementById('searchInput').addEventListener('input', (e) => {
       searchQuery = e.target.value;
@@ -43347,7 +44241,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "musememory",
-    version: "3.0.2",
+    version: "3.2.0",
     description: "Autonomous, self-organizing cognitive memory system for AI agents and agency networks",
     main: "dist/index.js",
     type: "module",
@@ -43368,13 +44262,17 @@ var init_package = __esm(() => {
       "build:gif": "bun run --cwd apps/website scripts/build-readme-gif.ts",
       "claims:generate": "bun scripts/generate-claims.ts && bun scripts/generate-cli-reference.ts",
       "claims:check": "bun scripts/generate-claims.ts --check",
+      "check:landed": "bun run scripts/check-landed.ts",
+      "check:landed:pr": "bun run scripts/check-landed.ts --pr",
       "docs:check": "bun scripts/check-doc-links.ts",
       test: "bun test",
       typecheck: "tsc --noEmit",
       validate: "bun run dist/index.js validate --dry-run",
       start: "bun run dist/index.js mcp",
       prepublishOnly: "bun run build && bun test",
-      "site:qa": "bun run --cwd apps/website scripts/qa-gate.ts"
+      "site:qa": "bun run --cwd apps/website scripts/qa-gate.ts",
+      "showreel:hash": "bun scripts/showreel-hash.ts",
+      "showreel:hash:write": "bun scripts/showreel-hash.ts --write"
     },
     bin: {
       memory: "dist/index.js",
@@ -43410,6 +44308,9 @@ var init_package = __esm(() => {
       url: "git+ssh://git@github.com/harshsinghmp/musememory.git"
     },
     license: "MIT",
+    publishConfig: {
+      access: "public"
+    },
     dependencies: {
       "@modelcontextprotocol/sdk": "^1.0.0",
       ajv: "^8.17.1",
@@ -44968,7 +45869,7 @@ var init_constitution = __esm(() => {
       trim_exempt: true,
       category: "runtime",
       severity: "critical",
-      source: "LifeOS Constitution R1"
+      source: "Agency Architecture R1"
     },
     {
       id: "R2-zero-secret-exposure",
@@ -44977,7 +45878,7 @@ var init_constitution = __esm(() => {
       trim_exempt: true,
       category: "security",
       severity: "critical",
-      source: "LifeOS Vibeguard Protocol"
+      source: "Vibeguard Security Protocol"
     },
     {
       id: "R3-evidence-before-claims",
@@ -45002,12 +45903,12 @@ var init_constitution = __esm(() => {
 
 // src/orchestrator/freshness.ts
 import { readFileSync as readFileSync49, statSync as statSync21 } from "node:fs";
-import { resolve as resolve7 } from "node:path";
+import { resolve as resolve8 } from "node:path";
 function cacheKey2(fullPath, symbol, mtimeMs) {
   return `${fullPath}::${symbol ?? "*"}::${mtimeMs}`;
 }
 function checkAnchorLive(workspaceRoot, anchor) {
-  const fullPath = resolve7(workspaceRoot, anchor.file_path);
+  const fullPath = resolve8(workspaceRoot, anchor.file_path);
   let mtimeMs = 0;
   try {
     mtimeMs = statSync21(fullPath).mtimeMs;
@@ -45553,7 +46454,8 @@ async function resolveMuseContext(store, workspaceRoot, input) {
     } 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");
+  const conflictedIds = new Set(allEntries.filter((e) => e.status === "conflicted").map((e) => e.id));
+  const constraintEntries = allEntries.filter((e) => (e.type === "constraint" || e.temporal_mode === "timeless") && e.status !== "archived" && e.status !== "superseded" && e.status !== "rejected" && !(e.status === "conflicted" && !input.include_conflicted));
   for (const ce of constraintEntries) {
     if (activeConstraints.length >= 5)
       break;
@@ -45579,6 +46481,8 @@ ${c.content}`);
         continue;
       if (e.status === "archived" || e.status === "superseded")
         continue;
+      if (e.status === "conflicted" && !input.include_conflicted)
+        continue;
       for (const anc of e.anchors) {
         let fileMatch = false;
         let symbolMatch = false;
@@ -45608,6 +46512,7 @@ ${c.content}`);
     suppressReinjection: false,
     suppressSelfEcho: false,
     suppressSeenChunks: false,
+    includeConflicted: input.include_conflicted === true,
     recordSeenChunks: false,
     echoHorizonMs: input.echo_horizon_ms,
     agent: input.agent,
@@ -45619,6 +46524,13 @@ ${c.content}`);
     active_file: input.active_file,
     symbol: input.symbol
   });
+  if (!input.include_conflicted && conflictedIds.size > 0) {
+    routeLookup.matched_routes = routeLookup.matched_routes.map((rt) => ({
+      ...rt,
+      entry_ids: rt.entry_ids.filter((id) => !conflictedIds.has(id))
+    }));
+    routeLookup.prioritized_entry_ids = routeLookup.prioritized_entry_ids.filter((id) => !conflictedIds.has(id));
+  }
   const candidatePool = trivialGate.isTrivial ? [] : [...entriesWithMatchingAnchors];
   if (!trivialGate.isTrivial) {
     for (const pid of routeLookup.prioritized_entry_ids) {
@@ -45635,6 +46547,18 @@ ${c.content}`);
       }
     }
   }
+  const withheldConflicted = [];
+  if (!input.include_conflicted && conflictedIds.size > 0) {
+    for (let i = candidatePool.length - 1;i >= 0; i--) {
+      if (conflictedIds.has(candidatePool[i].id)) {
+        const removed = candidatePool.splice(i, 1)[0];
+        withheldConflicted.push({
+          id: removed.id,
+          reason: "conflicted_status - resolve in memory conflicts; opt-in via include_conflicted: true"
+        });
+      }
+    }
+  }
   const withheldUntrusted = [];
   let filteredCandidates = candidatePool;
   if (!input.include_untrusted) {
@@ -45801,6 +46725,9 @@ ${c.content}`);
   if (withheldUntrusted.length > 0) {
     suggestedNextSteps.push(`${withheldUntrusted.length} untrusted memor${withheldUntrusted.length === 1 ? "y" : "ies"} withheld — pass include_untrusted: true to include them`);
   }
+  if (withheldConflicted.length > 0) {
+    suggestedNextSteps.push(`${withheldConflicted.length} conflicted memor${withheldConflicted.length === 1 ? "y" : "ies"} withheld — resolve them via memory conflicts or pass include_conflicted: true`);
+  }
   if (digestRefusalReason) {
     suggestedNextSteps.push(`Refused incomplete or corrupted CURRENT.md digest: ${digestRefusalReason} — re-generate with memory handoff or repair CURRENT.md`);
   }
@@ -46536,6 +47463,7 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
             limit: { type: "number" },
             token_budget: { type: "number", description: "Maximum token budget to consume" },
             include_superseded: { type: "boolean" },
+            include_conflicted: { type: "boolean", description: "Include memories flagged conflicted by the contradiction engine (excluded by default — known potential falsehoods)" },
             hybrid: { type: "boolean", description: "Use the offline vector+BM25 index (requires 'memory reindex'); falls back to live scoring when absent" },
             type: { type: "string" },
             status: { type: "string" },
@@ -46656,6 +47584,7 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
             limit: { type: "number" },
             token_budget: { type: "number", description: "Maximum token budget to consume" },
             include_superseded: { type: "boolean" },
+            include_conflicted: { type: "boolean", description: "Include memories flagged conflicted by the contradiction engine (excluded by default — known potential falsehoods)" },
             type: { type: "string" },
             status: { type: "string" },
             verified: { type: "boolean" },
@@ -47754,7 +48683,8 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
         inputSchema: {
           type: "object",
           properties: {
-            dir: { type: "string", description: "Optional project workspace directory path" }
+            dir: { type: "string", description: "Optional project workspace directory path" },
+            project: { type: "string", description: "Optional memory project scope filter" }
           }
         }
       },
@@ -47890,7 +48820,8 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
         inputSchema: {
           type: "object",
           properties: {
-            dir: { type: "string", description: "Optional project workspace directory path" }
+            dir: { type: "string", description: "Optional project workspace directory path" },
+            project: { type: "string", description: "Optional memory project scope filter" }
           }
         }
       },
@@ -47914,7 +48845,8 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
         inputSchema: {
           type: "object",
           properties: {
-            dir: { type: "string", description: "Optional workspace directory" }
+            dir: { type: "string", description: "Optional workspace directory" },
+            project: { type: "string", description: "Optional memory project scope filter" }
           }
         }
       },
@@ -47924,7 +48856,8 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
         inputSchema: {
           type: "object",
           properties: {
-            dir: { type: "string", description: "Optional workspace directory" }
+            dir: { type: "string", description: "Optional workspace directory" },
+            project: { type: "string", description: "Optional memory project scope filter" }
           }
         }
       },
@@ -47934,7 +48867,8 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
         inputSchema: {
           type: "object",
           properties: {
-            dir: { type: "string", description: "Optional workspace directory path" }
+            dir: { type: "string", description: "Optional workspace directory path" },
+            project: { type: "string", description: "Optional memory project scope filter" }
           }
         }
       },
@@ -48241,6 +49175,7 @@ You are equipped with Muse Memory, an autonomous persistent cognitive memory sys
             limit: clampLimit(a.limit, 10, 100, 1),
             tokenBudget: typeof a.token_budget === "number" ? a.token_budget : undefined,
             includeSuperseded: a.include_superseded === true,
+            includeConflicted: a.include_conflicted === true,
             type: a.type ? String(a.type) : undefined,
             status: a.status ? String(a.status) : undefined,
             verified: a.verified === true,
@@ -49144,7 +50079,14 @@ Path: ${item.path}`,
           });
         }
         case "memory_anchor_audit": {
-          const report = auditMemoryAnchors(activeStore, activeRoot);
+          const requestedProject = a.project ? String(a.project).trim() || undefined : undefined;
+          const canonicalProject = resolveProjectName(activeStore, requestedProject);
+          if (requestedProject && canonicalProject === undefined) {
+            return toolError(`no memories for project "${requestedProject}" — available: ${formatAvailable(activeStore)}`);
+          }
+          const report = auditMemoryAnchors(activeStore, activeRoot, {
+            project: canonicalProject
+          });
           return toolResult(report);
         }
         case "muse_context": {
@@ -49226,7 +50168,14 @@ Path: ${item.path}`,
           });
         }
         case "memory_drift_audit": {
-          const report = detectDocumentationCodeDrift(activeStore, activeRoot);
+          const requestedProject = a.project ? String(a.project).trim() || undefined : undefined;
+          const canonicalProject = resolveProjectName(activeStore, requestedProject);
+          if (requestedProject && canonicalProject === undefined) {
+            return toolError(`no memories for project "${requestedProject}" — available: ${formatAvailable(activeStore)}`);
+          }
+          const report = detectDocumentationCodeDrift(activeStore, activeRoot, {
+            project: canonicalProject
+          });
           return toolResult(report);
         }
         case "muse_why": {
@@ -49238,18 +50187,39 @@ Path: ${item.path}`,
           return toolResult(explanation);
         }
         case "muse_bug_clusters": {
-          const clusters = clusterRecurringBugsAndFriction(activeStore);
+          const requestedProject = a.project ? String(a.project).trim() || undefined : undefined;
+          const canonicalProject = resolveProjectName(activeStore, requestedProject);
+          if (requestedProject && canonicalProject === undefined) {
+            return toolError(`no memories for project "${requestedProject}" — available: ${formatAvailable(activeStore)}`);
+          }
+          const clusters = clusterRecurringBugsAndFriction(activeStore, {
+            project: canonicalProject
+          });
           return toolResult({
             total_clusters: clusters.length,
             clusters
           });
         }
         case "muse_tech_debt": {
-          const report = analyzeTechnicalDebt(activeStore, activeRoot);
+          const requestedProject = a.project ? String(a.project).trim() || undefined : undefined;
+          const canonicalProject = resolveProjectName(activeStore, requestedProject);
+          if (requestedProject && canonicalProject === undefined) {
+            return toolError(`no memories for project "${requestedProject}" — available: ${formatAvailable(activeStore)}`);
+          }
+          const report = analyzeTechnicalDebt(activeStore, activeRoot, {
+            project: canonicalProject
+          });
           return toolResult(report);
         }
         case "muse_health": {
-          const report = evaluateProjectHealth(activeStore, activeRoot);
+          const requestedProject = a.project ? String(a.project).trim() || undefined : undefined;
+          const canonicalProject = resolveProjectName(activeStore, requestedProject);
+          if (requestedProject && canonicalProject === undefined) {
+            return toolError(`no memories for project "${requestedProject}" — available: ${formatAvailable(activeStore)}`);
+          }
+          const report = evaluateProjectHealth(activeStore, activeRoot, {
+            project: canonicalProject
+          });
           return toolResult(report);
         }
         case "muse_sync_broadcast": {
@@ -50641,6 +51611,7 @@ async function handleSearchCommand({ positional, flags }) {
     tokenBudget,
     project: flags["project"],
     includeSuperseded: flags["include-superseded"] === "true",
+    includeConflicted: flags["include-conflicted"] === "true",
     type: flags["type"],
     status: flags["status"],
     verified: flags["verified"] === "true"
@@ -52544,7 +53515,17 @@ async function handleHealthCommand(parsed) {
     return 1;
   }
   const { root, store } = ctx;
-  const report = evaluateProjectHealth(store, root);
+  const requestedProject = parsed.flags["project"]?.trim() || undefined;
+  const canonicalProject = resolveProjectName(store, requestedProject);
+  if (requestedProject && canonicalProject === undefined) {
+    console.error(`Error: no memories for project "${requestedProject}" — available: ${formatAvailable(store)}`);
+    return 1;
+  }
+  const project = canonicalProject;
+  if (canonicalProject && canonicalProject !== requestedProject) {
+    console.error(`Note: project filter matched canonical "${canonicalProject}" (requested "${requestedProject}").`);
+  }
+  const report = evaluateProjectHealth(store, root, { project });
   if (parsed.flags.json) {
     console.log(JSON.stringify(report, null, 2));
     return report.gate_status === "FAIL" ? 1 : 0;
@@ -52556,6 +53537,7 @@ async function handleHealthCommand(parsed) {
 ${bold}\uD83C\uDFE5 MUSE MEMORY 5-PILLAR PROJECT HEALTH GATE${reset}`);
   console.log(`${"=".repeat(50)}`);
   console.log(`Project:       ${bold}${report.project}${reset}`);
+  console.log(`Scope:         ${report.scope.entry_count} ` + `${report.scope.entry_count === 1 ? "memory" : "memories"} across ` + `${report.scope.projects.length} project${report.scope.projects.length === 1 ? "" : "s"}` + (report.scope.filter ? ` (filtered to "${report.scope.filter}")` : ""));
   console.log(`Overall Grade: ${bold}${report.overall_grade}${reset} (${report.overall_score}/100)`);
   console.log(`Gate Status:   ${statusColor}${bold}${report.gate_status}${reset}
 `);
@@ -52704,9 +53686,98 @@ var init_health2 = __esm(() => {
   init_shared();
 });
 
+// src/cli/conflicts.ts
+async function handleConflictsCommand(parsed) {
+  const ctx = requireRoot(parsed.flags);
+  if (!ctx) {
+    console.error("Error: Could not resolve project root or initialize .memory directory.");
+    return 1;
+  }
+  const { store } = ctx;
+  const isTrue = (val) => val === true || val === "true" || val === "";
+  const dryRun = isTrue(parsed.flags["dry-run"]) || isTrue(parsed.flags["n"]);
+  const project = parsed.flags["project"];
+  await Promise.resolve().then(() => init_contradiction());
+  const recorded = listConflicts(store, { status: "open" });
+  const resolved = listConflicts(store, { status: "resolved" });
+  if (dryRun) {
+    const potential = scanPotentialConflicts(store, { project });
+    if (parsed.flags.json) {
+      console.log(JSON.stringify({
+        mode: "dry-run",
+        project: project ?? null,
+        recorded_open: recorded.length,
+        recorded_resolved: resolved.length,
+        potential_conflicts: potential
+      }, null, 2));
+      return 0;
+    }
+    const bold = "\x1B[1m";
+    const reset = "\x1B[0m";
+    const yellow = "\x1B[33m";
+    const red = "\x1B[31m";
+    console.log(`
+${bold}\uD83D\uDD0D CONTRADICTION ENGINE — DRY RUN${reset}`);
+    console.log(`${"=".repeat(56)}`);
+    console.log(`Project:            ${bold}${project ?? "all"}${reset}`);
+    console.log(`Recorded (open):    ${recorded.length}`);
+    console.log(`Recorded (resolved):${resolved.length}`);
+    console.log(`Potential pairs:    ${potential.length}
+`);
+    if (potential.length === 0) {
+      console.log(`  ✅ No memory pairs would be flagged as contradictory.
+`);
+      return 0;
+    }
+    console.log(`${yellow}Would be flagged (nothing was changed):${reset}`);
+    for (const pair of potential) {
+      console.log(`  ${red}✗${reset} ${pair.entry_a_title}`);
+      console.log(`      ${pair.entry_a_id}`);
+      console.log(`    ${red}✗${reset} ${pair.entry_b_title}`);
+      console.log(`      ${pair.entry_b_id}`);
+      console.log(`      reason: ${pair.reason ?? "unknown"}`);
+      console.log("");
+    }
+    console.log(`${bold}Note${reset}: flagging a pair moves BOTH memories to 'conflicted' (25 health points each)
+and removes both from every future sync broadcast. Resolve with 'memory_resolve_conflict'.
+`);
+    return 0;
+  }
+  if (parsed.flags.json) {
+    console.log(JSON.stringify({ mode: "recorded", open: recorded, resolved: resolved.length }, null, 2));
+    return 0;
+  }
+  const bold = "\x1B[1m";
+  const reset = "\x1B[0m";
+  console.log(`
+${bold}⚖️  CONFLICTS${reset}`);
+  console.log(`${"=".repeat(56)}`);
+  console.log(`Open:     ${recorded.length}`);
+  console.log(`Resolved: ${resolved.length}
+`);
+  if (recorded.length === 0) {
+    console.log(`  ✅ No open conflicts.
+`);
+    return 0;
+  }
+  for (const conflict of recorded) {
+    console.log(`${bold}${conflict.memory_a_id}${reset} ↔ ${bold}${conflict.memory_b_id}${reset}`);
+    console.log(`  type: ${conflict.conflict_type}   confidence: ${conflict.confidence}`);
+    console.log(`  reason: ${conflict.reason ?? "unknown"}`);
+    console.log(`  detected: ${conflict.detected_at}`);
+    console.log("");
+  }
+  console.log(`${bold}Tip${reset}: run 'memory conflicts --dry-run' to preview what would be flagged.
+`);
+  return 0;
+}
+var init_conflicts = __esm(() => {
+  init_shared();
+});
+
 // src/cli/sync.ts
 import { writeFileSync as writeFileSync39, readFileSync as readFileSync59 } from "node:fs";
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve9 } from "node:path";
 async function handleSyncCommand(parsed) {
   const ctx = requireRoot(parsed.flags);
   if (!ctx) {
@@ -52721,7 +53792,7 @@ async function handleSyncCommand(parsed) {
       project: parsed.flags.project
     });
     if (parsed.flags.out) {
-      const outPath = resolve8(process.cwd(), parsed.flags.out);
+      const outPath = resolve9(process.cwd(), parsed.flags.out);
       writeFileSync39(outPath, JSON.stringify(packet, null, 2), "utf-8");
       console.log(`\x1B[32m✓ Broadcast packet saved to '${outPath}' (${packet.payload.memories.length} memories)\x1B[0m`);
     } else {
@@ -52730,7 +53801,7 @@ async function handleSyncCommand(parsed) {
     return 0;
   }
   if (parsed.flags.ingest) {
-    const inPath = resolve8(process.cwd(), parsed.flags.ingest);
+    const inPath = resolve9(process.cwd(), parsed.flags.ingest);
     try {
       const raw = readFileSync59(inPath, "utf-8");
       const packet = JSON.parse(raw);
@@ -52755,7 +53826,8 @@ async function handleSyncCommand(parsed) {
     }
   }
   if (parsed.flags.pool || !parsed.flags.status && !parsed.flags.broadcast && !parsed.flags.ingest) {
-    const poolDir = typeof parsed.flags.pool === "string" ? resolve8(process.cwd(), parsed.flags.pool) : undefined;
+    const rawPool = parsed.flags.pool;
+    const poolDir = typeof rawPool === "string" && rawPool !== "true" && rawPool.trim() !== "" ? resolve9(process.cwd(), rawPool) : undefined;
     const report = syncWithSharedPool(store, root, poolDir, agentId);
     if (parsed.flags.json) {
       console.log(JSON.stringify(report, null, 2));
@@ -53112,6 +54184,394 @@ var init_versioning = __esm(() => {
   init_retention();
 });
 
+// src/cli/secrets.ts
+import { existsSync as existsSync69, readdirSync as readdirSync23, readFileSync as readFileSync61, statSync as statSync22 } from "node:fs";
+import { join as join64, relative as relative10, extname as extname2 } from "node:path";
+function isBinaryBuffer(buffer) {
+  const checkLength = Math.min(buffer.length, 1024);
+  for (let i = 0;i < checkLength; i++) {
+    if (buffer[i] === 0)
+      return true;
+  }
+  return false;
+}
+function walkScanFiles(dir, baseDir = dir, customIgnores = []) {
+  const results = [];
+  if (!existsSync69(dir))
+    return results;
+  const entries = readdirSync23(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join64(dir, entry.name);
+    const relPath = relative10(baseDir, fullPath);
+    if (entry.isDirectory()) {
+      if (DEFAULT_IGNORED_DIRS.has(entry.name) || customIgnores.some((pattern) => relPath.includes(pattern))) {
+        continue;
+      }
+      results.push(...walkScanFiles(fullPath, baseDir, customIgnores));
+    } else if (entry.isFile()) {
+      const ext = extname2(entry.name).toLowerCase();
+      if (BINARY_EXTENSIONS.has(ext))
+        continue;
+      if (customIgnores.some((pattern) => relPath.includes(pattern)))
+        continue;
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+async function executeSecretScan(options) {
+  const startTime = Date.now();
+  const targetDir = options.targetDir;
+  const customIgnores = options.ignorePatterns || [];
+  if (!existsSync69(targetDir)) {
+    return {
+      targetDir,
+      scannedFiles: 0,
+      findings: [],
+      clean: false,
+      durationMs: Date.now() - startTime
+    };
+  }
+  let files = [];
+  try {
+    const stat = statSync22(targetDir);
+    if (stat.isFile()) {
+      files = [targetDir];
+    } else {
+      files = walkScanFiles(targetDir, targetDir, customIgnores);
+    }
+  } catch {
+    files = [];
+  }
+  const findings = [];
+  for (const file of files) {
+    try {
+      const stats = statSync22(file);
+      if (stats.size > 5 * 1024 * 1024)
+        continue;
+      const buffer = readFileSync61(file);
+      if (isBinaryBuffer(buffer))
+        continue;
+      const content = buffer.toString("utf8");
+      const lines = content.split(/\r?\n/);
+      for (let i = 0;i < lines.length; i++) {
+        const line = lines[i];
+        if (!line.trim())
+          continue;
+        for (const rule of SECRET_RULES) {
+          if (rule.pattern.test(line)) {
+            findings.push({
+              file: relative10(targetDir, file) || file,
+              line: i + 1,
+              rule: rule.name,
+              redactedSnippet: redactSecrets(line.trim())
+            });
+            break;
+          }
+        }
+      }
+    } catch {}
+  }
+  const durationMs = Date.now() - startTime;
+  return {
+    targetDir,
+    scannedFiles: files.length,
+    findings,
+    clean: findings.length === 0,
+    durationMs
+  };
+}
+async function handleScanSecretsCommand(args) {
+  const targetDir = args.positional?.[0] || args.args?.[0] || ".";
+  const verbose = Boolean(args.flags.verbose || args.flags.v);
+  const jsonMode = Boolean(args.flags.json);
+  const silent = Boolean(args.flags.silent);
+  const failOnSecrets = args.flags["fail-on-secrets"] !== "false";
+  const customIgnores = args.flags.ignore ? String(args.flags.ignore).split(",").map((s) => s.trim()) : [];
+  if (!existsSync69(targetDir)) {
+    if (!silent) {
+      console.error(`
+❌ Error: Target path does not exist: ${targetDir}`);
+    }
+    return 1;
+  }
+  const result = await executeSecretScan({
+    targetDir,
+    verbose,
+    json: jsonMode,
+    silent,
+    ignorePatterns: customIgnores,
+    failOnSecrets
+  });
+  if (jsonMode) {
+    console.log(JSON.stringify(result, null, 2));
+    return result.clean ? 0 : 1;
+  }
+  if (silent) {
+    return result.clean ? 0 : 1;
+  }
+  console.log(`
+\uD83D\uDEE1️ Native Vibeguard Secret Scanner`);
+  console.log(`─────────────────────────────────────────────────────────────`);
+  console.log(`Target Directory : ${targetDir}`);
+  console.log(`Scanned Files    : ${result.scannedFiles}`);
+  console.log(`Duration         : ${result.durationMs}ms`);
+  if (result.clean) {
+    console.log(`
+✅ Zero credentials leaked. All files verified clean.`);
+    return 0;
+  }
+  console.log(`
+\uD83D\uDEA8 Potential Credential Leaks Detected: ${result.findings.length}
+`);
+  for (const finding of result.findings) {
+    console.log(`  \uD83D\uDCCD ${finding.file}:${finding.line}`);
+    console.log(`     Rule    : ${finding.rule}`);
+    console.log(`     Preview : ${finding.redactedSnippet}`);
+    console.log(``);
+  }
+  console.log(`❌ Audit failed. Remove or redact exposed secrets before committing.`);
+  return failOnSecrets ? 1 : 0;
+}
+var DEFAULT_IGNORED_DIRS, BINARY_EXTENSIONS;
+var init_secrets2 = __esm(() => {
+  init_secrets();
+  DEFAULT_IGNORED_DIRS = new Set([
+    ".git",
+    "node_modules",
+    "dist",
+    "build",
+    ".next",
+    ".astro",
+    "coverage",
+    ".turbo",
+    ".cache",
+    ".agents/archive",
+    "snapshots"
+  ]);
+  BINARY_EXTENSIONS = new Set([
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".webp",
+    ".ico",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".eot",
+    ".otf",
+    ".mp4",
+    ".webm",
+    ".mp3",
+    ".wav",
+    ".zip",
+    ".tar",
+    ".gz",
+    ".tgz",
+    ".7z",
+    ".rar",
+    ".sqlite",
+    ".db",
+    ".bin",
+    ".exe",
+    ".dll",
+    ".so",
+    ".dylib",
+    ".wasm",
+    ".lock",
+    ".lockb",
+    ".pdf"
+  ]);
+});
+
+// src/vault/system.ts
+import { existsSync as existsSync70, mkdirSync as mkdirSync36, writeFileSync as writeFileSync41 } from "node:fs";
+import { join as join65 } from "node:path";
+import os from "node:os";
+import { Socket } from "node:net";
+import { spawnSync } from "node:child_process";
+function probePort(port) {
+  return new Promise((resolve) => {
+    const socket = new Socket;
+    socket.setTimeout(100);
+    socket.once("connect", () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.once("timeout", () => {
+      socket.destroy();
+      resolve(false);
+    });
+    socket.once("error", () => {
+      socket.destroy();
+      resolve(false);
+    });
+    socket.connect(port, "127.0.0.1");
+  });
+}
+function runBinarySafe(binary, args) {
+  try {
+    const res = spawnSync(binary, args, { stdio: ["ignore", "pipe", "ignore"], timeout: 1500 });
+    if (res.status === 0 && res.stdout) {
+      return res.stdout.toString("utf8").trim();
+    }
+  } catch {
+    return;
+  }
+  return;
+}
+async function collectSystemTerrain() {
+  const cpus = os.cpus() || [];
+  const firstCpu = cpus[0] || { model: "Unknown", speed: 0 };
+  const host = {
+    platform: os.platform(),
+    arch: os.arch(),
+    hostname: os.hostname(),
+    release: os.release(),
+    cpus: {
+      model: firstCpu.model,
+      speed: firstCpu.speed,
+      count: cpus.length
+    },
+    totalMemoryGb: Math.round(os.totalmem() / 1024 / 1024 / 1024 * 100) / 100,
+    freeMemoryGb: Math.round(os.freemem() / 1024 / 1024 / 1024 * 100) / 100,
+    uptimeHours: Math.round(os.uptime() / 3600 * 10) / 10
+  };
+  const toolchains = {
+    bunVersion: process.versions.bun || runBinarySafe("bun", ["--version"]),
+    nodeVersion: process.versions.node || runBinarySafe("node", ["--version"]),
+    gitVersion: runBinarySafe("git", ["--version"])?.replace(/^git version\s*/, ""),
+    cargoVersion: runBinarySafe("cargo", ["--version"])?.replace(/^cargo\s*/, ""),
+    pythonVersion: runBinarySafe("python3", ["--version"])?.replace(/^Python\s*/, ""),
+    dockerAvailable: Boolean(runBinarySafe("docker", ["--version"]))
+  };
+  const knownServices = [
+    { port: 2222, name: "Muse Memory Studio" },
+    { port: 31337, name: "Pulse Dashboard" },
+    { port: 3600, name: "Ryoku Rashin Hub" },
+    { port: 7878, name: "Muse Daemon SSE" },
+    { port: 11434, name: "Ollama Local LLM" },
+    { port: 8000, name: "Local AI Endpoint" }
+  ];
+  const probedPorts = await Promise.all(knownServices.map(async (svc) => {
+    const listening = await probePort(svc.port);
+    return { port: svc.port, service: svc.name, listening };
+  }));
+  let installedAgents = [];
+  try {
+    const detected = detectAgents();
+    installedAgents = detected.filter((a) => a.installed).map((a) => a.name);
+  } catch {
+    installedAgents = ["antigravity", "opencode", "claude-code"];
+  }
+  return {
+    timestamp: new Date().toISOString(),
+    host,
+    toolchains,
+    agentEcosystem: {
+      activePorts: probedPorts.filter((p) => p.listening),
+      detectedAgents: installedAgents
+    }
+  };
+}
+function formatSystemTerrainMarkdown(terrain) {
+  const { host, toolchains, agentEcosystem } = terrain;
+  const lines = [
+    `# Machine & System Terrain`,
+    `> Deterministic hardware, runtime toolchains, and agent ecosystem map.`,
+    `> Collected at: \`${terrain.timestamp}\``,
+    ``,
+    `## \uD83D\uDDA5️ Host & Hardware`,
+    `| Property | Value |`,
+    `| --- | --- |`,
+    `| **OS / Platform** | \`${host.platform}\` (${host.release}) |`,
+    `| **Architecture** | \`${host.arch}\` |`,
+    `| **Hostname** | \`${host.hostname}\` |`,
+    `| **CPU Model** | ${host.cpus.model} |`,
+    `| **CPU Cores** | ${host.cpus.count} cores @ ${host.cpus.speed} MHz |`,
+    `| **Memory (RAM)** | ${host.freeMemoryGb} GB free / ${host.totalMemoryGb} GB total |`,
+    `| **Host Uptime** | ${host.uptimeHours} hours |`,
+    ``,
+    `## \uD83D\uDEE0️ Toolchains & Runtimes`,
+    `| Runtime / Tool | Version / Status |`,
+    `| --- | --- |`,
+    `| **Bun Runtime** | \`${toolchains.bunVersion || "Not Found"}\` |`,
+    `| **Node.js** | \`${toolchains.nodeVersion || "Not Found"}\` |`,
+    `| **Git CLI** | \`${toolchains.gitVersion || "Not Found"}\` |`,
+    `| **Cargo (Rust)** | \`${toolchains.cargoVersion || "Not Found"}\` |`,
+    `| **Python 3** | \`${toolchains.pythonVersion || "Not Found"}\` |`,
+    `| **Docker Engine** | \`${toolchains.dockerAvailable ? "Available" : "Unavailable"}\` |`,
+    ``,
+    `## \uD83E\uDD16 Agent Ecosystem`,
+    `### Installed Coding Agents (${agentEcosystem.detectedAgents.length})`,
+    agentEcosystem.detectedAgents.length > 0 ? agentEcosystem.detectedAgents.map((a) => `- \`${a}\``).join(`
+`) : `_No recognized agent platforms installed._`,
+    ``,
+    `### Active Local Agent Ports`
+  ];
+  if (agentEcosystem.activePorts.length > 0) {
+    lines.push(`| Port | Service | Status |`);
+    lines.push(`| --- | --- | --- |`);
+    for (const p of agentEcosystem.activePorts) {
+      lines.push(`| \`:${p.port}\` | ${p.service} | \uD83D\uDFE2 Active |`);
+    }
+  } else {
+    lines.push(`_No common agent daemons actively listening._`);
+  }
+  lines.push(``);
+  lines.push(`---`);
+  lines.push(`*Generated by Muse Vault System Collector.*`);
+  return lines.join(`
+`);
+}
+async function writeSystemTerrainMap(targetVaultDir) {
+  if (!existsSync70(targetVaultDir)) {
+    mkdirSync36(targetVaultDir, { recursive: true });
+  }
+  const terrain = await collectSystemTerrain();
+  const md = formatSystemTerrainMarkdown(terrain);
+  const targetFile = join65(targetVaultDir, "system.md");
+  writeFileSync41(targetFile, md, "utf8");
+  return targetFile;
+}
+async function handleTerrainCommand(args) {
+  const silent = Boolean(args.flags.silent);
+  const outFile = args.flags.out;
+  const projectRootInfo = findOrCreateProjectRoot(process.cwd());
+  const defaultVaultDir = join65(projectRootInfo.memoryDir, "vault");
+  const terrain = await collectSystemTerrain();
+  const markdown = formatSystemTerrainMarkdown(terrain);
+  if (outFile) {
+    writeFileSync41(outFile, markdown, "utf8");
+    if (!silent) {
+      console.log(`
+\uD83D\uDDFA️ Machine terrain written to: ${outFile}`);
+    }
+    return 0;
+  }
+  try {
+    const savedPath = await writeSystemTerrainMap(defaultVaultDir);
+    if (!silent) {
+      console.log(`
+\uD83D\uDDFA️ Machine terrain compiled to: ${savedPath}
+`);
+      console.log(markdown);
+    }
+    return 0;
+  } catch (err) {
+    if (!silent) {
+      console.error(`
+❌ Failed to write terrain map: ${err.message}`);
+    }
+    return 1;
+  }
+}
+var init_system = __esm(() => {
+  init_detect2();
+  init_root();
+});
+
 // src/cli.ts
 async function main(argv) {
   if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h" || argv[0] === "help") {
@@ -53276,10 +54736,19 @@ async function main(argv) {
       return handleLoopCommand(parsed);
     case "health":
       return handleHealthCommand(parsed);
+    case "conflicts":
+      return handleConflictsCommand(parsed);
     case "reconcile":
       return handleReconcileCommand(parsed);
     case "benchmark":
       return handleBenchmarkCommand(parsed);
+    case "scan-secrets":
+    case "secrets-scan":
+    case "vibe-scan":
+      return handleScanSecretsCommand(parsed);
+    case "terrain":
+    case "machine-terrain":
+      return handleTerrainCommand(parsed);
     case "code-impact":
     case "impact":
       return handleCodeImpactCommand(parsed);
@@ -53385,9 +54854,12 @@ Ecosystem, Migration & Connectivity:
   daemon [--port N]             Real-time agency hub (SSE event stream + publish API, default port 7878)
   sync [status|broadcast|ingest|pool] Cross-agent knowledge sync & P2P gossip mesh
   mesh [query|check|link|unlink|propagate] Multi-repo & monorepo cross-project mesh
-  health                        Run unified 5-pillar architectural health evaluation
+  health [--project P]         Run unified 5-pillar architectural health evaluation; --project scopes it to one memory project
+  conflicts [--dry-run]        Inspect recorded contradictions; --dry-run previews what would be flagged
   reconcile [--prune] [--stale] Reconcile orphaned & drifted code anchors across memories
   benchmark [--iterations N]    Run microsecond speed, quality & token economy benchmark suite
+  scan-secrets [dir] [--json]   Native Vibeguard secret scanner (zero external dependencies)
+  terrain [--out file.md]       Collect machine hardware, toolchain & agent ecosystem map
   code-impact <file> [--symbol] Synthesize code callers, ADRs, negative warnings & risk score
   pr-context [--base B] [--out] Generate memory-verified PR description from git diff
   mcp                           Run stdio MCP server for agent platforms
@@ -53412,9 +54884,12 @@ var init_cli = __esm(() => {
   init_lifecycle();
   init_evolution();
   init_health2();
+  init_conflicts();
   init_sync2();
   init_mesh2();
   init_versioning();
+  init_secrets2();
+  init_system();
 });
 
 // bin/memory.ts