memorix 1.0.2 → 1.0.3

package/dist/cli/index.js

@@ -42046,6 +42046,10 @@ var init_graph = __esm({
         );
         await this.save();
       }
+      /** Get all entity names (for Formation Pipeline entity resolution) */
+      getEntityNames() {
+        return this.entities.map((e3) => e3.name);
+      }
       /** Read the entire graph */
       async readGraph() {
         await this.init();
@@ -43813,6 +43817,624 @@ Respond in JSON only:
   }
 });
 
+// src/memory/formation/extract.ts
+function extractFacts(narrative, existingFacts) {
+  const existingLower = new Set(existingFacts.map((f4) => f4.toLowerCase().trim()));
+  const extracted = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { pattern, format } of FACT_PATTERNS) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(narrative)) !== null) {
+      const fact = format(match);
+      const normalized = fact.toLowerCase().trim();
+      if (existingLower.has(normalized) || seen.has(normalized)) continue;
+      if (fact.length < 5 || fact.length > 120) continue;
+      seen.add(normalized);
+      extracted.push(fact);
+    }
+  }
+  return extracted.slice(0, 10);
+}
+function improveTitle(title, narrative) {
+  const isGeneric = GENERIC_TITLE_PATTERNS.some((p2) => p2.test(title));
+  if (!isGeneric) return { title, improved: false };
+  const sentences = narrative.replace(/```[\s\S]*?```/g, "").split(/[.。!！?\n]/).map((s2) => s2.trim()).filter((s2) => s2.length >= 15);
+  if (sentences.length > 0) {
+    return { title: sentences[0].slice(0, 60), improved: true };
+  }
+  return { title, improved: false };
+}
+function resolveEntity(entityName, existingEntities) {
+  if (existingEntities.length === 0) return { entityName, resolved: false };
+  const lower = entityName.toLowerCase().replace(/[-_]/g, "");
+  for (const existing of existingEntities) {
+    const existingLower = existing.toLowerCase().replace(/[-_]/g, "");
+    if (lower === existingLower) {
+      return { entityName: existing, resolved: existing !== entityName };
+    }
+    if (lower.length >= 3 && existingLower.length >= 3) {
+      if (existingLower.includes(lower) || lower.includes(existingLower)) {
+        const canonical = existing.length >= entityName.length ? existing : entityName;
+        return { entityName: canonical, resolved: canonical !== entityName };
+      }
+    }
+  }
+  return { entityName, resolved: false };
+}
+function verifyType(declaredType, narrative, title) {
+  const content = `${title} ${narrative}`;
+  const scores = [];
+  for (const { type, patterns } of TYPE_SIGNALS) {
+    let score = 0;
+    for (const p2 of patterns) {
+      const regex2 = new RegExp(p2.source, p2.flags.includes("g") ? p2.flags : p2.flags + "g");
+      const matches = [...content.matchAll(regex2)];
+      score += matches.length;
+    }
+    if (score > 0) scores.push({ type, score });
+  }
+  if (scores.length === 0) return { type: declaredType, corrected: false };
+  scores.sort((a3, b3) => b3.score - a3.score);
+  const best = scores[0];
+  if (best.type !== declaredType && best.score >= 2) {
+    const declaredScore = scores.find((s2) => s2.type === declaredType)?.score ?? 0;
+    if (declaredScore === 0) {
+      return { type: best.type, corrected: true };
+    }
+  }
+  return { type: declaredType, corrected: false };
+}
+function runExtract(input, existingEntities) {
+  const callerFacts = input.facts ?? [];
+  const extractedFacts = extractFacts(input.narrative, callerFacts);
+  const allFacts = [...callerFacts, ...extractedFacts];
+  const { title, improved: titleImproved } = improveTitle(input.title, input.narrative);
+  const { entityName, resolved: entityResolved } = resolveEntity(
+    input.entityName,
+    existingEntities
+  );
+  const { type, corrected: typeCorrected } = verifyType(
+    input.type,
+    input.narrative,
+    input.title
+  );
+  return {
+    title,
+    titleImproved,
+    narrative: input.narrative,
+    facts: allFacts,
+    extractedFacts,
+    entityName,
+    entityResolved,
+    type,
+    typeCorrected
+  };
+}
+var FACT_PATTERNS, GENERIC_TITLE_PATTERNS, TYPE_SIGNALS;
+var init_extract = __esm({
+  "src/memory/formation/extract.ts"() {
+    "use strict";
+    init_esm_shims();
+    FACT_PATTERNS = [
+      // Key: Value pairs (e.g., "Port: 3000", "Timeout = 60s")
+      {
+        pattern: /\b([A-Z][a-zA-Z_-]{2,30})\s*[:=]\s*([^\n,;]{2,60})/g,
+        format: (m4) => `${m4[1]}: ${m4[2].trim()}`
+      },
+      // Arrow notation (e.g., "MySQL → PostgreSQL", "v1.0 → v2.0")
+      {
+        pattern: /\b(\S{2,30})\s*[→➜\->]+\s*(\S{2,30})/g,
+        format: (m4) => `${m4[1]} \u2192 ${m4[2]}`
+      },
+      // Version numbers (e.g., "v1.2.3", "version 2.0")
+      {
+        pattern: /\b(?:v(?:ersion)?\s*)(\d+\.\d+(?:\.\d+)?(?:-[\w.]+)?)\b/gi,
+        format: (m4) => `Version: ${m4[1]}`
+      },
+      // Error messages (e.g., "Error: ...", "ERR_...")
+      {
+        pattern: /\b(?:Error|ERR|ENOENT|ECONNREFUSED|TypeError|RangeError|SyntaxError|ReferenceError)[:\s]+([^\n]{5,80})/gi,
+        format: (m4) => `Error: ${m4[1].trim()}`
+      },
+      // Port numbers in context
+      {
+        pattern: /\b(?:port|PORT)\s*[:=]?\s*(\d{2,5})\b/gi,
+        format: (m4) => `Port: ${m4[1]}`
+      },
+      // Environment variables
+      {
+        pattern: /\b([A-Z][A-Z0-9_]{3,30})\s*=\s*(\S{1,60})/g,
+        format: (m4) => `${m4[1]}=${m4[2]}`
+      },
+      // npm/package versions (e.g., "react@18.2.0")
+      {
+        pattern: /\b([@a-z][\w./-]+)@(\d+\.\d+\.\d+(?:-[\w.]+)?)\b/g,
+        format: (m4) => `${m4[1]}@${m4[2]}`
+      }
+    ];
+    GENERIC_TITLE_PATTERNS = [
+      /^Updated \S+\.\w+$/i,
+      /^Created \S+\.\w+$/i,
+      /^Deleted \S+\.\w+$/i,
+      /^Modified \S+\.\w+$/i,
+      /^Changed \S+\.\w+$/i,
+      /^Session activity/i,
+      /^Activity \(/i,
+      /^Used \w+$/i,
+      /^Ran: /i
+    ];
+    TYPE_SIGNALS = [
+      {
+        type: "problem-solution",
+        patterns: [
+          /\b(fix|fixed|bug|error|issue|crash|broken|resolved|workaround|patch)\b/i,
+          /\b(修复|修正|解决|报错|崩溃|异常)\b/
+        ]
+      },
+      {
+        type: "gotcha",
+        patterns: [
+          /\b(gotcha|pitfall|trap|careful|warning|caveat|footgun|unexpected|beware)\b/i,
+          /\b(坑|陷阱|注意|小心|踩坑)\b/
+        ]
+      },
+      {
+        type: "decision",
+        patterns: [
+          /\b(decided|chose|chosen|selected|adopted|rejected|evaluated|compared)\b/i,
+          /\b(决定|选择|采用|弃用|对比|评估)\b/
+        ]
+      },
+      {
+        type: "what-changed",
+        patterns: [
+          /\b(changed|migrated|upgraded|refactored|replaced|renamed|moved|removed|added)\b/i,
+          /\b(改|迁移|升级|重构|替换|重命名|删除|新增)\b/
+        ]
+      },
+      {
+        type: "how-it-works",
+        patterns: [
+          /\b(works by|architecture|mechanism|pipeline|flow|under the hood|internally)\b/i,
+          /\b(原理|机制|流程|架构|内部)\b/
+        ]
+      },
+      {
+        type: "trade-off",
+        patterns: [
+          /\b(trade.?off|compromise|downside|cost|benefit|pro|con|versus|vs)\b/i,
+          /\b(权衡|折中|代价|收益|优缺点)\b/
+        ]
+      }
+    ];
+  }
+});
+
+// src/memory/formation/resolve.ts
+function wordOverlap(a3, b3) {
+  const wordsA = new Set(a3.toLowerCase().split(/\s+/).filter((w3) => w3.length > 2));
+  const wordsB = new Set(b3.toLowerCase().split(/\s+/).filter((w3) => w3.length > 2));
+  if (wordsA.size === 0 || wordsB.size === 0) return 0;
+  let intersection2 = 0;
+  for (const w3 of wordsA) {
+    if (wordsB.has(w3)) intersection2++;
+  }
+  return intersection2 / Math.max(wordsA.size, wordsB.size);
+}
+function entitiesMatch(a3, b3) {
+  const na = a3.toLowerCase().replace(/[-_]/g, "");
+  const nb = b3.toLowerCase().replace(/[-_]/g, "");
+  if (na === nb) return true;
+  if (na.length >= 3 && nb.length >= 3) {
+    if (na.includes(nb) || nb.includes(na)) return true;
+  }
+  return false;
+}
+function hasContradiction(oldText, newText) {
+  const negationPatterns = [
+    /\bnot\s+(\w+)/gi,
+    /\bno longer\b/i,
+    /\binstead of\b/i,
+    /\breplaced\b.*\bwith\b/i,
+    /\bremoved\b/i,
+    /\bdeprecated\b/i,
+    /\bobsolete\b/i,
+    /不再/,
+    /已弃用/,
+    /替换为/,
+    /改为/
+  ];
+  return negationPatterns.some((p2) => p2.test(newText));
+}
+function mergeNarratives(oldNarrative, newNarrative) {
+  if (newNarrative.length > oldNarrative.length * 1.5) return newNarrative;
+  if (oldNarrative.length > newNarrative.length * 1.5) return oldNarrative;
+  return `${newNarrative}
+
+[Previous context]: ${oldNarrative}`;
+}
+function mergeFacts2(oldFacts, newFacts) {
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const f4 of newFacts) {
+    const norm = f4.toLowerCase().trim();
+    if (!seen.has(norm) && f4.trim().length > 0) {
+      seen.add(norm);
+      merged.push(f4);
+    }
+  }
+  for (const f4 of oldFacts) {
+    const norm = f4.toLowerCase().trim();
+    if (!seen.has(norm) && f4.trim().length > 0) {
+      seen.add(norm);
+      merged.push(f4);
+    }
+  }
+  return merged;
+}
+function scoreCandidate(extracted, candidate) {
+  const entityMatch = entitiesMatch(extracted.entityName, candidate.entityName);
+  const contentOverlap = wordOverlap(
+    `${extracted.title} ${extracted.narrative}`,
+    `${candidate.title} ${candidate.narrative}`
+  );
+  const score = candidate.score * 0.6 + (entityMatch ? 0.2 : 0) + contentOverlap * 0.2;
+  const newLength = extracted.narrative.length + extracted.facts.join(" ").length;
+  const oldLength = candidate.narrative.length + candidate.facts.length;
+  const richer = newLength > oldLength * 1.15;
+  const contradiction = hasContradiction(candidate.narrative, extracted.narrative);
+  return { score, entityMatch, richer, contradiction };
+}
+async function runResolve(extracted, projectId, searchMemories, getObservation2) {
+  const query = `${extracted.title} ${extracted.narrative.substring(0, 200)}`;
+  let hits;
+  try {
+    hits = await searchMemories(query, 5, projectId);
+  } catch {
+    return { action: "new", reason: "Search unavailable, defaulting to new" };
+  }
+  if (hits.length === 0) {
+    return { action: "new", reason: "No similar existing memories found" };
+  }
+  const scored = hits.map((hit) => ({
+    hit,
+    ...scoreCandidate(extracted, hit)
+  }));
+  scored.sort((a3, b3) => b3.score - a3.score);
+  const best = scored[0];
+  if (best.hit.score >= SIMILARITY_DUPLICATE) {
+    if (best.richer) {
+      const existing = getObservation2(best.hit.observationId);
+      const oldFacts = existing?.facts ?? best.hit.facts.split("\n").filter(Boolean);
+      return {
+        action: "evolve",
+        targetId: best.hit.observationId,
+        reason: `Near-duplicate of #${best.hit.observationId} but richer content (score: ${best.score.toFixed(2)})`,
+        mergedNarrative: mergeNarratives(best.hit.narrative, extracted.narrative),
+        mergedFacts: mergeFacts2(oldFacts, extracted.facts)
+      };
+    }
+    return {
+      action: "discard",
+      targetId: best.hit.observationId,
+      reason: `Duplicate of #${best.hit.observationId} (score: ${best.score.toFixed(2)})`
+    };
+  }
+  if (best.score >= SIMILARITY_HIGH2) {
+    if (best.contradiction) {
+      const existing = getObservation2(best.hit.observationId);
+      const oldFacts = existing?.facts ?? best.hit.facts.split("\n").filter(Boolean);
+      return {
+        action: "evolve",
+        targetId: best.hit.observationId,
+        reason: `Supersedes #${best.hit.observationId}: contradiction detected (score: ${best.score.toFixed(2)})`,
+        mergedNarrative: extracted.narrative,
+        mergedFacts: mergeFacts2(oldFacts, extracted.facts)
+      };
+    }
+    if (best.richer) {
+      const existing = getObservation2(best.hit.observationId);
+      const oldFacts = existing?.facts ?? best.hit.facts.split("\n").filter(Boolean);
+      return {
+        action: "merge",
+        targetId: best.hit.observationId,
+        reason: `Merging with #${best.hit.observationId}: same topic, new content is richer (score: ${best.score.toFixed(2)})`,
+        mergedNarrative: mergeNarratives(best.hit.narrative, extracted.narrative),
+        mergedFacts: mergeFacts2(oldFacts, extracted.facts)
+      };
+    }
+    return {
+      action: "discard",
+      targetId: best.hit.observationId,
+      reason: `Already covered by #${best.hit.observationId} (score: ${best.score.toFixed(2)})`
+    };
+  }
+  if (best.score >= SIMILARITY_MEDIUM2 && best.entityMatch) {
+    const existing = getObservation2(best.hit.observationId);
+    const oldFacts = existing?.facts ?? best.hit.facts.split("\n").filter(Boolean);
+    const newFactCount = extracted.facts.length;
+    const oldFactCount = oldFacts.length;
+    if (newFactCount > oldFactCount) {
+      return {
+        action: "merge",
+        targetId: best.hit.observationId,
+        reason: `Same entity "${extracted.entityName}", new memory has more facts (${newFactCount} > ${oldFactCount})`,
+        mergedNarrative: mergeNarratives(best.hit.narrative, extracted.narrative),
+        mergedFacts: mergeFacts2(oldFacts, extracted.facts)
+      };
+    }
+  }
+  return { action: "new", reason: `Different from existing memories (best score: ${best.score.toFixed(2)})` };
+}
+var SIMILARITY_HIGH2, SIMILARITY_MEDIUM2, SIMILARITY_DUPLICATE;
+var init_resolve = __esm({
+  "src/memory/formation/resolve.ts"() {
+    "use strict";
+    init_esm_shims();
+    SIMILARITY_HIGH2 = 0.75;
+    SIMILARITY_MEDIUM2 = 0.5;
+    SIMILARITY_DUPLICATE = 0.9;
+  }
+});
+
+// src/memory/formation/evaluate.ts
+function factDensity(facts, narrativeLength) {
+  if (narrativeLength === 0) return 0;
+  const structuredChars = facts.reduce((sum, f4) => sum + f4.length, 0);
+  return Math.min(1, structuredChars / Math.max(narrativeLength, 100));
+}
+function specificityScore(content) {
+  let count3 = 0;
+  for (const p2 of SPECIFICITY_PATTERNS) {
+    p2.lastIndex = 0;
+    if (p2.test(content)) count3++;
+  }
+  return Math.min(1, count3 / 3);
+}
+function causalScore(content) {
+  let count3 = 0;
+  for (const p2 of CAUSAL_PATTERNS) {
+    p2.lastIndex = 0;
+    if (p2.test(content)) count3++;
+  }
+  return Math.min(1, count3 / 2);
+}
+function noiseScore(title, narrative) {
+  let noisiness = 0;
+  for (const p2 of NOISE_PATTERNS) {
+    if (p2.test(title)) {
+      noisiness += 0.3;
+      break;
+    }
+  }
+  const lines = narrative.split("\n").filter((l3) => l3.trim().length > 0);
+  let toolOutputLines = 0;
+  for (const line of lines) {
+    for (const p2 of TOOL_OUTPUT_PATTERNS) {
+      if (p2.test(line)) {
+        toolOutputLines++;
+        break;
+      }
+    }
+  }
+  if (lines.length > 0) {
+    noisiness += toolOutputLines / lines.length * 0.5;
+  }
+  if (narrative.length < 50) noisiness += 0.2;
+  return Math.min(1, noisiness);
+}
+function categorize(score) {
+  if (score >= 0.6) return "core";
+  if (score >= 0.35) return "contextual";
+  return "ephemeral";
+}
+function buildReason(typeWeight, factDens, specificity, causal, noise, category) {
+  const parts = [];
+  if (typeWeight >= 0.7) parts.push("high-value type");
+  else if (typeWeight <= 0.45) parts.push("low-value type");
+  if (factDens > 0.3) parts.push("fact-dense");
+  if (specificity > 0.3) parts.push("specific (versions/codes/paths)");
+  if (causal > 0.3) parts.push("causal reasoning");
+  if (noise > 0.3) parts.push("noisy content");
+  const detail = parts.length > 0 ? parts.join(", ") : "average content";
+  return `${category}: ${detail}`;
+}
+function runEvaluate(extracted) {
+  const content = `${extracted.title} ${extracted.narrative} ${extracted.facts.join(" ")}`;
+  const typeWeight = TYPE_WEIGHTS[extracted.type] ?? 0.5;
+  const factDens = factDensity(extracted.facts, extracted.narrative.length);
+  const specificity = specificityScore(content);
+  const causal = causalScore(content);
+  const noise = noiseScore(extracted.title, extracted.narrative);
+  const rawScore = typeWeight * 0.5 + factDens * 0.12 + specificity * 0.12 + causal * 0.12 - noise * 0.14;
+  const extractionBonus = extracted.extractedFacts.length > 0 ? 0.05 : 0;
+  const titlePenalty = extracted.titleImproved ? -0.03 : 0;
+  const correctionBonus = extracted.typeCorrected ? 0.03 : 0;
+  const score = Math.max(0, Math.min(1, rawScore + extractionBonus + titlePenalty + correctionBonus));
+  const category = categorize(score);
+  const reason = buildReason(typeWeight, factDens, specificity, causal, noise, category);
+  return { score, category, reason };
+}
+var TYPE_WEIGHTS, SPECIFICITY_PATTERNS, CAUSAL_PATTERNS, NOISE_PATTERNS, TOOL_OUTPUT_PATTERNS;
+var init_evaluate = __esm({
+  "src/memory/formation/evaluate.ts"() {
+    "use strict";
+    init_esm_shims();
+    TYPE_WEIGHTS = {
+      "gotcha": 0.85,
+      "decision": 0.8,
+      "problem-solution": 0.75,
+      "trade-off": 0.7,
+      "why-it-exists": 0.65,
+      "how-it-works": 0.6,
+      "discovery": 0.55,
+      "what-changed": 0.45,
+      "session-request": 0.4
+    };
+    SPECIFICITY_PATTERNS = [
+      /\b\d+\.\d+\.\d+\b/,
+      // Semantic version numbers
+      /\b(ERR_|ENOENT|ECONNREFUSED|E[A-Z]{3,})\b/,
+      // Error codes
+      /\b(port|PORT)\s*[:=]?\s*\d{2,5}\b/i,
+      // Port numbers
+      /\bhttps?:\/\/\S+/,
+      // URLs
+      /`[^`]{3,60}`/,
+      // Inline code references
+      /\b[A-Z][A-Z0-9_]{3,}\b/,
+      // Constants (e.g., MAX_RETRIES)
+      /\b\d+\s*(ms|s|sec|min|MB|GB|KB)\b/i
+      // Measurements with units
+    ];
+    CAUSAL_PATTERNS = [
+      /\b(because|therefore|due to|caused by|as a result|fixed by|resolved by)\b/i,
+      /\b(so that|in order to|leads to|results in|prevents)\b/i,
+      /(?:因为|所以|由于|导致|造成|因此|为了|解决)/
+    ];
+    NOISE_PATTERNS = [
+      /^Session activity/i,
+      /^Updated \S+\.\w+$/i,
+      /^Created \S+\.\w+$/i,
+      /^Deleted \S+\.\w+$/i,
+      /^File written successfully/i,
+      /^Command executed/i,
+      /^Tool: (read_file|list_dir|find_by_name)/i,
+      /^\s*$/
+    ];
+    TOOL_OUTPUT_PATTERNS = [
+      /^(file|directory|folder)\s+(created|deleted|moved|copied)/i,
+      /^Successfully\s+(installed|updated|removed)/i,
+      /^\d+ files? changed/i,
+      /^npm (WARN|notice)/i,
+      /^\s*at\s+\S+\s+\(/
+      // Stack trace lines
+    ];
+  }
+});
+
+// src/memory/formation/index.ts
+var formation_exports = {};
+__export(formation_exports, {
+  clearFormationMetrics: () => clearFormationMetrics,
+  getFormationMetrics: () => getFormationMetrics,
+  getMetricsSummary: () => getMetricsSummary,
+  runFormation: () => runFormation
+});
+function getFormationMetrics() {
+  return metricsBuffer;
+}
+function clearFormationMetrics() {
+  metricsBuffer.length = 0;
+}
+function getMetricsSummary() {
+  const total = metricsBuffer.length;
+  if (total === 0) {
+    return {
+      total: 0,
+      avgValueScore: 0,
+      avgExtractedFacts: 0,
+      titleImprovedRate: 0,
+      entityResolvedRate: 0,
+      typeCorectedRate: 0,
+      resolutionBreakdown: {},
+      categoryBreakdown: {},
+      avgDurationMs: 0
+    };
+  }
+  const sum = (fn) => metricsBuffer.reduce((s2, m4) => s2 + fn(m4), 0);
+  const resolutionBreakdown = {};
+  const categoryBreakdown = {};
+  for (const m4 of metricsBuffer) {
+    resolutionBreakdown[m4.resolutionAction] = (resolutionBreakdown[m4.resolutionAction] ?? 0) + 1;
+    categoryBreakdown[m4.valueCategory] = (categoryBreakdown[m4.valueCategory] ?? 0) + 1;
+  }
+  return {
+    total,
+    avgValueScore: sum((m4) => m4.valueScore) / total,
+    avgExtractedFacts: sum((m4) => m4.systemExtractedFacts) / total,
+    titleImprovedRate: sum((m4) => m4.titleImproved ? 1 : 0) / total,
+    entityResolvedRate: sum((m4) => m4.entityResolved ? 1 : 0) / total,
+    typeCorectedRate: sum((m4) => m4.typeCorrected ? 1 : 0) / total,
+    resolutionBreakdown,
+    categoryBreakdown,
+    avgDurationMs: sum((m4) => m4.durationMs) / total
+  };
+}
+async function runFormation(input, config2) {
+  const startTime = Date.now();
+  let stagesCompleted = 0;
+  const existingEntities = config2.getEntityNames();
+  const extraction = runExtract(input, existingEntities);
+  stagesCompleted = 1;
+  let resolution;
+  if (input.topicKey) {
+    resolution = {
+      action: "new",
+      reason: "TopicKey upsert \u2014 bypasses resolve stage"
+    };
+  } else {
+    resolution = await runResolve(
+      extraction,
+      input.projectId,
+      config2.searchMemories,
+      config2.getObservation
+    );
+  }
+  stagesCompleted = 2;
+  const evaluation = runEvaluate(extraction);
+  stagesCompleted = 3;
+  const durationMs = Date.now() - startTime;
+  const formed = {
+    // Final enriched data
+    entityName: extraction.entityName,
+    type: extraction.type,
+    title: extraction.title,
+    narrative: resolution.mergedNarrative ?? extraction.narrative,
+    facts: resolution.mergedFacts ?? extraction.facts,
+    // Stage results
+    extraction,
+    resolution,
+    evaluation,
+    // Pipeline metadata
+    pipeline: {
+      mode: "rules",
+      durationMs,
+      stagesCompleted,
+      shadow: config2.shadow
+    }
+  };
+  const metrics = {
+    systemExtractedFacts: extraction.extractedFacts.length,
+    titleImproved: extraction.titleImproved,
+    entityResolved: extraction.entityResolved,
+    typeCorrected: extraction.typeCorrected,
+    resolutionAction: resolution.action,
+    valueScore: evaluation.score,
+    valueCategory: evaluation.category,
+    durationMs,
+    mode: "rules"
+  };
+  if (metricsBuffer.length >= MAX_METRICS_BUFFER) {
+    metricsBuffer.shift();
+  }
+  metricsBuffer.push(metrics);
+  return formed;
+}
+var metricsBuffer, MAX_METRICS_BUFFER;
+var init_formation = __esm({
+  "src/memory/formation/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_extract();
+    init_resolve();
+    init_evaluate();
+    metricsBuffer = [];
+    MAX_METRICS_BUFFER = 500;
+  }
+});
+
 // src/memory/session.ts
 var session_exports = {};
 __export(session_exports, {
@@ -44451,7 +45073,7 @@ async function promoteToMiniSkill(projectDir2, projectId, observations2, options
     const title = generateTitle(observations2);
     const instruction = options2?.instruction || generateInstruction(observations2);
     const trigger = options2?.trigger || generateTrigger(observations2);
-    const facts = extractFacts(observations2);
+    const facts = extractFacts2(observations2);
     const tags = [
       ...options2?.tags || [],
       ...extractTags(observations2)
@@ -44559,7 +45181,7 @@ function generateTrigger(observations2) {
   }
   return parts.length > 0 ? parts.join("; ") : `Related to ${obs.title}`;
 }
-function extractFacts(observations2) {
+function extractFacts2(observations2) {
   const facts = /* @__PURE__ */ new Set();
   for (const obs of observations2) {
     for (const f4 of obs.facts) {
@@ -45662,7 +46284,7 @@ async function createMemorixServer(cwd, existingServer, sharedTeam) {
   let syncAdvisory = null;
   const server = existingServer ?? new McpServer({
     name: "memorix",
-    version: true ? "1.0.2" : "1.0.1"
+    version: true ? "1.0.3" : "1.0.1"
   });
   server.registerTool(
     "memorix_store",
@@ -45818,12 +46440,68 @@ Mode: ${decision.usedLLM ? "LLM" : "heuristic"}`
       const enrichment = enrichmentParts.length > 0 ? `
 Auto-enriched: ${enrichmentParts.join(", ")}` : "";
       const action = upserted ? "\u{1F504} Updated" : "\u2705 Stored";
+      let formationNote = "";
+      try {
+        const formationConfig = {
+          shadow: true,
+          useLLM: false,
+          minValueScore: 0.3,
+          searchMemories: async (q3, limit, pid) => {
+            const result = await compactSearch({ query: q3, limit, projectId: pid, status: "active" });
+            if (result.entries.length === 0) return [];
+            const details = await compactDetail(result.entries.map((e3) => e3.id));
+            return details.documents.map((d3, i2) => ({
+              id: Number(d3.id.replace("obs-", "")),
+              observationId: d3.observationId,
+              title: d3.title,
+              narrative: d3.narrative,
+              facts: d3.facts,
+              entityName: d3.entityName,
+              type: d3.type,
+              score: result.entries[i2]?.score ?? 0
+            }));
+          },
+          getObservation: (id) => {
+            const o3 = getObservation(id);
+            if (!o3) return null;
+            return {
+              id: o3.id,
+              entityName: o3.entityName,
+              type: o3.type,
+              title: o3.title,
+              narrative: o3.narrative,
+              facts: o3.facts,
+              topicKey: o3.topicKey
+            };
+          },
+          getEntityNames: () => graphManager.getEntityNames()
+        };
+        const formed = await runFormation({
+          entityName,
+          type,
+          title,
+          narrative,
+          facts: safeFacts,
+          projectId: project.id,
+          source: "explicit",
+          topicKey
+        }, formationConfig);
+        formationNote = `
+\u{1F52C} Formation[shadow]: ${formed.evaluation.category} (${formed.evaluation.score.toFixed(2)}) | ${formed.resolution.action} | ${formed.pipeline.durationMs}ms`;
+        if (formed.extraction.extractedFacts.length > 0) {
+          formationNote += ` | +${formed.extraction.extractedFacts.length} facts`;
+        }
+        if (formed.extraction.titleImproved) formationNote += " | title\u2191";
+        if (formed.extraction.entityResolved) formationNote += ` | entity\u2192${formed.entityName}`;
+        if (formed.extraction.typeCorrected) formationNote += ` | type\u2192${formed.type}`;
+      } catch {
+      }
       return {
         content: [
           {
             type: "text",
             text: `${action} observation #${obs.id} "${title}" (~${obs.tokens} tokens)
-Entity: ${entityName} | Type: ${type} | Project: ${project.id}${obs.topicKey ? ` | Topic: ${obs.topicKey}` : ""}${compactAction}${compressionNote}${enrichment}`
+Entity: ${entityName} | Type: ${type} | Project: ${project.id}${obs.topicKey ? ` | Topic: ${obs.topicKey}` : ""}${compactAction}${compressionNote}${enrichment}${formationNote}`
           }
         ]
       };
@@ -46178,6 +46856,53 @@ Archived memories can be restored manually if needed.` }]
       };
     }
   );
+  server.registerTool(
+    "memorix_formation_metrics",
+    {
+      title: "Formation Pipeline Metrics",
+      description: "Show aggregated metrics from the Memory Formation Pipeline running in shadow mode. Reports value scores, resolution actions, fact extraction rates, and processing times.",
+      inputSchema: {}
+    },
+    async () => {
+      const summary = getMetricsSummary();
+      if (summary.total === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: "\u{1F4CA} Formation Pipeline: No metrics collected yet.\nStore some observations to start collecting shadow mode data."
+          }]
+        };
+      }
+      const lines = [
+        "\u{1F4CA} **Formation Pipeline Metrics** (shadow mode)",
+        "",
+        `**Total observations processed:** ${summary.total}`,
+        `**Average value score:** ${summary.avgValueScore.toFixed(3)}`,
+        `**Average processing time:** ${summary.avgDurationMs.toFixed(1)}ms`,
+        "",
+        "### Quality Indicators",
+        `- **Avg system-extracted facts:** ${summary.avgExtractedFacts.toFixed(1)} per observation`,
+        `- **Title improved rate:** ${(summary.titleImprovedRate * 100).toFixed(1)}%`,
+        `- **Entity resolved rate:** ${(summary.entityResolvedRate * 100).toFixed(1)}%`,
+        `- **Type corrected rate:** ${(summary.typeCorectedRate * 100).toFixed(1)}%`,
+        "",
+        "### Value Categories"
+      ];
+      for (const [cat, count3] of Object.entries(summary.categoryBreakdown)) {
+        const pct = (count3 / summary.total * 100).toFixed(1);
+        const icon = cat === "core" ? "\u{1F7E2}" : cat === "contextual" ? "\u{1F7E1}" : "\u{1F534}";
+        lines.push(`- ${icon} **${cat}:** ${count3} (${pct}%)`);
+      }
+      lines.push("", "### Resolution Actions");
+      for (const [action, count3] of Object.entries(summary.resolutionBreakdown)) {
+        const pct = (count3 / summary.total * 100).toFixed(1);
+        lines.push(`- **${action}:** ${count3} (${pct}%)`);
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
   let enableKG = false;
   try {
     const { homedir: homedir17 } = await import("os");
@@ -47491,6 +48216,7 @@ var init_server4 = __esm({
     init_engine2();
     init_provider2();
     init_memory_manager();
+    init_formation();
     lastInternalWriteMs = 0;
     markInternalWrite = () => {
       lastInternalWriteMs = Date.now();
@@ -47698,7 +48424,7 @@ var init_serve = __esm({
             });
           } else {
             console.error(`[memorix] cwd may not be a valid project, trying MCP roots protocol...`);
-            const mcpServer = new McpServer2({ name: "memorix", version: true ? "1.0.2" : "1.0.1" });
+            const mcpServer = new McpServer2({ name: "memorix", version: true ? "1.0.3" : "1.0.1" });
             mcpServer.registerTool("_memorix_loading", {
               description: "Memorix is initializing, detecting project root...",
               inputSchema: {}
@@ -50448,6 +51174,28 @@ async function runHook() {
       const projectId = canonicalId;
       await initObservations2(dataDir);
       await storeObservation2({ ...observation, projectId });
+      try {
+        const { runFormation: runFormation2 } = await Promise.resolve().then(() => (init_formation(), formation_exports));
+        runFormation2({
+          entityName: observation.entityName,
+          type: observation.type,
+          title: observation.title,
+          narrative: observation.narrative,
+          facts: observation.facts,
+          projectId,
+          source: "hook"
+        }, {
+          shadow: true,
+          useLLM: false,
+          minValueScore: 0.3,
+          searchMemories: async () => [],
+          // Skip search in hooks for speed
+          getObservation: () => null,
+          getEntityNames: () => []
+        }).catch(() => {
+        });
+      } catch {
+      }
       const emoji2 = TYPE_EMOJI[observation.type] ?? "\u{1F4DD}";
       output.systemMessage = (output.systemMessage ?? "") + `
 ${emoji2} Memorix saved: ${observation.title} [${observation.type}]`;