@fenglimg/fabric-server 2.2.0-rc.8 → 2.2.0

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/index.ts
-import { existsSync as existsSync8 } from "fs";
-import { readFile as readFile16 } from "fs/promises";
-import { join as join20, resolve as resolve4 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { readFile as readFile17 } from "fs/promises";
+import { join as join21, 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";
@@ -700,13 +700,9 @@ function appendPayloadWarning(warnings, guardResult, actionHint) {
 // src/config-loader.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { join as join4 } from "path";
-import { selectionTokenTtlMsSchema, planContextTopKSchema, resolveRetrievalBudget } from "@fenglimg/fabric-shared";
-var RETRIEVAL_BUDGET_PROFILES = ["conservative", "balanced", "generous"];
-function readRetrievalBudgetProfile(config) {
-  const raw = config.retrieval_budget_profile;
-  return typeof raw === "string" && RETRIEVAL_BUDGET_PROFILES.includes(raw) ? raw : void 0;
-}
+import { selectionTokenTtlMsSchema, planContextTopKSchema } from "@fenglimg/fabric-shared";
 var PLAN_CONTEXT_TOP_K_DEFAULT = 24;
+var RECALL_RELEVANCE_RATIO_DEFAULT = 0.25;
 function readFabricConfig(projectRoot) {
   const configPath = join4(projectRoot, ".fabric", "fabric-config.json");
   if (!existsSync2(configPath)) {
@@ -719,18 +715,7 @@ function readFabricConfig(projectRoot) {
   return parsed;
 }
 function readPayloadLimits(projectRoot) {
-  const config = readFabricConfig(projectRoot);
-  const explicit = config.mcpPayloadLimits;
-  const profile = readRetrievalBudgetProfile(config);
-  if (profile === void 0 && explicit === void 0) {
-    return void 0;
-  }
-  const resolved = resolveRetrievalBudget({
-    profile,
-    payloadWarnBytes: explicit?.warnBytes,
-    payloadHardBytes: explicit?.hardBytes
-  });
-  return { warnBytes: resolved.payloadWarnBytes, hardBytes: resolved.payloadHardBytes };
+  return readFabricConfig(projectRoot).mcpPayloadLimits;
 }
 function readSelectionTokenTtlMs(projectRoot) {
   try {
@@ -776,17 +761,27 @@ function readDefaultLayerFilter(projectRoot) {
 }
 function readPlanContextTopK(projectRoot) {
   try {
-    const config = readFabricConfig(projectRoot);
-    const raw = config.plan_context_top_k;
+    const raw = readFabricConfig(projectRoot).plan_context_top_k;
     if (raw !== void 0) {
       const parsed = planContextTopKSchema.safeParse(raw);
       if (parsed.success) return parsed.data;
     }
-    return resolveRetrievalBudget({ profile: readRetrievalBudgetProfile(config) }).topK;
+    return PLAN_CONTEXT_TOP_K_DEFAULT;
   } catch {
     return PLAN_CONTEXT_TOP_K_DEFAULT;
   }
 }
+function readRecallRelevanceRatio(projectRoot) {
+  try {
+    const raw = readFabricConfig(projectRoot).recall_relevance_ratio;
+    if (typeof raw === "number" && Number.isFinite(raw) && raw >= 0 && raw <= 1) {
+      return raw;
+    }
+    return RECALL_RELEVANCE_RATIO_DEFAULT;
+  } catch {
+    return RECALL_RELEVANCE_RATIO_DEFAULT;
+  }
+}
 function readOrphanDemoteThresholdDays(projectRoot) {
   try {
     const cfg = readFabricConfig(projectRoot);
@@ -2033,6 +2028,8 @@ async function buildKnowledgeCensus(projectRoot) {
   const census = {
     by_type: {},
     by_layer: { team: 0, personal: 0, project: 0 },
+    broad_by_type: {},
+    narrow_total: 0,
     dropped_other_project: 0,
     total: 0
   };
@@ -2042,10 +2039,16 @@ async function buildKnowledgeCensus(projectRoot) {
     const kept = filterByActiveProject(all, activeProject);
     census.dropped_other_project = all.length - kept.length;
     for (const entry of kept) {
-      const type = extractRuleDescription(entry.source)?.knowledge_type;
+      const desc = extractRuleDescription(entry.source);
+      const type = desc?.knowledge_type;
+      const isNarrow = desc?.relevance_scope === "narrow";
       if (typeof type === "string") {
         census.by_type[type] = (census.by_type[type] ?? 0) + 1;
+        if (!isNarrow) {
+          census.broad_by_type[type] = (census.broad_by_type[type] ?? 0) + 1;
+        }
       }
+      if (isNarrow) census.narrow_total += 1;
       if (scopeRoot(entry.semanticScope) === "project") {
         census.by_layer.project += 1;
       } else {
@@ -2069,6 +2072,7 @@ async function buildAlwaysActiveBodies(projectRoot) {
       if (desc === void 0) continue;
       const type = desc.knowledge_type;
       if (typeof type !== "string" || !ALWAYS_ACTIVE_TYPES.has(type)) continue;
+      if (desc.relevance_scope === "narrow") continue;
       out.push({
         stable_id: entry.qualifiedId,
         type,
@@ -2643,11 +2647,23 @@ async function planContext(projectRoot, input) {
       scoringContext.vectorWeight = embedConfig.weight;
     }
   }
-  const builtItems = sortDescriptionItems(rawItems, scoringContext);
-  const rankedCandidates = dedupeDescriptionIndex(builtItems);
+  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 rankedCandidates = rankedScored.map((entry) => entry.item);
   const topK = readPlanContextTopK(projectRoot);
-  const omittedCandidateCount = Math.max(0, rankedCandidates.length - topK);
-  const topKCandidates = omittedCandidateCount > 0 ? rankedCandidates.slice(0, topK) : rankedCandidates;
+  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 topKCandidates = survivingScored.map((entry) => entry.item);
+  const omittedCandidateCount = Math.max(0, rankedCandidates.length - topKCandidates.length);
   let candidates = topKCandidates;
   const relatedAppended = {};
   if (input.include_related === true) {
@@ -2889,7 +2905,7 @@ function compareScopeThenId(left, right, scopeRank) {
 }
 function sortDescriptionItems(rawItems, scoringContext) {
   if (scoringContext === void 0) {
-    return [...rawItems].sort((left, right) => compareStableIds(left.stable_id, right.stable_id));
+    return [...rawItems].sort((left, right) => compareStableIds(left.stable_id, right.stable_id)).map((item) => ({ item, score: 0 }));
   }
   const scored = rawItems.map((item) => ({
     item,
@@ -2899,7 +2915,7 @@ function sortDescriptionItems(rawItems, scoringContext) {
     (left, right) => left.score !== right.score ? right.score - left.score : compareScopeThenId(left.item, right.item, scoringContext.scopeRank)
     // W2/A4 scope tie-break
   );
-  return scored.map((entry) => entry.item);
+  return scored;
 }
 function documentTextForItem(description) {
   return [
@@ -2930,16 +2946,6 @@ function buildPreflightDiagnostics(suppressedStableIds) {
 function dedupeStableIds(stableIds) {
   return Array.from(new Set(stableIds));
 }
-function dedupeDescriptionIndex(items) {
-  const seenStableIds = /* @__PURE__ */ new Set();
-  return items.filter((item) => {
-    if (seenStableIds.has(item.stable_id)) {
-      return false;
-    }
-    seenStableIds.add(item.stable_id);
-    return true;
-  });
-}
 var RECENCY_WINDOW_MS = 7 * 24 * 60 * 60 * 1e3;
 var RECENCY_BOOST = 25;
 var LOCALITY_SAME_FILE = 100;
@@ -3091,7 +3097,7 @@ function buildNextSteps(planResult, paths, candidateById, candidateLookup) {
   const omitted = planResult.omitted_candidate_count ?? 0;
   if (omitted > 0) {
     nextSteps.push(
-      `${omitted} lower-ranked candidate(s) were omitted by the retrieval budget \u2014 pass a narrower intent (or raise plan_context_top_k / the retrieval_budget_profile) to surface them.`
+      `${omitted} lower-ranked candidate(s) were omitted by the retrieval budget \u2014 pass a narrower intent (or raise plan_context_top_k) to surface them.`
     );
   }
   const surfacedPaths = new Set(paths.map((p) => p.stable_id));
@@ -3409,11 +3415,155 @@ import { enforcePayloadLimit as enforcePayloadLimit4 } from "@fenglimg/fabric-sh
 
 // src/services/review.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync4 } from "fs";
-import { readFile as readFile5, readdir, stat as stat2, unlink } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { readFile as readFile6, readdir as readdir2, stat as stat2, unlink as unlink2 } from "fs/promises";
 import { homedir } from "os";
-import { basename, isAbsolute, join as join9, relative, resolve as resolve2, sep as sep2 } from "path";
+import { basename, isAbsolute, join as join10, relative, resolve as resolve2, sep as sep2 } from "path";
 import { allocateStoreKnowledgeId, isPersonalScope as isPersonalScope2 } 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";
+var PENDING_TYPES = ["decisions", "pitfalls", "guidelines", "models", "processes"];
+var DISAMBIGUATION_SUFFIX = /^(.+)-([2-9])\.md$/u;
+var SOURCE_SESSIONS_LINE = /^source_sessions:\s*\[(.*)\]\s*$/mu;
+var CREATED_AT_LINE = /^created_at:\s*(.+)$/mu;
+function parseSourceSessions(content) {
+  const m = SOURCE_SESSIONS_LINE.exec(content);
+  if (!m) return [];
+  try {
+    const arr = JSON.parse(`[${m[1]}]`);
+    return Array.isArray(arr) ? arr.filter((s) => typeof s === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function parseCreatedAt(content) {
+  const m = CREATED_AT_LINE.exec(content);
+  return m ? m[1].trim() : "";
+}
+function resolveBaseSlug(name, present) {
+  const m = DISAMBIGUATION_SUFFIX.exec(name);
+  if (m && present.has(`${m[1]}.md`)) return m[1];
+  return name.replace(/\.md$/u, "");
+}
+function unionSessions(survivor, twins) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const s of [survivor, ...twins]) {
+    for (const sid of s.sourceSessions) {
+      if (sid.length > 0 && !seen.has(sid)) {
+        seen.add(sid);
+        out.push(sid);
+      }
+    }
+  }
+  return out;
+}
+function buildMergedContent(survivor, twins) {
+  const union = unionSessions(survivor, twins);
+  let merged = survivor.content.replace(
+    SOURCE_SESSIONS_LINE,
+    `source_sessions: [${union.map((s) => JSON.stringify(s)).join(", ")}]`
+  );
+  if (!merged.endsWith("\n")) merged += "\n";
+  for (const twin of twins) {
+    const body = extractBody(twin.content).trim();
+    if (body.length === 0) continue;
+    merged += `
+## Evidence (merged from session ${twin.primarySession || "unknown"})
+
+${body}
+`;
+  }
+  return merged;
+}
+function chooseSurvivor(baseSlug, group) {
+  const exact = group.find((p) => p.name === `${baseSlug}.md`);
+  if (exact) return exact;
+  return [...group].sort((a, b) => {
+    if (a.createdAt !== b.createdAt) return a.createdAt < b.createdAt ? -1 : 1;
+    return a.name < b.name ? -1 : 1;
+  })[0];
+}
+async function mergePendingTwins(projectRoot) {
+  const merged = [];
+  for (const layer of ["team", "personal"]) {
+    let pendingBase2;
+    try {
+      pendingBase2 = resolveStorePendingBase(layer, projectRoot);
+    } catch {
+      continue;
+    }
+    for (const type of PENDING_TYPES) {
+      const dir = join9(pendingBase2, type);
+      if (!existsSync4(dir)) continue;
+      let names;
+      try {
+        names = (await readdir(dir)).filter((n) => n.endsWith(".md"));
+      } catch {
+        continue;
+      }
+      if (names.length < 2) continue;
+      const present = new Set(names);
+      const groups = /* @__PURE__ */ new Map();
+      for (const name of names) {
+        const base = resolveBaseSlug(name, present);
+        const arr = groups.get(base);
+        if (arr) arr.push(name);
+        else groups.set(base, [name]);
+      }
+      for (const [baseSlug, groupNames] of groups) {
+        if (groupNames.length < 2) continue;
+        const parsed = [];
+        for (const name of groupNames) {
+          const abs = join9(dir, name);
+          let content;
+          try {
+            content = await readFile5(abs, "utf8");
+          } catch {
+            continue;
+          }
+          const sourceSessions = parseSourceSessions(content);
+          parsed.push({
+            name,
+            abs,
+            content,
+            sourceSessions,
+            primarySession: sourceSessions[0] ?? "",
+            createdAt: parseCreatedAt(content)
+          });
+        }
+        if (parsed.length < 2) continue;
+        const distinctPrimaries = new Set(parsed.map((p) => p.primarySession).filter((s) => s.length > 0));
+        if (distinctPrimaries.size < 2) continue;
+        const survivor = chooseSurvivor(baseSlug, parsed);
+        const twins = parsed.filter((p) => p.abs !== survivor.abs);
+        const mergedContent = buildMergedContent(survivor, twins);
+        try {
+          await atomicWriteText(survivor.abs, mergedContent);
+          for (const twin of twins) {
+            await unlink(twin.abs);
+          }
+        } catch {
+          continue;
+        }
+        merged.push({
+          layer,
+          type,
+          base_slug: baseSlug,
+          survivor: survivor.abs,
+          removed: twins.map((t) => t.abs),
+          source_sessions: unionSessions(survivor, twins)
+        });
+      }
+    }
+  }
+  return { merged };
+}
+
+// src/services/review.ts
 var PLURAL_TYPES = [
   "decisions",
   "pitfalls",
@@ -3520,6 +3670,10 @@ function isVisibleByLifecycle(fm, filters) {
   return true;
 }
 async function listPending(projectRoot, filters) {
+  try {
+    await mergePendingTwins(projectRoot);
+  } catch {
+  }
   const items = [];
   const typesToScan = filters?.type !== void 0 ? [filters.type] : PLURAL_TYPES;
   const sources = [];
@@ -3539,22 +3693,22 @@ async function listPending(projectRoot, filters) {
   }
   for (const source of sources) {
     for (const type of typesToScan) {
-      const dir = join9(source.root, type);
-      if (!existsSync4(dir)) {
+      const dir = join10(source.root, type);
+      if (!existsSync5(dir)) {
         continue;
       }
       let entries;
       try {
-        entries = await readdir(dir);
+        entries = await readdir2(dir);
       } catch {
         continue;
       }
       for (const name of entries) {
         if (!name.endsWith(".md")) continue;
-        const absolutePath = join9(dir, name);
+        const absolutePath = join10(dir, name);
         let content;
         try {
-          content = await readFile5(absolutePath, "utf8");
+          content = await readFile6(absolutePath, "utf8");
         } catch {
           continue;
         }
@@ -3664,7 +3818,7 @@ async function approveOne(projectRoot, pendingPath) {
   let targetAbs;
   let writtenTarget = false;
   try {
-    const content = await readFile5(sourceAbs, "utf8");
+    const content = await readFile6(sourceAbs, "utf8");
     const fm = parseFrontmatter(content);
     const pluralType = fm.type;
     if (pluralType === void 0 || !PLURAL_TYPES.includes(pluralType)) {
@@ -3678,14 +3832,14 @@ async function approveOne(projectRoot, pendingPath) {
     );
     allocatedId = stableId;
     const newFilename = `${stableId}--${slug}.md`;
-    targetAbs = join9(resolveStoreCanonicalBase(layer, projectRoot), pluralType, newFilename);
+    targetAbs = join10(resolveStoreCanonicalBase(layer, projectRoot), pluralType, newFilename);
     await ensureParentDirectory(targetAbs);
     const rewritten = rewriteFrontmatterForPromote(content, stableId);
     await atomicWriteText(targetAbs, rewritten);
     writtenTarget = true;
     if (sourceIsStore) {
-      if (existsSync4(sourceAbs)) {
-        await unlink(sourceAbs);
+      if (existsSync5(sourceAbs)) {
+        await unlink2(sourceAbs);
       }
     } else if (sourceOrigin === "team") {
       try {
@@ -3694,13 +3848,13 @@ async function approveOne(projectRoot, pendingPath) {
           stdio: ["ignore", "pipe", "pipe"]
         });
       } catch {
-        if (existsSync4(sourceAbs)) {
-          await unlink(sourceAbs);
+        if (existsSync5(sourceAbs)) {
+          await unlink2(sourceAbs);
         }
       }
     } else {
-      if (existsSync4(sourceAbs)) {
-        await unlink(sourceAbs);
+      if (existsSync5(sourceAbs)) {
+        await unlink2(sourceAbs);
       }
     }
     await emitEventBestEffort2(projectRoot, {
@@ -3711,9 +3865,9 @@ async function approveOne(projectRoot, pendingPath) {
     });
     return { pending_path: pendingPath, stable_id: stableId };
   } catch (err) {
-    if (writtenTarget && targetAbs !== void 0 && existsSync4(targetAbs)) {
+    if (writtenTarget && targetAbs !== void 0 && existsSync5(targetAbs)) {
       try {
-        await unlink(targetAbs);
+        await unlink2(targetAbs);
       } catch {
       }
     }
@@ -3732,14 +3886,14 @@ async function rejectAll(projectRoot, pendingPaths, reason) {
   for (const pendingPath of pendingPaths) {
     try {
       const sandboxed = resolveSandboxedPath(projectRoot, pendingPath, { allowPersonal: true });
-      if (existsSync4(sandboxed.abs)) {
-        const content = await readFile5(sandboxed.abs, "utf8");
+      if (existsSync5(sandboxed.abs)) {
+        const content = await readFile6(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) {
           await ensureParentDirectory(rejectedAbs);
           await atomicWriteText(rejectedAbs, merged);
-          await unlink(sandboxed.abs);
+          await unlink2(sandboxed.abs);
         } else if (merged !== content) {
           await atomicWriteText(sandboxed.abs, merged);
         }
@@ -3760,7 +3914,7 @@ async function modifyEntry(projectRoot, pendingPath, changes) {
   if (target === null) {
     throw new Error(`modify target not found: ${pendingPath}`);
   }
-  const content = await readFile5(target.absPath, "utf8");
+  const content = await readFile6(target.absPath, "utf8");
   const fm = parseFrontmatter(content);
   const currentLayer = fm.layer ?? "team";
   if (changes.semantic_scope !== void 0 && isPersonalScope2(changes.semantic_scope)) {
@@ -3805,7 +3959,7 @@ function resolveModifyTarget(projectRoot, pendingPath) {
   } catch {
     return null;
   }
-  if (existsSync4(sandboxed.abs)) {
+  if (existsSync5(sandboxed.abs)) {
     return {
       absPath: sandboxed.abs,
       isInProjectTree: sandboxed.isInProjectTree,
@@ -3852,7 +4006,7 @@ async function modifyLayerFlip(projectRoot, target, content, fm, changes) {
     pluralType,
     resolveWriteTargetStoreDir(toLayer, projectRoot)
   );
-  const toAbs = join9(
+  const toAbs = join10(
     resolveStoreCanonicalBase(toLayer, projectRoot),
     pluralType,
     `${newStableId}--${slug}.md`
@@ -3880,12 +4034,12 @@ async function modifyLayerFlip(projectRoot, target, content, fm, changes) {
         stdio: ["ignore", "pipe", "pipe"]
       });
     } catch {
-      if (existsSync4(target.absPath)) {
-        await unlink(target.absPath);
+      if (existsSync5(target.absPath)) {
+        await unlink2(target.absPath);
       }
     }
-  } else if (existsSync4(target.absPath)) {
-    await unlink(target.absPath);
+  } else if (existsSync5(target.absPath)) {
+    await unlink2(target.absPath);
   }
   const flipReason = `layer_flip:${priorStableId ?? "<unassigned>"}->${newStableId}`;
   const flipTimestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -3948,10 +4102,10 @@ function getSearchDirectoryCache(cacheKey) {
   return created;
 }
 async function listIndexedSearchEntries(source, type) {
-  const dir = join9(source.root, type);
+  const dir = join10(source.root, type);
   let entries;
   try {
-    entries = await readdir(dir);
+    entries = await readdir2(dir);
   } catch {
     return [];
   }
@@ -3961,7 +4115,7 @@ async function listIndexedSearchEntries(source, type) {
   const indexed = [];
   for (const name of entries) {
     if (!name.endsWith(".md")) continue;
-    const absolutePath = join9(dir, name);
+    const absolutePath = join10(dir, name);
     let fingerprint;
     try {
       const st = await stat2(absolutePath);
@@ -3978,7 +4132,7 @@ async function listIndexedSearchEntries(source, type) {
     }
     let content;
     try {
-      content = await readFile5(absolutePath, "utf8");
+      content = await readFile6(absolutePath, "utf8");
       searchEntryIndexContentReads += 1;
     } catch {
       directoryCache.files.delete(absolutePath);
@@ -4098,8 +4252,8 @@ async function deferAll(projectRoot, pendingPaths, until, reason) {
     let stableId;
     try {
       const sandboxed = resolveSandboxedPath(projectRoot, pendingPath, { allowPersonal: true });
-      if (existsSync4(sandboxed.abs)) {
-        const content = await readFile5(sandboxed.abs, "utf8");
+      if (existsSync5(sandboxed.abs)) {
+        const content = await readFile6(sandboxed.abs, "utf8");
         stableId = parseFrontmatter(content).id;
         const patch = {
           status: "deferred",
@@ -4371,9 +4525,9 @@ function registerReview(server, tracker) {
 }
 
 // src/services/doctor.ts
-import { access as access4, readFile as readFile14, readdir as readdirAsync, stat as statAsync, unlink as unlink3, writeFile as writeFile3 } from "fs/promises";
+import { access as access4, readFile as readFile15, readdir as readdirAsync, stat as statAsync, unlink as unlink4, writeFile as writeFile3 } from "fs/promises";
 import { constants as constants2 } from "fs";
-import { isAbsolute as isAbsolute2, join as join19, posix as posix4, resolve as resolve3 } from "path";
+import { isAbsolute as isAbsolute2, join as join20, posix as posix4, resolve as resolve3 } from "path";
 import {
   createTranslator,
   forensicReportSchema,
@@ -4587,8 +4741,8 @@ function createKnowledgeSummaryOpaqueCheck(t, inspection) {
 }
 
 // src/services/doctor-stable-id-collision.ts
-import { readFile as readFile6 } from "fs/promises";
-import { basename as basename2, join as join10 } from "path";
+import { readFile as readFile7 } from "fs/promises";
+import { basename as basename2, join as join11 } from "path";
 import {
   buildStoreResolveInput as buildStoreResolveInput4,
   createStoreResolver as createStoreResolver4,
@@ -4615,7 +4769,7 @@ function resolveIntegrityStores(projectRoot) {
     return {
       store_uuid: entry.store_uuid,
       alias: entry.alias,
-      dir: join10(globalRoot, storeRelativePathForMount3(mounted ?? { store_uuid: entry.store_uuid }))
+      dir: join11(globalRoot, storeRelativePathForMount3(mounted ?? { store_uuid: entry.store_uuid }))
     };
   });
   return { dirs, personalUuids };
@@ -4634,7 +4788,7 @@ async function inspectStoreStableIdIntegrity(projectRoot) {
   for (const ref of await readKnowledgeAcrossStores2(resolved.dirs)) {
     let source;
     try {
-      source = await readFile6(ref.file, "utf8");
+      source = await readFile7(ref.file, "utf8");
     } catch {
       continue;
     }
@@ -4718,8 +4872,8 @@ function createLayerMismatchCheck(t, inspection) {
 
 // src/services/doctor-relevance-paths.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync5, readdirSync, statSync as statSync3 } from "fs";
-import { join as join11, sep as sep3 } from "path";
+import { existsSync as existsSync6, readdirSync, statSync as statSync3 } from "fs";
+import { join as join12, sep as sep3 } from "path";
 import { minimatch } from "minimatch";
 var MS_PER_DAY = 24 * 60 * 60 * 1e3;
 var RELEVANCE_PATHS_DRIFT_WINDOW_DAYS = 90;
@@ -4740,7 +4894,7 @@ function expandGlob(rawGlob) {
   return rawGlob.endsWith("/") ? `${rawGlob}**` : rawGlob;
 }
 function collectWorkspacePaths(projectRoot) {
-  if (!existsSync5(projectRoot)) {
+  if (!existsSync6(projectRoot)) {
     return [];
   }
   try {
@@ -4762,7 +4916,7 @@ function collectWorkspacePaths(projectRoot) {
       continue;
     }
     for (const entry of entries) {
-      const abs = join11(current, entry.name);
+      const abs = join12(current, entry.name);
       const rel = toPosix(abs.slice(projectRoot.length + 1));
       if (rel.length === 0) continue;
       if (entry.isDirectory()) {
@@ -4955,16 +5109,16 @@ function createNarrowNoPathsCheck(t, inspection) {
 }
 
 // src/services/doctor-broad-index.ts
-import { readFile as readFile7 } from "fs/promises";
-import { join as join12 } from "path";
+import { readFile as readFile8 } from "fs/promises";
+import { join as join13 } 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 = join12(projectRoot, ".fabric", "fabric-config.json");
+  const configPath = join13(projectRoot, ".fabric", "fabric-config.json");
   try {
-    const raw = await readFile7(configPath, "utf8");
+    const raw = await readFile8(configPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const v = parsed.broad_index_backstop;
@@ -5145,8 +5299,8 @@ function createStaleArchiveCheck(t, inspection) {
 }
 
 // src/services/doctor-scope-lint.ts
-import { readFile as readFile8 } from "fs/promises";
-import { join as join13 } from "path";
+import { readFile as readFile9 } from "fs/promises";
+import { join as join14 } from "path";
 import {
   buildStoreResolveInput as buildStoreResolveInput5,
   createStoreResolver as createStoreResolver5,
@@ -5181,7 +5335,7 @@ async function resolveLintStores(projectRoot) {
   const globalRoot = resolveGlobalRoot4();
   return Promise.all(readSet.stores.map(async (entry) => {
     const mounted = input.mountedStores.find((s) => s.store_uuid === entry.store_uuid);
-    const dir = join13(
+    const dir = join14(
       globalRoot,
       storeRelativePathForMount4(mounted ?? { store_uuid: entry.store_uuid })
     );
@@ -5213,7 +5367,7 @@ async function lintStoreScopes(projectRoot) {
     }
     let source;
     try {
-      source = await readFile8(ref.file, "utf8");
+      source = await readFile9(ref.file, "utf8");
     } catch {
       continue;
     }
@@ -5335,8 +5489,8 @@ function createUnboundProjectCheck(t, violation) {
 }
 
 // src/services/doctor-store-counters.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
+import { join as join15 } from "path";
 import {
   buildStoreResolveInput as buildStoreResolveInput6,
   createStoreResolver as createStoreResolver6,
@@ -5363,7 +5517,7 @@ function resolveCounterStores(projectRoot) {
   return readSet.stores.map((entry) => ({
     uuid: entry.store_uuid,
     alias: entry.alias,
-    dir: join14(
+    dir: join15(
       globalRoot,
       storeRelativePathForMount5(
         input.mountedStores.find((s) => s.store_uuid === entry.store_uuid) ?? {
@@ -5391,8 +5545,8 @@ function readEntryId(file) {
 function computeStoreDiskMax(storeDir) {
   const max = defaultAgentsMetaCounters();
   for (const type of STORE_KNOWLEDGE_TYPE_DIRS) {
-    const dir = join14(storeDir, STORE_LAYOUT2.knowledgeDir, type);
-    if (!existsSync6(dir)) {
+    const dir = join15(storeDir, STORE_LAYOUT2.knowledgeDir, type);
+    if (!existsSync7(dir)) {
       continue;
     }
     let names;
@@ -5405,7 +5559,7 @@ function computeStoreDiskMax(storeDir) {
       if (!name.endsWith(".md")) {
         continue;
       }
-      const parsed = parseKnowledgeId2(readEntryId(join14(dir, name)) ?? "");
+      const parsed = parseKnowledgeId2(readEntryId(join15(dir, name)) ?? "");
       if (parsed === null) {
         continue;
       }
@@ -5488,7 +5642,7 @@ function createStoreCounterCheck(t, drifts) {
 
 // src/services/doctor-store-orphan.ts
 import { readdirSync as readdirSync3 } from "fs";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 import {
   STORES_ROOT_DIR,
   addMountedStore,
@@ -5512,15 +5666,15 @@ function inspectStoreOrphans(globalRoot = resolveGlobalRoot6()) {
     return [];
   }
   const registered = new Set(config.stores.map((s) => s.store_uuid));
-  const storesRoot = join15(globalRoot, STORES_ROOT_DIR);
+  const storesRoot = join16(globalRoot, STORES_ROOT_DIR);
   const orphans = [];
   for (const group of listDir(storesRoot)) {
     if (group === STORE_BY_ALIAS_DIR) {
       continue;
     }
-    const groupDir = join15(storesRoot, group);
+    const groupDir = join16(storesRoot, group);
     for (const mount of listDir(groupDir)) {
-      const dir = join15(groupDir, mount);
+      const dir = join16(groupDir, mount);
       const identity = readStoreIdentity(dir);
       if (identity === null || registered.has(identity.store_uuid)) {
         continue;
@@ -5593,7 +5747,7 @@ import {
 
 // src/services/events-jsonl-gates.ts
 import { promises as fs } from "fs";
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 var EVENTS_JSONL_SIZE_WARN_BYTES = 10 * 1024 * 1024;
 var METRICS_STALE_WARN_MS = 10 * 60 * 1e3;
 var ROTATION_OVERDUE_WARN_MS = 90 * 24 * 60 * 60 * 1e3;
@@ -5615,7 +5769,7 @@ async function inspectEventsJsonlGates(projectRoot, options = {}) {
     if (!(isNodeError(error) && error.code === "ENOENT")) throw error;
   }
   let metricsStalenessMs = null;
-  if (existsSync7(metricsPath)) {
+  if (existsSync8(metricsPath)) {
     try {
       const stat4 = await fs.stat(metricsPath);
       metricsStalenessMs = Math.max(0, now.getTime() - stat4.mtimeMs);
@@ -5657,9 +5811,18 @@ async function inspectEventsJsonlGates(projectRoot, options = {}) {
 }
 
 // src/services/doctor-skill-lints.ts
-import { readdir as readdir2, readFile as readFile9 } from "fs/promises";
-import { join as join16, posix as posix2 } from "path";
+import { readdir as readdir3, readFile as readFile10 } from "fs/promises";
+import { join as join17, posix as posix2 } from "path";
 var FABRIC_SKILL_SLUGS = ["fabric-archive", "fabric-review", "fabric-import"];
+var ROUTER_VALID_LEAF_SLUGS = /* @__PURE__ */ new Set([
+  "fabric-archive",
+  "fabric-review",
+  "fabric-import",
+  "fabric-sync",
+  "fabric-store",
+  "fabric-audit",
+  "fabric-connect"
+]);
 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(['"', "'", "[", "{", ">", "|"]);
@@ -5680,7 +5843,7 @@ function issueCheck(name, status, kind, code, message, actionHint, audience) {
 }
 async function listMarkdownFiles(dir) {
   try {
-    return (await readdir2(dir)).filter((name) => name.endsWith(".md"));
+    return (await readdir3(dir)).filter((name) => name.endsWith(".md"));
   } catch {
     return null;
   }
@@ -5688,8 +5851,8 @@ async function listMarkdownFiles(dir) {
 async function inspectSkillRefMirror(projectRoot) {
   const driftedPaths = [];
   for (const slug of FABRIC_SKILL_SLUGS) {
-    const claudeRef = join16(projectRoot, ".claude", "skills", slug, "ref");
-    const codexRef = join16(projectRoot, ".codex", "skills", slug, "ref");
+    const claudeRef = join17(projectRoot, ".claude", "skills", slug, "ref");
+    const codexRef = join17(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);
@@ -5706,8 +5869,8 @@ async function inspectSkillRefMirror(projectRoot) {
       let codexBody;
       try {
         [claudeBody, codexBody] = await Promise.all([
-          readFile9(join16(claudeRef, fname), "utf8"),
-          readFile9(join16(codexRef, fname), "utf8")
+          readFile10(join17(claudeRef, fname), "utf8"),
+          readFile10(join17(codexRef, fname), "utf8")
         ]);
       } catch {
         continue;
@@ -5726,10 +5889,10 @@ async function inspectSkillTokenBudget(projectRoot) {
   const overSize = [];
   let highestSeverity = "ok";
   for (const slug of FABRIC_SKILL_SLUGS) {
-    const skillMdPath = join16(projectRoot, ".claude", "skills", slug, "SKILL.md");
+    const skillMdPath = join17(projectRoot, ".claude", "skills", slug, "SKILL.md");
     let body;
     try {
-      body = await readFile9(skillMdPath, "utf8");
+      body = await readFile10(skillMdPath, "utf8");
     } catch {
       continue;
     }
@@ -5750,10 +5913,10 @@ async function inspectSkillDescription(projectRoot) {
   const CJK_PATTERN = /[\u3400-\u4dbf\u4e00-\u9fff]/u;
   const ASCII_PATTERN = /[a-zA-Z]{2,}/u;
   for (const slug of FABRIC_SKILL_SLUGS) {
-    const skillMdPath = join16(projectRoot, ".claude", "skills", slug, "SKILL.md");
+    const skillMdPath = join17(projectRoot, ".claude", "skills", slug, "SKILL.md");
     let body;
     try {
-      body = await readFile9(skillMdPath, "utf8");
+      body = await readFile10(skillMdPath, "utf8");
     } catch {
       continue;
     }
@@ -5784,19 +5947,19 @@ async function inspectSkillDescription(projectRoot) {
 async function inspectSkillMdYamlInvalid(projectRoot) {
   const candidates = [];
   for (const rootRel of SKILL_MD_FRONTMATTER_ROOTS) {
-    const rootAbs = join16(projectRoot, rootRel);
+    const rootAbs = join17(projectRoot, rootRel);
     let dirEntries;
     try {
-      dirEntries = await readdir2(rootAbs, { withFileTypes: true });
+      dirEntries = await readdir3(rootAbs, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const dirEntry of dirEntries) {
       if (!dirEntry.isDirectory()) continue;
-      const skillFile = join16(rootAbs, dirEntry.name, "SKILL.md");
+      const skillFile = join17(rootAbs, dirEntry.name, "SKILL.md");
       let raw;
       try {
-        raw = await readFile9(skillFile, "utf8");
+        raw = await readFile10(skillFile, "utf8");
       } catch {
         continue;
       }
@@ -5844,6 +6007,68 @@ function extractSkillFrontmatterLines(raw) {
   }
   return null;
 }
+function extractMarkdownSectionBody(markdown, sectionName) {
+  const lines = markdown.split(/\r?\n/u);
+  const headingRe = /^(#{2,3})\s+(.+?)\s*$/u;
+  let start = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const h = headingRe.exec(lines[i]);
+    if (h && h[2] === sectionName) {
+      start = i + 1;
+      break;
+    }
+  }
+  if (start === -1) return null;
+  const out = [];
+  for (let i = start; i < lines.length; i++) {
+    if (headingRe.test(lines[i])) break;
+    out.push(lines[i]);
+  }
+  return out.join("\n");
+}
+async function inspectRouterChainRef(projectRoot) {
+  const candidatePaths = [
+    join17(projectRoot, ".claude", "skills", "fabric", "SKILL.md"),
+    join17(projectRoot, ".codex", "skills", "fabric", "SKILL.md")
+  ];
+  let body = null;
+  for (const candidate of candidatePaths) {
+    try {
+      body = await readFile10(candidate, "utf8");
+      break;
+    } catch {
+    }
+  }
+  if (body === null) return { status: "ok", unknownRefs: [] };
+  const chainSection = extractMarkdownSectionBody(body, "S_CHAIN");
+  if (chainSection === null) return { status: "ok", unknownRefs: [] };
+  const refs = /* @__PURE__ */ new Set();
+  const tokenRe = /`(fabric-[a-z]+)`/gu;
+  let match;
+  while ((match = tokenRe.exec(chainSection)) !== null) {
+    refs.add(match[1]);
+  }
+  const unknownRefs = [...refs].filter((slug) => !ROUTER_VALID_LEAF_SLUGS.has(slug)).sort();
+  return unknownRefs.length === 0 ? { status: "ok", unknownRefs: [] } : { status: "drift", unknownRefs };
+}
+function createRouterChainRefCheck(t, inspection) {
+  if (inspection.status === "ok") {
+    return okCheck(t("doctor.check.router_chain_ref.name"), t("doctor.check.router_chain_ref.ok"));
+  }
+  const count = inspection.unknownRefs.length;
+  return issueCheck(
+    t("doctor.check.router_chain_ref.name"),
+    "warn",
+    "warning",
+    "router_chain_ref_drift",
+    t(`doctor.check.router_chain_ref.message.${count === 1 ? "singular" : "plural"}`, {
+      count: String(count),
+      list: inspection.unknownRefs.join(", ")
+    }),
+    t("doctor.check.router_chain_ref.remediation"),
+    "maintainer"
+  );
+}
 function createSkillRefMirrorCheck(t, inspection) {
   if (inspection.status === "ok") {
     return okCheck(t("doctor.check.skill_ref_mirror.name"), t("doctor.check.skill_ref_mirror.ok"));
@@ -5920,8 +6145,8 @@ function createSkillMdYamlInvalidCheck(t, inspection) {
 
 // src/services/doctor-hooks-lints.ts
 import { constants } from "fs";
-import { access, readdir as readdir3, readFile as readFile10, stat as stat3 } from "fs/promises";
-import { join as join17, posix as posix3 } from "path";
+import { access, readdir as readdir4, readFile as readFile11, stat as stat3 } from "fs/promises";
+import { join as join18, posix as posix3 } from "path";
 import { Script } from "vm";
 var HOOKS_RUNTIME_CLIENT_DIRS = [
   { client: "claude", dir: ".claude/hooks" },
@@ -5970,7 +6195,7 @@ function isHookWiredForEvent(hooks, event, hookFile) {
 }
 async function readDirectoryFileNames(dir) {
   try {
-    return await readdir3(dir);
+    return await readdir4(dir);
   } catch {
     return null;
   }
@@ -5983,14 +6208,14 @@ async function isFile(absPath) {
   }
 }
 async function inspectHooksWired(projectRoot) {
-  const claudeEntries = await readDirectoryFileNames(join17(projectRoot, ".claude"));
+  const claudeEntries = await readDirectoryFileNames(join18(projectRoot, ".claude"));
   if (claudeEntries === null) {
     return { status: "skipped", missingHooks: [] };
   }
-  const settingsPath = join17(projectRoot, ".claude", "settings.json");
+  const settingsPath = join18(projectRoot, ".claude", "settings.json");
   let parsed;
   try {
-    parsed = JSON.parse(await readFile10(settingsPath, "utf8"));
+    parsed = JSON.parse(await readFile11(settingsPath, "utf8"));
   } catch {
     return { status: "missing-settings", missingHooks: [] };
   }
@@ -6013,8 +6238,8 @@ async function inspectHooksWired(projectRoot) {
 }
 async function inspectHookCacheWritability(projectRoot) {
   const relPath = posix3.join(".fabric", ".cache");
-  const fabricDir = join17(projectRoot, ".fabric");
-  const cacheDir = join17(projectRoot, ".fabric", ".cache");
+  const fabricDir = join18(projectRoot, ".fabric");
+  const cacheDir = join18(projectRoot, ".fabric", ".cache");
   try {
     try {
       const cacheStats = await stat3(cacheDir);
@@ -6063,12 +6288,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 = join17(projectRoot, dir);
+    const absDir = join18(projectRoot, dir);
     const entries = await readDirectoryFileNames(absDir);
     if (entries === null) continue;
     for (const name of entries) {
       if (!name.endsWith(".cjs")) continue;
-      const abs = join17(absDir, name);
+      const abs = join18(absDir, name);
       if (!await isFile(abs)) continue;
       const arr = hookFilesByBasename.get(name) ?? [];
       arr.push({ client, abs });
@@ -6083,7 +6308,7 @@ async function inspectHooksContentDrift(projectRoot) {
     const hashes = [];
     for (const { client, abs } of copies) {
       try {
-        const body = await readFile10(abs, "utf8");
+        const body = await readFile11(abs, "utf8");
         hashes.push({ client, sha: sha256(body) });
       } catch {
       }
@@ -6105,18 +6330,18 @@ async function inspectHooksRuntime(projectRoot) {
   const issues = [];
   let scanned = 0;
   for (const { client, dir } of HOOKS_RUNTIME_CLIENT_DIRS) {
-    const absDir = join17(projectRoot, dir);
+    const absDir = join18(projectRoot, dir);
     const entries = await readDirectoryFileNames(absDir);
     if (entries === null) continue;
     for (const name of entries) {
       if (!name.endsWith(".cjs")) continue;
-      const abs = join17(absDir, name);
+      const abs = join18(absDir, name);
       const displayPath = `${dir}/${name}`;
       if (!await isFile(abs)) continue;
       scanned += 1;
       let body;
       try {
-        body = await readFile10(abs, "utf8");
+        body = await readFile11(abs, "utf8");
       } catch (err) {
         issues.push({
           path: displayPath,
@@ -6253,8 +6478,8 @@ function createHookCacheWritabilityCheck(t, inspection) {
 }
 
 // src/services/doctor-bootstrap-lints.ts
-import { access as access2, readFile as readFile11 } from "fs/promises";
-import { join as join18 } from "path";
+import { access as access2, readFile as readFile12 } from "fs/promises";
+import { join as join19 } from "path";
 import {
   BOOTSTRAP_MARKER_BEGIN,
   BOOTSTRAP_MARKER_END,
@@ -6286,17 +6511,17 @@ async function fileExists(path) {
 }
 async function inspectBootstrapAnchor(projectRoot) {
   const [hasAgentsMd, hasClaudeMd] = await Promise.all([
-    fileExists(join18(projectRoot, "AGENTS.md")),
-    fileExists(join18(projectRoot, "CLAUDE.md"))
+    fileExists(join19(projectRoot, "AGENTS.md")),
+    fileExists(join19(projectRoot, "CLAUDE.md"))
   ]);
   return { hasAgentsMd, hasClaudeMd };
 }
 async function inspectL1BootstrapSnapshotDrift(target) {
-  const abs = join18(target, ".fabric", "AGENTS.md");
+  const abs = join19(target, ".fabric", "AGENTS.md");
   const canonical = resolveBootstrapCanonical();
   let onDisk;
   try {
-    onDisk = await readFile11(abs, "utf8");
+    onDisk = await readFile12(abs, "utf8");
   } catch {
     return { status: "missing", canonical, onDisk: null };
   }
@@ -6322,17 +6547,17 @@ function createL1BootstrapSnapshotDriftCheck(t, inspection) {
   );
 }
 async function inspectL2ManagedBlockDrift(target) {
-  const snapshotPath = join18(target, ".fabric", "AGENTS.md");
+  const snapshotPath = join19(target, ".fabric", "AGENTS.md");
   let snapshot;
   try {
-    snapshot = await readFile11(snapshotPath, "utf8");
+    snapshot = await readFile12(snapshotPath, "utf8");
   } catch {
     return { status: "ok", drifted: [] };
   }
-  const projectRulesPath = join18(target, ".fabric", "project-rules.md");
+  const projectRulesPath = join19(target, ".fabric", "project-rules.md");
   let expectedBody = snapshot;
   try {
-    const projectRules = await readFile11(projectRulesPath, "utf8");
+    const projectRules = await readFile12(projectRulesPath, "utf8");
     expectedBody = `${snapshot}
 ---
 ${projectRules}`;
@@ -6341,12 +6566,12 @@ ${projectRules}`;
   const drifted = [];
   let anyManagedBlockFound = false;
   const blockTargets = [
-    join18(target, "AGENTS.md")
+    join19(target, "AGENTS.md")
   ];
   for (const abs of blockTargets) {
     let content;
     try {
-      content = await readFile11(abs, "utf8");
+      content = await readFile12(abs, "utf8");
     } catch {
       continue;
     }
@@ -6369,9 +6594,9 @@ ${projectRules}`;
       drifted.push({ path: abs, expected: expectedBody, actual: body });
     }
   }
-  const claudeMdPath = join18(target, "CLAUDE.md");
+  const claudeMdPath = join19(target, "CLAUDE.md");
   try {
-    const claudeContent = await readFile11(claudeMdPath, "utf8");
+    const claudeContent = await readFile12(claudeMdPath, "utf8");
     anyManagedBlockFound = true;
     const lines = claudeContent.split(/\r?\n/u);
     const hasAtImport = lines.some((line) => line.trim() === "@.fabric/AGENTS.md");
@@ -6439,7 +6664,7 @@ import { appendFile as appendFile3 } from "fs/promises";
 import { minimatch as minimatch2 } from "minimatch";
 
 // src/services/cite-rollup.ts
-import { readFile as readFile12 } from "fs/promises";
+import { readFile as readFile13 } from "fs/promises";
 import { createLedgerWriteQueue as createLedgerWriteQueue3 } from "@fenglimg/fabric-shared/node/atomic-write";
 var citeRollupQueue = createLedgerWriteQueue3();
 async function appendCiteRollupRow(projectRoot, row) {
@@ -6451,7 +6676,7 @@ async function readCiteRollup(projectRoot) {
   const path = getCiteRollupPath(projectRoot);
   let raw;
   try {
-    raw = await readFile12(path, "utf8");
+    raw = await readFile13(path, "utf8");
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") return [];
     throw error;
@@ -7565,6 +7790,7 @@ async function runDoctorReport(target) {
   const hookCacheWritability = await inspectHookCacheWritability(projectRoot);
   const staleServeLock = inspectStaleServeLock(projectRoot, lintNow);
   const skillMdYamlInvalid = await inspectSkillMdYamlInvalid(projectRoot);
+  const routerChainRef = await inspectRouterChainRef(projectRoot);
   const onboardCoverage = await inspectOnboardCoverage(projectRoot);
   const [hooksWired, hooksRuntime, hooksContentDrift] = await Promise.all([
     inspectHooksWired(projectRoot),
@@ -7575,7 +7801,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(join19(projectRoot, path))])
+      TARGET_FILE_PATHS.map(async (path) => [path, await pathExists(join20(projectRoot, path))])
     )
   );
   const checks = [
@@ -7641,6 +7867,9 @@ async function runDoctorReport(target) {
     // rc.12 lint #29: skill_md_yaml_invalid. Warning kind — surfaces
     // SKILL.md frontmatter that Codex CLI silently drops at load.
     createSkillMdYamlInvalidCheck(t, skillMdYamlInvalid),
+    // B2 skill-router (A4): S_CHAIN reference backstop. Warning kind — flags an
+    // S_CHAIN `fabric-*` reference to a leaf no longer in the install set.
+    createRouterChainRefCheck(t, routerChainRef),
     // v2.0.0-rc.23 TASK-014 (F8c): Onboard coverage advisory. Info kind.
     // Surfaces uncovered S5 onboard slots and recommends /fabric-archive
     // first-run phase. Sits adjacent to Skill markdown YAML — both are
@@ -7772,7 +8001,7 @@ async function runDoctorFix(target) {
   const fixed = [];
   const ledgerWarnings = [];
   if (before.fixable_errors.some((issue) => issue.code === "bootstrap_snapshot_drift")) {
-    const snapshotPath = join19(projectRoot, ".fabric", "AGENTS.md");
+    const snapshotPath = join20(projectRoot, ".fabric", "AGENTS.md");
     await ensureParentDirectory(snapshotPath);
     await atomicWriteText4(snapshotPath, resolveBootstrapCanonical2());
     fixed.push(findIssue(before.fixable_errors, "bootstrap_snapshot_drift"));
@@ -7845,9 +8074,9 @@ 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 = join19(projectRoot, ".fabric", ".serve.lock");
+      const lockFilePath = join20(projectRoot, ".fabric", ".serve.lock");
       try {
-        await unlink3(lockFilePath);
+        await unlink4(lockFilePath);
       } catch (err) {
         const errno = err;
         if (errno.code !== "ENOENT") throw err;
@@ -7962,10 +8191,10 @@ function createApplyLintMessage(succeeded, failed, manualErrorCount) {
 }
 async function applySessionHintsStaleCleanup(projectRoot, candidate) {
   const detail = `deleted (${candidate.age_days}d old)`;
-  const absPath = join19(projectRoot, candidate.path);
+  const absPath = join20(projectRoot, candidate.path);
   try {
-    const { unlink: unlink4 } = await import("fs/promises");
-    await unlink4(absPath);
+    const { unlink: unlink5 } = await import("fs/promises");
+    await unlink5(absPath);
     return {
       kind: "knowledge_session_hints_stale_cleanup",
       path: candidate.path,
@@ -7987,9 +8216,9 @@ function truncateErrorMessage(error) {
   return raw.length > 240 ? `${raw.slice(0, 237)}...` : raw;
 }
 async function inspectForensic(projectRoot) {
-  const path = join19(projectRoot, ".fabric", "forensic.json");
+  const path = join20(projectRoot, ".fabric", "forensic.json");
   try {
-    const parsed = forensicReportSchema.parse(JSON.parse(await readFile14(path, "utf8")));
+    const parsed = forensicReportSchema.parse(JSON.parse(await readFile15(path, "utf8")));
     return { present: true, valid: true, report: parsed };
   } catch (error) {
     if (isMissingFileError(error)) {
@@ -8019,7 +8248,7 @@ async function inspectEventLedger(projectRoot) {
   try {
     await access4(path, constants2.W_OK);
     const { warnings } = await readEventLedger(projectRoot);
-    const raw = await readFile14(path, "utf8");
+    const raw = await readFile15(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 = [];
@@ -8564,7 +8793,7 @@ async function inspectPreexistingRootFiles(projectRoot) {
   const candidates = ["CLAUDE.md", "AGENTS.md"];
   const detected = [];
   for (const name of candidates) {
-    if (await pathExists(join19(projectRoot, name))) {
+    if (await pathExists(join20(projectRoot, name))) {
       detected.push(name);
     }
   }
@@ -8649,7 +8878,7 @@ async function buildLastActiveIndex(projectRoot) {
   return map;
 }
 async function inspectSessionHintsStale(projectRoot, now) {
-  const cacheDir = join19(projectRoot, ".fabric", ".cache");
+  const cacheDir = join20(projectRoot, ".fabric", ".cache");
   let entries;
   try {
     entries = await readdirAsync(cacheDir, { withFileTypes: true });
@@ -8661,7 +8890,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 = join19(cacheDir, entry.name);
+    const absPath = join20(cacheDir, entry.name);
     let mtimeMs = 0;
     try {
       mtimeMs = (await statAsync(absPath)).mtimeMs;
@@ -8693,9 +8922,9 @@ function inspectStaleServeLock(projectRoot, now) {
   };
 }
 async function readUnderseedThresholdFromConfig(projectRoot) {
-  const configPath = join19(projectRoot, ".fabric", "fabric-config.json");
+  const configPath = join20(projectRoot, ".fabric", "fabric-config.json");
   try {
-    const raw = await readFile14(configPath, "utf8");
+    const raw = await readFile15(configPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const v = parsed.underseed_node_threshold;
@@ -8811,10 +9040,10 @@ async function inspectOnboardCoverage(projectRoot) {
   return { filled, missing, opted_out: optedOut };
 }
 async function readOnboardOptedOut(projectRoot) {
-  const path = join19(projectRoot, ".fabric", "fabric-config.json");
+  const path = join20(projectRoot, ".fabric", "fabric-config.json");
   let raw;
   try {
-    raw = await readFile14(path, "utf8");
+    raw = await readFile15(path, "utf8");
   } catch {
     return [];
   }
@@ -8916,22 +9145,22 @@ async function* iterateCanonicalFilenames(projectRoot) {
   }
 }
 async function rewriteThreeEndManagedBlocks(projectRoot) {
-  const snapshotPath = join19(projectRoot, ".fabric", "AGENTS.md");
+  const snapshotPath = join20(projectRoot, ".fabric", "AGENTS.md");
   if (!await pathExists(snapshotPath)) {
     return;
   }
   let snapshot;
   try {
-    snapshot = await readFile14(snapshotPath, "utf8");
+    snapshot = await readFile15(snapshotPath, "utf8");
   } catch {
     return;
   }
-  const projectRulesPath = join19(projectRoot, ".fabric", "project-rules.md");
+  const projectRulesPath = join20(projectRoot, ".fabric", "project-rules.md");
   const hasProjectRules = await pathExists(projectRulesPath);
   let expectedBody = snapshot;
   if (hasProjectRules) {
     try {
-      const projectRules = await readFile14(projectRulesPath, "utf8");
+      const projectRules = await readFile15(projectRulesPath, "utf8");
       expectedBody = `${snapshot}
 ---
 ${projectRules}`;
@@ -8942,7 +9171,7 @@ ${projectRules}`;
 ${expectedBody}
 ${BOOTSTRAP_MARKER_END2}`;
   const blockTargets = [
-    join19(projectRoot, "AGENTS.md")
+    join20(projectRoot, "AGENTS.md")
   ];
   for (const abs of blockTargets) {
     if (!await pathExists(abs)) {
@@ -8950,7 +9179,7 @@ ${BOOTSTRAP_MARKER_END2}`;
     }
     let existing;
     try {
-      existing = await readFile14(abs, "utf8");
+      existing = await readFile15(abs, "utf8");
     } catch {
       continue;
     }
@@ -8975,11 +9204,11 @@ ${managedBlock}
     }
     await atomicWriteText4(abs, next);
   }
-  const claudeMdPath = join19(projectRoot, "CLAUDE.md");
+  const claudeMdPath = join20(projectRoot, "CLAUDE.md");
   if (await pathExists(claudeMdPath)) {
     let claudeContent;
     try {
-      claudeContent = await readFile14(claudeMdPath, "utf8");
+      claudeContent = await readFile15(claudeMdPath, "utf8");
     } catch {
       return;
     }
@@ -9045,7 +9274,7 @@ async function collectEntryPoints(root) {
       continue;
     }
     for (const entry of await readdirAsync(current, { withFileTypes: true })) {
-      const absolutePath = join19(current, entry.name);
+      const absolutePath = join20(current, entry.name);
       const relativePath = normalizePath2(absolutePath.slice(root.length + 1));
       if (relativePath.length === 0) {
         continue;
@@ -9121,7 +9350,7 @@ async function enrichDescriptions(projectRoot, opts = {}) {
     scanned += 1;
     let source;
     try {
-      source = await readFile14(absPath, "utf8");
+      source = await readFile15(absPath, "utf8");
     } catch {
       continue;
     }
@@ -9340,6 +9569,25 @@ async function runDoctorConflictLint(projectRoot, opts = {}) {
   };
 }
 
+// src/services/summary-cold-eval.ts
+var COLD_EVAL_RUBRIC = [
+  "You are a ZERO-CONTEXT judge. You are shown ONLY a one-line knowledge summary \u2014",
+  "never the full entry body. For each summary decide: could a reader who has NOT",
+  "seen the body ACT on this line alone (apply the decision / avoid the pitfall /",
+  "follow the rule)?",
+  "",
+  "PASS (self_sufficient=true): the line states the thesis \u2014 the what + the",
+  "operative so-what. FAIL (self_sufficient=false): the line only POINTS at the",
+  "body ('explains the approach', 'covers the edge cases') without stating it.",
+  "When you FAIL one, return a suggested_summary that states the thesis in one line."
+].join("\n");
+function buildColdEvalBatch(candidates) {
+  const judgeable = candidates.filter(
+    (c) => typeof c.summary === "string" && c.summary.trim().length > 0
+  );
+  return { rubric: COLD_EVAL_RUBRIC, candidates: judgeable };
+}
+
 // src/services/rotation-tick.ts
 var DEFAULT_TICK_INTERVAL_MS = 6 * 60 * 60 * 1e3;
 var tickTimers = /* @__PURE__ */ new Map();
@@ -9375,7 +9623,7 @@ import { IOFabricError as IOFabricError2, RuleError } from "@fenglimg/fabric-sha
 
 // src/services/read-ledger.ts
 import { randomUUID as randomUUID6 } from "crypto";
-import { access as access5, copyFile, readFile as readFile15, rm } from "fs/promises";
+import { access as access5, copyFile, readFile as readFile16, rm } from "fs/promises";
 import { ledgerEntrySchema } from "@fenglimg/fabric-shared";
 async function resolveLedgerPaths(projectRoot) {
   const primaryPath = getLedgerPath(projectRoot);
@@ -9403,7 +9651,7 @@ async function readLegacyLedger(projectRoot) {
   const { readPath } = await resolveLedgerPaths(projectRoot);
   let raw;
   try {
-    raw = await readFile15(readPath, "utf8");
+    raw = await readFile16(readPath, "utf8");
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") {
       return [];
@@ -9658,8 +9906,8 @@ function formatError(error) {
 }
 function formatPreexistingRootMessage(projectRoot) {
   const preexisting = [];
-  if (existsSync8(join20(projectRoot, "CLAUDE.md"))) preexisting.push("CLAUDE.md");
-  if (existsSync8(join20(projectRoot, "AGENTS.md"))) preexisting.push("AGENTS.md");
+  if (existsSync9(join21(projectRoot, "CLAUDE.md"))) preexisting.push("CLAUDE.md");
+  if (existsSync9(join21(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.`;
 }
@@ -9685,7 +9933,7 @@ function createFabricServer(tracker) {
   const server = new McpServer(
     {
       name: "fabric-knowledge-server",
-      version: "2.2.0-rc.8"
+      version: "2.2.0"
     },
     {
       instructions: FABRIC_SERVER_INSTRUCTIONS
@@ -9704,10 +9952,10 @@ function createFabricServer(tracker) {
     },
     async (_uri) => {
       const projectRoot = process.env.FABRIC_PROJECT_ROOT ?? process.cwd();
-      const path = join20(projectRoot, ".fabric", "bootstrap", "README.md");
+      const path = join21(projectRoot, ".fabric", "bootstrap", "README.md");
       let text = "";
-      if (existsSync8(path)) {
-        text = await readFile16(path, "utf8");
+      if (existsSync9(path)) {
+        text = await readFile17(path, "utf8");
       }
       return {
         contents: [
@@ -9797,6 +10045,7 @@ if (isMainModule) {
 }
 export {
   AGENTS_MD_RESOURCE_URI,
+  COLD_EVAL_RUBRIC,
   DEFAULT_CONFLICT_SIMILARITY_THRESHOLD,
   EVENT_LEDGER_PATH,
   FABRIC_SERVER_INSTRUCTIONS,
@@ -9806,6 +10055,7 @@ export {
   METRIC_COUNTER_NAMES,
   appendEventLedgerEvent,
   buildAlwaysActiveBodies,
+  buildColdEvalBatch,
   buildKnowledgeCensus,
   bumpCounter,
   contextCache,