memorix 1.0.2 → 1.0.3

package/dist/index.js

@@ -3577,7 +3577,7 @@ async function promoteToMiniSkill(projectDir2, projectId, observations2, options
     const title = generateTitle(observations2);
     const instruction = options?.instruction || generateInstruction(observations2);
     const trigger = options?.trigger || generateTrigger(observations2);
-    const facts = extractFacts(observations2);
+    const facts = extractFacts2(observations2);
     const tags = [
       ...options?.tags || [],
       ...extractTags(observations2)
@@ -3685,7 +3685,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 f of obs.facts) {
@@ -5841,6 +5841,10 @@ var KnowledgeGraphManager = class {
     );
     await this.save();
   }
+  /** Get all entity names (for Formation Pipeline entity resolution) */
+  getEntityNames() {
+    return this.entities.map((e) => e.name);
+  }
   /** Read the entire graph */
   async readGraph() {
     await this.init();
@@ -8207,6 +8211,588 @@ var WorkspaceSyncEngine = class _WorkspaceSyncEngine {
 // src/server.ts
 init_provider2();
 init_memory_manager();
+
+// src/memory/formation/index.ts
+init_esm_shims();
+
+// src/memory/formation/extract.ts
+init_esm_shims();
+var 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: (m) => `${m[1]}: ${m[2].trim()}`
+  },
+  // Arrow notation (e.g., "MySQL → PostgreSQL", "v1.0 → v2.0")
+  {
+    pattern: /\b(\S{2,30})\s*[→➜\->]+\s*(\S{2,30})/g,
+    format: (m) => `${m[1]} \u2192 ${m[2]}`
+  },
+  // Version numbers (e.g., "v1.2.3", "version 2.0")
+  {
+    pattern: /\b(?:v(?:ersion)?\s*)(\d+\.\d+(?:\.\d+)?(?:-[\w.]+)?)\b/gi,
+    format: (m) => `Version: ${m[1]}`
+  },
+  // Error messages (e.g., "Error: ...", "ERR_...")
+  {
+    pattern: /\b(?:Error|ERR|ENOENT|ECONNREFUSED|TypeError|RangeError|SyntaxError|ReferenceError)[:\s]+([^\n]{5,80})/gi,
+    format: (m) => `Error: ${m[1].trim()}`
+  },
+  // Port numbers in context
+  {
+    pattern: /\b(?:port|PORT)\s*[:=]?\s*(\d{2,5})\b/gi,
+    format: (m) => `Port: ${m[1]}`
+  },
+  // Environment variables
+  {
+    pattern: /\b([A-Z][A-Z0-9_]{3,30})\s*=\s*(\S{1,60})/g,
+    format: (m) => `${m[1]}=${m[2]}`
+  },
+  // npm/package versions (e.g., "react@18.2.0")
+  {
+    pattern: /\b([@a-z][\w./-]+)@(\d+\.\d+\.\d+(?:-[\w.]+)?)\b/g,
+    format: (m) => `${m[1]}@${m[2]}`
+  }
+];
+var 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
+];
+var 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/
+    ]
+  }
+];
+function extractFacts(narrative, existingFacts) {
+  const existingLower = new Set(existingFacts.map((f) => f.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((p) => p.test(title));
+  if (!isGeneric) return { title, improved: false };
+  const sentences = narrative.replace(/```[\s\S]*?```/g, "").split(/[.。!！?\n]/).map((s) => s.trim()).filter((s) => s.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 p of patterns) {
+      const regex = new RegExp(p.source, p.flags.includes("g") ? p.flags : p.flags + "g");
+      const matches = [...content.matchAll(regex)];
+      score += matches.length;
+    }
+    if (score > 0) scores.push({ type, score });
+  }
+  if (scores.length === 0) return { type: declaredType, corrected: false };
+  scores.sort((a, b) => b.score - a.score);
+  const best = scores[0];
+  if (best.type !== declaredType && best.score >= 2) {
+    const declaredScore = scores.find((s) => s.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
+  };
+}
+
+// src/memory/formation/resolve.ts
+init_esm_shims();
+var SIMILARITY_HIGH2 = 0.75;
+var SIMILARITY_MEDIUM2 = 0.5;
+var SIMILARITY_DUPLICATE = 0.9;
+function wordOverlap(a, b) {
+  const wordsA = new Set(a.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
+  const wordsB = new Set(b.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
+  if (wordsA.size === 0 || wordsB.size === 0) return 0;
+  let intersection = 0;
+  for (const w of wordsA) {
+    if (wordsB.has(w)) intersection++;
+  }
+  return intersection / Math.max(wordsA.size, wordsB.size);
+}
+function entitiesMatch(a, b) {
+  const na = a.toLowerCase().replace(/[-_]/g, "");
+  const nb = b.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((p) => p.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 f of newFacts) {
+    const norm = f.toLowerCase().trim();
+    if (!seen.has(norm) && f.trim().length > 0) {
+      seen.add(norm);
+      merged.push(f);
+    }
+  }
+  for (const f of oldFacts) {
+    const norm = f.toLowerCase().trim();
+    if (!seen.has(norm) && f.trim().length > 0) {
+      seen.add(norm);
+      merged.push(f);
+    }
+  }
+  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((a, b) => b.score - a.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)})` };
+}
+
+// src/memory/formation/evaluate.ts
+init_esm_shims();
+var 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
+};
+var 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
+];
+var 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,
+  /(?:因为|所以|由于|导致|造成|因此|为了|解决)/
+];
+var 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*$/
+];
+var 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
+];
+function factDensity(facts, narrativeLength) {
+  if (narrativeLength === 0) return 0;
+  const structuredChars = facts.reduce((sum, f) => sum + f.length, 0);
+  return Math.min(1, structuredChars / Math.max(narrativeLength, 100));
+}
+function specificityScore(content) {
+  let count2 = 0;
+  for (const p of SPECIFICITY_PATTERNS) {
+    p.lastIndex = 0;
+    if (p.test(content)) count2++;
+  }
+  return Math.min(1, count2 / 3);
+}
+function causalScore(content) {
+  let count2 = 0;
+  for (const p of CAUSAL_PATTERNS) {
+    p.lastIndex = 0;
+    if (p.test(content)) count2++;
+  }
+  return Math.min(1, count2 / 2);
+}
+function noiseScore(title, narrative) {
+  let noisiness = 0;
+  for (const p of NOISE_PATTERNS) {
+    if (p.test(title)) {
+      noisiness += 0.3;
+      break;
+    }
+  }
+  const lines = narrative.split("\n").filter((l) => l.trim().length > 0);
+  let toolOutputLines = 0;
+  for (const line of lines) {
+    for (const p of TOOL_OUTPUT_PATTERNS) {
+      if (p.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 };
+}
+
+// src/memory/formation/index.ts
+var metricsBuffer = [];
+var MAX_METRICS_BUFFER = 500;
+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((s, m) => s + fn(m), 0);
+  const resolutionBreakdown = {};
+  const categoryBreakdown = {};
+  for (const m of metricsBuffer) {
+    resolutionBreakdown[m.resolutionAction] = (resolutionBreakdown[m.resolutionAction] ?? 0) + 1;
+    categoryBreakdown[m.valueCategory] = (categoryBreakdown[m.valueCategory] ?? 0) + 1;
+  }
+  return {
+    total,
+    avgValueScore: sum((m) => m.valueScore) / total,
+    avgExtractedFacts: sum((m) => m.systemExtractedFacts) / total,
+    titleImprovedRate: sum((m) => m.titleImproved ? 1 : 0) / total,
+    entityResolvedRate: sum((m) => m.entityResolved ? 1 : 0) / total,
+    typeCorectedRate: sum((m) => m.typeCorrected ? 1 : 0) / total,
+    resolutionBreakdown,
+    categoryBreakdown,
+    avgDurationMs: sum((m) => m.durationMs) / total
+  };
+}
+async function runFormation(input, config) {
+  const startTime = Date.now();
+  let stagesCompleted = 0;
+  const existingEntities = config.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,
+      config.searchMemories,
+      config.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: config.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;
+}
+
+// src/server.ts
 var lastInternalWriteMs = 0;
 var markInternalWrite = () => {
   lastInternalWriteMs = Date.now();
@@ -8338,7 +8924,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",
@@ -8494,12 +9080,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 (q, limit, pid) => {
+            const result = await compactSearch({ query: q, limit, projectId: pid, status: "active" });
+            if (result.entries.length === 0) return [];
+            const details = await compactDetail(result.entries.map((e) => e.id));
+            return details.documents.map((d, i) => ({
+              id: Number(d.id.replace("obs-", "")),
+              observationId: d.observationId,
+              title: d.title,
+              narrative: d.narrative,
+              facts: d.facts,
+              entityName: d.entityName,
+              type: d.type,
+              score: result.entries[i]?.score ?? 0
+            }));
+          },
+          getObservation: (id) => {
+            const o = getObservation(id);
+            if (!o) return null;
+            return {
+              id: o.id,
+              entityName: o.entityName,
+              type: o.type,
+              title: o.title,
+              narrative: o.narrative,
+              facts: o.facts,
+              topicKey: o.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}`
           }
         ]
       };
@@ -8854,6 +9496,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, count2] of Object.entries(summary.categoryBreakdown)) {
+        const pct = (count2 / summary.total * 100).toFixed(1);
+        const icon = cat === "core" ? "\u{1F7E2}" : cat === "contextual" ? "\u{1F7E1}" : "\u{1F534}";
+        lines.push(`- ${icon} **${cat}:** ${count2} (${pct}%)`);
+      }
+      lines.push("", "### Resolution Actions");
+      for (const [action, count2] of Object.entries(summary.resolutionBreakdown)) {
+        const pct = (count2 / summary.total * 100).toFixed(1);
+        lines.push(`- **${action}:** ${count2} (${pct}%)`);
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
   let enableKG = false;
   try {
     const { homedir: homedir16 } = await import("os");