@fenglimg/fabric-server 2.3.0-rc.1 → 2.3.0-rc.10

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/index.ts
-import { existsSync as existsSync9 } from "fs";
-import { readFile as readFile19 } from "fs/promises";
-import { join as join23, resolve as resolve4 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { readFile as readFile22 } from "fs/promises";
+import { join as join27, resolve as resolve4 } from "path";
 import { fileURLToPath } from "url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -742,7 +742,7 @@ var SUPPORTED_EMBED_MODELS = /* @__PURE__ */ new Set([
 function readEmbedConfig(projectRoot) {
   try {
     const config = readFabricConfig(projectRoot);
-    const enabled = config.embed_enabled === true;
+    const enabled = config.embed_enabled !== false;
     const rawWeight = config.embed_weight;
     const weight = typeof rawWeight === "number" && Number.isInteger(rawWeight) && rawWeight >= 0 && rawWeight <= 49 ? rawWeight : 30;
     const rawModel = config.embed_model;
@@ -817,6 +817,73 @@ function readOrphanDemoteThresholdDays(projectRoot) {
     return {};
   }
 }
+function readCredibilityHalfLives(projectRoot) {
+  const defaults = {
+    decisions: 180,
+    guidelines: 150,
+    models: 150,
+    pitfalls: 120,
+    processes: 120
+  };
+  try {
+    const cfg = readFabricConfig(projectRoot);
+    const validate = (v) => {
+      if (typeof v !== "number" || !Number.isFinite(v) || v < 1 || v > 3650 || !Number.isInteger(v)) {
+        return void 0;
+      }
+      return v;
+    };
+    const out = { ...defaults };
+    const dec = validate(cfg.credibility_half_life_decisions_days);
+    if (dec !== void 0) out.decisions = dec;
+    const gui = validate(cfg.credibility_half_life_guidelines_days);
+    if (gui !== void 0) out.guidelines = gui;
+    const mod = validate(cfg.credibility_half_life_models_days);
+    if (mod !== void 0) out.models = mod;
+    const pit = validate(cfg.credibility_half_life_pitfalls_days);
+    if (pit !== void 0) out.pitfalls = pit;
+    const pro = validate(cfg.credibility_half_life_processes_days);
+    if (pro !== void 0) out.processes = pro;
+    return out;
+  } catch {
+    return { ...defaults };
+  }
+}
+function readCredibilityFloors(projectRoot) {
+  const defaults = {
+    draft: 0.4,
+    verified: 0.55,
+    proven: 0.7
+  };
+  try {
+    const cfg = readFabricConfig(projectRoot);
+    const validate = (v) => {
+      if (typeof v !== "number" || !Number.isFinite(v) || v < 0 || v > 1) {
+        return void 0;
+      }
+      return v;
+    };
+    const out = { ...defaults };
+    const draft = validate(cfg.credibility_floor_draft);
+    if (draft !== void 0) out.draft = draft;
+    const verified = validate(cfg.credibility_floor_verified);
+    if (verified !== void 0) out.verified = verified;
+    const proven = validate(cfg.credibility_floor_proven);
+    if (proven !== void 0) out.proven = proven;
+    return out;
+  } catch {
+    return { ...defaults };
+  }
+}
+function readFusion(projectRoot) {
+  try {
+    const raw = readFabricConfig(projectRoot).fusion;
+    if (raw === "rrf" || raw === "additive") return raw;
+    return "auto";
+  } catch {
+    return "auto";
+  }
+}
 function readConflictLintThreshold(projectRoot) {
   try {
     const cfgPath = join4(projectRoot, ".fabric", "fabric-config.json");
@@ -884,7 +951,7 @@ async function awaitFirstReconcileGate(timeoutMs = 5e3) {
 
 // src/services/extract-knowledge.ts
 import { existsSync as existsSync3 } from "fs";
-import { readFile as readFile4 } from "fs/promises";
+import { readFile as readFile5 } from "fs/promises";
 import { join as join7 } from "path";
 import {
   PROPOSED_REASON_DESCRIPTIONS_BY_LOCALE
@@ -892,10 +959,14 @@ import {
 import { hasSecrets, isPersonalScope, redactPii, resolveGlobalLocale } from "@fenglimg/fabric-shared";
 
 // src/services/cross-store-write.ts
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile3 } from "fs/promises";
 import { join as join5 } from "path";
 import {
+  STORE_KNOWLEDGE_TYPE_DIRS,
   STORE_LAYOUT,
   STORE_PENDING_DIR,
+  STORE_PROJECT_ID_PATTERN,
   buildStoreResolveInput,
   createStoreResolver,
   isPersonalLeakIntoSharedStore,
@@ -907,6 +978,7 @@ import {
   PersonalScopeLeakError,
   StoreWriteTargetUnresolvedError
 } from "@fenglimg/fabric-shared/errors";
+import { withFileLock as withFileLock2 } from "@fenglimg/fabric-shared/node/atomic-write";
 function writeTargetUnresolved(scope, layer) {
   const actionHint = layer === "personal" ? "run `fabric install --global` to mint your personal store, then retry" : `mount + bind a shared store, then set an explicit route: \`fabric store switch-write <alias> --scope ${scope}\``;
   return new StoreWriteTargetUnresolvedError(
@@ -943,8 +1015,25 @@ function resolveWriteTargetStoreDir(layer, projectRoot, semanticScope) {
 function resolveStorePendingBase(layer, projectRoot, semanticScope) {
   return join5(resolveWriteTargetStoreDir(layer, projectRoot, semanticScope), STORE_LAYOUT.knowledgeDir, STORE_PENDING_DIR);
 }
-function resolveStoreCanonicalBase(layer, projectRoot) {
-  return join5(resolveWriteTargetStoreDir(layer, projectRoot), STORE_LAYOUT.knowledgeDir);
+var STORE_PROJECTS_DIR = "projects";
+function isValidWriteProjectSegment(project) {
+  if (project.length === 0) {
+    return false;
+  }
+  if (project === STORE_PROJECTS_DIR) {
+    return false;
+  }
+  if (STORE_KNOWLEDGE_TYPE_DIRS.includes(project)) {
+    return false;
+  }
+  return STORE_PROJECT_ID_PATTERN.test(project);
+}
+function resolveStoreCanonicalBase(layer, projectRoot, project) {
+  const base = join5(resolveWriteTargetStoreDir(layer, projectRoot), STORE_LAYOUT.knowledgeDir);
+  if (layer === "team" && project !== void 0 && isValidWriteProjectSegment(project)) {
+    return join5(base, STORE_PROJECTS_DIR, project);
+  }
+  return base;
 }
 function resolveWriteScopeMeta(layer, projectRoot, semanticScope) {
   const input = buildStoreResolveInput(projectRoot);
@@ -969,7 +1058,7 @@ function resolveWriteScopeMeta(layer, projectRoot, semanticScope) {
 }
 
 // src/services/cross-store-recall.ts
-import { readFile as readFile3, stat } from "fs/promises";
+import { readFile as readFile4, stat } from "fs/promises";
 import { join as join6 } from "path";
 import {
   buildStoreResolveInput as buildStoreResolveInput2,
@@ -986,7 +1075,6 @@ import {
   deriveAgentsMetaStableId,
   isKnowledgeStableId,
   KnowledgeTypeSchema,
-  LayerSchema,
   MaturitySchema,
   parseKnowledgeId,
   StableIdSchema
@@ -1069,8 +1157,7 @@ function extractRuleDescription(source) {
     id: knowledge?.id,
     knowledge_type: knowledge?.knowledge_type,
     maturity: knowledge?.maturity,
-    knowledge_layer: knowledge?.knowledge_layer,
-    layer_reason: knowledge?.layer_reason,
+    // W4/Track1 (D1): no `knowledge_layer` — layer derives from the id prefix.
     created_at: knowledge?.created_at,
     tags: knowledge?.tags,
     // v2.0-rc.5 (C1): default-safe values when there is no frontmatter at all;
@@ -1080,7 +1167,9 @@ function extractRuleDescription(source) {
     relevance_scope: knowledge?.relevance_scope ?? "broad",
     relevance_paths: knowledge?.relevance_paths ?? [],
     // v2.2 H2-related (W1-T7): graph edges, undefined when absent.
-    related: knowledge?.related
+    related: knowledge?.related,
+    // v2.2 glossary aliases FIELD (C-002): synonym terms, undefined when absent.
+    aliases: knowledge?.aliases
   };
 }
 function extractDescriptionFromFrontmatter(frontmatter) {
@@ -1095,18 +1184,18 @@ function extractDescriptionFromFrontmatter(frontmatter) {
     tech_stack: extractInlineArray(frontmatter, "tech_stack"),
     impact: extractInlineArray(frontmatter, "impact"),
     must_read_if: extractScalar(frontmatter, "must_read_if") ?? summary,
-    entities: extractInlineArray(frontmatter, "entities"),
     id: knowledge.id,
     knowledge_type: knowledge.knowledge_type,
     maturity: knowledge.maturity,
-    knowledge_layer: knowledge.knowledge_layer,
-    layer_reason: knowledge.layer_reason,
+    // W4/Track1 (D1): no `knowledge_layer` — layer derives from the id prefix.
     created_at: knowledge.created_at,
     tags: knowledge.tags,
     relevance_scope: knowledge.relevance_scope,
     relevance_paths: knowledge.relevance_paths,
     // v2.2 H2-related (W1-T7): graph edges parsed from frontmatter.
-    related: knowledge.related
+    related: knowledge.related,
+    // v2.2 glossary aliases FIELD (C-002): synonym terms for the BM25 body.
+    aliases: knowledge.aliases
   };
 }
 function isForbiddenCrossLayerEdge(sourceLayer, targetId) {
@@ -1131,8 +1220,6 @@ function extractKnowledgeFieldsFromFrontmatter(frontmatter) {
   const rawId = extractScalar(frontmatter, "id");
   const rawType = extractScalar(frontmatter, "type");
   const rawMaturity = extractScalar(frontmatter, "maturity");
-  const rawLayer = extractScalar(frontmatter, "layer");
-  const rawLayerReason = extractScalar(frontmatter, "layer_reason");
   const rawCreatedAt = extractScalar(frontmatter, "created_at");
   let id;
   if (rawId !== void 0) {
@@ -1169,16 +1256,6 @@ function extractKnowledgeFieldsFromFrontmatter(frontmatter) {
       maturity = parsed.data;
     } else {
       process.stderr.write(`[fabric] frontmatter: unknown maturity ${JSON.stringify(rawMaturity)}; skipping
-`);
-    }
-  }
-  let knowledge_layer;
-  if (rawLayer !== void 0) {
-    const parsed = LayerSchema.safeParse(rawLayer);
-    if (parsed.success) {
-      knowledge_layer = parsed.data;
-    } else {
-      process.stderr.write(`[fabric] frontmatter: unknown layer ${JSON.stringify(rawLayer)}; skipping
 `);
     }
   }
@@ -1191,23 +1268,12 @@ function extractKnowledgeFieldsFromFrontmatter(frontmatter) {
 `);
     }
   }
-  if (id !== void 0 && knowledge_layer !== void 0) {
-    const decoded = parseKnowledgeId(id);
-    if (decoded !== null && decoded.layer !== knowledge_layer) {
-      process.stderr.write(
-        `[fabric] frontmatter: id ${id} encodes layer ${decoded.layer} but layer field says ${knowledge_layer}; dropping both
-`
-      );
-      id = void 0;
-      knowledge_layer = void 0;
-    }
-  }
   const tags = extractInlineArray(frontmatter, "tags");
   const rawRelevanceScope = extractScalar(frontmatter, "relevance_scope");
   const relevance_scope = rawRelevanceScope === "narrow" || rawRelevanceScope === "broad" ? rawRelevanceScope : "broad";
   const relevance_paths = extractInlineArray(frontmatter, "relevance_paths");
   const rawRelated = extractInlineArray(frontmatter, "related");
-  const sourceLayer = knowledge_layer ?? (id !== void 0 ? parseKnowledgeId(id)?.layer ?? "team" : "team");
+  const sourceLayer = id !== void 0 ? parseKnowledgeId(id)?.layer ?? "team" : "team";
   const related = rawRelated.filter((targetId) => {
     if (isForbiddenCrossLayerEdge(sourceLayer, targetId)) {
       process.stderr.write(
@@ -1218,17 +1284,17 @@ function extractKnowledgeFieldsFromFrontmatter(frontmatter) {
     }
     return true;
   });
+  const aliases = extractInlineArray(frontmatter, "aliases");
   return {
     id,
     knowledge_type,
     maturity,
-    knowledge_layer,
-    layer_reason: rawLayerReason,
     created_at,
     tags: tags.length > 0 ? tags : void 0,
     relevance_scope,
     relevance_paths,
-    related: related.length > 0 ? related : void 0
+    related: related.length > 0 ? related : void 0,
+    aliases: aliases.length > 0 ? aliases : void 0
   };
 }
 function extractScalar(frontmatter, key) {
@@ -1274,7 +1340,13 @@ async function readSetFingerprint(refs) {
   return parts.sort().join("\n");
 }
 var SEMANTIC_SCOPE_LINE = /^semantic_scope:\s*"?([^"\n]+?)"?\s*$/mu;
-function readSemanticScope(source, layer) {
+function readSemanticScope(source, layer, project) {
+  if (layer === "personal") {
+    return "personal";
+  }
+  if (typeof project === "string" && project.length > 0) {
+    return `project:${project}`;
+  }
   const match = SEMANTIC_SCOPE_LINE.exec(source);
   return match?.[1] ?? layer;
 }
@@ -1341,7 +1413,7 @@ async function walkReadSetStoresUncached(snapshot) {
   const entries = await Promise.all(snapshot.refs.map(async (ref) => {
     let source;
     try {
-      source = await readFile3(ref.file, "utf8");
+      source = await readFile4(ref.file, "utf8");
     } catch {
       return null;
     }
@@ -1353,7 +1425,7 @@ async function walkReadSetStoresUncached(snapshot) {
       type: ref.type,
       alias: ref.alias,
       layer,
-      semanticScope: readSemanticScope(source, layer),
+      semanticScope: readSemanticScope(source, layer, ref.project),
       source
     };
   }));
@@ -1371,7 +1443,9 @@ async function buildCrossStoreRawItems(projectRoot) {
       stable_id: entry.qualifiedId,
       description: {
         ...baseDescription,
-        knowledge_layer: entry.layer,
+        // W4/Track1 (D1): no `knowledge_layer` backfill — a candidate's layer is
+        // derived from its stable_id prefix (layerFromStableId in plan-context),
+        // the single source of truth (KT-DEC-0004).
         semantic_scope: entry.semanticScope
       }
     });
@@ -1534,11 +1608,44 @@ function buildBm25Model(docs) {
   for (const field of BM25_FIELDS) {
     avgFieldLength[field] = totalDocs > 0 ? totalFieldLength[field] / totalDocs : 0;
   }
+  const serialized = {
+    version: 1,
+    totalDocs,
+    documentFrequency: [...documentFrequency],
+    avgFieldLength,
+    perDoc: [...perDoc].map(([id, stats]) => ({
+      id,
+      fieldTermFreq: emptyFieldRecord(() => []),
+      fieldLength: { ...stats.fieldLength }
+    }))
+  };
+  for (const entry of serialized.perDoc) {
+    const stats = perDoc.get(entry.id);
+    if (stats === void 0) continue;
+    for (const field of BM25_FIELDS) {
+      entry.fieldTermFreq[field] = [...stats.fieldTermFreq[field]];
+    }
+  }
+  return modelFromStats(serialized);
+}
+function modelFromStats(serialized) {
+  const totalDocs = serialized.totalDocs;
+  const documentFrequency = new Map(serialized.documentFrequency);
+  const avgFieldLength = serialized.avgFieldLength;
+  const perDoc = /* @__PURE__ */ new Map();
+  for (const entry of serialized.perDoc) {
+    const fieldTermFreq = emptyFieldRecord(() => /* @__PURE__ */ new Map());
+    for (const field of BM25_FIELDS) {
+      fieldTermFreq[field] = new Map(entry.fieldTermFreq[field]);
+    }
+    perDoc.set(entry.id, { fieldTermFreq, fieldLength: entry.fieldLength });
+  }
   const idf = (term) => {
     const n = documentFrequency.get(term) ?? 0;
     return Math.log(1 + (totalDocs - n + 0.5) / (n + 0.5));
   };
   return {
+    __serialized: serialized,
     scoreDoc(id, queryTerms) {
       const data = perDoc.get(id);
       if (data === void 0 || queryTerms.length === 0) {
@@ -1574,9 +1681,186 @@ function buildBm25Model(docs) {
     }
   };
 }
+function serializeBm25Model(model) {
+  return model.__serialized;
+}
+function rehydrateBm25Model(serialized) {
+  return modelFromStats(serialized);
+}
+var SYNONYM_PAIRS = {
+  // Code / engineering actions
+  refactor: ["restructure", "rewrite", "redesign", "reorganize", "clean", "rework"],
+  optimize: ["improve", "speed-up", "tune", "accelerate", "perf", "performance"],
+  debug: ["fix", "troubleshoot", "diagnose", "investigate", "resolve", "correct"],
+  migrate: ["port", "move", "transfer", "upgrade", "transition", "convert"],
+  "set up": ["init", "initialize", "configure", "bootstrap", "install", "onboard"],
+  implement: ["add", "build", "create", "develop", "write", "introduce", "introduce"],
+  // Architecture / design
+  architecture: ["design", "structure", "layout", "organization", "pattern", "system"],
+  "data model": ["schema", "entity", "type", "structure", "contract", "shape"],
+  // Quality / correctness
+  test: ["verify", "validate", "assert", "check", "spec", "coverage"],
+  lint: ["check", "validate", "audit", "inspect", "analyze"],
+  // Communication / impact
+  documentation: ["docs", "readme", "guide", "spec", "explanation", "reference"],
+  decision: ["adr", "rationale", "why", "motivation", "reason", "trade-off"],
+  // Change management
+  release: ["deploy", "ship", "publish", "cut", "version", "tag"],
+  rollback: ["revert", "undo", "back-out", "backout", "restore"],
+  // Containers / infra
+  container: ["docker", "image", "oci", "cri-o"],
+  deploy: ["release", "rollout", "ship", "publish", "promote"],
+  // Project / process
+  on_boarding: ["getting-started", "quickstart", "newcomer", "new-hire", "first-time"],
+  best_practice: ["convention", "guideline", "standard", "rule", "recommendation"],
+  // Tech stacks
+  api: ["endpoint", "route", "service", "interface", "rpc", "rest"],
+  typescript: ["ts", "types", "type-safe"],
+  react: ["jsx", "tsx", "component", "ui"],
+  node: ["nodejs", "runtime", "backend", "server"],
+  database: ["db", "sql", "nosql", "storage", "persistence"]
+};
+var STEMMING_PATTERNS = [
+  { suffix: "e", alternatives: ["es", "ed", "ing", "ation"] },
+  { suffix: "y", alternatives: ["ies", "ied", "ying"] }
+  // Catch-all for non-verb / already-stemmed query terms: no-op by default.
+];
+var DEFAULT_IDF_WEIGHT = 1;
+var COMMON_TERMS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "as",
+  "is",
+  "it",
+  "at",
+  "be",
+  "do",
+  "has",
+  "have",
+  "was",
+  "are",
+  "been",
+  "this",
+  "that",
+  "these",
+  "those",
+  "will",
+  "can",
+  "may",
+  "would",
+  "could",
+  "should",
+  "does",
+  "not",
+  "no",
+  "if",
+  "so",
+  "up",
+  "out",
+  "all",
+  "each",
+  "every",
+  "both",
+  "some",
+  "any",
+  "such",
+  "only",
+  "own",
+  "same",
+  "too",
+  "very",
+  "just",
+  "about",
+  "over",
+  "than",
+  "then",
+  "also"
+]);
+function idfWeight(term) {
+  return COMMON_TERMS.has(term) ? 0.3 : DEFAULT_IDF_WEIGHT;
+}
+function expandQueryTerms(text) {
+  const baseTerms = tokenize(text);
+  const weighted = /* @__PURE__ */ new Map();
+  for (const term of baseTerms) {
+    const lower = term.toLowerCase();
+    const aliases = /* @__PURE__ */ new Set();
+    const syns = SYNONYM_PAIRS[lower];
+    if (syns !== void 0) {
+      for (const s of syns) aliases.add(s);
+    }
+    for (const [key, values] of Object.entries(SYNONYM_PAIRS)) {
+      if (values.includes(lower)) {
+        aliases.add(key);
+      }
+    }
+    for (const { suffix, alternatives } of STEMMING_PATTERNS) {
+      if (lower.endsWith(suffix) && lower.length > suffix.length) {
+        const stem = lower.slice(0, -suffix.length);
+        for (const alt of alternatives) {
+          aliases.add(stem + alt);
+        }
+      }
+    }
+    const originalWeight = idfWeight(lower);
+    weighted.set(term, originalWeight);
+    for (const alias of aliases) {
+      if (!weighted.has(alias)) {
+        weighted.set(alias, originalWeight * 0.5);
+      }
+    }
+  }
+  return weighted;
+}
 function buildQueryTerms(text) {
   return tokenize(text);
 }
+function rankDocuments(model, ids, queryTerms) {
+  if (queryTerms.length === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const scored = [];
+  ids.forEach((id, order) => {
+    const score = model.scoreDoc(id, queryTerms);
+    if (score > 0) {
+      scored.push({ id, score, order });
+    }
+  });
+  scored.sort((a, b) => a.score !== b.score ? b.score - a.score : a.order - b.order);
+  const ranks = /* @__PURE__ */ new Map();
+  scored.forEach((entry, index) => {
+    ranks.set(entry.id, index + 1);
+  });
+  return ranks;
+}
+function rankByScore(ids, scores) {
+  const scored = [];
+  ids.forEach((id, order) => {
+    const score = scores.get(id) ?? 0;
+    if (score > 0) {
+      scored.push({ id, score, order });
+    }
+  });
+  scored.sort((a, b) => a.score !== b.score ? b.score - a.score : a.order - b.order);
+  const ranks = /* @__PURE__ */ new Map();
+  scored.forEach((entry, index) => {
+    ranks.set(entry.id, index + 1);
+  });
+  return ranks;
+}
 
 // src/services/conflict-lint.ts
 function buildSimilarityModel(docs) {
@@ -1940,7 +2224,7 @@ async function extractKnowledge(projectRoot, input) {
   const writeScopeMeta = resolveWriteScopeMeta(layer, projectRoot, semanticScope);
   await ensureParentDirectory(absolutePath);
   if (existsSync3(absolutePath)) {
-    const existing = await readFile4(absolutePath, "utf8");
+    const existing = await readFile5(absolutePath, "utf8");
     const existingKey = readFrontmatterKey(existing, "x-fabric-idempotency-key");
     if (existingKey === effectiveIdempotencyKey) {
       const fresh2 = renderFreshEntry({
@@ -2073,7 +2357,7 @@ async function resolveDisambiguatedSlugPath(args) {
         idempotencyKey: candidateKey
       };
     }
-    const existing = await readFile4(candidatePath, "utf8");
+    const existing = await readFile5(candidatePath, "utf8");
     const existingKey = readFrontmatterKey(existing, "x-fabric-idempotency-key");
     if (existingKey === candidateKey) {
       return {
@@ -2670,13 +2954,47 @@ var LEDGER_DUAL_WRITE_METRIC_NAMES = {
   edit_intent_checked: METRIC_COUNTER_NAMES.edit_intent_checked
 };
 
+// src/services/plan-context.ts
+import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile3 } from "fs/promises";
+import { join as join10 } from "path";
+
 // src/services/vector-retrieval.ts
+import { mkdirSync } from "fs";
+import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile2 } from "fs/promises";
+import { createRequire } from "module";
+import { join as join9 } from "path";
+import { resolveGlobalRoot as resolveGlobalRoot3 } from "@fenglimg/fabric-shared";
 var embedderLoad;
 var OPTIONAL_EMBED_PACKAGE = "fastembed";
+function isEmbedderResolvable() {
+  try {
+    createRequire(import.meta.url).resolve(OPTIONAL_EMBED_PACKAGE);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var embedderModuleLoader = (name) => import(name);
+var MISSING_EMBEDDER_HINT = "[fabric] vector semantic recall is enabled but the optional 'fastembed' package is unavailable \u2014 falling back to text-only ranking. Install it where the server resolves modules (e.g. `npm i -g fastembed`) to enable embeddings, or set embed_enabled:false to silence this.\n";
+var defaultMissingEmbedderHint = () => {
+  process.stderr.write(MISSING_EMBEDDER_HINT);
+};
+var missingEmbedderHinted = false;
+var emitMissingEmbedderHint = defaultMissingEmbedderHint;
+function hintMissingEmbedderOnce() {
+  if (missingEmbedderHinted) {
+    return;
+  }
+  missingEmbedderHinted = true;
+  emitMissingEmbedderHint();
+}
+function defaultEmbedCacheDir() {
+  return join9(resolveGlobalRoot3(), "cache", "embed");
+}
 function buildEmbedInitOptions(modelName) {
   return {
     maxLength: 512,
-    cacheDir: process.env.FABRIC_EMBED_CACHE_DIR,
+    cacheDir: process.env.FABRIC_EMBED_CACHE_DIR ?? defaultEmbedCacheDir(),
     ...typeof modelName === "string" && modelName.length > 0 ? { model: modelName } : {}
   };
 }
@@ -2685,11 +3003,14 @@ async function loadEmbedder(modelName) {
     embedderLoad = (async () => {
       try {
         const moduleName = OPTIONAL_EMBED_PACKAGE;
-        const mod = await import(moduleName);
+        const mod = await embedderModuleLoader(moduleName);
         if (mod?.FlagEmbedding?.init === void 0) {
+          hintMissingEmbedderOnce();
           return null;
         }
-        const model = await mod.FlagEmbedding.init(buildEmbedInitOptions(modelName));
+        const initOpts = buildEmbedInitOptions(modelName);
+        mkdirSync(initOpts.cacheDir, { recursive: true });
+        const model = await mod.FlagEmbedding.init(initOpts);
         return {
           async embed(texts) {
             const out = [];
@@ -2702,6 +3023,7 @@ async function loadEmbedder(modelName) {
           }
         };
       } catch {
+        hintMissingEmbedderOnce();
         return null;
       }
     })();
@@ -2732,7 +3054,7 @@ function cosineSimilarity(a, b) {
   if (!Number.isFinite(sim)) {
     return 0;
   }
-  return Math.max(-1, Math.min(1, sim));
+  return Math.max(0, Math.min(1, sim));
 }
 var docVectorCache = /* @__PURE__ */ new Map();
 var DOC_VECTOR_CACHE_MAX = 1e4;
@@ -2749,11 +3071,63 @@ function cacheDocVector(text, vector) {
     docVectorCache.delete(lru);
   }
 }
-async function buildVectorScores(embedder, queryText, items) {
+var VECTOR_CACHE_VERSION = 1;
+var VECTOR_CACHE_DIR = ".fabric/cache/vectors";
+function vectorCachePath(projectRoot, revision) {
+  const safe = revision.replace(/[^A-Za-z0-9_-]/g, "_");
+  return join9(projectRoot, VECTOR_CACHE_DIR, `${safe}.json`);
+}
+async function loadVectorCacheFromDisk(ctx) {
+  try {
+    const raw = await readFile6(vectorCachePath(ctx.projectRoot, ctx.corpusRevision), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== VECTOR_CACHE_VERSION) return null;
+    if (parsed.embedding_model !== ctx.embeddingModel) return null;
+    if (parsed.corpus_revision !== ctx.corpusRevision) return null;
+    if (!Array.isArray(parsed.vectors) || parsed.vectors.length === 0) return null;
+    const dimension = parsed.dimension;
+    if (!Number.isInteger(dimension) || dimension <= 0) return null;
+    const out = /* @__PURE__ */ new Map();
+    for (const entry of parsed.vectors) {
+      if (!Array.isArray(entry) || entry.length !== 2) return null;
+      const [text, vector] = entry;
+      if (typeof text !== "string" || !Array.isArray(vector)) return null;
+      if (vector.length !== dimension) return null;
+      out.set(text, vector);
+    }
+    return out;
+  } catch {
+    return null;
+  }
+}
+async function saveVectorCacheToDisk(ctx, vectors, dimension) {
+  try {
+    const payload = {
+      version: VECTOR_CACHE_VERSION,
+      embedding_model: ctx.embeddingModel,
+      dimension,
+      corpus_revision: ctx.corpusRevision,
+      vectors
+    };
+    const path = vectorCachePath(ctx.projectRoot, ctx.corpusRevision);
+    await mkdir4(join9(ctx.projectRoot, VECTOR_CACHE_DIR), { recursive: true });
+    await writeFile2(path, JSON.stringify(payload), "utf8");
+  } catch {
+  }
+}
+async function buildVectorScores(embedder, queryText, items, cache2) {
   if (embedder === null || queryText.trim().length === 0 || items.length === 0) {
     return null;
   }
   try {
+    if (cache2 !== void 0) {
+      const fromDisk = await loadVectorCacheFromDisk(cache2);
+      if (fromDisk !== null) {
+        for (const [text, vector] of fromDisk) {
+          cacheDocVector(text, vector);
+        }
+      }
+    }
     const missTexts = [];
     for (const item of items) {
       if (!docVectorCache.has(item.text)) {
@@ -2769,6 +3143,24 @@ async function buildVectorScores(embedder, queryText, items) {
     for (let m = 0; m < missTexts.length; m += 1) {
       cacheDocVector(missTexts[m], embedded[m + 1]);
     }
+    const staleTexts = [];
+    for (const item of items) {
+      const cached = docVectorCache.get(item.text);
+      if (cached !== void 0 && cached.length !== queryVec.length) {
+        docVectorCache.delete(item.text);
+        staleTexts.push(item.text);
+      }
+    }
+    if (staleTexts.length > 0) {
+      const reEmbedded = await embedder.embed(staleTexts);
+      if (reEmbedded.length !== staleTexts.length) {
+        return null;
+      }
+      for (let s = 0; s < staleTexts.length; s += 1) {
+        cacheDocVector(staleTexts[s], reEmbedded[s]);
+      }
+    }
+    const embeddedNewDoc = missTexts.length > 0 || staleTexts.length > 0;
     const scores = /* @__PURE__ */ new Map();
     for (const item of items) {
       const docVec = docVectorCache.get(item.text);
@@ -2777,6 +3169,20 @@ async function buildVectorScores(embedder, queryText, items) {
       }
       scores.set(item.stable_id, cosineSimilarity(queryVec, docVec));
     }
+    if (cache2 !== void 0 && embeddedNewDoc) {
+      const snapshot = [];
+      for (const item of items) {
+        const vec = docVectorCache.get(item.text);
+        if (vec !== void 0) {
+          snapshot.push([item.text, vec]);
+        }
+      }
+      const dimension = snapshot.length > 0 ? snapshot[0][1].length : 0;
+      const uniform = dimension > 0 && snapshot.every(([, v]) => v.length === dimension);
+      if (uniform) {
+        await saveVectorCacheToDisk(cache2, snapshot, dimension);
+      }
+    }
     return scores;
   } catch {
     return null;
@@ -2784,6 +3190,11 @@ async function buildVectorScores(embedder, queryText, items) {
 }
 
 // src/services/plan-context.ts
+function layerFromStableId(qualifiedId) {
+  const colon = qualifiedId.lastIndexOf(":");
+  const localId = colon === -1 ? qualifiedId : qualifiedId.slice(colon + 1);
+  return localId.startsWith("KP-") ? "personal" : "team";
+}
 var SELECTION_TOKEN_TTL_DEFAULT_MS = 30 * 60 * 1e3;
 var selectionTokenCache = /* @__PURE__ */ new Map();
 var SELECTION_TOKEN_CACHE_MAX = 1e3;
@@ -2837,56 +3248,28 @@ async function planContext(projectRoot, input) {
     ...input.known_tech ?? [],
     ...Object.values(input.detected_entities ?? {}).flat()
   ].join(" ");
-  const scoringContext = {
-    nowMs: Date.now(),
-    targetPaths: input.target_paths ?? dedupePaths(input.paths),
-    queryTerms: buildQueryTerms(queryText)
-  };
   const storeRawItems = await buildCrossStoreRawItems(projectRoot).catch(() => []);
   const { rawItems: allRawItems, suppressedStableIds } = partitionEmptyShells(storeRawItems);
   const effectiveLayerFilter = input.layer_filter ?? readDefaultLayerFilter(projectRoot);
-  const rawItems = effectiveLayerFilter === "both" ? allRawItems : allRawItems.filter((item) => item.description.knowledge_layer === effectiveLayerFilter);
-  const docTexts = /* @__PURE__ */ new Map();
-  for (const item of rawItems) {
-    docTexts.set(item.stable_id, documentTextForItem(item.description));
-  }
-  scoringContext.docTexts = docTexts;
-  if (scoringContext.queryTerms.length > 0 && rawItems.length > 0) {
-    scoringContext.bm25 = getOrBuildBm25Model(revision, rawItems, docTexts);
-  }
-  scoringContext.scopeRank = buildScopeRankMap(rawItems, projectRoot);
-  const embedConfig = readEmbedConfig(projectRoot);
-  if (embedConfig.enabled && queryText.trim().length > 0 && rawItems.length > 0) {
-    const embedder = await loadEmbedder(embedConfig.model);
-    const vectorScores = await buildVectorScores(
-      embedder,
-      queryText,
-      rawItems.map((item) => ({
-        stable_id: item.stable_id,
-        text: docTexts.get(item.stable_id) ?? documentTextForItem(item.description)
-      }))
-    );
-    if (vectorScores !== null) {
-      scoringContext.vectorScores = vectorScores;
-      scoringContext.vectorWeight = embedConfig.weight;
-    }
-  }
-  const scoredSorted = sortDescriptionItems(rawItems, scoringContext);
-  const seenStableIds = /* @__PURE__ */ new Set();
-  const rankedScored = scoredSorted.filter(({ item }) => {
-    if (seenStableIds.has(item.stable_id)) return false;
-    seenStableIds.add(item.stable_id);
-    return true;
+  const rawItems = effectiveLayerFilter === "both" ? allRawItems : allRawItems.filter((item) => layerFromStableId(item.stable_id) === effectiveLayerFilter);
+  const scoringContext = await buildScoringContext(projectRoot, revision, rawItems, {
+    queryText,
+    targetPaths: input.target_paths ?? dedupePaths(input.paths)
   });
+  const rankedScored = rankDescriptionItems(rawItems, scoringContext, "triage");
   const rankedCandidates = rankedScored.map((entry) => entry.item);
-  const topK = readPlanContextTopK(projectRoot);
-  const cappedScored = rankedScored.slice(0, topK);
-  const relevanceRatio = readRecallRelevanceRatio(projectRoot);
-  const hasQuery = scoringContext.queryTerms.length > 0;
-  const maxScore = rankedScored.length > 0 ? rankedScored[0].score : 0;
-  const relevanceFloor = maxScore * relevanceRatio;
-  const survivingScored = hasQuery && maxScore > 0 && relevanceRatio > 0 ? cappedScored.filter((entry) => entry.score >= relevanceFloor) : cappedScored;
+  const survivingScored = rankDescriptionItems(rawItems, scoringContext, "recall", {
+    topK: readPlanContextTopK(projectRoot),
+    relevanceRatio: readRecallRelevanceRatio(projectRoot)
+  });
   const topKCandidates = survivingScored.map((entry) => entry.item);
+  const candidateScores = /* @__PURE__ */ new Map();
+  for (const entry of survivingScored) {
+    candidateScores.set(entry.item.stable_id, {
+      score: entry.score,
+      score_breakdown: scoreBreakdownForItem(entry.item, scoringContext)
+    });
+  }
   const topKIds = new Set(topKCandidates.map((item) => item.stable_id));
   const retrievalDropped = rankedCandidates.filter((item) => !topKIds.has(item.stable_id)).map((item) => ({ id: item.stable_id, reason: "retrieval_budget" }));
   const omittedCandidateCount = retrievalDropped.length;
@@ -2992,6 +3375,8 @@ async function planContext(projectRoot, input) {
     // ONLY when at least one neighbour was actually appended. Empty (graph-empty
     // no-op) → field omitted, steady-state wire shape unchanged.
     ...Object.keys(relatedAppended).length > 0 ? { related_appended: relatedAppended } : {},
+    // P1 recall-observability: runtime-only score channel (Map → {} on the wire).
+    ...candidateScores.size > 0 ? { candidate_scores: candidateScores } : {},
     ...payloadTrimDropped > 0 ? { payload_trimmed: true } : {},
     ...payloadOverBudget ? { payload_over_budget: true } : {}
   };
@@ -3080,10 +3465,38 @@ function partitionEmptyShells(items) {
 }
 var bm25ModelCache = null;
 var bm25BuildCount = 0;
-function getOrBuildBm25Model(revision, rawItems, docTexts) {
+var BM25_CACHE_DIR = ".fabric/cache/bm25";
+function bm25CachePath(projectRoot, revision) {
+  const safe = revision.replace(/[^A-Za-z0-9_-]/g, "_");
+  return join10(projectRoot, BM25_CACHE_DIR, `${safe}.json`);
+}
+async function loadBm25ModelFromDisk(projectRoot, revision) {
+  try {
+    const raw = await readFile7(bm25CachePath(projectRoot, revision), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== 1) return null;
+    return rehydrateBm25Model(parsed);
+  } catch {
+    return null;
+  }
+}
+async function saveBm25ModelToDisk(projectRoot, revision, model) {
+  try {
+    const path = bm25CachePath(projectRoot, revision);
+    await mkdir5(join10(projectRoot, BM25_CACHE_DIR), { recursive: true });
+    await writeFile3(path, JSON.stringify(serializeBm25Model(model)), "utf8");
+  } catch {
+  }
+}
+async function getOrBuildBm25Model(projectRoot, revision, rawItems, docTexts) {
   if (bm25ModelCache !== null && bm25ModelCache.revision === revision) {
     return bm25ModelCache.model;
   }
+  const fromDisk = await loadBm25ModelFromDisk(projectRoot, revision);
+  if (fromDisk !== null) {
+    bm25ModelCache = { revision, model: fromDisk };
+    return fromDisk;
+  }
   bm25BuildCount += 1;
   const model = buildBm25Model(
     rawItems.map((item) => ({
@@ -3092,6 +3505,7 @@ function getOrBuildBm25Model(revision, rawItems, docTexts) {
     }))
   );
   bm25ModelCache = { revision, model };
+  await saveBm25ModelToDisk(projectRoot, revision, model);
   return model;
 }
 function compareStableIds(a, b) {
@@ -3111,7 +3525,7 @@ function buildScopeRankMap(items, projectRoot) {
     const colon = it.stable_id.indexOf(":");
     const alias = colon === -1 ? "" : it.stable_id.slice(0, colon);
     const localId = colon === -1 ? it.stable_id : it.stable_id.slice(colon + 1);
-    const semanticScope = it.description.semantic_scope ?? it.description.knowledge_layer ?? "team";
+    const semanticScope = it.description.semantic_scope ?? layerFromStableId(it.stable_id);
     return {
       global_ref: it.stable_id,
       store_uuid: aliasToUuid.get(alias) ?? alias,
@@ -3137,6 +3551,103 @@ function compareScopeThenId(left, right, scopeRank) {
   }
   return compareStableIds(left.stable_id, right.stable_id);
 }
+async function buildScoringContext(projectRoot, revision, rawItems, opts) {
+  const scoringContext = {
+    nowMs: Date.now(),
+    targetPaths: opts.targetPaths,
+    queryTerms: buildQueryTerms(opts.queryText),
+    // PLN-004 F1: resolve the credibility half-lives + floors ONCE here (never per
+    // candidate) so credibilityFactor is a pure lookup on the ranking hot path.
+    credibilityHalfLives: readCredibilityHalfLives(projectRoot),
+    credibilityFloors: readCredibilityFloors(projectRoot)
+  };
+  const docTexts = /* @__PURE__ */ new Map();
+  for (const item of rawItems) {
+    docTexts.set(item.stable_id, documentTextForItem(item.description));
+  }
+  scoringContext.docTexts = docTexts;
+  if (scoringContext.queryTerms.length > 0 && rawItems.length > 0) {
+    scoringContext.bm25 = await getOrBuildBm25Model(projectRoot, revision, rawItems, docTexts);
+  }
+  scoringContext.scopeRank = buildScopeRankMap(rawItems, projectRoot);
+  const embedConfig = readEmbedConfig(projectRoot);
+  if (embedConfig.enabled && opts.queryText.trim().length > 0 && rawItems.length > 0) {
+    const embedder = await loadEmbedder(embedConfig.model);
+    const vectorScores = await buildVectorScores(
+      embedder,
+      opts.queryText,
+      rawItems.map((item) => ({
+        stable_id: item.stable_id,
+        text: docTexts.get(item.stable_id) ?? documentTextForItem(item.description)
+      })),
+      { projectRoot, corpusRevision: revision, embeddingModel: embedConfig.model }
+    );
+    if (vectorScores !== null) {
+      scoringContext.vectorScores = vectorScores;
+      scoringContext.vectorWeight = embedConfig.weight;
+    }
+  }
+  const configuredFusion = readFusion(projectRoot);
+  const vectorActive = scoringContext.vectorScores !== void 0 && scoringContext.vectorScores.size > 0;
+  scoringContext.fusion = configuredFusion === "auto" ? vectorActive ? "rrf" : "additive" : configuredFusion;
+  let queryTermWeights;
+  if (scoringContext.queryTerms.length > 0) {
+    queryTermWeights = expandQueryTerms(opts.queryText);
+  }
+  if (scoringContext.fusion === "rrf" && scoringContext.queryTerms.length > 0 && rawItems.length > 0) {
+    const rankIds = rawItems.map((item) => item.stable_id).sort((a, b) => compareStableIds(a, b));
+    if (scoringContext.bm25 !== void 0) {
+      scoringContext.bm25Ranks = rankDocuments(scoringContext.bm25, rankIds, scoringContext.queryTerms);
+    }
+    if (scoringContext.vectorScores !== void 0) {
+      scoringContext.vectorRanks = rankByScore(rankIds, scoringContext.vectorScores);
+    }
+  }
+  return scoringContext;
+}
+var PROXIMITY_WINDOW = 6;
+var PROXIMITY_BOOST_CAP = 0.15;
+function proximityBoost(item, context, contentScore2) {
+  if (contentScore2 <= 0) return 0;
+  const text = context.docTexts?.get(item.stable_id);
+  if (text === void 0 || text.length === 0) return 0;
+  const tokens = text.toLowerCase().split(/[^a-z0-9_$#]+/u).filter(Boolean);
+  const queryTerms = context.queryTerms;
+  if (queryTerms.length < 2) return 0;
+  const positions = /* @__PURE__ */ new Map();
+  for (const qt of queryTerms) {
+    const qtLower = qt.toLowerCase();
+    const pos = [];
+    for (let i = 0; i < tokens.length; i++) {
+      if (tokens[i] === qtLower) {
+        pos.push(i);
+      }
+    }
+    if (pos.length > 0) {
+      positions.set(qtLower, pos);
+    }
+  }
+  if (positions.size < 2) return 0;
+  const termList = [...positions.entries()];
+  let minDist = Infinity;
+  for (let i = 0; i < termList.length; i++) {
+    const [, posI] = termList[i];
+    for (let j = i + 1; j < termList.length; j++) {
+      const [, posJ] = termList[j];
+      for (const pi of posI) {
+        for (const pj of posJ) {
+          const dist = Math.abs(pi - pj);
+          if (dist < minDist) minDist = dist;
+        }
+      }
+    }
+  }
+  if (!Number.isFinite(minDist)) return 0;
+  if (minDist >= PROXIMITY_WINDOW) return 0;
+  const ratio = 1 - minDist / PROXIMITY_WINDOW;
+  const boost = contentScore2 * PROXIMITY_BOOST_CAP * ratio;
+  return boost;
+}
 function sortDescriptionItems(rawItems, scoringContext) {
   if (scoringContext === void 0) {
     return [...rawItems].sort((left, right) => compareStableIds(left.stable_id, right.stable_id)).map((item) => ({ item, score: 0 }));
@@ -3151,6 +3662,25 @@ function sortDescriptionItems(rawItems, scoringContext) {
   );
   return scored;
 }
+function rankDescriptionItems(items, scoringContext, mode, options = {}) {
+  const sorted = sortDescriptionItems(items, scoringContext);
+  const seen = /* @__PURE__ */ new Set();
+  const rankedScored = sorted.filter(({ item }) => {
+    if (seen.has(item.stable_id)) return false;
+    seen.add(item.stable_id);
+    return true;
+  });
+  if (mode === "triage") {
+    return rankedScored;
+  }
+  const topK = options.topK ?? rankedScored.length;
+  const cappedScored = rankedScored.slice(0, topK);
+  const relevanceRatio = options.relevanceRatio ?? 0;
+  const hasQuery = scoringContext.queryTerms.length > 0;
+  const maxScore = rankedScored.length > 0 ? rankedScored[0].score : 0;
+  const relevanceFloor = maxScore * relevanceRatio;
+  return hasQuery && maxScore > 0 && relevanceRatio > 0 ? cappedScored.filter((entry) => entry.score >= relevanceFloor) : cappedScored;
+}
 function documentTextForItem(description) {
   return [
     description.summary,
@@ -3158,17 +3688,21 @@ function documentTextForItem(description) {
     ...description.intent_clues,
     ...description.tech_stack,
     ...description.impact,
-    ...description.entities ?? [],
-    ...description.tags ?? []
+    ...description.tags ?? [],
+    // v2.2 glossary aliases (C-002): long-tail synonym terms feed the flat
+    // vector-embedding document verbatim, same as the BM25F summary slot below.
+    ...description.aliases ?? []
   ].join(" ");
 }
 function documentFieldsForItem(description) {
   return {
     title: tokenize2(description.summary),
-    tags: tokenize2(
-      [...description.tags ?? [], ...description.tech_stack, ...description.entities ?? []].join(" ")
+    tags: tokenize2([...description.tags ?? [], ...description.tech_stack].join(" ")),
+    summary: tokenize2(
+      [description.must_read_if, ...description.intent_clues, ...description.aliases ?? []].join(
+        " "
+      )
     ),
-    summary: tokenize2([description.must_read_if, ...description.intent_clues].join(" ")),
     body: tokenize2(description.impact.join(" "))
   };
 }
@@ -3199,6 +3733,9 @@ var BM25_WEIGHT = 50;
 var SALIENCE_PROVEN = 15;
 var SALIENCE_VERIFIED = 8;
 var SALIENCE_DRAFT = 0;
+var RRF_K = 10;
+var RRF_NORMALIZATION = 2e3;
+var RRF_STRUCTURAL_SCALE = 0.2;
 function salienceScore(item) {
   switch (item.description?.maturity) {
     case "proven":
@@ -3209,35 +3746,109 @@ function salienceScore(item) {
       return SALIENCE_DRAFT;
   }
 }
-function scoreDescriptionItem(item, context) {
-  let score = 0;
-  if (context.bm25 !== void 0 && context.queryTerms.length > 0) {
-    score += BM25_WEIGHT * context.bm25.scoreDoc(item.stable_id, context.queryTerms);
+function contentScore(item, context) {
+  const hasQuery = context.queryTerms.length > 0;
+  if (context.fusion === "rrf" && hasQuery) {
+    let rrf = 0;
+    const bm25Rank = context.bm25Ranks?.get(item.stable_id);
+    if (bm25Rank !== void 0) rrf += 1 / (RRF_K + bm25Rank);
+    const vectorRank = context.vectorRanks?.get(item.stable_id);
+    if (vectorRank !== void 0) rrf += 1 / (RRF_K + vectorRank);
+    return RRF_NORMALIZATION * rrf;
+  }
+  let content = 0;
+  if (context.bm25 !== void 0 && hasQuery) {
+    content += BM25_WEIGHT * context.bm25.scoreDoc(item.stable_id, context.queryTerms);
   }
   if (context.vectorScores !== void 0) {
-    score += (context.vectorWeight ?? 0) * (context.vectorScores.get(item.stable_id) ?? 0);
+    content += (context.vectorWeight ?? 0) * (context.vectorScores.get(item.stable_id) ?? 0);
   }
-  score += salienceScore(item);
+  return content;
+}
+function recencyBoost(item, context) {
   const createdAtRaw = item.description?.created_at;
   if (typeof createdAtRaw === "string" && createdAtRaw.length > 0) {
     const createdMs = Date.parse(createdAtRaw);
     if (Number.isFinite(createdMs) && context.nowMs - createdMs < RECENCY_WINDOW_MS) {
-      score += RECENCY_BOOST;
+      return RECENCY_BOOST;
     }
   }
-  if (context.targetPaths.length > 0) {
-    const relevancePaths = item.description?.relevance_paths ?? [];
-    let best = 0;
-    outer: for (const rp of relevancePaths) {
-      for (const tp of context.targetPaths) {
-        const tier = localityTier(rp, tp);
-        if (tier > best) best = tier;
-        if (best === LOCALITY_SAME_FILE) break outer;
-      }
+  return 0;
+}
+function localityBoost(item, context) {
+  if (context.targetPaths.length === 0) return 0;
+  const relevancePaths = item.description?.relevance_paths ?? [];
+  let best = 0;
+  outer: for (const rp of relevancePaths) {
+    for (const tp of context.targetPaths) {
+      const tier = localityTier(rp, tp);
+      if (tier > best) best = tier;
+      if (best === LOCALITY_SAME_FILE) break outer;
     }
-    score += best;
   }
-  return score;
+  return best;
+}
+function structuralScaleFor(context) {
+  return context.fusion === "rrf" && context.queryTerms.length > 0 ? RRF_STRUCTURAL_SCALE : 1;
+}
+function credibilityFactor(item, context) {
+  const halfLives = context.credibilityHalfLives;
+  const floors = context.credibilityFloors;
+  if (halfLives === void 0 || floors === void 0) return 1;
+  const createdAtRaw = item.description?.created_at;
+  if (typeof createdAtRaw !== "string" || createdAtRaw.length === 0) return 1;
+  const createdMs = Date.parse(createdAtRaw);
+  if (!Number.isFinite(createdMs)) return 1;
+  const ageDays = (context.nowMs - createdMs) / (24 * 60 * 60 * 1e3);
+  if (ageDays <= 0) return 1;
+  const type = item.description?.knowledge_type;
+  const halfLife = type !== void 0 ? halfLives[type] : halfLives.decisions;
+  const factor = Math.pow(2, -ageDays / halfLife);
+  const maturity = item.description?.maturity;
+  const floor = maturity !== void 0 ? floors[maturity] : floors.draft;
+  return Math.max(floor, Math.min(1, factor));
+}
+function scoreDescriptionItem(item, context) {
+  const content = contentScore(item, context);
+  const structural = salienceScore(item) + recencyBoost(item, context) + localityBoost(item, context);
+  const proximity = proximityBoost(item, context, content);
+  return (content + structuralScaleFor(context) * structural + proximity) * credibilityFactor(item, context);
+}
+function scoreBreakdownForItem(item, context) {
+  const hasQuery = context.queryTerms.length > 0;
+  const rrfMode = context.fusion === "rrf" && hasQuery;
+  let bm25 = 0;
+  let vector = 0;
+  let bm25Rank;
+  let vectorRank;
+  if (rrfMode) {
+    bm25Rank = context.bm25Ranks?.get(item.stable_id);
+    if (bm25Rank !== void 0) bm25 = RRF_NORMALIZATION * (1 / (RRF_K + bm25Rank));
+    vectorRank = context.vectorRanks?.get(item.stable_id);
+    if (vectorRank !== void 0) vector = RRF_NORMALIZATION * (1 / (RRF_K + vectorRank));
+  } else {
+    bm25 = context.bm25 !== void 0 && hasQuery ? BM25_WEIGHT * context.bm25.scoreDoc(item.stable_id, context.queryTerms) : 0;
+    vector = context.vectorScores !== void 0 ? (context.vectorWeight ?? 0) * (context.vectorScores.get(item.stable_id) ?? 0) : 0;
+  }
+  const scale = structuralScaleFor(context);
+  const salience = salienceScore(item) * scale;
+  const recency = recencyBoost(item, context) * scale;
+  const locality = localityBoost(item, context) * scale;
+  const proximity = proximityBoost(item, context, bm25 + vector);
+  const credibility = credibilityFactor(item, context);
+  const final = (bm25 + vector + salience + recency + locality + proximity) * credibility;
+  return {
+    final,
+    ...bm25 !== 0 ? { bm25 } : {},
+    ...bm25Rank !== void 0 ? { bm25_rank: bm25Rank } : {},
+    ...vector !== 0 ? { vector } : {},
+    ...vectorRank !== void 0 ? { vector_rank: vectorRank } : {},
+    salience,
+    recency,
+    locality,
+    proximity,
+    credibility
+  };
 }
 function localityTier(relevancePath, targetPath) {
   if (relevancePath === targetPath) return LOCALITY_SAME_FILE;
@@ -3274,7 +3885,13 @@ function relatedLookupKeys(stableId) {
 var RECALL_DIRECTIVE = "These entries are auto-accounted as citations for edits whose paths overlap this recall \u2014 no first-line cite needed. Speak up only to dismiss one you judge inapplicable: `dismissed: <id> (<reason>)`.";
 async function recall(projectRoot, input) {
   const planResult = await planContext(projectRoot, input);
-  const { selection_token: _token, payload_trimmed: _pt, payload_over_budget: _pob, ...planRest } = planResult;
+  const {
+    selection_token: _token,
+    payload_trimmed: _pt,
+    payload_over_budget: _pob,
+    candidate_scores: candidateScores,
+    ...planRest
+  } = planResult;
   let bodyIndex;
   try {
     bodyIndex = await buildCrossStoreBodyIndex(projectRoot);
@@ -3323,13 +3940,15 @@ async function recall(projectRoot, input) {
   const pathByStableId = new Map(paths.map((p) => [p.stable_id, p]));
   const entries = planRest.candidates.map((c, index) => {
     const readPath = pathByStableId.get(c.stable_id);
+    const scored = candidateScores?.get(c.stable_id);
     return {
       stable_id: c.stable_id,
       rank: index + 1,
-      description: c.description,
+      description: slimDescription(c.description),
       ...readPath ? { read_path: readPath.path } : {},
       ...readPath?.store ? { store: readPath.store } : {},
-      ...isAlwaysActive(c) ? { body_in_context: true } : {}
+      ...isAlwaysActive(c) ? { body_in_context: true } : {},
+      ...scored ? { score: scored.score, score_breakdown: scored.score_breakdown } : {}
     };
   });
   const { entries: _reqProfiles, candidates: _candidates, ...planRestNoLists } = planRest;
@@ -3345,6 +3964,14 @@ function isAlwaysActive(candidate) {
   const { relevance_scope, knowledge_type } = candidate.description;
   return (relevance_scope ?? "broad") !== "narrow" && ALWAYS_ACTIVE_TYPES2.has(knowledge_type ?? "");
 }
+function slimDescription(d) {
+  return {
+    summary: d.summary,
+    must_read_if: d.must_read_if,
+    intent_clues: d.intent_clues,
+    ...d.knowledge_type !== void 0 ? { knowledge_type: d.knowledge_type } : {}
+  };
+}
 function buildNextSteps(planResult, paths, candidateById, candidateLookup) {
   const nextSteps = [];
   const omitted = (planResult.dropped ?? []).filter((d) => d.reason === "retrieval_budget").length;
@@ -3489,22 +4116,8 @@ import {
 import { enforcePayloadLimit as enforcePayloadLimit3 } from "@fenglimg/fabric-shared/node/mcp-payload-guard";
 
 // src/services/archive-scan.ts
+import { isHighValueArchiveCandidate } from "@fenglimg/fabric-shared";
 var ANTI_LOOP_HOURS = 12;
-var HIGH_VALUE_EVENT_TYPES = /* @__PURE__ */ new Set([
-  "knowledge_context_planned",
-  "edit_paths_recorded",
-  "edit_intent_checked"
-  // the real high-freq edit signal (rc.37 NEW-14/B3)
-]);
-var NORMATIVE_KEYWORDS = [
-  "\u4EE5\u540E",
-  "always",
-  "never",
-  "from now on",
-  "\u4E0B\u6B21",
-  "\u8BB0\u4E00\u4E0B",
-  "\u6C38\u8FDC\u4E0D\u8981"
-];
 var PROPOSED_KEYS_WINDOW_MS = 30 * 24 * 60 * 60 * 1e3;
 async function collectArchiveScan(projectRoot, input = {}) {
   const nowMs = typeof input.now_ms === "number" ? input.now_ms : Date.now();
@@ -3572,7 +4185,7 @@ async function collectArchiveScan(projectRoot, input = {}) {
       continue;
     }
     if (typeof attempt.covered_through_ts === "number") {
-      if (hasHighValueSignal(events, sid, attempt.covered_through_ts)) {
+      if (isHighValueArchiveCandidate(events, sid, attempt.covered_through_ts)) {
         kept.push(sid);
       } else {
         dropped.push({ session_id: sid, reason: "no_new_signal" });
@@ -3598,28 +4211,6 @@ async function collectArchiveScan(projectRoot, input = {}) {
     already_proposed_keys: [...proposedKeys]
   };
 }
-function hasHighValueSignal(events, sessionId, watermarkTs) {
-  let latestTurn = null;
-  for (const e of events) {
-    if (e.session_id !== sessionId) continue;
-    if (typeof e.ts !== "number" || e.ts <= watermarkTs) continue;
-    if (typeof e.event_type === "string" && HIGH_VALUE_EVENT_TYPES.has(e.event_type)) {
-      return true;
-    }
-    if (e.event_type === "assistant_turn_observed") {
-      if (!latestTurn || typeof latestTurn.ts === "number" && e.ts > latestTurn.ts) {
-        latestTurn = e;
-      }
-    }
-  }
-  if (latestTurn) {
-    const haystack = JSON.stringify(latestTurn).toLowerCase();
-    for (const kw of NORMATIVE_KEYWORDS) {
-      if (haystack.includes(kw.toLowerCase())) return true;
-    }
-  }
-  return false;
-}
 
 // src/tools/archive-scan.ts
 function registerArchiveScan(server, tracker) {
@@ -3679,9 +4270,9 @@ import { enforcePayloadLimit as enforcePayloadLimit4 } from "@fenglimg/fabric-sh
 // src/services/review.ts
 import { execFileSync } from "child_process";
 import { existsSync as existsSync5 } from "fs";
-import { readFile as readFile6, readdir as readdir2, stat as stat2, unlink as unlink2 } from "fs/promises";
+import { readFile as readFile9, readdir as readdir2, stat as stat2, unlink as unlink2 } from "fs/promises";
 import { homedir } from "os";
-import { basename, isAbsolute, join as join10, relative, resolve as resolve2, sep as sep2 } from "path";
+import { basename, isAbsolute, join as join12, relative, resolve as resolve2, sep as sep2 } from "path";
 
 // src/services/promotion-gate.ts
 function toLocalId(id) {
@@ -3717,12 +4308,12 @@ async function hasUnresolvedDismissal(projectRoot, id) {
 }
 
 // src/services/review.ts
-import { allocateStoreKnowledgeId, isPersonalScope as isPersonalScope2 } from "@fenglimg/fabric-shared";
+import { allocateStoreKnowledgeId, isPersonalScope as isPersonalScope2, loadProjectConfig as loadProjectConfig3 } from "@fenglimg/fabric-shared";
 
 // src/services/pending-dedupe.ts
 import { existsSync as existsSync4 } from "fs";
-import { readdir, readFile as readFile5, unlink } from "fs/promises";
-import { join as join9 } from "path";
+import { readdir, readFile as readFile8, unlink } from "fs/promises";
+import { join as join11 } from "path";
 var PENDING_TYPES = ["decisions", "pitfalls", "guidelines", "models", "processes"];
 var DISAMBIGUATION_SUFFIX = /^(.+)-([2-9])\.md$/u;
 var SOURCE_SESSIONS_LINE = /^source_sessions:\s*\[(.*)\]\s*$/mu;
@@ -3795,7 +4386,7 @@ async function mergePendingTwins(projectRoot) {
       continue;
     }
     for (const type of PENDING_TYPES) {
-      const dir = join9(pendingBase2, type);
+      const dir = join11(pendingBase2, type);
       if (!existsSync4(dir)) continue;
       let names;
       try {
@@ -3816,10 +4407,10 @@ async function mergePendingTwins(projectRoot) {
         if (groupNames.length < 2) continue;
         const parsed = [];
         for (const name of groupNames) {
-          const abs = join9(dir, name);
+          const abs = join11(dir, name);
           let content;
           try {
-            content = await readFile5(abs, "utf8");
+            content = await readFile8(abs, "utf8");
           } catch {
             continue;
           }
@@ -3919,7 +4510,7 @@ async function reviewPending(projectRoot, input) {
     case "search":
       return {
         action: "search",
-        items: await searchEntries(projectRoot, input.query, input.filters)
+        items: await triageSearch(projectRoot, input.query, input.filters)
       };
     default: {
       const exhaustive = input;
@@ -3999,7 +4590,7 @@ async function listPending(projectRoot, filters) {
   }
   for (const source of sources) {
     for (const type of typesToScan) {
-      const dir = join10(source.root, type);
+      const dir = join12(source.root, type);
       if (!existsSync5(dir)) {
         continue;
       }
@@ -4011,10 +4602,10 @@ async function listPending(projectRoot, filters) {
       }
       for (const name of entries) {
         if (!name.endsWith(".md")) continue;
-        const absolutePath = join10(dir, name);
+        const absolutePath = join12(dir, name);
         let content;
         try {
-          content = await readFile6(absolutePath, "utf8");
+          content = await readFile9(absolutePath, "utf8");
         } catch {
           continue;
         }
@@ -4124,7 +4715,7 @@ async function approveOne(projectRoot, pendingPath) {
   let targetAbs;
   let writtenTarget = false;
   try {
-    const content = await readFile6(sourceAbs, "utf8");
+    const content = await readFile9(sourceAbs, "utf8");
     const fm = parseFrontmatter(content);
     const pluralType = fm.type;
     if (pluralType === void 0 || !PLURAL_TYPES.includes(pluralType)) {
@@ -4138,7 +4729,12 @@ async function approveOne(projectRoot, pendingPath) {
     );
     allocatedId = stableId;
     const newFilename = `${stableId}--${slug}.md`;
-    targetAbs = join10(resolveStoreCanonicalBase(layer, projectRoot), pluralType, newFilename);
+    const promoteProject = layer === "team" ? loadProjectConfig3(projectRoot)?.active_project : void 0;
+    targetAbs = join12(
+      resolveStoreCanonicalBase(layer, projectRoot, promoteProject),
+      pluralType,
+      newFilename
+    );
     await ensureParentDirectory(targetAbs);
     const rewritten = rewriteFrontmatterMerge(
       rewriteFrontmatterForPromote(content, stableId),
@@ -4196,7 +4792,7 @@ async function rejectAll(projectRoot, pendingPaths, reason) {
     try {
       const sandboxed = resolveSandboxedPath(projectRoot, pendingPath, { allowPersonal: true });
       if (existsSync5(sandboxed.abs)) {
-        const content = await readFile6(sandboxed.abs, "utf8");
+        const content = await readFile9(sandboxed.abs, "utf8");
         const merged = rewriteFrontmatterMerge(content, { status: "rejected" });
         const rejectedAbs = sandboxed.abs.includes(`${sep2}pending${sep2}`) ? sandboxed.abs.replace(`${sep2}pending${sep2}`, `${sep2}rejected${sep2}`) : null;
         if (rejectedAbs !== null) {
@@ -4223,7 +4819,7 @@ async function modifyEntry(projectRoot, pendingPath, changes) {
   if (target === null) {
     throw new Error(`modify target not found: ${pendingPath}`);
   }
-  const content = await readFile6(target.absPath, "utf8");
+  const content = await readFile9(target.absPath, "utf8");
   const fm = parseFrontmatter(content);
   const currentLayer = fm.layer ?? "team";
   if (fm.maturity === "verified" && changes.maturity === "proven" && fm.id !== void 0) {
@@ -4325,8 +4921,9 @@ async function modifyLayerFlip(projectRoot, target, content, fm, changes) {
     pluralType,
     resolveWriteTargetStoreDir(toLayer, projectRoot)
   );
-  const toAbs = join10(
-    resolveStoreCanonicalBase(toLayer, projectRoot),
+  const flipProject = toLayer === "team" ? loadProjectConfig3(projectRoot)?.active_project : void 0;
+  const toAbs = join12(
+    resolveStoreCanonicalBase(toLayer, projectRoot, flipProject),
     pluralType,
     `${newStableId}--${slug}.md`
   );
@@ -4348,20 +4945,22 @@ async function modifyLayerFlip(projectRoot, target, content, fm, changes) {
     { ...effectivePatch, last_review_confirmed_at: (/* @__PURE__ */ new Date()).toISOString() },
     { id: newStableId }
   );
-  await atomicWriteText(toAbs, rewritten);
+  let moved = false;
   if (target.isInProjectTree) {
     const relSource = relative(projectRoot, target.absPath);
+    const relDest = relative(projectRoot, toAbs);
     try {
-      execFileSync("git", ["rm", "--quiet", "-f", relSource], {
+      execFileSync("git", ["mv", "-f", relSource, relDest], {
         cwd: projectRoot,
         stdio: ["ignore", "pipe", "pipe"]
       });
+      moved = true;
     } catch {
-      if (existsSync5(target.absPath)) {
-        await unlink2(target.absPath);
-      }
+      moved = false;
     }
-  } else if (existsSync5(target.absPath)) {
+  }
+  await atomicWriteText(toAbs, rewritten);
+  if (!moved && existsSync5(target.absPath) && target.absPath !== toAbs) {
     await unlink2(target.absPath);
   }
   const flipReason = `layer_flip:${priorStableId ?? "<unassigned>"}->${newStableId}`;
@@ -4425,7 +5024,7 @@ function getSearchDirectoryCache(cacheKey) {
   return created;
 }
 async function listIndexedSearchEntries(source, type) {
-  const dir = join10(source.root, type);
+  const dir = join12(source.root, type);
   let entries;
   try {
     entries = await readdir2(dir);
@@ -4438,7 +5037,7 @@ async function listIndexedSearchEntries(source, type) {
   const indexed = [];
   for (const name of entries) {
     if (!name.endsWith(".md")) continue;
-    const absolutePath = join10(dir, name);
+    const absolutePath = join12(dir, name);
     let fingerprint;
     try {
       const st = await stat2(absolutePath);
@@ -4455,7 +5054,7 @@ async function listIndexedSearchEntries(source, type) {
     }
     let content;
     try {
-      content = await readFile6(absolutePath, "utf8");
+      content = await readFile9(absolutePath, "utf8");
       searchEntryIndexContentReads += 1;
     } catch {
       directoryCache.files.delete(absolutePath);
@@ -4482,9 +5081,42 @@ async function listIndexedSearchEntries(source, type) {
   }
   return indexed;
 }
-async function searchEntries(projectRoot, query, filters) {
+function matchesTriageQuery(indexed, lowerQuery, includeBody) {
+  const haystacks = [
+    indexed.fm.title ?? "",
+    indexed.fm.summary ?? "",
+    ...indexed.fm.tags ?? [],
+    indexed.name,
+    includeBody ? indexed.body : ""
+  ].map((s) => s.toLowerCase());
+  return haystacks.some((h) => h.includes(lowerQuery));
+}
+function pendingEntryToRankerItem(indexed) {
+  const { fm, name } = indexed;
+  const slug = name.replace(/\.md$/u, "");
+  const summary = fm.summary ?? fm.title ?? slug;
+  const description = {
+    summary,
+    intent_clues: [],
+    tech_stack: [],
+    impact: [],
+    must_read_if: fm.title ?? summary,
+    ...fm.id !== void 0 ? { id: fm.id } : {},
+    ...fm.type !== void 0 ? { knowledge_type: fm.type } : {},
+    maturity: fm.maturity ?? "draft",
+    // W4/Track1 (D1): no `knowledge_layer` field — layer is derived from the
+    // stable_id prefix (KT-DEC-0004), never carried on the description.
+    ...fm.semantic_scope !== void 0 ? { semantic_scope: fm.semantic_scope } : {},
+    ...fm.created_at !== void 0 ? { created_at: fm.created_at } : {},
+    tags: fm.tags ?? [],
+    relevance_scope: fm.relevance_scope ?? "broad",
+    relevance_paths: fm.relevance_paths ?? []
+  };
+  return { stable_id: indexed.absolutePath, description };
+}
+async function triageSearch(projectRoot, query, filters) {
   const lowerQuery = query.toLowerCase();
-  const items = [];
+  const includeBody = filters?.include_body === true;
   const sources = [];
   for (const layer of ["team", "personal"]) {
     const isPersonal = layer === "personal";
@@ -4507,10 +5139,12 @@ async function searchEntries(projectRoot, query, filters) {
     }
   }
   const typesToScan = filters?.type !== void 0 ? [filters.type] : PLURAL_TYPES;
+  const matchedByKey = /* @__PURE__ */ new Map();
+  const rankerItems = [];
   for (const source of sources) {
     for (const type of typesToScan) {
       for (const indexed of await listIndexedSearchEntries(source, type)) {
-        const { absolutePath, fm, layer, maturity, name } = indexed;
+        const { fm, layer, maturity } = indexed;
         if (filters?.layer !== void 0 && filters.layer !== "both" && filters.layer !== layer) {
           continue;
         }
@@ -4531,42 +5165,56 @@ async function searchEntries(projectRoot, query, filters) {
         if (!isVisibleByLifecycle(fm, filters)) {
           continue;
         }
-        const bodyForSearch = filters?.include_body === true ? indexed.body : "";
-        const haystacks = [
-          fm.title ?? "",
-          fm.summary ?? "",
-          ...fm.tags ?? [],
-          name,
-          bodyForSearch
-        ].map((s) => s.toLowerCase());
-        const matches = haystacks.some((h) => h.includes(lowerQuery));
-        if (!matches) continue;
-        const reportedPath = source.isStore ? absolutePath : source.isPersonal ? `~/${relative(resolvePersonalRoot(), absolutePath)}` : relative(projectRoot, absolutePath);
-        items.push({
-          area: source.isPending ? "pending" : "canonical",
-          path: reportedPath,
-          ...source.isPersonal ? { path_absolute: absolutePath } : {},
-          type,
-          layer,
-          maturity,
-          // Only pending entries carry an origin tag (canonical hits live
-          // outside the dual-pending-root convention).
-          ...source.isPending ? { origin: source.isPersonal ? "personal" : "team" } : {},
-          ...fm.tags !== void 0 && fm.tags.length > 0 ? { tags: fm.tags } : {},
-          ...fm.title !== void 0 ? { title: fm.title } : {},
-          ...fm.summary !== void 0 ? { summary: fm.summary } : {},
-          ...fm.status !== void 0 ? { status: fm.status } : {},
-          ...fm.deferred_until !== void 0 ? { deferred_until: fm.deferred_until } : {},
-          // v2.0.0-rc.27 TASK-006 (audit §2.23): body emission when opted in.
-          ...filters?.include_body === true ? { body: bodyForSearch } : {},
-          // Canonical hits always have an id; pending hits typically don't
-          // yet — surface the frontmatter id when present so consumers can
-          // dedupe across runs.
-          ...fm.id !== void 0 ? { stable_id: fm.id } : {}
-        });
+        if (!matchesTriageQuery(indexed, lowerQuery, includeBody)) continue;
+        const item = pendingEntryToRankerItem(indexed);
+        matchedByKey.set(item.stable_id, { indexed, source, type });
+        rankerItems.push(item);
       }
     }
   }
+  if (rankerItems.length === 0) {
+    return [];
+  }
+  let revision;
+  try {
+    revision = await computeReadSetRevision(projectRoot);
+  } catch {
+    revision = "triage-search";
+  }
+  const scoringContext = await buildScoringContext(projectRoot, revision, rankerItems, {
+    queryText: query,
+    targetPaths: []
+  });
+  const ranked = rankDescriptionItems(rankerItems, scoringContext, "triage");
+  const items = [];
+  for (const { item } of ranked) {
+    const match = matchedByKey.get(item.stable_id);
+    if (match === void 0) continue;
+    const { indexed, source, type } = match;
+    const { absolutePath, fm, layer, maturity } = indexed;
+    const reportedPath = source.isStore ? absolutePath : source.isPersonal ? `~/${relative(resolvePersonalRoot(), absolutePath)}` : relative(projectRoot, absolutePath);
+    items.push({
+      area: source.isPending ? "pending" : "canonical",
+      path: reportedPath,
+      ...source.isPersonal ? { path_absolute: absolutePath } : {},
+      type,
+      layer,
+      maturity,
+      // Only pending entries carry an origin tag (canonical hits live
+      // outside the dual-pending-root convention).
+      ...source.isPending ? { origin: source.isPersonal ? "personal" : "team" } : {},
+      ...fm.tags !== void 0 && fm.tags.length > 0 ? { tags: fm.tags } : {},
+      ...fm.title !== void 0 ? { title: fm.title } : {},
+      ...fm.summary !== void 0 ? { summary: fm.summary } : {},
+      ...fm.status !== void 0 ? { status: fm.status } : {},
+      ...fm.deferred_until !== void 0 ? { deferred_until: fm.deferred_until } : {},
+      // v2.0.0-rc.27 TASK-006 (audit §2.23): body emission when opted in.
+      ...includeBody ? { body: indexed.body } : {},
+      // Canonical hits always have an id; pending hits typically don't yet —
+      // surface the frontmatter id when present so consumers can dedupe.
+      ...fm.id !== void 0 ? { stable_id: fm.id } : {}
+    });
+  }
   return items;
 }
 async function deferAll(projectRoot, pendingPaths, until, reason) {
@@ -4576,7 +5224,7 @@ async function deferAll(projectRoot, pendingPaths, until, reason) {
     try {
       const sandboxed = resolveSandboxedPath(projectRoot, pendingPath, { allowPersonal: true });
       if (existsSync5(sandboxed.abs)) {
-        const content = await readFile6(sandboxed.abs, "utf8");
+        const content = await readFile9(sandboxed.abs, "utf8");
         stableId = parseFrontmatter(content).id;
         const patch = {
           status: "deferred",
@@ -4737,6 +5385,9 @@ ${content}`;
   if (patch.relevance_paths !== void 0) updates.relevance_paths = `relevance_paths: ${flowArray(patch.relevance_paths)}`;
   if (patch.semantic_scope !== void 0) updates.semantic_scope = `semantic_scope: ${patch.semantic_scope}`;
   if (patch.related !== void 0) updates.related = `related: ${flowArray(patch.related)}`;
+  if (patch.must_read_if !== void 0) updates.must_read_if = `must_read_if: ${quoteIfNeeded(patch.must_read_if)}`;
+  if (patch.intent_clues !== void 0) updates.intent_clues = `intent_clues: ${flowArray(patch.intent_clues)}`;
+  if (patch.impact !== void 0) updates.impact = `impact: ${flowArray(patch.impact)}`;
   if (patch.status !== void 0) updates.status = `status: ${patch.status}`;
   if (patch.deferred_until !== void 0) updates.deferred_until = `deferred_until: ${quoteIfNeeded(patch.deferred_until)}`;
   if (patch.last_review_confirmed_at !== void 0) updates.last_review_confirmed_at = `last_review_confirmed_at: ${quoteIfNeeded(patch.last_review_confirmed_at)}`;
@@ -4774,6 +5425,9 @@ function appendPatchLines(lines, patch) {
   if (patch.relevance_scope !== void 0) lines.push(`relevance_scope: ${patch.relevance_scope}`);
   if (patch.relevance_paths !== void 0) lines.push(`relevance_paths: ${flowArray(patch.relevance_paths)}`);
   if (patch.related !== void 0) lines.push(`related: ${flowArray(patch.related)}`);
+  if (patch.must_read_if !== void 0) lines.push(`must_read_if: ${quoteIfNeeded(patch.must_read_if)}`);
+  if (patch.intent_clues !== void 0) lines.push(`intent_clues: ${flowArray(patch.intent_clues)}`);
+  if (patch.impact !== void 0) lines.push(`impact: ${flowArray(patch.impact)}`);
   if (patch.status !== void 0) lines.push(`status: ${patch.status}`);
   if (patch.deferred_until !== void 0) lines.push(`deferred_until: ${quoteIfNeeded(patch.deferred_until)}`);
   if (patch.last_review_confirmed_at !== void 0) lines.push(`last_review_confirmed_at: ${quoteIfNeeded(patch.last_review_confirmed_at)}`);
@@ -4917,9 +5571,9 @@ function registerPending(server, tracker) {
 }
 
 // src/services/doctor.ts
-import { access as access4, readFile as readFile16, readdir as readdirAsync, stat as statAsync, unlink as unlink4, writeFile as writeFile3 } from "fs/promises";
+import { access as access4, readFile as readFile19, readdir as readdirAsync, stat as statAsync, unlink as unlink4, writeFile as writeFile5 } from "fs/promises";
 import { constants as constants2 } from "fs";
-import { isAbsolute as isAbsolute2, join as join21, posix as posix5, resolve as resolve3 } from "path";
+import { isAbsolute as isAbsolute2, join as join24, posix as posix5, resolve as resolve3 } from "path";
 import {
   createTranslator,
   forensicReportSchema,
@@ -5027,6 +5681,7 @@ function createGlobalCliVersionCheck(t, inspection) {
 }
 
 // src/services/doctor-health.ts
+import { isHighValueArchiveCandidate as isHighValueArchiveCandidate2 } from "@fenglimg/fabric-shared";
 var DOCTOR_HEALTH_PENALTY_MANUAL_ERROR = 15;
 var DOCTOR_HEALTH_PENALTY_FIXABLE_ERROR = 8;
 var DOCTOR_HEALTH_PENALTY_WARNING = 3;
@@ -5046,6 +5701,64 @@ function computeDoctorHealth(manualErrorCount, fixableErrorCount, warningCount)
     }
   };
 }
+async function checkBacklogAge(projectRoot, nowMs = Date.now()) {
+  const empty = {
+    count: 0,
+    oldest_days: null,
+    median_age_days: 0,
+    ages_days: []
+  };
+  let events = [];
+  try {
+    const result = await readEventLedger(projectRoot);
+    events = result.events;
+  } catch {
+    return empty;
+  }
+  if (!Array.isArray(events) || events.length === 0) return empty;
+  const sids = /* @__PURE__ */ new Set();
+  const lastAttemptCoveredThrough = /* @__PURE__ */ new Map();
+  const firstEventTs = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (typeof e.session_id !== "string" || e.session_id.length === 0) continue;
+    if (typeof e.ts !== "number") continue;
+    sids.add(e.session_id);
+    const priorFirst = firstEventTs.get(e.session_id);
+    if (priorFirst === void 0 || e.ts < priorFirst) {
+      firstEventTs.set(e.session_id, e.ts);
+    }
+    if (e.event_type === "session_archive_attempted" && typeof e.covered_through_ts === "number") {
+      const prior = lastAttemptCoveredThrough.get(e.session_id);
+      if (prior === void 0 || e.ts > prior) {
+        lastAttemptCoveredThrough.set(e.session_id, e.covered_through_ts);
+      }
+    }
+  }
+  const agesMs = [];
+  for (const sid of sids) {
+    const watermark = lastAttemptCoveredThrough.get(sid) ?? null;
+    if (!isHighValueArchiveCandidate2(events, sid, watermark)) continue;
+    const first = firstEventTs.get(sid);
+    if (typeof first !== "number") continue;
+    const ageMs = Math.max(0, nowMs - first);
+    agesMs.push(ageMs);
+  }
+  if (agesMs.length === 0) return empty;
+  const agesDays = agesMs.map((ms) => Math.floor(ms / 864e5));
+  agesDays.sort((a, b) => a - b);
+  const oldestDays = agesDays[agesDays.length - 1];
+  const medianAgeDays = agesDays.length % 2 === 1 ? agesDays[Math.floor(agesDays.length / 2)] : Math.floor((agesDays[agesDays.length / 2 - 1] + agesDays[agesDays.length / 2]) / 2);
+  return {
+    count: agesDays.length,
+    oldest_days: oldestDays,
+    median_age_days: medianAgeDays,
+    ages_days: agesDays
+  };
+}
+function renderBacklogAgeLine(metric) {
+  if (metric.count === 0) return "  backlog: 0 high-value";
+  return `  backlog: ${metric.count} high-value, oldest ${metric.oldest_days}d`;
+}
 
 // src/services/doctor-summary-opaque.ts
 var KNOWLEDGE_SUMMARY_OPAQUE_THRESHOLD = 0.3;
@@ -5133,13 +5846,13 @@ function createKnowledgeSummaryOpaqueCheck(t, inspection) {
 }
 
 // src/services/doctor-stable-id-collision.ts
-import { readFile as readFile7 } from "fs/promises";
-import { basename as basename2, join as join11 } from "path";
+import { readFile as readFile10 } from "fs/promises";
+import { basename as basename2, join as join13 } from "path";
 import {
   buildStoreResolveInput as buildStoreResolveInput4,
   createStoreResolver as createStoreResolver4,
   readKnowledgeAcrossStores as readKnowledgeAcrossStores2,
-  resolveGlobalRoot as resolveGlobalRoot3,
+  resolveGlobalRoot as resolveGlobalRoot4,
   storeRelativePathForMount as storeRelativePathForMount3
 } from "@fenglimg/fabric-shared";
 var ID_LINE = /^id:\s*"?([^"\n]+?)"?\s*$/mu;
@@ -5155,13 +5868,13 @@ function resolveIntegrityStores(projectRoot) {
   const personalUuids = new Set(
     input.mountedStores.filter((s) => s.personal).map((s) => s.store_uuid)
   );
-  const globalRoot = resolveGlobalRoot3();
+  const globalRoot = resolveGlobalRoot4();
   const dirs = readSet.stores.map((entry) => {
     const mounted = input.mountedStores.find((s) => s.store_uuid === entry.store_uuid);
     return {
       store_uuid: entry.store_uuid,
       alias: entry.alias,
-      dir: join11(globalRoot, storeRelativePathForMount3(mounted ?? { store_uuid: entry.store_uuid }))
+      dir: join13(globalRoot, storeRelativePathForMount3(mounted ?? { store_uuid: entry.store_uuid }))
     };
   });
   return { dirs, personalUuids };
@@ -5180,7 +5893,7 @@ async function inspectStoreStableIdIntegrity(projectRoot) {
   for (const ref of await readKnowledgeAcrossStores2(resolved.dirs)) {
     let source;
     try {
-      source = await readFile7(ref.file, "utf8");
+      source = await readFile10(ref.file, "utf8");
     } catch {
       continue;
     }
@@ -5265,7 +5978,7 @@ function createLayerMismatchCheck(t, inspection) {
 // src/services/doctor-relevance-paths.ts
 import { execFileSync as execFileSync2 } from "child_process";
 import { existsSync as existsSync6, readdirSync, statSync as statSync3 } from "fs";
-import { join as join12, sep as sep3 } from "path";
+import { join as join14, sep as sep3 } from "path";
 import { minimatch } from "minimatch";
 var MS_PER_DAY = 24 * 60 * 60 * 1e3;
 var RELEVANCE_PATHS_DRIFT_WINDOW_DAYS = 90;
@@ -5308,7 +6021,7 @@ function collectWorkspacePaths(projectRoot) {
       continue;
     }
     for (const entry of entries) {
-      const abs = join12(current, entry.name);
+      const abs = join14(current, entry.name);
       const rel = toPosix(abs.slice(projectRoot.length + 1));
       if (rel.length === 0) continue;
       if (entry.isDirectory()) {
@@ -5501,16 +6214,16 @@ function createNarrowNoPathsCheck(t, inspection) {
 }
 
 // src/services/doctor-broad-index.ts
-import { readFile as readFile8 } from "fs/promises";
-import { join as join13 } from "path";
+import { readFile as readFile11 } from "fs/promises";
+import { join as join15 } from "path";
 var DEFAULT_BROAD_INDEX_BACKSTOP = 50;
 var BROAD_INDEX_BACKSTOP_MIN = 20;
 var BROAD_INDEX_BACKSTOP_MAX = 500;
 var BROAD_INDEX_DRIFT_RATIO = 0.8;
 async function readBroadIndexBackstop(projectRoot) {
-  const configPath = join13(projectRoot, ".fabric", "fabric-config.json");
+  const configPath = join15(projectRoot, ".fabric", "fabric-config.json");
   try {
-    const raw = await readFile8(configPath, "utf8");
+    const raw = await readFile11(configPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const v = parsed.broad_index_backstop;
@@ -5827,15 +6540,15 @@ function createBroadReviewRecheckCheck(t, inspection) {
 }
 
 // src/services/doctor-scope-lint.ts
-import { readFile as readFile9 } from "fs/promises";
-import { join as join14 } from "path";
+import { readFile as readFile12 } from "fs/promises";
+import { join as join16 } from "path";
 import {
   buildStoreResolveInput as buildStoreResolveInput5,
   createStoreResolver as createStoreResolver5,
   isPersonalScope as isPersonalScope3,
   readKnowledgeAcrossStores as readKnowledgeAcrossStores3,
   readStoreProjects,
-  resolveGlobalRoot as resolveGlobalRoot4,
+  resolveGlobalRoot as resolveGlobalRoot5,
   scopeRoot as scopeRoot2,
   storeRelativePathForMount as storeRelativePathForMount4
 } from "@fenglimg/fabric-shared";
@@ -5860,10 +6573,10 @@ async function resolveLintStores(projectRoot) {
   const personalUuids = new Set(
     input.mountedStores.filter((s) => s.personal).map((s) => s.store_uuid)
   );
-  const globalRoot = resolveGlobalRoot4();
+  const globalRoot = resolveGlobalRoot5();
   return Promise.all(readSet.stores.map(async (entry) => {
     const mounted = input.mountedStores.find((s) => s.store_uuid === entry.store_uuid);
-    const dir = join14(
+    const dir = join16(
       globalRoot,
       storeRelativePathForMount4(mounted ?? { store_uuid: entry.store_uuid })
     );
@@ -5895,7 +6608,7 @@ async function lintStoreScopes(projectRoot) {
     }
     let source;
     try {
-      source = await readFile9(ref.file, "utf8");
+      source = await readFile12(ref.file, "utf8");
     } catch {
       continue;
     }
@@ -5978,9 +6691,9 @@ function createScopeLintCheck(t, violations) {
 }
 
 // src/services/doctor-unbound-project.ts
-import { loadProjectConfig as loadProjectConfig3 } from "@fenglimg/fabric-shared";
+import { loadProjectConfig as loadProjectConfig4 } from "@fenglimg/fabric-shared";
 function detectUnboundProject(projectRoot) {
-  const config = loadProjectConfig3(projectRoot);
+  const config = loadProjectConfig4(projectRoot);
   const alias = config?.active_write_store;
   if (typeof alias !== "string" || alias.length === 0) {
     return null;
@@ -6016,9 +6729,56 @@ function createUnboundProjectCheck(t, violation) {
   };
 }
 
+// src/services/doctor-write-route-lint.ts
+import { loadProjectConfig as loadProjectConfig5 } from "@fenglimg/fabric-shared";
+function detectWriteRouteUnbound(projectRoot) {
+  const config = loadProjectConfig5(projectRoot);
+  const routes = config?.write_routes ?? [];
+  if (!Array.isArray(routes) || routes.length === 0) {
+    return [];
+  }
+  const boundIds = new Set(
+    (config?.required_stores ?? []).map((r) => typeof r?.id === "string" ? r.id : "").filter((id) => id.length > 0)
+  );
+  const violations = [];
+  for (const route of routes) {
+    const scope = typeof route?.scope === "string" ? route.scope : "";
+    const store = typeof route?.store === "string" ? route.store : "";
+    if (scope.length === 0 || store.length === 0) {
+      continue;
+    }
+    if (!boundIds.has(store)) {
+      violations.push({ scope, store });
+    }
+  }
+  return violations;
+}
+function createWriteRouteUnboundCheck(t, violations) {
+  if (violations.length === 0) {
+    return {
+      name: t("doctor.check.write_route_target_unbound.name"),
+      status: "ok",
+      message: t("doctor.check.write_route_target_unbound.ok")
+    };
+  }
+  const summary = violations.map((v) => `${v.scope} \u2192 ${v.store}`).join(", ");
+  return {
+    name: t("doctor.check.write_route_target_unbound.name"),
+    status: "warn",
+    kind: "warning",
+    code: "write_route_target_unbound",
+    fixable: false,
+    message: t("doctor.check.write_route_target_unbound.message", {
+      count: String(violations.length),
+      routes: summary
+    }),
+    actionHint: t("doctor.check.write_route_target_unbound.remediation")
+  };
+}
+
 // src/services/doctor-store-counters.ts
 import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
-import { join as join15 } from "path";
+import { join as join17 } from "path";
 import {
   buildStoreResolveInput as buildStoreResolveInput6,
   createStoreResolver as createStoreResolver6,
@@ -6027,8 +6787,8 @@ import {
   parseKnowledgeId as parseKnowledgeId2,
   readStoreCounters,
   reconcileStoreCounters,
-  resolveGlobalRoot as resolveGlobalRoot5,
-  STORE_KNOWLEDGE_TYPE_DIRS,
+  resolveGlobalRoot as resolveGlobalRoot6,
+  STORE_KNOWLEDGE_TYPE_DIRS as STORE_KNOWLEDGE_TYPE_DIRS2,
   STORE_LAYOUT as STORE_LAYOUT2,
   storeRelativePathForMount as storeRelativePathForMount5
 } from "@fenglimg/fabric-shared";
@@ -6041,11 +6801,11 @@ function resolveCounterStores(projectRoot) {
   if (readSet.stores.length === 0) {
     return [];
   }
-  const globalRoot = resolveGlobalRoot5();
+  const globalRoot = resolveGlobalRoot6();
   return readSet.stores.map((entry) => ({
     uuid: entry.store_uuid,
     alias: entry.alias,
-    dir: join15(
+    dir: join17(
       globalRoot,
       storeRelativePathForMount5(
         input.mountedStores.find((s) => s.store_uuid === entry.store_uuid) ?? {
@@ -6072,8 +6832,8 @@ function readEntryId(file) {
 }
 function computeStoreDiskMax(storeDir) {
   const max = defaultAgentsMetaCounters();
-  for (const type of STORE_KNOWLEDGE_TYPE_DIRS) {
-    const dir = join15(storeDir, STORE_LAYOUT2.knowledgeDir, type);
+  for (const type of STORE_KNOWLEDGE_TYPE_DIRS2) {
+    const dir = join17(storeDir, STORE_LAYOUT2.knowledgeDir, type);
     if (!existsSync7(dir)) {
       continue;
     }
@@ -6087,7 +6847,7 @@ function computeStoreDiskMax(storeDir) {
       if (!name.endsWith(".md")) {
         continue;
       }
-      const parsed = parseKnowledgeId2(readEntryId(join15(dir, name)) ?? "");
+      const parsed = parseKnowledgeId2(readEntryId(join17(dir, name)) ?? "");
       if (parsed === null) {
         continue;
       }
@@ -6170,14 +6930,14 @@ function createStoreCounterCheck(t, drifts) {
 
 // src/services/doctor-store-orphan.ts
 import { readdirSync as readdirSync3 } from "fs";
-import { join as join16 } from "path";
+import { join as join18 } from "path";
 import {
   STORES_ROOT_DIR,
   addMountedStore,
   disambiguateAlias,
   loadGlobalConfig,
   readStoreIdentity,
-  resolveGlobalRoot as resolveGlobalRoot6,
+  resolveGlobalRoot as resolveGlobalRoot7,
   saveGlobalConfig
 } from "@fenglimg/fabric-shared";
 var STORE_BY_ALIAS_DIR = "by-alias";
@@ -6188,21 +6948,21 @@ function listDir(dir) {
     return [];
   }
 }
-function inspectStoreOrphans(globalRoot = resolveGlobalRoot6()) {
+function inspectStoreOrphans(globalRoot = resolveGlobalRoot7()) {
   const config = loadGlobalConfig(globalRoot);
   if (config === null) {
     return [];
   }
   const registered = new Set(config.stores.map((s) => s.store_uuid));
-  const storesRoot = join16(globalRoot, STORES_ROOT_DIR);
+  const storesRoot = join18(globalRoot, STORES_ROOT_DIR);
   const orphans = [];
   for (const group of listDir(storesRoot)) {
     if (group === STORE_BY_ALIAS_DIR) {
       continue;
     }
-    const groupDir = join16(storesRoot, group);
+    const groupDir = join18(storesRoot, group);
     for (const mount of listDir(groupDir)) {
-      const dir = join16(groupDir, mount);
+      const dir = join18(groupDir, mount);
       const identity = readStoreIdentity(dir);
       if (identity === null || registered.has(identity.store_uuid)) {
         continue;
@@ -6212,7 +6972,7 @@ function inspectStoreOrphans(globalRoot = resolveGlobalRoot6()) {
   }
   return orphans;
 }
-function fixStoreOrphans(globalRoot = resolveGlobalRoot6()) {
+function fixStoreOrphans(globalRoot = resolveGlobalRoot7()) {
   let config = loadGlobalConfig(globalRoot);
   if (config === null) {
     return [];
@@ -6267,6 +7027,195 @@ function createStoreOrphanCheck(t, orphans) {
   };
 }
 
+// src/services/doctor-project-registry-drift.ts
+import { readdir as readdir3, rmdir } from "fs/promises";
+import { join as join19 } from "path";
+import {
+  addStoreProject,
+  buildStoreResolveInput as buildStoreResolveInput7,
+  createStoreResolver as createStoreResolver7,
+  readStoreProjects as readStoreProjects2,
+  resolveGlobalRoot as resolveGlobalRoot8,
+  STORE_KNOWLEDGE_TYPE_DIRS as STORE_KNOWLEDGE_TYPE_DIRS3,
+  STORE_LAYOUT as STORE_LAYOUT3,
+  STORE_PROJECT_ID_PATTERN as STORE_PROJECT_ID_PATTERN2,
+  storeRelativePathForMount as storeRelativePathForMount6
+} from "@fenglimg/fabric-shared";
+var PROJECTS_DIR = "projects";
+var EMPTY_INSPECTION = { findings: [] };
+function resolveDriftStores(projectRoot) {
+  const input = buildStoreResolveInput7(projectRoot);
+  if (input === null) {
+    return [];
+  }
+  const readSet = createStoreResolver7().resolveReadSet(input);
+  if (readSet.stores.length === 0) {
+    return [];
+  }
+  const globalRoot = resolveGlobalRoot8();
+  return readSet.stores.map((entry) => {
+    const mounted = input.mountedStores.find((s) => s.store_uuid === entry.store_uuid);
+    return {
+      uuid: entry.store_uuid,
+      alias: entry.alias,
+      dir: join19(globalRoot, storeRelativePathForMount6(mounted ?? { store_uuid: entry.store_uuid }))
+    };
+  });
+}
+async function listDir2(dir) {
+  try {
+    return await readdir3(dir);
+  } catch {
+    return [];
+  }
+}
+async function listProjectFolders(storeDir) {
+  const projectsRoot = join19(storeDir, STORE_LAYOUT3.knowledgeDir, PROJECTS_DIR);
+  const reserved = /* @__PURE__ */ new Set([PROJECTS_DIR, ...STORE_KNOWLEDGE_TYPE_DIRS3]);
+  return (await listDir2(projectsRoot)).filter((id) => STORE_PROJECT_ID_PATTERN2.test(id) && !reserved.has(id)).sort();
+}
+async function folderHasEntries(storeDir, projectId) {
+  const base = join19(storeDir, STORE_LAYOUT3.knowledgeDir, PROJECTS_DIR, projectId);
+  for (const type of STORE_KNOWLEDGE_TYPE_DIRS3) {
+    const names = await listDir2(join19(base, type));
+    if (names.some((name) => name.endsWith(".md"))) {
+      return true;
+    }
+  }
+  return false;
+}
+async function inspectProjectRegistryDrift(projectRoot) {
+  const stores = resolveDriftStores(projectRoot);
+  if (stores.length === 0) {
+    return EMPTY_INSPECTION;
+  }
+  const findings = [];
+  for (const store of stores) {
+    const registered = new Set((await readStoreProjects2(store.dir)).map((p) => p.id));
+    const folders = await listProjectFolders(store.dir);
+    const folderSet = new Set(folders);
+    const base = { store_alias: store.alias, store_uuid: store.uuid, store_dir: store.dir };
+    for (const projectId of folders) {
+      if (registered.has(projectId)) {
+        if (!await folderHasEntries(store.dir, projectId)) {
+          findings.push({ ...base, project_id: projectId, kind: "empty_folder" });
+        }
+        continue;
+      }
+      const kind = await folderHasEntries(store.dir, projectId) ? "unregistered_write" : "orphan_folder";
+      findings.push({ ...base, project_id: projectId, kind });
+    }
+    void folderSet;
+  }
+  findings.sort(
+    (a, b) => a.store_alias.localeCompare(b.store_alias) || a.project_id.localeCompare(b.project_id)
+  );
+  return { findings };
+}
+async function fixProjectRegistryDrift(projectRoot) {
+  const registered = [];
+  const pruned = [];
+  const { findings } = await inspectProjectRegistryDrift(projectRoot);
+  for (const finding of findings) {
+    if (finding.kind === "empty_folder") {
+      if (await folderHasEntries(finding.store_dir, finding.project_id)) {
+        continue;
+      }
+      try {
+        const base = join19(
+          finding.store_dir,
+          STORE_LAYOUT3.knowledgeDir,
+          PROJECTS_DIR,
+          finding.project_id
+        );
+        for (const type of STORE_KNOWLEDGE_TYPE_DIRS3) {
+          await rmdir(join19(base, type)).catch(() => void 0);
+        }
+        await rmdir(base);
+        pruned.push(finding);
+      } catch {
+      }
+      continue;
+    }
+    try {
+      await addStoreProject(finding.store_dir, {
+        id: finding.project_id,
+        created_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      registered.push(finding);
+    } catch {
+    }
+  }
+  return { registered, pruned };
+}
+function createProjectRegistryDriftCheck(t, inspection) {
+  const { findings } = inspection;
+  if (findings.length === 0) {
+    return {
+      name: t("doctor.check.project_registry_drift.name"),
+      status: "ok",
+      message: t("doctor.check.project_registry_drift.ok")
+    };
+  }
+  const unregistered = findings.filter((f) => f.kind === "unregistered_write").length;
+  const orphans = findings.filter((f) => f.kind === "orphan_folder").length;
+  const empties = findings.filter((f) => f.kind === "empty_folder").length;
+  const breakdown = [
+    unregistered > 0 ? `${unregistered} unregistered-write` : null,
+    orphans > 0 ? `${orphans} orphan-folder` : null,
+    empties > 0 ? `${empties} empty-folder` : null
+  ].filter((part) => part !== null).join(", ");
+  if (unregistered > 0) {
+    const first2 = findings.find((f) => f.kind === "unregistered_write");
+    return {
+      name: t("doctor.check.project_registry_drift.name"),
+      status: "error",
+      kind: "manual_error",
+      code: "project_registry_drift",
+      fixable: true,
+      message: t("doctor.check.project_registry_drift.message.unregistered", {
+        total: String(findings.length),
+        breakdown,
+        projectId: first2.project_id,
+        storeAlias: first2.store_alias
+      }),
+      actionHint: t("doctor.check.project_registry_drift.remediation")
+    };
+  }
+  if (orphans > 0) {
+    const first2 = findings.find((f) => f.kind === "orphan_folder");
+    return {
+      name: t("doctor.check.project_registry_drift.name"),
+      status: "warn",
+      kind: "warning",
+      code: "project_registry_drift",
+      fixable: true,
+      message: t("doctor.check.project_registry_drift.message.orphan", {
+        total: String(findings.length),
+        breakdown,
+        projectId: first2.project_id,
+        storeAlias: first2.store_alias
+      }),
+      actionHint: t("doctor.check.project_registry_drift.remediation")
+    };
+  }
+  const first = findings.find((f) => f.kind === "empty_folder");
+  return {
+    name: t("doctor.check.project_registry_drift.name"),
+    status: "warn",
+    kind: "info",
+    code: "project_registry_drift",
+    fixable: true,
+    message: t("doctor.check.project_registry_drift.message.empty", {
+      total: String(findings.length),
+      breakdown,
+      projectId: first.project_id,
+      storeAlias: first.store_alias
+    }),
+    actionHint: t("doctor.check.project_registry_drift.remediation")
+  };
+}
+
 // src/services/legacy-serve-lock-probe.ts
 import {
   isAlive,
@@ -6339,12 +7288,37 @@ async function inspectEventsJsonlGates(projectRoot, options = {}) {
 }
 
 // src/services/doctor-skill-lints.ts
-import { readdir as readdir3, readFile as readFile10 } from "fs/promises";
-import { join as join17, posix as posix2 } from "path";
+import { readdir as readdir4, readFile as readFile13 } from "fs/promises";
+import { join as join20, posix as posix2 } from "path";
 var FABRIC_SKILL_SLUGS = ["fabric-archive", "fabric-review"];
+var FABRIC_CONTRACT_SKILL_SLUGS = ["fabric-archive", "fabric-review", "fabric-store", "fabric-sync"];
 var SKILL_MD_FRONTMATTER_ROOTS = [".claude/skills", ".codex/skills"];
 var SKILL_FRONTMATTER_KEY_PATTERN = /^([A-Za-z_][A-Za-z0-9_-]*):[ \t]+(.+?)[ \t]*$/u;
 var SKILL_QUOTED_VALUE_LEADS = /* @__PURE__ */ new Set(['"', "'", "[", "{", ">", "|"]);
+var SKILL_CONTRACT_TOKENS = {
+  "fabric-archive": [
+    "## Hard Rules",
+    "### DISPLAY Rules",
+    "### WRITE Rules",
+    "mcp__fabric__fab_propose",
+    "only legal write path",
+    "reached-but-inert"
+  ],
+  "fabric-review": [
+    "## Hard Rules",
+    "### DISPLAY Rules",
+    "### WRITE Rules",
+    "mcp__fabric__fab_review",
+    "only legal mutation path",
+    "reached-but-inert",
+    "changes next action",
+    "must_read_if",
+    "intent_clues",
+    "impact"
+  ],
+  "fabric-store": ["thin shim", "CLI", "\u672C skill \u53EA", "NEVER"],
+  "fabric-sync": ["thin shim", "CLI", "\u672C skill \u53EA", "NEVER"]
+};
 function okCheck(name, message) {
   return { name, status: "ok", message };
 }
@@ -6362,7 +7336,7 @@ function issueCheck(name, status, kind, code, message, actionHint, audience) {
 }
 async function listMarkdownFiles(dir) {
   try {
-    return (await readdir3(dir)).filter((name) => name.endsWith(".md"));
+    return (await readdir4(dir)).filter((name) => name.endsWith(".md"));
   } catch {
     return null;
   }
@@ -6370,8 +7344,8 @@ async function listMarkdownFiles(dir) {
 async function inspectSkillRefMirror(projectRoot) {
   const driftedPaths = [];
   for (const slug of FABRIC_SKILL_SLUGS) {
-    const claudeRef = join17(projectRoot, ".claude", "skills", slug, "ref");
-    const codexRef = join17(projectRoot, ".codex", "skills", slug, "ref");
+    const claudeRef = join20(projectRoot, ".claude", "skills", slug, "ref");
+    const codexRef = join20(projectRoot, ".codex", "skills", slug, "ref");
     const [claudeFiles, codexFiles] = await Promise.all([listMarkdownFiles(claudeRef), listMarkdownFiles(codexRef)]);
     if (claudeFiles === null || codexFiles === null) continue;
     const claudeSet = new Set(claudeFiles);
@@ -6388,8 +7362,8 @@ async function inspectSkillRefMirror(projectRoot) {
       let codexBody;
       try {
         [claudeBody, codexBody] = await Promise.all([
-          readFile10(join17(claudeRef, fname), "utf8"),
-          readFile10(join17(codexRef, fname), "utf8")
+          readFile13(join20(claudeRef, fname), "utf8"),
+          readFile13(join20(codexRef, fname), "utf8")
         ]);
       } catch {
         continue;
@@ -6408,10 +7382,10 @@ async function inspectSkillTokenBudget(projectRoot) {
   const overSize = [];
   let highestSeverity = "ok";
   for (const slug of FABRIC_SKILL_SLUGS) {
-    const skillMdPath = join17(projectRoot, ".claude", "skills", slug, "SKILL.md");
+    const skillMdPath = join20(projectRoot, ".claude", "skills", slug, "SKILL.md");
     let body;
     try {
-      body = await readFile10(skillMdPath, "utf8");
+      body = await readFile13(skillMdPath, "utf8");
     } catch {
       continue;
     }
@@ -6431,11 +7405,12 @@ async function inspectSkillDescription(projectRoot) {
   const issues = [];
   const CJK_PATTERN = /[\u3400-\u4dbf\u4e00-\u9fff]/u;
   const ASCII_PATTERN = /[a-zA-Z]{2,}/u;
+  const ANTI_TRIGGER_PATTERN = /\bNOT\b|ONLY when|do not|不要|不是|非/u;
   for (const slug of FABRIC_SKILL_SLUGS) {
-    const skillMdPath = join17(projectRoot, ".claude", "skills", slug, "SKILL.md");
+    const skillMdPath = join20(projectRoot, ".claude", "skills", slug, "SKILL.md");
     let body;
     try {
-      body = await readFile10(skillMdPath, "utf8");
+      body = await readFile13(skillMdPath, "utf8");
     } catch {
       continue;
     }
@@ -6460,25 +7435,75 @@ async function inspectSkillDescription(projectRoot) {
     if (!ASCII_PATTERN.test(description)) {
       issues.push({ slug, problem: "no_ascii", detail: "no English trigger phrase" });
     }
+    if (!ANTI_TRIGGER_PATTERN.test(description)) {
+      issues.push({
+        slug,
+        problem: "missing_anti_trigger",
+        detail: "no explicit non-trigger phrase such as NOT/\u4E0D\u662F/\u4E0D\u8981"
+      });
+    }
+  }
+  return { status: issues.length === 0 ? "ok" : "warn", issues };
+}
+async function inspectSkillContract(projectRoot) {
+  const issues = [];
+  for (const rootRel of SKILL_MD_FRONTMATTER_ROOTS) {
+    const client = rootRel.startsWith(".claude") ? ".claude" : ".codex";
+    for (const slug of FABRIC_CONTRACT_SKILL_SLUGS) {
+      const skillDir = join20(projectRoot, rootRel, slug);
+      const skillMdPath = join20(skillDir, "SKILL.md");
+      let body;
+      try {
+        body = await readFile13(skillMdPath, "utf8");
+      } catch {
+        continue;
+      }
+      for (const token of SKILL_CONTRACT_TOKENS[slug]) {
+        if (body.includes(token)) continue;
+        issues.push({
+          slug,
+          client,
+          problem: slug === "fabric-store" || slug === "fabric-sync" ? "missing_thin_shim_token" : "missing_contract_token",
+          detail: token
+        });
+      }
+      const refDir = join20(skillDir, "ref");
+      let refFiles;
+      try {
+        refFiles = (await readdir4(refDir)).filter((name) => name.endsWith(".md"));
+      } catch {
+        refFiles = null;
+      }
+      if (refFiles === null) continue;
+      for (const fname of refFiles) {
+        if (body.includes(fname) || body.includes(`ref/${fname}`)) continue;
+        issues.push({
+          slug,
+          client,
+          problem: "missing_ref_entry",
+          detail: fname
+        });
+      }
+    }
   }
   return { status: issues.length === 0 ? "ok" : "warn", issues };
 }
 async function inspectSkillMdYamlInvalid(projectRoot) {
   const candidates = [];
   for (const rootRel of SKILL_MD_FRONTMATTER_ROOTS) {
-    const rootAbs = join17(projectRoot, rootRel);
+    const rootAbs = join20(projectRoot, rootRel);
     let dirEntries;
     try {
-      dirEntries = await readdir3(rootAbs, { withFileTypes: true });
+      dirEntries = await readdir4(rootAbs, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const dirEntry of dirEntries) {
       if (!dirEntry.isDirectory()) continue;
-      const skillFile = join17(rootAbs, dirEntry.name, "SKILL.md");
+      const skillFile = join20(rootAbs, dirEntry.name, "SKILL.md");
       let raw;
       try {
-        raw = await readFile10(skillFile, "utf8");
+        raw = await readFile13(skillFile, "utf8");
       } catch {
         continue;
       }
@@ -6580,6 +7605,25 @@ function createSkillDescriptionCheck(t, inspection) {
     "maintainer"
   );
 }
+function createSkillContractCheck(t, inspection) {
+  if (inspection.status === "ok") {
+    return okCheck(t("doctor.check.skill_contract.name"), t("doctor.check.skill_contract.ok"));
+  }
+  const list = inspection.issues.map((issue) => `${issue.client}/${issue.slug}: ${issue.problem} (${issue.detail})`).join("; ");
+  const count = inspection.issues.length;
+  return issueCheck(
+    t("doctor.check.skill_contract.name"),
+    "warn",
+    "warning",
+    "skill_contract_integrity",
+    t(`doctor.check.skill_contract.message.${count === 1 ? "singular" : "plural"}`, {
+      count: String(count),
+      list
+    }),
+    t("doctor.check.skill_contract.remediation"),
+    "maintainer"
+  );
+}
 function createSkillMdYamlInvalidCheck(t, inspection) {
   if (inspection.candidates.length === 0) {
     return okCheck(t("doctor.check.skill_md_yaml_invalid.name"), t("doctor.check.skill_md_yaml_invalid.ok"));
@@ -6601,8 +7645,8 @@ function createSkillMdYamlInvalidCheck(t, inspection) {
 }
 
 // src/services/doctor-retired-references-lint.ts
-import { readdir as readdir4, readFile as readFile11, stat as stat3 } from "fs/promises";
-import { join as join18, posix as posix3, relative as relative2 } from "path";
+import { readdir as readdir5, readFile as readFile14, stat as stat3 } from "fs/promises";
+import { join as join21, posix as posix3, relative as relative2 } from "path";
 var RETIRED_TOKENS = [
   { token: "fab_plan_context", replacement: "fab_recall", reason: "retrieval collapsed to one lean fab_recall (KT-DEC-0026)" },
   { token: "fab_get_knowledge_sections", replacement: "fab_recall", reason: "two-step fetch retired (KT-DEC-0026)" },
@@ -6625,7 +7669,7 @@ var RETIRED_TOKENS = [
 ];
 var HOOK_DIRS = [".claude/hooks", ".codex/hooks"];
 var SKILL_DIRS = [".claude/skills", ".codex/skills"];
-var BOOTSTRAP_FILES = ["AGENTS.md", "CLAUDE.md", join18(".fabric", "AGENTS.md")];
+var BOOTSTRAP_FILES = ["AGENTS.md", "CLAUDE.md", join21(".fabric", "AGENTS.md")];
 function isCommentLine(line) {
   const t = line.trim();
   return t.startsWith("//") || t.startsWith("*") || t.startsWith("/*");
@@ -6633,13 +7677,13 @@ function isCommentLine(line) {
 async function walkFiles(dir, exts) {
   let entries;
   try {
-    entries = await readdir4(dir, { withFileTypes: true });
+    entries = await readdir5(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   const out = [];
   for (const e of entries) {
-    const full = join18(dir, e.name);
+    const full = join21(dir, e.name);
     if (e.isDirectory()) {
       out.push(...await walkFiles(full, exts));
     } else if (exts.some((ext) => e.name.endsWith(ext))) {
@@ -6665,29 +7709,29 @@ async function inspectRetiredReferences(projectRoot) {
   let scannedFiles = 0;
   const toRel = (p) => posix3.normalize(relative2(projectRoot, p).split("\\").join("/"));
   for (const rel of BOOTSTRAP_FILES) {
-    const abs = join18(projectRoot, rel);
+    const abs = join21(projectRoot, rel);
     try {
       if ((await stat3(abs)).isFile()) {
         scannedFiles += 1;
-        scanText(toRel(abs), await readFile11(abs, "utf8"), false, hits);
+        scanText(toRel(abs), await readFile14(abs, "utf8"), false, hits);
       }
     } catch {
     }
   }
   for (const dir of SKILL_DIRS) {
-    for (const file of await walkFiles(join18(projectRoot, dir), [".md"])) {
+    for (const file of await walkFiles(join21(projectRoot, dir), [".md"])) {
       scannedFiles += 1;
       try {
-        scanText(toRel(file), await readFile11(file, "utf8"), false, hits);
+        scanText(toRel(file), await readFile14(file, "utf8"), false, hits);
       } catch {
       }
     }
   }
   for (const dir of HOOK_DIRS) {
-    for (const file of await walkFiles(join18(projectRoot, dir), [".cjs"])) {
+    for (const file of await walkFiles(join21(projectRoot, dir), [".cjs"])) {
       scannedFiles += 1;
       try {
-        scanText(toRel(file), await readFile11(file, "utf8"), true, hits);
+        scanText(toRel(file), await readFile14(file, "utf8"), true, hits);
       } catch {
       }
     }
@@ -6722,8 +7766,8 @@ function createRetiredReferenceCheck(t, inspection) {
 
 // src/services/doctor-hooks-lints.ts
 import { constants } from "fs";
-import { access, readdir as readdir5, readFile as readFile12, stat as stat4 } from "fs/promises";
-import { join as join19, posix as posix4 } from "path";
+import { access, readdir as readdir6, readFile as readFile15, stat as stat4 } from "fs/promises";
+import { join as join22, posix as posix4 } from "path";
 import { Script } from "vm";
 var HOOKS_RUNTIME_CLIENT_DIRS = [
   { client: "claude", dir: ".claude/hooks" },
@@ -6772,7 +7816,7 @@ function isHookWiredForEvent(hooks, event, hookFile) {
 }
 async function readDirectoryFileNames(dir) {
   try {
-    return await readdir5(dir);
+    return await readdir6(dir);
   } catch {
     return null;
   }
@@ -6785,21 +7829,27 @@ async function isFile(absPath) {
   }
 }
 async function inspectHooksWired(projectRoot) {
-  const claudeEntries = await readDirectoryFileNames(join19(projectRoot, ".claude"));
+  const claudeEntries = await readDirectoryFileNames(join22(projectRoot, ".claude"));
   if (claudeEntries === null) {
     return { status: "skipped", missingHooks: [] };
   }
-  const settingsPath = join19(projectRoot, ".claude", "settings.json");
+  const settingsPath = join22(projectRoot, ".claude", "settings.json");
   let parsed;
   try {
-    parsed = JSON.parse(await readFile12(settingsPath, "utf8"));
+    parsed = JSON.parse(await readFile15(settingsPath, "utf8"));
   } catch {
     return { status: "missing-settings", missingHooks: [] };
   }
   const required = [
     { event: "Stop", hookFile: "fabric-hint.cjs" },
     { event: "SessionStart", hookFile: "knowledge-hint-broad.cjs" },
-    { event: "PreToolUse", hookFile: "knowledge-hint-narrow.cjs" }
+    // ux-w2-6 (rc.9): PreToolUse is the SINGLE merged orchestrator
+    // knowledge-pretooluse.cjs which internally requires knowledge-hint-narrow.cjs
+    // (and cite-policy-evict.cjs) so a single edit produces ONE additionalContext
+    // envelope instead of two. The stale reference to narrow.cjs here was the
+    // rc.30 BUG-M3 false-negative source — narrow.cjs still exists on disk as a
+    // lib but is NOT registered as a PreToolUse hook.
+    { event: "PreToolUse", hookFile: "knowledge-pretooluse.cjs" }
   ];
   const missing = [];
   const hooksSection = isRecord(parsed) ? parsed.hooks : void 0;
@@ -6815,8 +7865,8 @@ async function inspectHooksWired(projectRoot) {
 }
 async function inspectHookCacheWritability(projectRoot) {
   const relPath = posix4.join(".fabric", ".cache");
-  const fabricDir = join19(projectRoot, ".fabric");
-  const cacheDir = join19(projectRoot, ".fabric", ".cache");
+  const fabricDir = join22(projectRoot, ".fabric");
+  const cacheDir = join22(projectRoot, ".fabric", ".cache");
   try {
     try {
       const cacheStats = await stat4(cacheDir);
@@ -6865,12 +7915,12 @@ async function inspectHookCacheWritability(projectRoot) {
 async function inspectHooksContentDrift(projectRoot) {
   const hookFilesByBasename = /* @__PURE__ */ new Map();
   for (const { client, dir } of HOOKS_RUNTIME_CLIENT_DIRS) {
-    const absDir = join19(projectRoot, dir);
+    const absDir = join22(projectRoot, dir);
     const entries = await readDirectoryFileNames(absDir);
     if (entries === null) continue;
     for (const name of entries) {
       if (!name.endsWith(".cjs")) continue;
-      const abs = join19(absDir, name);
+      const abs = join22(absDir, name);
       if (!await isFile(abs)) continue;
       const arr = hookFilesByBasename.get(name) ?? [];
       arr.push({ client, abs });
@@ -6885,7 +7935,7 @@ async function inspectHooksContentDrift(projectRoot) {
     const hashes = [];
     for (const { client, abs } of copies) {
       try {
-        const body = await readFile12(abs, "utf8");
+        const body = await readFile15(abs, "utf8");
         hashes.push({ client, sha: sha256(body) });
       } catch {
       }
@@ -6907,18 +7957,18 @@ async function inspectHooksRuntime(projectRoot) {
   const issues = [];
   let scanned = 0;
   for (const { client, dir } of HOOKS_RUNTIME_CLIENT_DIRS) {
-    const absDir = join19(projectRoot, dir);
+    const absDir = join22(projectRoot, dir);
     const entries = await readDirectoryFileNames(absDir);
     if (entries === null) continue;
     for (const name of entries) {
       if (!name.endsWith(".cjs")) continue;
-      const abs = join19(absDir, name);
+      const abs = join22(absDir, name);
       const displayPath = `${dir}/${name}`;
       if (!await isFile(abs)) continue;
       scanned += 1;
       let body;
       try {
-        body = await readFile12(abs, "utf8");
+        body = await readFile15(abs, "utf8");
       } catch (err) {
         issues.push({
           path: displayPath,
@@ -7055,8 +8105,8 @@ function createHookCacheWritabilityCheck(t, inspection) {
 }
 
 // src/services/doctor-bootstrap-lints.ts
-import { access as access2, readFile as readFile13 } from "fs/promises";
-import { join as join20 } from "path";
+import { access as access2, readFile as readFile16 } from "fs/promises";
+import { join as join23 } from "path";
 import {
   BOOTSTRAP_MARKER_BEGIN,
   BOOTSTRAP_MARKER_END,
@@ -7088,17 +8138,17 @@ async function fileExists(path) {
 }
 async function inspectBootstrapAnchor(projectRoot) {
   const [hasAgentsMd, hasClaudeMd] = await Promise.all([
-    fileExists(join20(projectRoot, "AGENTS.md")),
-    fileExists(join20(projectRoot, "CLAUDE.md"))
+    fileExists(join23(projectRoot, "AGENTS.md")),
+    fileExists(join23(projectRoot, "CLAUDE.md"))
   ]);
   return { hasAgentsMd, hasClaudeMd };
 }
 async function inspectL1BootstrapSnapshotDrift(target) {
-  const abs = join20(target, ".fabric", "AGENTS.md");
+  const abs = join23(target, ".fabric", "AGENTS.md");
   const canonical = resolveBootstrapCanonical();
   let onDisk;
   try {
-    onDisk = await readFile13(abs, "utf8");
+    onDisk = await readFile16(abs, "utf8");
   } catch {
     return { status: "missing", canonical, onDisk: null };
   }
@@ -7124,17 +8174,17 @@ function createL1BootstrapSnapshotDriftCheck(t, inspection) {
   );
 }
 async function inspectL2ManagedBlockDrift(target) {
-  const snapshotPath = join20(target, ".fabric", "AGENTS.md");
+  const snapshotPath = join23(target, ".fabric", "AGENTS.md");
   let snapshot;
   try {
-    snapshot = await readFile13(snapshotPath, "utf8");
+    snapshot = await readFile16(snapshotPath, "utf8");
   } catch {
     return { status: "ok", drifted: [] };
   }
-  const projectRulesPath = join20(target, ".fabric", "project-rules.md");
+  const projectRulesPath = join23(target, ".fabric", "project-rules.md");
   let expectedBody = snapshot;
   try {
-    const projectRules = await readFile13(projectRulesPath, "utf8");
+    const projectRules = await readFile16(projectRulesPath, "utf8");
     expectedBody = `${snapshot}
 ---
 ${projectRules}`;
@@ -7143,12 +8193,12 @@ ${projectRules}`;
   const drifted = [];
   let anyManagedBlockFound = false;
   const blockTargets = [
-    join20(target, "AGENTS.md")
+    join23(target, "AGENTS.md")
   ];
   for (const abs of blockTargets) {
     let content;
     try {
-      content = await readFile13(abs, "utf8");
+      content = await readFile16(abs, "utf8");
     } catch {
       continue;
     }
@@ -7171,9 +8221,9 @@ ${projectRules}`;
       drifted.push({ path: abs, expected: expectedBody, actual: body });
     }
   }
-  const claudeMdPath = join20(target, "CLAUDE.md");
+  const claudeMdPath = join23(target, "CLAUDE.md");
   try {
-    const claudeContent = await readFile13(claudeMdPath, "utf8");
+    const claudeContent = await readFile16(claudeMdPath, "utf8");
     anyManagedBlockFound = true;
     const lines = claudeContent.split(/\r?\n/u);
     const hasAtImport = lines.some((line) => line.trim() === "@.fabric/AGENTS.md");
@@ -7241,7 +8291,7 @@ import { appendFile as appendFile3 } from "fs/promises";
 import { minimatch as minimatch2 } from "minimatch";
 
 // src/services/cite-rollup.ts
-import { readFile as readFile14 } from "fs/promises";
+import { readFile as readFile17 } from "fs/promises";
 import { createLedgerWriteQueue as createLedgerWriteQueue3 } from "@fenglimg/fabric-shared/node/atomic-write";
 var citeRollupQueue = createLedgerWriteQueue3();
 async function appendCiteRollupRow(projectRoot, row) {
@@ -7253,7 +8303,7 @@ async function readCiteRollup(projectRoot) {
   const path = getCiteRollupPath(projectRoot);
   let raw;
   try {
-    raw = await readFile14(path, "utf8");
+    raw = await readFile17(path, "utf8");
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") return [];
     throw error;
@@ -7844,6 +8894,18 @@ async function runDoctorCiteCoverage(projectRoot, options) {
       }
     }
   }
+  const editSessionIds = /* @__PURE__ */ new Set();
+  for (const edit of editEvents) {
+    if (typeof edit.session_id === "string" && edit.session_id.length > 0) {
+      editSessionIds.add(edit.session_id);
+    }
+  }
+  let recallsInWindow = 0;
+  for (const list of plannedBySession.values()) recallsInWindow += list.length;
+  let recallSessionsCorrelated = 0;
+  for (const sid of plannedBySession.keys()) {
+    if (editSessionIds.has(sid)) recallSessionsCorrelated += 1;
+  }
   const noneTotal = Object.values(noneHistogram).reduce((a, b) => a + b, 0);
   const compliantCites = qualifyingCites + noneTotal;
   const noncompliantCites = expectedButMissed;
@@ -7911,6 +8973,11 @@ async function runDoctorCiteCoverage(projectRoot, options) {
     uncorrelatable_edits: uncorrelatableEdits,
     recall_backed_edits: recallBackedEdits,
     recall_coverage_rate: recallCoverageRate,
+    recall_diagnostics: {
+      recalls_in_window: recallsInWindow,
+      recall_sessions: plannedBySession.size,
+      recall_sessions_correlated: recallSessionsCorrelated
+    },
     exposed_and_mutated: {
       count: exposedAndMutated.count,
       ...exposedAndMutated.ids.length > 0 ? { ids: exposedAndMutated.ids } : {}
@@ -8316,6 +9383,7 @@ async function runDoctorReport(target) {
     skillRefMirror,
     skillTokenBudget,
     skillDescription,
+    skillContract,
     retiredReferences
   ] = await Promise.all([
     inspectForensic(projectRoot),
@@ -8337,6 +9405,7 @@ async function runDoctorReport(target) {
     inspectSkillRefMirror(projectRoot),
     inspectSkillTokenBudget(projectRoot),
     inspectSkillDescription(projectRoot),
+    inspectSkillContract(projectRoot),
     // ux-w2-2: registry-driven stale-pointer scan over the agent-consumed
     // surface (bootstrap + SKILL.md + installed hooks).
     inspectRetiredReferences(projectRoot)
@@ -8354,6 +9423,7 @@ async function runDoctorReport(target) {
   const driftUnconsumed = await inspectDriftUnconsumed(projectRoot);
   const storeCounterDrift = inspectStoreCounters(projectRoot);
   const storeOrphans = inspectStoreOrphans();
+  const projectRegistryDrift = await inspectProjectRegistryDrift(projectRoot);
   const stableIdIntegrity = await inspectStoreStableIdIntegrity(projectRoot);
   const relevancePaths = await inspectStoreRelevancePaths(projectRoot);
   const broadIndexDrift = await inspectBroadIndexDrift(projectRoot);
@@ -8383,7 +9453,7 @@ async function runDoctorReport(target) {
   const globalCliVersion = process.env.VITEST === "true" ? { status: "ok", version: "test-skipped" } : inspectGlobalCliVersion();
   const targetFiles = Object.fromEntries(
     await Promise.all(
-      TARGET_FILE_PATHS.map(async (path) => [path, await pathExists(join21(projectRoot, path))])
+      TARGET_FILE_PATHS.map(async (path) => [path, await pathExists(join24(projectRoot, path))])
     )
   );
   const checks = [
@@ -8422,6 +9492,7 @@ async function runDoctorReport(target) {
     createSkillRefMirrorCheck(t, skillRefMirror),
     createSkillTokenBudgetCheck(t, skillTokenBudget),
     createSkillDescriptionCheck(t, skillDescription),
+    createSkillContractCheck(t, skillContract),
     // ux-w2-2: retired-reference (stale-pointer) lint — registry-driven.
     createRetiredReferenceCheck(t, retiredReferences),
     createCiteGoodhartCheck(t, citeGoodhart),
@@ -8437,6 +9508,12 @@ async function runDoctorReport(target) {
     // (warning). `--fix` adopts it (rescue-before-delete — re-register, never
     // an on-disk delete).
     createStoreOrphanCheck(t, storeOrphans),
+    // W2 (F-003): project-registry drift over projects.json ↔ projects/ folder
+    // tree. unregistered-write (data unrouted) → manual_error; orphan-folder →
+    // warning; empty-folder → info; ghost-registration emits nothing (DA-05).
+    // `--fix` rescue-registers orphans/unregistered (addStoreProject — never a
+    // non-empty delete) and prunes only genuinely-empty registered folders.
+    createProjectRegistryDriftCheck(t, projectRegistryDrift),
     // rc.5 TASK-010: read-side underseeded-corpus check (#22). Info kind —
     // does not bump report status. Recommends running the fabric-import skill
     // to backfill knowledge when the corpus is below the threshold floor.
@@ -8512,6 +9589,14 @@ async function runDoctorReport(target) {
     // fresh-install hole is sealed in store.stage.ts; this covers existing repos
     // (CLI `--fix` backfills via ensureStoreProjectBinding).
     createUnboundProjectCheck(t, detectUnboundProject(projectRoot)),
+    // write_route_target_unbound — every write_routes[i].store must resolve
+    // against required_stores. Catches "route survived migration to single
+    // team slot" (werewolf-minigame case): route says `team → cocos` but
+    // required_stores only holds `team`, so fab_propose(audience:"team")
+    // would report "no write-target store resolved" at runtime. Static
+    // config-level check, no resolver, aligned with KT-DEC-0048 read-tolerant
+    // doctrine.
+    createWriteRouteUnboundCheck(t, detectWriteRouteUnbound(projectRoot)),
     // rc.31 BUG-G2/G5: promote-ledger invariant. Sits adjacent to onboard
     // coverage — both are observability advisories built off events.jsonl.
     ...promoteLedgerInvariant === null ? [] : [createPromoteLedgerInvariantCheck(t, promoteLedgerInvariant)],
@@ -8587,7 +9672,7 @@ async function runDoctorFix(target) {
   const fixed = [];
   const ledgerWarnings = [];
   if (before.fixable_errors.some((issue) => issue.code === "bootstrap_snapshot_drift")) {
-    const snapshotPath = join21(projectRoot, ".fabric", "AGENTS.md");
+    const snapshotPath = join24(projectRoot, ".fabric", "AGENTS.md");
     await ensureParentDirectory(snapshotPath);
     await atomicWriteText4(snapshotPath, resolveBootstrapCanonical2());
     fixed.push(findIssue(before.fixable_errors, "bootstrap_snapshot_drift"));
@@ -8611,6 +9696,18 @@ async function runDoctorFix(target) {
       fixed.push(findIssue(before.warnings, "store_orphan"));
     }
   }
+  const registryDriftFound = before.manual_errors.some((issue) => issue.code === "project_registry_drift") || before.warnings.some((issue) => issue.code === "project_registry_drift") || before.infos.some((issue) => issue.code === "project_registry_drift");
+  if (registryDriftFound) {
+    const result = await fixProjectRegistryDrift(projectRoot);
+    if (result.registered.length > 0 || result.pruned.length > 0) {
+      fixed.push(
+        findIssue(
+          [...before.manual_errors, ...before.warnings, ...before.infos],
+          "project_registry_drift"
+        )
+      );
+    }
+  }
   if (before.fixable_errors.some((issue) => issue.code === "event_ledger_partial_write")) {
     const ledgerPath = getEventLedgerPath(projectRoot);
     const truncResult = await truncateLedgerToLastNewline(ledgerPath);
@@ -8660,7 +9757,7 @@ async function runDoctorFix(target) {
   if (before.infos.some((issue) => issue.code === "stale_serve_lock")) {
     const lockInspection = inspectStaleServeLock(projectRoot, Date.now());
     if (lockInspection.present && !lockInspection.pidAlive) {
-      const lockFilePath = join21(projectRoot, ".fabric", ".serve.lock");
+      const lockFilePath = join24(projectRoot, ".fabric", ".serve.lock");
       try {
         await unlink4(lockFilePath);
       } catch (err) {
@@ -8777,7 +9874,7 @@ function createApplyLintMessage(succeeded, failed, manualErrorCount) {
 }
 async function applySessionHintsStaleCleanup(projectRoot, candidate) {
   const detail = `deleted (${candidate.age_days}d old)`;
-  const absPath = join21(projectRoot, candidate.path);
+  const absPath = join24(projectRoot, candidate.path);
   try {
     const { unlink: unlink5 } = await import("fs/promises");
     await unlink5(absPath);
@@ -8802,9 +9899,9 @@ function truncateErrorMessage(error) {
   return raw.length > 240 ? `${raw.slice(0, 237)}...` : raw;
 }
 async function inspectForensic(projectRoot) {
-  const path = join21(projectRoot, ".fabric", "forensic.json");
+  const path = join24(projectRoot, ".fabric", "forensic.json");
   try {
-    const parsed = forensicReportSchema.parse(JSON.parse(await readFile16(path, "utf8")));
+    const parsed = forensicReportSchema.parse(JSON.parse(await readFile19(path, "utf8")));
     return { present: true, valid: true, report: parsed };
   } catch (error) {
     if (isMissingFileError(error)) {
@@ -8834,7 +9931,7 @@ async function inspectEventLedger(projectRoot) {
   try {
     await access4(path, constants2.W_OK);
     const { warnings } = await readEventLedger(projectRoot);
-    const raw = await readFile16(path, "utf8");
+    const raw = await readFile19(path, "utf8");
     const invalidLine = raw.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean).find((line) => !isValidJsonLine(line));
     const partialWarning = warnings.find((w) => w.kind === "partial_write_at_tail");
     const schemaVersionSamples = [];
@@ -9379,7 +10476,7 @@ async function inspectPreexistingRootFiles(projectRoot) {
   const candidates = ["CLAUDE.md", "AGENTS.md"];
   const detected = [];
   for (const name of candidates) {
-    if (await pathExists(join21(projectRoot, name))) {
+    if (await pathExists(join24(projectRoot, name))) {
       detected.push(name);
     }
   }
@@ -9464,7 +10561,7 @@ async function buildLastActiveIndex(projectRoot) {
   return map;
 }
 async function inspectSessionHintsStale(projectRoot, now) {
-  const cacheDir = join21(projectRoot, ".fabric", ".cache");
+  const cacheDir = join24(projectRoot, ".fabric", ".cache");
   let entries;
   try {
     entries = await readdirAsync(cacheDir, { withFileTypes: true });
@@ -9476,7 +10573,7 @@ async function inspectSessionHintsStale(projectRoot, now) {
     if (!entry.isFile()) continue;
     if (!entry.name.startsWith(SESSION_HINTS_FILE_PREFIX)) continue;
     if (!entry.name.endsWith(SESSION_HINTS_FILE_SUFFIX)) continue;
-    const absPath = join21(cacheDir, entry.name);
+    const absPath = join24(cacheDir, entry.name);
     let mtimeMs = 0;
     try {
       mtimeMs = (await statAsync(absPath)).mtimeMs;
@@ -9508,9 +10605,9 @@ function inspectStaleServeLock(projectRoot, now) {
   };
 }
 async function readUnderseedThresholdFromConfig(projectRoot) {
-  const configPath = join21(projectRoot, ".fabric", "fabric-config.json");
+  const configPath = join24(projectRoot, ".fabric", "fabric-config.json");
   try {
-    const raw = await readFile16(configPath, "utf8");
+    const raw = await readFile19(configPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const v = parsed.underseed_node_threshold;
@@ -9626,10 +10723,10 @@ async function inspectOnboardCoverage(projectRoot) {
   return { filled, missing, opted_out: optedOut };
 }
 async function readOnboardOptedOut(projectRoot) {
-  const path = join21(projectRoot, ".fabric", "fabric-config.json");
+  const path = join24(projectRoot, ".fabric", "fabric-config.json");
   let raw;
   try {
-    raw = await readFile16(path, "utf8");
+    raw = await readFile19(path, "utf8");
   } catch {
     return [];
   }
@@ -9731,22 +10828,22 @@ async function* iterateCanonicalFilenames(projectRoot) {
   }
 }
 async function rewriteThreeEndManagedBlocks(projectRoot) {
-  const snapshotPath = join21(projectRoot, ".fabric", "AGENTS.md");
+  const snapshotPath = join24(projectRoot, ".fabric", "AGENTS.md");
   if (!await pathExists(snapshotPath)) {
     return;
   }
   let snapshot;
   try {
-    snapshot = await readFile16(snapshotPath, "utf8");
+    snapshot = await readFile19(snapshotPath, "utf8");
   } catch {
     return;
   }
-  const projectRulesPath = join21(projectRoot, ".fabric", "project-rules.md");
+  const projectRulesPath = join24(projectRoot, ".fabric", "project-rules.md");
   const hasProjectRules = await pathExists(projectRulesPath);
   let expectedBody = snapshot;
   if (hasProjectRules) {
     try {
-      const projectRules = await readFile16(projectRulesPath, "utf8");
+      const projectRules = await readFile19(projectRulesPath, "utf8");
       expectedBody = `${snapshot}
 ---
 ${projectRules}`;
@@ -9757,7 +10854,7 @@ ${projectRules}`;
 ${expectedBody}
 ${BOOTSTRAP_MARKER_END2}`;
   const blockTargets = [
-    join21(projectRoot, "AGENTS.md")
+    join24(projectRoot, "AGENTS.md")
   ];
   for (const abs of blockTargets) {
     if (!await pathExists(abs)) {
@@ -9765,7 +10862,7 @@ ${BOOTSTRAP_MARKER_END2}`;
     }
     let existing;
     try {
-      existing = await readFile16(abs, "utf8");
+      existing = await readFile19(abs, "utf8");
     } catch {
       continue;
     }
@@ -9790,11 +10887,11 @@ ${managedBlock}
     }
     await atomicWriteText4(abs, next);
   }
-  const claudeMdPath = join21(projectRoot, "CLAUDE.md");
+  const claudeMdPath = join24(projectRoot, "CLAUDE.md");
   if (await pathExists(claudeMdPath)) {
     let claudeContent;
     try {
-      claudeContent = await readFile16(claudeMdPath, "utf8");
+      claudeContent = await readFile19(claudeMdPath, "utf8");
     } catch {
       return;
     }
@@ -9821,7 +10918,7 @@ ${managedBlock}
 async function ensureEventLedger(projectRoot) {
   const path = getEventLedgerPath(projectRoot);
   await ensureParentDirectory(path);
-  await writeFile3(path, "", { encoding: "utf8", flag: "a" });
+  await writeFile5(path, "", { encoding: "utf8", flag: "a" });
 }
 function createFixMessage(fixed, report) {
   const fixedText = fixed.length === 0 ? "No deterministic doctor fixes were needed." : `Applied ${fixed.length} deterministic doctor fix${fixed.length === 1 ? "" : "es"}.`;
@@ -9860,7 +10957,7 @@ async function collectEntryPoints(root) {
       continue;
     }
     for (const entry of await readdirAsync(current, { withFileTypes: true })) {
-      const absolutePath = join21(current, entry.name);
+      const absolutePath = join24(current, entry.name);
       const relativePath = normalizePath2(absolutePath.slice(root.length + 1));
       if (relativePath.length === 0) {
         continue;
@@ -9936,7 +11033,7 @@ async function enrichDescriptions(projectRoot, opts = {}) {
     scanned += 1;
     let source;
     try {
-      source = await readFile16(absPath, "utf8");
+      source = await readFile19(absPath, "utf8");
     } catch {
       continue;
     }
@@ -10074,16 +11171,16 @@ async function runDoctorConflictLint(projectRoot, opts = {}) {
 }
 
 // src/services/why-not-surfaced.ts
-import { readFile as readFile17 } from "fs/promises";
-import { basename as basename3, join as join22 } from "path";
+import { readFile as readFile20 } from "fs/promises";
+import { basename as basename3, join as join25 } from "path";
 import {
-  buildStoreResolveInput as buildStoreResolveInput7,
-  createStoreResolver as createStoreResolver7,
-  loadProjectConfig as loadProjectConfig4,
+  buildStoreResolveInput as buildStoreResolveInput8,
+  createStoreResolver as createStoreResolver8,
+  loadProjectConfig as loadProjectConfig6,
   readKnowledgeAcrossStores as readKnowledgeAcrossStores4,
-  resolveGlobalRoot as resolveGlobalRoot7,
+  resolveGlobalRoot as resolveGlobalRoot9,
   scopeRoot as scopeRoot3,
-  storeRelativePathForMount as storeRelativePathForMount6
+  storeRelativePathForMount as storeRelativePathForMount7
 } from "@fenglimg/fabric-shared";
 var SEMANTIC_SCOPE_LINE3 = /^semantic_scope:\s*"?([^"\n]+?)"?\s*$/mu;
 var RELEVANCE_SCOPE_LINE = /^relevance_scope:\s*"?(broad|narrow)"?\s*$/mu;
@@ -10107,15 +11204,15 @@ async function explainWhyNotSurfaced(projectRoot, query) {
     activeProject: null,
     relevanceScope: null
   };
-  const input = buildStoreResolveInput7(projectRoot);
+  const input = buildStoreResolveInput8(projectRoot);
   if (input === null) {
     return base;
   }
-  const globalRoot = resolveGlobalRoot7();
+  const globalRoot = resolveGlobalRoot9();
   const allStores = input.mountedStores.map((s) => ({
     store_uuid: s.store_uuid,
     alias: s.alias,
-    dir: join22(globalRoot, storeRelativePathForMount6(s))
+    dir: join25(globalRoot, storeRelativePathForMount7(s))
   }));
   const refs = await readKnowledgeAcrossStores4(allStores);
   const candidate = refs.find((ref) => fileMatchesId(ref.file, localId));
@@ -10124,7 +11221,7 @@ async function explainWhyNotSurfaced(projectRoot, query) {
   }
   let source;
   try {
-    source = await readFile17(candidate.file, "utf8");
+    source = await readFile20(candidate.file, "utf8");
   } catch {
     return base;
   }
@@ -10133,9 +11230,9 @@ async function explainWhyNotSurfaced(projectRoot, query) {
   }
   const semanticScope = SEMANTIC_SCOPE_LINE3.exec(source)?.[1] ?? null;
   const relevanceScope = RELEVANCE_SCOPE_LINE.exec(source)?.[1] ?? "broad";
-  const activeProject = loadProjectConfig4(projectRoot)?.active_project ?? null;
+  const activeProject = loadProjectConfig6(projectRoot)?.active_project ?? null;
   const boundUuids = new Set(
-    createStoreResolver7().resolveReadSet(input).stores.map((s) => s.store_uuid)
+    createStoreResolver8().resolveReadSet(input).stores.map((s) => s.store_uuid)
   );
   const storeBound = boundUuids.has(candidate.store_uuid);
   const found = {
@@ -10177,6 +11274,191 @@ function buildColdEvalBatch(candidates) {
   return { rubric: COLD_EVAL_RUBRIC, candidates: judgeable };
 }
 
+// src/services/doctor-related-graph.ts
+function buildRelatedGraph(nodes) {
+  const brokenLinks = [];
+  const inDegree = /* @__PURE__ */ new Map();
+  const allIds = /* @__PURE__ */ new Set();
+  const edgeSources = [];
+  for (const node of nodes) {
+    const bareId = extractBareStableId(node.qualifiedId);
+    allIds.add(node.qualifiedId);
+    if (bareId !== null) {
+      allIds.add(bareId);
+    }
+    const related = node.related;
+    if (related !== void 0 && related.length > 0) {
+      edgeSources.push({ source: node.qualifiedId, related });
+      for (const rel of related) {
+        inDegree.set(rel, (inDegree.get(rel) ?? 0) + 1);
+      }
+    }
+  }
+  for (const { source, related } of edgeSources) {
+    for (const rel of related) {
+      if (!allIds.has(rel)) {
+        brokenLinks.push({ source, target: rel });
+      }
+    }
+  }
+  const hubEntries = [...inDegree.entries()].map(([stableId, degree]) => ({ stableId, inDegree: degree })).sort((a, b) => b.inDegree - a.inDegree || a.stableId.localeCompare(b.stableId));
+  return {
+    brokenLinks,
+    hubEntries,
+    totalEntries: nodes.length
+  };
+}
+function extractBareStableId(qualifiedId) {
+  const colonIdx = qualifiedId.indexOf(":");
+  if (colonIdx > 0 && colonIdx < qualifiedId.length - 1) {
+    return qualifiedId.slice(colonIdx + 1);
+  }
+  return null;
+}
+async function inspectRelatedGraph(projectRoot) {
+  const entries = await collectStoreCanonicalEntries(projectRoot);
+  return buildRelatedGraph(
+    entries.map((entry) => ({
+      qualifiedId: entry.qualifiedId,
+      related: entry.description.related
+    }))
+  );
+}
+
+// src/services/store-precheck.ts
+import { existsSync as existsSync9, readFileSync as readFileSync4 } from "fs";
+import { join as join26 } from "path";
+import {
+  buildStoreResolveInput as buildStoreResolveInput9,
+  createStoreResolver as createStoreResolver9,
+  resolveGlobalRoot as resolveGlobalRoot10,
+  storeRelativePathForMount as storeRelativePathForMount8
+} from "@fenglimg/fabric-shared";
+var CACHE_TTL_MS = 6e4;
+var cache = /* @__PURE__ */ new Map();
+function clearPrecheckCache() {
+  cache.clear();
+}
+function evaluateStoreDir(storeDir, identity) {
+  if (!existsSync9(storeDir)) {
+    return {
+      uuid: identity.uuid,
+      alias: identity.alias,
+      reachable: false,
+      reason: `directory not found at ${storeDir}`
+    };
+  }
+  const storeJsonPath = join26(storeDir, "store.json");
+  const gitDirPath = join26(storeDir, ".git");
+  const hasStoreJson = existsSync9(storeJsonPath) && isValidStoreJson(storeJsonPath);
+  const hasGitDir = existsSync9(gitDirPath);
+  if (!hasStoreJson && !hasGitDir) {
+    return {
+      uuid: identity.uuid,
+      alias: identity.alias,
+      reachable: false,
+      reason: `no store.json or .git found in ${storeDir}`
+    };
+  }
+  return { uuid: identity.uuid, alias: identity.alias, reachable: true };
+}
+function isValidStoreJson(path) {
+  try {
+    JSON.parse(readFileSync4(path, "utf8"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function precheckStoreReachability(projectRoot, globalRoot = resolveGlobalRoot10(), now = Date.now()) {
+  const cached = cache.get(projectRoot);
+  if (cached !== void 0 && cached.expiresAt > now) {
+    return cached.result;
+  }
+  const input = buildStoreResolveInput9(projectRoot, globalRoot);
+  if (input === null) {
+    const result2 = { stores: [], allReachable: true };
+    cache.set(projectRoot, { result: result2, expiresAt: now + CACHE_TTL_MS });
+    return result2;
+  }
+  const readSet = createStoreResolver9().resolveReadSet(input);
+  const stores = readSet.stores.map((entry) => {
+    const mounted = input.mountedStores.find((s) => s.store_uuid === entry.store_uuid);
+    const storeDir = join26(
+      globalRoot,
+      storeRelativePathForMount8(mounted ?? { store_uuid: entry.store_uuid })
+    );
+    return evaluateStoreDir(storeDir, { uuid: entry.store_uuid, alias: entry.alias });
+  });
+  const result = {
+    stores,
+    allReachable: stores.every((s) => s.reachable)
+  };
+  cache.set(projectRoot, { result, expiresAt: now + CACHE_TTL_MS });
+  return result;
+}
+
+// src/services/doctor-consumption-lint.ts
+var DEFAULT_WINDOW_DAYS = 30;
+var DEFAULT_TOP_N = 10;
+var DEFAULT_MIN_TOTAL_ENTRIES = 20;
+var DEFAULT_MIN_CONSUMED_WINDOWS = 30;
+var DEFAULT_MIN_CONSUMED_EVENTS = 50;
+var CONSUMED_PREFIX = "knowledge_consumed:";
+var MS_PER_DAY5 = 24 * 60 * 60 * 1e3;
+function resolveConfig(config) {
+  return {
+    windowDays: config?.windowDays ?? DEFAULT_WINDOW_DAYS,
+    topN: config?.topN ?? DEFAULT_TOP_N,
+    minTotalEntries: config?.minTotalEntries ?? DEFAULT_MIN_TOTAL_ENTRIES,
+    minConsumedWindows: config?.minConsumedWindows ?? DEFAULT_MIN_CONSUMED_WINDOWS,
+    minConsumedEvents: config?.minConsumedEvents ?? DEFAULT_MIN_CONSUMED_EVENTS
+  };
+}
+function aggregateConsumption(rows, allQualifiedIds, now, config) {
+  const cfg = resolveConfig(config);
+  const cutoffMs = now - cfg.windowDays * MS_PER_DAY5;
+  const consumed = /* @__PURE__ */ new Map();
+  let consumedWindows = 0;
+  let totalConsumedEvents = 0;
+  for (const row of rows) {
+    const rowTs = Date.parse(row.timestamp);
+    if (!Number.isFinite(rowTs) || rowTs < cutoffMs) continue;
+    if (row.counters === null || typeof row.counters !== "object") continue;
+    let windowHadConsumption = false;
+    for (const [counterName, rawCount] of Object.entries(row.counters)) {
+      if (!counterName.startsWith(CONSUMED_PREFIX)) continue;
+      const count = typeof rawCount === "number" ? rawCount : 0;
+      if (count <= 0) continue;
+      const id = counterName.slice(CONSUMED_PREFIX.length);
+      if (id.length === 0) continue;
+      consumed.set(id, (consumed.get(id) ?? 0) + count);
+      totalConsumedEvents += count;
+      windowHadConsumption = true;
+    }
+    if (windowHadConsumption) consumedWindows += 1;
+  }
+  const topConsumed = [...consumed.entries()].map(([stableId, count]) => ({ stableId, count })).sort((a, b) => b.count - a.count || a.stableId.localeCompare(b.stableId)).slice(0, cfg.topN);
+  const dataMature = consumedWindows >= cfg.minConsumedWindows && totalConsumedEvents >= cfg.minConsumedEvents && allQualifiedIds.length >= cfg.minTotalEntries;
+  const zeroConsumed = dataMature ? allQualifiedIds.filter((id) => !consumed.has(id)).sort((a, b) => a.localeCompare(b)) : [];
+  return {
+    topConsumed,
+    zeroConsumed,
+    totalEntries: allQualifiedIds.length,
+    consumedEntries: consumed.size,
+    consumedWindows,
+    totalConsumedEvents,
+    dataMature,
+    windowDays: cfg.windowDays
+  };
+}
+async function inspectConsumption(projectRoot, config, now = Date.now()) {
+  const rows = await readMetrics(projectRoot);
+  const entries = await collectStoreCanonicalEntries(projectRoot);
+  const allQualifiedIds = entries.map((entry) => entry.qualifiedId);
+  return aggregateConsumption(rows, allQualifiedIds, now, config);
+}
+
 // src/services/rotation-tick.ts
 var DEFAULT_TICK_INTERVAL_MS = 6 * 60 * 60 * 1e3;
 var tickTimers = /* @__PURE__ */ new Map();
@@ -10212,7 +11494,7 @@ import { IOFabricError as IOFabricError2, RuleError } from "@fenglimg/fabric-sha
 
 // src/services/read-ledger.ts
 import { randomUUID as randomUUID7 } from "crypto";
-import { access as access5, copyFile, readFile as readFile18, rm } from "fs/promises";
+import { access as access5, copyFile, readFile as readFile21, rm } from "fs/promises";
 import { ledgerEntrySchema } from "@fenglimg/fabric-shared";
 async function resolveLedgerPaths(projectRoot) {
   const primaryPath = getLedgerPath(projectRoot);
@@ -10240,7 +11522,7 @@ async function readLegacyLedger(projectRoot) {
   const { readPath } = await resolveLedgerPaths(projectRoot);
   let raw;
   try {
-    raw = await readFile18(readPath, "utf8");
+    raw = await readFile21(readPath, "utf8");
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") {
       return [];
@@ -10495,8 +11777,8 @@ function formatError(error) {
 }
 function formatPreexistingRootMessage(projectRoot) {
   const preexisting = [];
-  if (existsSync9(join23(projectRoot, "CLAUDE.md"))) preexisting.push("CLAUDE.md");
-  if (existsSync9(join23(projectRoot, "AGENTS.md"))) preexisting.push("AGENTS.md");
+  if (existsSync10(join27(projectRoot, "CLAUDE.md"))) preexisting.push("CLAUDE.md");
+  if (existsSync10(join27(projectRoot, "AGENTS.md"))) preexisting.push("AGENTS.md");
   if (preexisting.length === 0) return null;
   return `[startup] info: detected ${preexisting.join(", ")} at project root. Note: Fabric serves knowledge from mounted stores via MCP \u2014 root markdown files are not auto-loaded into the AI context.`;
 }
@@ -10523,7 +11805,7 @@ function createFabricServer(tracker) {
   const server = new McpServer(
     {
       name: "fabric-knowledge-server",
-      version: "2.3.0-rc.1"
+      version: "2.3.0-rc.10"
     },
     {
       instructions: FABRIC_SERVER_INSTRUCTIONS
@@ -10543,10 +11825,10 @@ function createFabricServer(tracker) {
     },
     async (_uri) => {
       const projectRoot = process.env.FABRIC_PROJECT_ROOT ?? process.cwd();
-      const path = join23(projectRoot, ".fabric", "bootstrap", "README.md");
+      const path = join27(projectRoot, ".fabric", "bootstrap", "README.md");
       let text = "";
-      if (existsSync9(path)) {
-        text = await readFile19(path, "utf8");
+      if (existsSync10(path)) {
+        text = await readFile22(path, "utf8");
       }
       return {
         contents: [
@@ -10644,19 +11926,27 @@ export {
   LEGACY_LEDGER_PATH,
   METRICS_LEDGER_PATH,
   METRIC_COUNTER_NAMES,
+  OPTIONAL_EMBED_PACKAGE,
   RETIRED_TOKENS,
+  aggregateConsumption,
   appendEventLedgerEvent,
   buildAlwaysActiveBodies,
   buildColdEvalBatch,
   buildKnowledgeCensus,
+  buildRelatedGraph,
   bumpCounter,
+  checkBacklogAge,
+  clearPrecheckCache,
+  collectStoreCanonicalEntries,
   contextCache,
   createFabricServer,
   createInFlightTracker,
   createShutdownHandler,
+  defaultEmbedCacheDir,
   detectUnboundProject,
   drainCounters,
   enrichDescriptions,
+  evaluateStoreDir,
   explainWhyNotSurfaced,
   extractKnowledge,
   findConflictCandidates,
@@ -10667,17 +11957,25 @@ export {
   getLedgerPath,
   getLegacyLedgerPath,
   getMetricsLedgerPath,
+  inspectConsumption,
+  inspectRelatedGraph,
   inspectRetiredReferences,
+  isEmbedderResolvable,
   lintConflicts,
   loadConflictEntries,
+  loadEmbedder,
   pairSimilarity,
   planContext,
+  precheckStoreReachability,
+  readEmbedConfig,
   readEventLedger,
+  readFusion,
   readLedger,
   readMetrics,
   readSelectionToken,
   recall,
   rehydrateAgentsMetaAt,
+  renderBacklogAgeLine,
   resolveLedgerPaths,
   reviewKnowledge,
   reviewPending,