@fenglimg/fabric-server 2.0.0-rc.1 → 2.0.0-rc.11

package/dist/{chunk-NRWDWAVO.js → chunk-MMGHD42I.js}

@@ -6,7 +6,7 @@ var ContextCache = class {
   defaultTtlMs;
   // Slot 1: raw AgentsMeta keyed by projectRoot
   metaSlot = /* @__PURE__ */ new Map();
-  // Slot 2: GetRulesContext keyed by projectRoot
+  // Slot 2: GetKnowledgeContext keyed by projectRoot
   contextSlot = /* @__PURE__ */ new Map();
   // Slot 3: audit sliding-window cursor keyed by projectRoot
   auditSlot = /* @__PURE__ */ new Map();
@@ -276,20 +276,20 @@ function flushAndSyncEventLedger(projectRoot) {
   }
 }
 
-// src/services/rule-meta-builder.ts
+// src/services/knowledge-meta-builder.ts
 import { mkdir as mkdir2, readdir, readFile as readFile3 } from "fs/promises";
 import { existsSync as existsSync2, statSync } from "fs";
 import { homedir } from "os";
 import { isAbsolute, join as join3, relative, resolve as resolve2, sep as sep2 } from "path";
 import {
-  RULE_TEST_INDEX_SCHEMA_VERSION,
+  KNOWLEDGE_TEST_INDEX_SCHEMA_VERSION,
   agentsMetaSchema as agentsMetaSchema3,
   defaultAgentsMetaCounters,
   deriveAgentsMetaLayer,
   deriveAgentsMetaStableId,
   deriveAgentsMetaTopologyType,
   isKnowledgeStableId,
-  ruleTestIndexSchema,
+  knowledgeTestIndexSchema,
   KnowledgeTypeSchema,
   MaturitySchema,
   LayerSchema,
@@ -297,34 +297,35 @@ import {
   parseKnowledgeId
 } from "@fenglimg/fabric-shared";
 import { atomicWriteText as atomicWriteText2 } from "@fenglimg/fabric-shared/node/atomic-write";
-async function buildRuleMeta(projectRootInput) {
+async function buildKnowledgeMeta(projectRootInput) {
   const projectRoot = normalizeProjectRoot(projectRootInput);
   assertExistingDirectory(projectRoot);
   const metaPath = join3(projectRoot, ".fabric", "agents.meta.json");
-  const ruleTestIndexPath = join3(projectRoot, ".fabric", "rule-test.index.json");
+  const knowledgeTestIndexPath = join3(projectRoot, ".fabric", ".cache", "knowledge-test.index.json");
   const existingMeta = await readExistingMeta(metaPath);
-  const existingRuleTestIndex = await readExistingRuleTestIndex(ruleTestIndexPath);
-  const meta = await computeRulesBasedAgentsMeta(projectRoot, existingMeta);
-  const ruleTestIndex = await computeRuleTestIndex(projectRoot, meta, existingRuleTestIndex);
+  const existingKnowledgeTestIndex = await readExistingKnowledgeTestIndex(knowledgeTestIndexPath);
+  const meta = await computeKnowledgeBasedAgentsMeta(projectRoot, existingMeta);
+  const knowledgeTestIndex = await computeKnowledgeTestIndex(projectRoot, meta, existingKnowledgeTestIndex);
   return {
     meta,
-    ruleTestIndex,
-    changed: existingMeta === void 0 || stableStringify(existingMeta) !== stableStringify(meta) || existingRuleTestIndex === void 0 || !isSameRuleTestIndex(existingRuleTestIndex, ruleTestIndex)
+    knowledgeTestIndex,
+    changed: existingMeta === void 0 || stableStringify(existingMeta) !== stableStringify(meta) || existingKnowledgeTestIndex === void 0 || !isSameKnowledgeTestIndex(existingKnowledgeTestIndex, knowledgeTestIndex)
   };
 }
-async function writeRuleMeta(projectRootInput, options) {
+async function writeKnowledgeMeta(projectRootInput, options) {
   const projectRoot = normalizeProjectRoot(projectRootInput);
   const metaPath = join3(projectRoot, ".fabric", "agents.meta.json");
-  const ruleTestIndexPath = join3(projectRoot, ".fabric", "rule-test.index.json");
+  const knowledgeTestIndexPath = join3(projectRoot, ".fabric", ".cache", "knowledge-test.index.json");
   const existingMeta = await readExistingMeta(metaPath);
-  const result = await buildRuleMeta(projectRoot);
+  const result = await buildKnowledgeMeta(projectRoot);
   if (!result.changed) {
     return result;
   }
   await ensureParentDirectory(metaPath);
   await atomicWriteText2(metaPath, `${JSON.stringify(result.meta, null, 2)}
 `);
-  await atomicWriteText2(ruleTestIndexPath, `${JSON.stringify(result.ruleTestIndex, null, 2)}
+  await ensureParentDirectory(knowledgeTestIndexPath);
+  await atomicWriteText2(knowledgeTestIndexPath, `${JSON.stringify(result.knowledgeTestIndex, null, 2)}
 `);
   if (existingMeta === void 0 || stableStringify(existingMeta) !== stableStringify(result.meta)) {
     await recordBaselineSynced(projectRoot, {
@@ -338,7 +339,7 @@ async function writeRuleMeta(projectRootInput, options) {
   }
   return result;
 }
-async function computeRulesBasedAgentsMeta(projectRootInput, existingMeta) {
+async function computeKnowledgeBasedAgentsMeta(projectRootInput, existingMeta) {
   const projectRoot = normalizeProjectRoot(projectRootInput);
   assertExistingDirectory(projectRoot);
   const previousMeta = existingMeta ?? await readExistingMeta(join3(projectRoot, ".fabric", "agents.meta.json"));
@@ -372,7 +373,7 @@ async function computeRulesBasedAgentsMeta(projectRootInput, existingMeta) {
     counters
   };
 }
-async function computeRuleTestIndex(projectRootInput, computedMeta, previousIndex) {
+async function computeKnowledgeTestIndex(projectRootInput, computedMeta, previousIndex) {
   const projectRoot = normalizeProjectRoot(projectRootInput);
   assertExistingDirectory(projectRoot);
   const previousLinks = indexPreviousRuleTestEntries(previousIndex?.links ?? []);
@@ -408,7 +409,7 @@ async function computeRuleTestIndex(projectRootInput, computedMeta, previousInde
     });
   }
   return {
-    schema_version: RULE_TEST_INDEX_SCHEMA_VERSION,
+    schema_version: KNOWLEDGE_TEST_INDEX_SCHEMA_VERSION,
     generated_at: (/* @__PURE__ */ new Date()).toISOString(),
     revision: computedMeta.revision,
     previous_revision: previousIndex?.revision !== void 0 && previousIndex.revision !== computedMeta.revision ? previousIndex.revision : previousIndex?.previous_revision,
@@ -416,14 +417,14 @@ async function computeRuleTestIndex(projectRootInput, computedMeta, previousInde
     orphan_annotations: orphanAnnotations.sort(compareRuleTestEntries)
   };
 }
-function deriveRuleMetaLayer(relativePath) {
+function deriveKnowledgeMetaLayer(relativePath) {
   return deriveAgentsMetaLayer(toAgentsCompatiblePath(relativePath));
 }
-function deriveRuleMetaTopologyType(relativePath) {
+function deriveKnowledgeMetaTopologyType(relativePath) {
   return deriveAgentsMetaTopologyType(toAgentsCompatiblePath(relativePath));
 }
-function isSameRuleTestIndex(left, right) {
-  return stableStringify(toComparableRuleTestIndex(left)) === stableStringify(toComparableRuleTestIndex(right));
+function isSameKnowledgeTestIndex(left, right) {
+  return stableStringify(toComparableKnowledgeTestIndex(left)) === stableStringify(toComparableKnowledgeTestIndex(right));
 }
 function stableStringify(value) {
   return JSON.stringify(value, Object.keys(flattenKeys(value)).sort());
@@ -452,7 +453,7 @@ async function readExistingMeta(metaPath) {
     return void 0;
   }
 }
-async function readExistingRuleTestIndex(indexPath) {
+async function readExistingKnowledgeTestIndex(indexPath) {
   let raw;
   try {
     raw = await readFile3(indexPath, "utf8");
@@ -463,7 +464,7 @@ async function readExistingRuleTestIndex(indexPath) {
     throw error;
   }
   try {
-    return ruleTestIndexSchema.parse(JSON.parse(raw));
+    return knowledgeTestIndexSchema.parse(JSON.parse(raw));
   } catch {
     return void 0;
   }
@@ -615,7 +616,7 @@ function compareRuleTestEntries(left, right) {
 function compareAnnotationEntries(left, right) {
   return left.stableId.localeCompare(right.stableId) || left.testFile.localeCompare(right.testFile) || left.line - right.line;
 }
-function toComparableRuleTestIndex(index) {
+function toComparableKnowledgeTestIndex(index) {
   const { generated_at: _generatedAt, ...comparable } = index;
   return comparable;
 }
@@ -627,7 +628,7 @@ function indexExistingNodesByContentRef(existingMeta) {
   return byContentRef;
 }
 function deriveNodeId(file) {
-  const layer = deriveRuleMetaLayer(file);
+  const layer = deriveKnowledgeMetaLayer(file);
   const relativeStem = getRuleRelativeStem(file);
   if (file.startsWith(PERSONAL_CONTENT_REF_PREFIX)) {
     return `${layer}/personal/${relativeStem}`;
@@ -638,8 +639,8 @@ function deriveNodeId(file) {
   return `${layer}/${relativeStem}`;
 }
 function createDefaultNodeMeta(contentRef) {
-  const layer = deriveRuleMetaLayer(contentRef);
-  const topologyType = deriveRuleMetaTopologyType(contentRef);
+  const layer = deriveKnowledgeMetaLayer(contentRef);
+  const topologyType = deriveKnowledgeMetaTopologyType(contentRef);
   return {
     file: contentRef,
     content_ref: contentRef,
@@ -676,8 +677,12 @@ function toAgentsCompatiblePath(contentRef) {
 function sortNodes(nodes) {
   return Object.fromEntries(Object.entries(nodes).sort(([left], [right]) => left.localeCompare(right)));
 }
+function isPendingNode(node) {
+  const ref = node.content_ref ?? node.file ?? "";
+  return ref.startsWith(".fabric/knowledge/pending/") || ref.startsWith("~/.fabric/knowledge/pending/");
+}
 function computeRevision(nodes) {
-  const revisionSource = Object.entries(sortNodes(nodes)).map(([id, node]) => [id, node.hash, node.stable_id ?? "", node.identity_source ?? ""].join("|")).join("\n");
+  const revisionSource = Object.entries(sortNodes(nodes)).filter(([, node]) => !isPendingNode(node)).map(([id, node]) => [id, node.hash, node.stable_id ?? "", node.identity_source ?? ""].join("|")).join("\n");
   return sha256(revisionSource);
 }
 function collectSyncedFiles(existingMeta, computedMeta) {
@@ -810,7 +815,10 @@ function extractRuleDescription(source) {
     knowledge_layer: void 0,
     layer_reason: void 0,
     created_at: void 0,
-    tags: void 0
+    tags: void 0,
+    // v2.0-rc.5 (C1): default-safe values when there is no frontmatter at all.
+    relevance_scope: "broad",
+    relevance_paths: []
   };
 }
 function extractRuleSections(source) {
@@ -836,7 +844,9 @@ function extractDescriptionFromFrontmatter(frontmatter) {
     knowledge_layer: knowledge.knowledge_layer,
     layer_reason: knowledge.layer_reason,
     created_at: knowledge.created_at,
-    tags: knowledge.tags
+    tags: knowledge.tags,
+    relevance_scope: knowledge.relevance_scope,
+    relevance_paths: knowledge.relevance_paths
   };
 }
 function extractKnowledgeFieldsFromFrontmatter(frontmatter) {
@@ -907,6 +917,9 @@ function extractKnowledgeFieldsFromFrontmatter(frontmatter) {
     }
   }
   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");
   return {
     id,
     knowledge_type,
@@ -914,7 +927,9 @@ function extractKnowledgeFieldsFromFrontmatter(frontmatter) {
     knowledge_layer,
     layer_reason: rawLayerReason,
     created_at,
-    tags: tags.length > 0 ? tags : void 0
+    tags: tags.length > 0 ? tags : void 0,
+    relevance_scope,
+    relevance_paths
   };
 }
 function extractScalar(frontmatter, key) {
@@ -943,7 +958,7 @@ function isNodeError3(error) {
   return error instanceof Error;
 }
 
-// src/services/rule-sync.ts
+// src/services/knowledge-sync.ts
 import { readdir as readdir2, readFile as readFile4, stat } from "fs/promises";
 import { existsSync as existsSync3, statSync as statSync2 } from "fs";
 import { join as join4, relative as relative2, sep as sep3 } from "path";
@@ -951,7 +966,7 @@ import { RuleValidationError } from "@fenglimg/fabric-shared/errors";
 var lastSyncState = /* @__PURE__ */ new Map();
 var freshSyncCooldown = /* @__PURE__ */ new Map();
 var SYNC_COOLDOWN_MS = 500;
-function invalidateRuleSyncCooldown(projectRoot) {
+function invalidateKnowledgeSyncCooldown(projectRoot) {
   freshSyncCooldown.delete(projectRoot);
 }
 async function readMetaEntries(projectRoot) {
@@ -1125,14 +1140,14 @@ async function appendRuleSyncEvents(projectRoot, events) {
     });
   }
 }
-async function ensureRulesFresh(projectRoot, opts) {
+async function ensureKnowledgeFresh(projectRoot, opts) {
   const mode = opts?.mode ?? "incremental";
   const cooldownExpiry = freshSyncCooldown.get(projectRoot);
   if (cooldownExpiry !== void 0 && Date.now() < cooldownExpiry && mode !== "full") {
     return { status: "fresh", events: [], warnings: [] };
   }
   const throwOnInvalidFrontmatter = opts?.throwOnInvalidFrontmatter ?? false;
-  const source = "ensureRulesFresh";
+  const source = "ensureKnowledgeFresh";
   const events = [];
   const warnings = [];
   const metaEntries = await readMetaEntries(projectRoot);
@@ -1181,11 +1196,11 @@ async function ensureRulesFresh(projectRoot, opts) {
     reconciled_files: events.map((e) => e.path)
   };
 }
-async function reconcileRules(projectRoot, opts) {
+async function reconcileKnowledge(projectRoot, opts) {
   freshSyncCooldown.delete(projectRoot);
   const trigger = opts?.trigger;
   const startTime = Date.now();
-  const source = "reconcileRules";
+  const source = "reconcileKnowledge";
   const events = [];
   const warnings = [];
   const metaEntries = await readMetaEntries(projectRoot);
@@ -1217,7 +1232,7 @@ async function reconcileRules(projectRoot, opts) {
     }
   }
   if (events.length > 0) {
-    await writeRuleMeta(projectRoot, { source: "sync_meta" });
+    await writeKnowledgeMeta(projectRoot, { source: "sync_meta" });
     await appendRuleSyncEvents(projectRoot, events);
     contextCache.invalidate("file_watch", projectRoot);
   }
@@ -1229,7 +1244,7 @@ async function reconcileRules(projectRoot, opts) {
         event_type: "meta_reconciled_on_startup",
         reconciled_files: reconciledFiles,
         duration_ms,
-        source: "reconcileRules"
+        source: "reconcileKnowledge"
       });
     } else {
       await appendEventLedgerEvent(projectRoot, {
@@ -1237,7 +1252,7 @@ async function reconcileRules(projectRoot, opts) {
         reconciled_files: reconciledFiles,
         duration_ms,
         trigger,
-        source: "reconcileRules"
+        source: "reconcileKnowledge"
       });
     }
   }
@@ -1254,19 +1269,59 @@ async function reconcileRules(projectRoot, opts) {
 }
 
 // src/services/doctor.ts
+import { execFileSync } from "child_process";
 import { existsSync as existsSync4, readdirSync, readFileSync, statSync as statSync3 } from "fs";
-import { access, mkdir as mkdir3, readFile as readFile5, writeFile as writeFile2 } from "fs/promises";
+import { access, mkdir as mkdir3, readFile as readFile5, rename, writeFile as writeFile2 } from "fs/promises";
 import { constants } from "fs";
-import { isAbsolute as isAbsolute2, join as join5, posix, resolve as resolve3 } from "path";
+import { homedir as homedir2 } from "os";
+import { isAbsolute as isAbsolute2, join as join5, posix, relative as nodeRelative, resolve as resolve3, sep as sep4 } from "path";
+import { minimatch } from "minimatch";
 import {
   agentsMetaSchema as agentsMetaSchema4,
   AgentsMetaCountersSchema,
   forensicReportSchema,
   parseKnowledgeId as parseKnowledgeId2,
-  ruleTestIndexSchema as ruleTestIndexSchema2
+  knowledgeTestIndexSchema as knowledgeTestIndexSchema2
 } from "@fenglimg/fabric-shared";
 import { detectFramework } from "@fenglimg/fabric-shared/node";
-import { atomicWriteJson as atomicWriteJson2 } from "@fenglimg/fabric-shared/node/atomic-write";
+import { atomicWriteJson as atomicWriteJson2, atomicWriteText as atomicWriteText3 } from "@fenglimg/fabric-shared/node/atomic-write";
+var ORPHAN_DEMOTE_THRESHOLD_DAYS = {
+  stable: 90,
+  endorsed: 30,
+  draft: 14
+};
+var STALE_ARCHIVE_ADDITIONAL_DAYS = 90;
+var PENDING_OVERDUE_THRESHOLD_DAYS = 14;
+var PENDING_AUTO_ARCHIVE_THRESHOLD_DAYS = 30;
+var DEFAULT_UNDERSEED_NODE_THRESHOLD = 10;
+var SESSION_HINTS_STALE_DAYS = 7;
+var SESSION_HINTS_FILE_PREFIX = "session-hints-";
+var SESSION_HINTS_FILE_SUFFIX = ".json";
+var NARROW_RATIO_THRESHOLD = 0.2;
+var NARROW_MIN_TOTAL = 10;
+var SILENCE_RATE_THRESHOLD = 0.95;
+var SILENCE_WINDOW_DAYS = 30;
+var EDIT_COUNTER_FILE_REL = posix.join(".fabric", ".cache", "edit-counter");
+var HINT_SILENCE_COUNTER_FILE_REL = posix.join(
+  ".fabric",
+  ".cache",
+  "hint-silence-counter"
+);
+var MS_PER_DAY = 24 * 60 * 60 * 1e3;
+var MATURITY_LINE_PATTERN = /^maturity:\s*("?)(stable|endorsed|draft)\1\s*$/mu;
+var CREATED_AT_LINE_PATTERN = /^created_at:\s*("?)([^"\n]+)\1\s*$/mu;
+var RELEVANCE_SCOPE_LINE_PATTERN = /^relevance_scope:\s*("?)(narrow|broad)\1\s*$/mu;
+var RELEVANCE_PATHS_LINE_PATTERN = /^relevance_paths:\s*\[([^\]]*)\]\s*$/mu;
+var RELEVANCE_PATHS_DRIFT_WINDOW_DAYS = 90;
+var SYNTHESIZED_PROMOTED_REASON = "[synthesized] filesystem-edit-fallback";
+var KNOWLEDGE_CANONICAL_TYPE_DIRS = [
+  "decisions",
+  "pitfalls",
+  "guidelines",
+  "models",
+  "processes"
+];
+var CANONICAL_KNOWLEDGE_FILENAME_PATTERN = /^(K[PT]-(?:MOD|DEC|GLD|PIT|PRO)-\d{4,})--[a-z0-9][a-z0-9-]*\.md$/u;
 var KNOWLEDGE_SUBDIRS2 = ["decisions", "pitfalls", "guidelines", "models", "processes", "pending"];
 var COUNTER_TYPE_CODES = ["MOD", "DEC", "GLD", "PIT", "PRO"];
 var SCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".ts", ".tsx"]);
@@ -1285,7 +1340,7 @@ var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
 var TARGET_FILE_PATHS = [
   ".fabric/forensic.json",
   ".fabric/agents.meta.json",
-  ".fabric/rule-test.index.json",
+  ".fabric/.cache/knowledge-test.index.json",
   ".fabric/events.jsonl",
   ".fabric/knowledge"
 ];
@@ -1297,12 +1352,12 @@ async function runDoctorReport(target) {
     forensic,
     meta,
     eventLedger,
-    ruleTestIndex
+    knowledgeTestIndex
   ] = await Promise.all([
     inspectForensic(projectRoot),
     inspectMeta(projectRoot),
     inspectEventLedger(projectRoot),
-    inspectRuleTestIndex(projectRoot)
+    inspectKnowledgeTestIndex(projectRoot)
   ]);
   const mcpConfigInWrongFile = inspectMcpConfigInWrongFile(projectRoot);
   const metaManuallyDiverged = await inspectMetaManuallyDiverged(projectRoot);
@@ -1312,6 +1367,21 @@ async function runDoctorReport(target) {
   const counterDesync = inspectCounterDesync(meta);
   const preexistingRootFiles = inspectPreexistingRootFiles(projectRoot);
   const bootstrapAnchor = inspectBootstrapAnchor(projectRoot);
+  const filesystemEditFallback = eventLedger.exists && eventLedger.writable && eventLedger.parseable ? await inspectFilesystemEditFallback(projectRoot) : { synthesized: 0, synthesizedStableIds: [] };
+  const lintNow = Date.now();
+  const orphanDemote = await inspectOrphanDemote(projectRoot, lintNow);
+  const staleArchive = await inspectStaleArchive(projectRoot, lintNow);
+  const pendingOverdue = inspectPendingOverdue(projectRoot, lintNow);
+  const stableIdDuplicate = inspectStableIdDuplicate(projectRoot);
+  const layerMismatch = inspectLayerMismatch(projectRoot);
+  const indexDrift = inspectIndexDrift(projectRoot, meta);
+  const underseeded = inspectUnderseeded(projectRoot);
+  const narrowNoPaths = inspectNarrowNoPaths(projectRoot);
+  const relevancePathsDangling = inspectRelevancePathsDangling(projectRoot);
+  const relevancePathsDrift = inspectRelevancePathsDrift(projectRoot);
+  const narrowTooFew = inspectNarrowTooFew(projectRoot, lintNow);
+  const sessionHintsStale = inspectSessionHintsStale(projectRoot, lintNow);
+  const relevanceFieldsMissing = inspectRelevanceFieldsMissing(projectRoot);
   const checks = [
     createBootstrapAnchorCheck(bootstrapAnchor),
     createKnowledgeDirMissingCheck(knowledgeDirMissing),
@@ -1327,7 +1397,7 @@ async function runDoctorReport(target) {
     // [MANDATORY_INJECTION] sections out of legacy rule files, a structural
     // concept that has no v2 equivalent. rc.4 will introduce a dedicated v2
     // lint suite for the new knowledge frontmatter contract.
-    createRuleTestIndexCheck(ruleTestIndex),
+    createKnowledgeTestIndexCheck(knowledgeTestIndex),
     createEventLedgerCheck(eventLedger),
     createEventLedgerPartialWriteCheck(eventLedger),
     createMcpConfigInWrongFileCheck(mcpConfigInWrongFile),
@@ -1335,6 +1405,42 @@ async function runDoctorReport(target) {
     createKnowledgeDirUnindexedCheck(knowledgeDirUnindexed),
     createStableIdCollisionCheck(stableIdCollision),
     createCounterDesyncCheck(counterDesync),
+    createFilesystemEditFallbackCheck(filesystemEditFallback),
+    // rc.4 TASK-001: read-side lint checks #16-18. Findings only — mutation
+    // + event emission lands in TASK-003 behind --apply-lint.
+    createOrphanDemoteCheck(orphanDemote),
+    createStaleArchiveCheck(staleArchive),
+    createPendingOverdueCheck(pendingOverdue),
+    // rc.4 TASK-002: read-side integrity checks #19-21. Stable_id duplicate
+    // runs first in this trio — it is the most critical integrity break and
+    // surfaces ahead of layer-mismatch / index-drift in the report so a
+    // human operator triages the collision before reasoning about counter
+    // state. Index drift is the only fixable_error of the three; stable_id
+    // duplicate and layer mismatch require manual triage (rename / move).
+    createStableIdDuplicateCheck(stableIdDuplicate),
+    createLayerMismatchCheck(layerMismatch),
+    createIndexDriftCheck(indexDrift),
+    // 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.
+    createUnderseededCheck(underseeded),
+    // rc.5 TASK-013 (C4): relevance_paths hygiene checks #23/#24/#25.
+    // All three are flag-only in rc.5 (no apply-lint mutations).
+    //   #23 narrow_no_paths        — warning kind (silent recall risk)
+    //   #24 relevance_paths_dangling — warning kind (glob → zero matches)
+    //   #25 relevance_paths_drift  — info kind (git-log heuristic; noisy)
+    createNarrowNoPathsCheck(narrowNoPaths),
+    createRelevancePathsDanglingCheck(relevancePathsDangling),
+    createRelevancePathsDriftCheck(relevancePathsDrift),
+    // rc.6 TASK-023 (E6): narrow_too_few (lint #26). Info kind; both arms
+    // (structural + telemetry) recommend the same fabric-import action.
+    createNarrowTooFewCheck(narrowTooFew),
+    // rc.6 TASK-021 (E3): session-hints cache hygiene (lint #27). Info kind.
+    createSessionHintsStaleCheck(sessionHintsStale),
+    // v2.0.0-rc.9 TASK-003 (A3): relevance fields back-fill (lint #28).
+    // Info kind — applies to pending entries only; canonical entries get
+    // the fields written verbatim by fab_review.approve/modify.
+    createRelevanceFieldsMissingCheck(relevanceFieldsMissing),
     createPreexistingRootFilesCheck(preexistingRootFiles)
     // v2.0 / rc.2: `createLegacyClientPathCheck` removed. The schema now
     // rejects retired clientPaths keys (windsurf/rooCode/geminiCLI) at Zod
@@ -1401,19 +1507,19 @@ async function runDoctorFix(target) {
     (issue) => [
       "agents_meta_missing",
       "agents_meta_stale",
-      "rule_test_index_missing",
-      "rule_test_index_stale",
+      "knowledge_test_index_missing",
+      "knowledge_test_index_stale",
       "content_ref_missing",
       "knowledge_dir_unindexed"
     ].includes(issue.code)
   )) {
-    await reconcileRules(projectRoot, { trigger: "doctor" });
+    await reconcileKnowledge(projectRoot, { trigger: "doctor" });
     for (const issue of before.fixable_errors.filter(
       (candidate) => [
         "agents_meta_missing",
         "agents_meta_stale",
-        "rule_test_index_missing",
-        "rule_test_index_stale",
+        "knowledge_test_index_missing",
+        "knowledge_test_index_stale",
         "content_ref_missing",
         "knowledge_dir_unindexed"
       ].includes(candidate.code)
@@ -1449,6 +1555,394 @@ async function runDoctorFix(target) {
     report
   };
 }
+var MANUAL_LINT_ERROR_CODES = /* @__PURE__ */ new Set([
+  "knowledge_stable_id_duplicate",
+  "knowledge_layer_mismatch"
+]);
+async function runDoctorApplyLint(target) {
+  const projectRoot = normalizeTarget(target);
+  const before = await runDoctorReport(projectRoot);
+  const mutations = [];
+  const blockingManual = before.manual_errors.find(
+    (issue) => MANUAL_LINT_ERROR_CODES.has(issue.code)
+  );
+  if (blockingManual !== void 0) {
+    return {
+      changed: false,
+      mutations: [],
+      manual_errors: before.manual_errors,
+      aborted: true,
+      abort_reason: `Manual repair required for ${blockingManual.code}: ${blockingManual.message} - apply-lint cannot resolve this safely; triage by hand.`,
+      message: `apply-lint aborted: ${blockingManual.code} requires manual repair.`,
+      report: before
+    };
+  }
+  const now = Date.now();
+  const orphanDemote = await inspectOrphanDemote(projectRoot, now);
+  for (const candidate of orphanDemote.candidates) {
+    if (candidate.next_maturity === null) {
+      continue;
+    }
+    mutations.push(await applyOrphanDemote(projectRoot, candidate, now));
+  }
+  const staleArchive = await inspectStaleArchive(projectRoot, now);
+  for (const candidate of staleArchive.candidates) {
+    mutations.push(await applyStaleArchive(projectRoot, candidate, now));
+  }
+  const pendingAutoArchive = inspectPendingAutoArchive(projectRoot, now);
+  for (const candidate of pendingAutoArchive.candidates) {
+    mutations.push(await applyPendingAutoArchive(projectRoot, candidate, now));
+  }
+  const sessionHintsStale = inspectSessionHintsStale(projectRoot, now);
+  for (const candidate of sessionHintsStale.candidates) {
+    mutations.push(await applySessionHintsStaleCleanup(projectRoot, candidate));
+  }
+  const relevanceFieldsMissing = inspectRelevanceFieldsMissing(projectRoot);
+  let relevanceTouchedCount = 0;
+  for (const candidate of relevanceFieldsMissing.candidates) {
+    const mutation = await applyRelevanceFieldsMissing(candidate);
+    mutations.push(mutation);
+    if (mutation.applied) {
+      relevanceTouchedCount += 1;
+    }
+  }
+  try {
+    await appendEventLedgerEvent(projectRoot, {
+      event_type: "relevance_migration_run",
+      timestamp: new Date(now).toISOString(),
+      scanned_count: relevanceFieldsMissing.scanned_count,
+      touched_count: relevanceTouchedCount
+    });
+  } catch {
+  }
+  const meta = await inspectMeta(projectRoot);
+  const indexDrift = inspectIndexDrift(projectRoot, meta);
+  if (indexDrift.drifts.length > 0) {
+    mutations.push(await applyIndexDriftFix(projectRoot, indexDrift));
+  }
+  contextCache.invalidate("meta_write", projectRoot);
+  const after = await runDoctorReport(projectRoot);
+  const successCount = mutations.filter((m) => m.applied).length;
+  const failureCount = mutations.length - successCount;
+  return {
+    changed: successCount > 0,
+    mutations,
+    manual_errors: after.manual_errors,
+    aborted: false,
+    message: createApplyLintMessage(successCount, failureCount, after.manual_errors.length),
+    report: after
+  };
+}
+function createApplyLintMessage(succeeded, failed, manualErrorCount) {
+  const parts = [];
+  if (succeeded === 0 && failed === 0) {
+    parts.push("No apply-lint mutations were needed.");
+  } else {
+    parts.push(`Applied ${succeeded} apply-lint mutation${succeeded === 1 ? "" : "s"}.`);
+    if (failed > 0) {
+      parts.push(`${failed} mutation${failed === 1 ? "" : "s"} failed.`);
+    }
+  }
+  parts.push(
+    manualErrorCount === 0 ? "No manual errors remain." : `${manualErrorCount} manual error${manualErrorCount === 1 ? "" : "s"} remain.`
+  );
+  return parts.join(" ");
+}
+function rewriteFrontmatterMaturity(source, newMaturity) {
+  const FM_PATTERN = /^(?:\uFEFF)?---\r?\n([\s\S]*?)\r?\n---/u;
+  const fm = FM_PATTERN.exec(source);
+  if (fm === null) {
+    return null;
+  }
+  const block = fm[1];
+  if (!MATURITY_LINE_PATTERN.test(block)) {
+    return null;
+  }
+  const replacedBlock = block.replace(
+    MATURITY_LINE_PATTERN,
+    (line) => line.replace(/(stable|endorsed|draft)/u, newMaturity)
+  );
+  const blockStart = source.indexOf(block);
+  if (blockStart < 0) {
+    return null;
+  }
+  return source.slice(0, blockStart) + replacedBlock + source.slice(blockStart + block.length);
+}
+async function applyOrphanDemote(projectRoot, candidate, now) {
+  const next = candidate.next_maturity;
+  if (next === null) {
+    return {
+      kind: "knowledge_orphan_demote_required",
+      path: candidate.path,
+      detail: `${candidate.maturity} -> (none, already at terminal tier)`,
+      applied: false,
+      error: "next_maturity is null; orphan-demote not applicable"
+    };
+  }
+  const detail = `${candidate.maturity} -> ${next}`;
+  const absPath = join5(projectRoot, candidate.path);
+  try {
+    const source = await readFile5(absPath, "utf8");
+    const rewritten = rewriteFrontmatterMaturity(source, next);
+    if (rewritten === null) {
+      return {
+        kind: "knowledge_orphan_demote_required",
+        path: candidate.path,
+        detail,
+        applied: false,
+        error: "frontmatter missing maturity field; cannot rewrite"
+      };
+    }
+    if (rewritten === source) {
+      return {
+        kind: "knowledge_orphan_demote_required",
+        path: candidate.path,
+        detail,
+        applied: false,
+        error: "rewrite produced byte-identical output"
+      };
+    }
+    await atomicWriteText3(absPath, rewritten);
+    try {
+      await appendEventLedgerEvent(projectRoot, {
+        event_type: "knowledge_demoted",
+        stable_id: candidate.stable_id,
+        timestamp: new Date(now).toISOString(),
+        reason: `lint:orphan_demote ${candidate.maturity}->${next} after ${candidate.age_days}d inactive`
+      });
+    } catch (ledgerError) {
+      try {
+        await atomicWriteText3(absPath, source);
+      } catch (rollbackError) {
+        return {
+          kind: "knowledge_orphan_demote_required",
+          path: candidate.path,
+          detail,
+          applied: false,
+          error: `ledger append failed (${truncateErrorMessage(ledgerError)}); rollback also failed (${truncateErrorMessage(rollbackError)}); disk may be in inconsistent state`
+        };
+      }
+      return {
+        kind: "knowledge_orphan_demote_required",
+        path: candidate.path,
+        detail,
+        applied: false,
+        error: `ledger append failed (${truncateErrorMessage(ledgerError)}); frontmatter rolled back`
+      };
+    }
+    return {
+      kind: "knowledge_orphan_demote_required",
+      path: candidate.path,
+      detail,
+      applied: true
+    };
+  } catch (error) {
+    return {
+      kind: "knowledge_orphan_demote_required",
+      path: candidate.path,
+      detail,
+      applied: false,
+      error: truncateErrorMessage(error)
+    };
+  }
+}
+async function applyStaleArchive(projectRoot, candidate, now) {
+  const sourceAbs = join5(projectRoot, candidate.path);
+  const destAbs = join5(projectRoot, candidate.archive_path);
+  const detail = `${candidate.path} -> ${candidate.archive_path}`;
+  try {
+    await mkdir3(join5(destAbs, ".."), { recursive: true });
+    try {
+      await rename(sourceAbs, destAbs);
+    } catch (renameError) {
+      if (renameError instanceof Error && "code" in renameError && renameError.code === "EXDEV") {
+        const data = await readFile5(sourceAbs);
+        await writeFile2(destAbs, data);
+        const { unlink } = await import("fs/promises");
+        await unlink(sourceAbs);
+      } else {
+        throw renameError;
+      }
+    }
+    try {
+      await appendEventLedgerEvent(projectRoot, {
+        event_type: "knowledge_archived",
+        stable_id: candidate.stable_id,
+        timestamp: new Date(now).toISOString(),
+        reason: `lint:stale_archive ${candidate.path} -> ${candidate.archive_path} after ${candidate.age_days}d inactive`
+      });
+    } catch (ledgerError) {
+      try {
+        await rename(destAbs, sourceAbs);
+      } catch (rollbackError) {
+        return {
+          kind: "knowledge_stale_archive_required",
+          path: candidate.path,
+          detail,
+          applied: false,
+          error: `ledger append failed (${truncateErrorMessage(ledgerError)}); rollback also failed (${truncateErrorMessage(rollbackError)}); file may be stranded at ${candidate.archive_path}`
+        };
+      }
+      return {
+        kind: "knowledge_stale_archive_required",
+        path: candidate.path,
+        detail,
+        applied: false,
+        error: `ledger append failed (${truncateErrorMessage(ledgerError)}); archive rolled back`
+      };
+    }
+    return {
+      kind: "knowledge_stale_archive_required",
+      path: candidate.path,
+      detail,
+      applied: true
+    };
+  } catch (error) {
+    return {
+      kind: "knowledge_stale_archive_required",
+      path: candidate.path,
+      detail,
+      applied: false,
+      error: truncateErrorMessage(error)
+    };
+  }
+}
+async function applyPendingAutoArchive(projectRoot, candidate, now) {
+  const detail = `${candidate.pending_path} -> ${candidate.archived_to}`;
+  try {
+    await mkdir3(join5(candidate.archived_to_abs, ".."), { recursive: true });
+    let moved = false;
+    if (candidate.layer === "team") {
+      try {
+        const relSource = relativePosix(projectRoot, candidate.pending_path_abs);
+        const relDest = relativePosix(projectRoot, candidate.archived_to_abs);
+        execFileSync("git", ["mv", "-f", relSource, relDest], {
+          cwd: projectRoot,
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        moved = true;
+      } catch {
+      }
+    }
+    if (!moved) {
+      try {
+        await rename(candidate.pending_path_abs, candidate.archived_to_abs);
+      } catch (renameError) {
+        if (renameError instanceof Error && "code" in renameError && renameError.code === "EXDEV") {
+          const data = await readFile5(candidate.pending_path_abs);
+          await writeFile2(candidate.archived_to_abs, data);
+          const { unlink } = await import("fs/promises");
+          await unlink(candidate.pending_path_abs);
+        } else {
+          throw renameError;
+        }
+      }
+    }
+    try {
+      await appendEventLedgerEvent(projectRoot, {
+        event_type: "pending_auto_archived",
+        pending_path: candidate.pending_path,
+        archived_to: candidate.archived_to,
+        reason: "auto_archive_30d"
+      });
+    } catch (ledgerError) {
+      try {
+        await rename(candidate.archived_to_abs, candidate.pending_path_abs);
+      } catch (rollbackError) {
+        return {
+          kind: "knowledge_pending_auto_archive",
+          path: candidate.pending_path,
+          detail,
+          applied: false,
+          error: `ledger append failed (${truncateErrorMessage(ledgerError)}); rollback also failed (${truncateErrorMessage(rollbackError)}); file may be stranded at ${candidate.archived_to}`
+        };
+      }
+      return {
+        kind: "knowledge_pending_auto_archive",
+        path: candidate.pending_path,
+        detail,
+        applied: false,
+        error: `ledger append failed (${truncateErrorMessage(ledgerError)}); archive rolled back`
+      };
+    }
+    return {
+      kind: "knowledge_pending_auto_archive",
+      path: candidate.pending_path,
+      detail,
+      applied: true
+    };
+  } catch (error) {
+    return {
+      kind: "knowledge_pending_auto_archive",
+      path: candidate.pending_path,
+      detail,
+      applied: false,
+      error: truncateErrorMessage(error)
+    };
+  }
+}
+function relativePosix(projectRoot, absolutePath) {
+  const rel = nodeRelative(projectRoot, absolutePath);
+  return rel.split(sep4).join("/");
+}
+async function applySessionHintsStaleCleanup(projectRoot, candidate) {
+  const detail = `deleted (${candidate.age_days}d old)`;
+  const absPath = join5(projectRoot, candidate.path);
+  try {
+    const { unlink } = await import("fs/promises");
+    await unlink(absPath);
+    return {
+      kind: "knowledge_session_hints_stale_cleanup",
+      path: candidate.path,
+      detail,
+      applied: true
+    };
+  } catch (error) {
+    return {
+      kind: "knowledge_session_hints_stale_cleanup",
+      path: candidate.path,
+      detail,
+      applied: false,
+      error: truncateErrorMessage(error)
+    };
+  }
+}
+async function applyIndexDriftFix(projectRoot, inspection) {
+  const metaPath = join5(projectRoot, ".fabric", "agents.meta.json");
+  const detailParts = [];
+  try {
+    const meta = agentsMetaSchema4.parse(JSON.parse(await readFile5(metaPath, "utf8")));
+    const baseCounters = AgentsMetaCountersSchema.parse(meta.counters ?? void 0);
+    const updatedCounters = {
+      KP: { ...baseCounters.KP },
+      KT: { ...baseCounters.KT }
+    };
+    for (const drift of inspection.drifts) {
+      updatedCounters[drift.layer][drift.type] = drift.proposed_after;
+      detailParts.push(`${drift.layer}.${drift.type}: ${drift.counter} -> ${drift.proposed_after}`);
+    }
+    const updated = { ...meta, counters: updatedCounters };
+    await atomicWriteJson2(metaPath, updated, { indent: 2 });
+    return {
+      kind: "knowledge_index_drift",
+      path: "agents.meta.json#counters",
+      detail: detailParts.join("; "),
+      applied: true
+    };
+  } catch (error) {
+    return {
+      kind: "knowledge_index_drift",
+      path: "agents.meta.json#counters",
+      detail: detailParts.join("; ") || "(no counters processed)",
+      applied: false,
+      error: truncateErrorMessage(error)
+    };
+  }
+}
+function truncateErrorMessage(error) {
+  const raw = error instanceof Error ? error.message : String(error);
+  return raw.length > 240 ? `${raw.slice(0, 237)}...` : raw;
+}
 async function inspectForensic(projectRoot) {
   const path = join5(projectRoot, ".fabric", "forensic.json");
   try {
@@ -1537,7 +2031,7 @@ async function inspectMeta(projectRoot) {
 }
 async function tryBuildRuleMeta(projectRoot) {
   try {
-    return await buildRuleMeta(projectRoot);
+    return await buildKnowledgeMeta(projectRoot);
   } catch {
     return null;
   }
@@ -1597,15 +2091,15 @@ async function inspectEventLedger(projectRoot) {
     };
   }
 }
-async function inspectRuleTestIndex(projectRoot) {
-  const path = join5(projectRoot, ".fabric", "rule-test.index.json");
+async function inspectKnowledgeTestIndex(projectRoot) {
+  const path = join5(projectRoot, ".fabric", ".cache", "knowledge-test.index.json");
   const built = await tryBuildRuleMeta(projectRoot);
   try {
-    const index = ruleTestIndexSchema2.parse(JSON.parse(await readFile5(path, "utf8")));
+    const index = knowledgeTestIndexSchema2.parse(JSON.parse(await readFile5(path, "utf8")));
     return {
       present: true,
       valid: true,
-      stale: built === null ? false : !isSameRuleTestIndex(index, built.ruleTestIndex),
+      stale: built === null ? false : !isSameKnowledgeTestIndex(index, built.knowledgeTestIndex),
       linkCount: index.links.length,
       orphanCount: index.orphan_annotations.length
     };
@@ -1616,7 +2110,7 @@ async function inspectRuleTestIndex(projectRoot) {
       stale: true,
       linkCount: 0,
       orphanCount: 0,
-      error: isMissingFileError(error) ? ".fabric/rule-test.index.json is missing." : error instanceof Error ? error.message : String(error)
+      error: isMissingFileError(error) ? ".fabric/.cache/knowledge-test.index.json is missing." : error instanceof Error ? error.message : String(error)
     };
   }
 }
@@ -1732,17 +2226,17 @@ function createRuleContentRefCheck(meta) {
   }
   return okCheck("Rule content refs", "All content_ref entries resolve to .fabric/knowledge files.");
 }
-function createRuleTestIndexCheck(index) {
+function createKnowledgeTestIndexCheck(index) {
   if (!index.present) {
-    return issueCheck("Rule-test index", "error", "fixable_error", "rule_test_index_missing", index.error, "Run `fab doctor --fix` to rebuild .fabric/rule-test.index.json.");
+    return issueCheck("Knowledge-test index", "error", "fixable_error", "knowledge_test_index_missing", index.error, "Run `fab doctor --fix` to rebuild .fabric/.cache/knowledge-test.index.json.");
   }
   if (!index.valid) {
-    return issueCheck("Rule-test index", "error", "manual_error", "rule_test_index_invalid", index.error, "Delete .fabric/rule-test.index.json and run `fab doctor --fix` to regenerate it.");
+    return issueCheck("Knowledge-test index", "error", "manual_error", "knowledge_test_index_invalid", index.error, "Delete .fabric/.cache/knowledge-test.index.json and run `fab doctor --fix` to regenerate it.");
   }
   if (index.stale) {
-    return issueCheck("Rule-test index", "error", "fixable_error", "rule_test_index_stale", ".fabric/rule-test.index.json is stale.", "Run `fab doctor --fix` to rebuild the rule-test index.");
+    return issueCheck("Knowledge-test index", "error", "fixable_error", "knowledge_test_index_stale", ".fabric/.cache/knowledge-test.index.json is stale.", "Run `fab doctor --fix` to rebuild the knowledge-test index.");
   }
-  return okCheck("Rule-test index", `${index.linkCount} link${index.linkCount === 1 ? "" : "s"} and ${index.orphanCount} orphan annotation${index.orphanCount === 1 ? "" : "s"} indexed.`);
+  return okCheck("Knowledge-test index", `${index.linkCount} link${index.linkCount === 1 ? "" : "s"} and ${index.orphanCount} orphan annotation${index.orphanCount === 1 ? "" : "s"} indexed.`);
 }
 function createEventLedgerCheck(ledger) {
   if (!ledger.exists) {
@@ -2071,6 +2565,83 @@ function inspectPreexistingRootFiles(projectRoot) {
   const detected = candidates.filter((name) => existsSync4(join5(projectRoot, name)));
   return { detected };
 }
+async function inspectFilesystemEditFallback(projectRoot) {
+  const knowledgeRoot = join5(projectRoot, ".fabric", "knowledge");
+  if (!existsSync4(knowledgeRoot)) {
+    return { synthesized: 0, synthesizedStableIds: [] };
+  }
+  const canonicalIds = /* @__PURE__ */ new Set();
+  for (const typeDir of KNOWLEDGE_CANONICAL_TYPE_DIRS) {
+    const dir = join5(knowledgeRoot, typeDir);
+    if (!existsSync4(dir)) {
+      continue;
+    }
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isFile()) {
+        continue;
+      }
+      const match = CANONICAL_KNOWLEDGE_FILENAME_PATTERN.exec(entry.name);
+      if (match === null) {
+        continue;
+      }
+      canonicalIds.add(match[1]);
+    }
+  }
+  if (canonicalIds.size === 0) {
+    return { synthesized: 0, synthesizedStableIds: [] };
+  }
+  let promotedIds = /* @__PURE__ */ new Set();
+  try {
+    const { events } = await readEventLedger(projectRoot, { event_type: "knowledge_promoted" });
+    promotedIds = new Set(
+      events.map((event) => event.event_type === "knowledge_promoted" ? event.stable_id : void 0).filter((id) => typeof id === "string")
+    );
+  } catch {
+    promotedIds = /* @__PURE__ */ new Set();
+  }
+  const orphanIds = [];
+  for (const id of canonicalIds) {
+    if (!promotedIds.has(id)) {
+      orphanIds.push(id);
+    }
+  }
+  orphanIds.sort();
+  for (const stable_id of orphanIds) {
+    await appendEventLedgerEvent(projectRoot, {
+      event_type: "knowledge_promoted",
+      stable_id,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      reason: SYNTHESIZED_PROMOTED_REASON,
+      correlation_id: "doctor-synthesized",
+      session_id: "doctor-synthesized"
+    });
+  }
+  return { synthesized: orphanIds.length, synthesizedStableIds: orphanIds };
+}
+function createFilesystemEditFallbackCheck(inspection) {
+  if (inspection.synthesized === 0) {
+    return okCheck(
+      "Filesystem-edit fallback",
+      "No orphan canonical knowledge entries detected; events.jsonl promotion trail is complete."
+    );
+  }
+  const sample = inspection.synthesizedStableIds.slice(0, 3).join(", ");
+  return {
+    name: "Filesystem-edit fallback",
+    status: "ok",
+    kind: "info",
+    code: "knowledge_promoted_synthesized",
+    fixable: false,
+    message: `Synthesized ${inspection.synthesized} knowledge_promoted event${inspection.synthesized === 1 ? "" : "s"} for orphan canonical entries (${sample}${inspection.synthesizedStableIds.length > 3 ? ", ..." : ""}). Reason='${SYNTHESIZED_PROMOTED_REASON}'.`,
+    actionHint: "These entries were moved into .fabric/knowledge/<type>/ outside fab_review.approve. The synthesized events restore audit-trail completeness."
+  };
+}
 function createPreexistingRootFilesCheck(inspection) {
   if (inspection.detected.length === 0) {
     return okCheck("Preexisting root markdown", "No CLAUDE.md or AGENTS.md detected at project root.");
@@ -2085,82 +2656,1288 @@ function createPreexistingRootFilesCheck(inspection) {
     actionHint: "Move knowledge content to `.fabric/knowledge/{type}/` if you want it available in MCP responses."
   };
 }
-async function fixMcpConfigInWrongFile(projectRoot) {
-  const settingsPath = join5(projectRoot, ".claude", "settings.json");
-  if (!existsSync4(settingsPath)) {
-    return;
-  }
-  let settings;
+async function buildLastConsumedIndex(projectRoot) {
+  const map = /* @__PURE__ */ new Map();
+  let events;
   try {
-    const parsed = JSON.parse(readFileSync(settingsPath, "utf8"));
-    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return;
-    }
-    settings = parsed;
+    ({ events } = await readEventLedger(projectRoot));
   } catch {
-    return;
-  }
-  const mcpServers = settings.mcpServers;
-  if (mcpServers === null || typeof mcpServers !== "object" || Array.isArray(mcpServers)) {
-    return;
-  }
-  const { fabric: _removed, ...remainingServers } = mcpServers;
-  const cleaned = { ...settings };
-  if (Object.keys(remainingServers).length === 0) {
-    delete cleaned.mcpServers;
-  } else {
-    cleaned.mcpServers = remainingServers;
+    return map;
   }
-  await atomicWriteJson2(settingsPath, cleaned, { indent: 2 });
-  await appendEventLedgerEvent(projectRoot, {
-    event_type: "mcp_config_migrated",
-    source: "doctor_fix",
-    removed_from: ".claude/settings.json"
-  });
-}
-async function ensureKnowledgeSubdirs(projectRoot) {
-  for (const sub of KNOWLEDGE_SUBDIRS2) {
-    await mkdir3(join5(projectRoot, ".fabric", "knowledge", sub), { recursive: true });
+  for (const event of events) {
+    if (event.event_type !== "knowledge_consumed" && event.event_type !== "knowledge_demoted" && event.event_type !== "knowledge_archived") {
+      continue;
+    }
+    const ts = event.ts;
+    if (typeof ts !== "number" || !Number.isFinite(ts)) {
+      continue;
+    }
+    const stableId = event.stable_id;
+    if (typeof stableId !== "string" || stableId.length === 0) {
+      continue;
+    }
+    const prev = map.get(stableId);
+    if (prev === void 0 || ts > prev) {
+      map.set(stableId, ts);
+    }
   }
+  return map;
 }
-async function fixCounterDesync(projectRoot) {
-  const metaPath = join5(projectRoot, ".fabric", "agents.meta.json");
-  if (!existsSync4(metaPath)) {
-    return;
-  }
-  let meta;
+async function buildLastActiveIndex(projectRoot) {
+  const map = /* @__PURE__ */ new Map();
+  let events;
   try {
-    meta = agentsMetaSchema4.parse(JSON.parse(await readFile5(metaPath, "utf8")));
+    ({ events } = await readEventLedger(projectRoot));
   } catch {
-    return;
+    return map;
   }
-  const synthetic = {
-    present: true,
-    valid: true,
-    meta,
-    revision: meta.revision,
-    computedRevision: null,
-    ruleCount: 0,
-    missingContentRefs: [],
-    invalidContentRefs: [],
-    stale: false,
-    changed: false
-  };
-  const desync = inspectCounterDesync(synthetic);
-  if (desync.desyncs.length === 0 || desync.correctedCounters === null) {
-    return;
+  for (const event of events) {
+    const ts = event.ts;
+    if (typeof ts !== "number" || !Number.isFinite(ts)) {
+      continue;
+    }
+    const ids = [];
+    switch (event.event_type) {
+      case "knowledge_proposed":
+      case "knowledge_promote_started":
+      case "knowledge_promoted":
+      case "knowledge_promote_failed":
+      case "knowledge_layer_changed":
+      case "knowledge_slug_renamed":
+      case "knowledge_demoted":
+      case "knowledge_archived":
+      case "knowledge_archive_attempted":
+      case "knowledge_deferred":
+      case "knowledge_rejected": {
+        if (typeof event.stable_id === "string" && event.stable_id.length > 0) {
+          ids.push(event.stable_id);
+        }
+        break;
+      }
+      case "knowledge_context_planned": {
+        ids.push(...event.required_stable_ids, ...event.ai_selectable_stable_ids, ...event.final_stable_ids);
+        break;
+      }
+      case "knowledge_selection": {
+        ids.push(
+          ...event.required_stable_ids,
+          ...event.ai_selectable_stable_ids,
+          ...event.ai_selected_stable_ids,
+          ...event.final_stable_ids
+        );
+        break;
+      }
+      case "knowledge_sections_fetched": {
+        ids.push(...event.final_stable_ids, ...event.ai_selected_stable_ids);
+        break;
+      }
+      default:
+        break;
+    }
+    for (const id of ids) {
+      const prev = map.get(id);
+      if (prev === void 0 || ts > prev) {
+        map.set(id, ts);
+      }
+    }
   }
-  const updated = { ...meta, counters: desync.correctedCounters };
-  await atomicWriteJson2(metaPath, updated, { indent: 2 });
+  return map;
 }
-async function ensureEventLedger(projectRoot) {
-  const path = getEventLedgerPath(projectRoot);
-  await ensureParentDirectory(path);
-  await writeFile2(path, "", { encoding: "utf8", flag: "a" });
+function maturityThresholdDays(maturity) {
+  return ORPHAN_DEMOTE_THRESHOLD_DAYS[maturity];
 }
-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"}.`;
-  const manualText = report.manual_errors.length === 0 ? "No manual errors remain." : `${report.manual_errors.length} manual error${report.manual_errors.length === 1 ? "" : "s"} remain.`;
+function nextLowerMaturity(current) {
+  if (current === "stable") return "endorsed";
+  if (current === "endorsed") return "draft";
+  return null;
+}
+function extractKnowledgeFrontmatterMaturity(source) {
+  const FM_PATTERN = /^(?:\uFEFF)?---\r?\n([\s\S]*?)\r?\n---/u;
+  const fm = FM_PATTERN.exec(source);
+  if (fm === null) {
+    return null;
+  }
+  const match = MATURITY_LINE_PATTERN.exec(fm[1]);
+  return match === null ? null : match[2];
+}
+function extractKnowledgeFrontmatterCreatedAt(source) {
+  const FM_PATTERN = /^(?:\uFEFF)?---\r?\n([\s\S]*?)\r?\n---/u;
+  const fm = FM_PATTERN.exec(source);
+  if (fm === null) {
+    return null;
+  }
+  const match = CREATED_AT_LINE_PATTERN.exec(fm[1]);
+  if (match === null) {
+    return null;
+  }
+  const parsed = Date.parse(match[2]);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function* iterateCanonicalEntries(projectRoot, lastActiveIndex) {
+  const knowledgeRoot = join5(projectRoot, ".fabric", "knowledge");
+  if (!existsSync4(knowledgeRoot)) {
+    return;
+  }
+  for (const typeDir of KNOWLEDGE_CANONICAL_TYPE_DIRS) {
+    const dir = join5(knowledgeRoot, typeDir);
+    if (!existsSync4(dir)) {
+      continue;
+    }
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isFile()) {
+        continue;
+      }
+      const match = CANONICAL_KNOWLEDGE_FILENAME_PATTERN.exec(entry.name);
+      if (match === null) {
+        continue;
+      }
+      const stableId = match[1];
+      const absPath = join5(dir, entry.name);
+      let source;
+      try {
+        source = readFileSync(absPath, "utf8");
+      } catch {
+        continue;
+      }
+      const maturity = extractKnowledgeFrontmatterMaturity(source);
+      if (maturity === null) {
+        continue;
+      }
+      const createdAt = extractKnowledgeFrontmatterCreatedAt(source);
+      const eventTs = lastActiveIndex.get(stableId) ?? 0;
+      let lastReferenceMs = Math.max(createdAt ?? 0, eventTs);
+      if (lastReferenceMs === 0) {
+        try {
+          lastReferenceMs = statSync3(absPath).mtimeMs;
+        } catch {
+          lastReferenceMs = 0;
+        }
+      }
+      const relPath = posix.join(
+        ".fabric/knowledge",
+        typeDir,
+        entry.name
+      );
+      yield { stable_id: stableId, maturity, type: typeDir, absPath, relPath, lastReferenceMs };
+    }
+  }
+}
+async function inspectOrphanDemote(projectRoot, now) {
+  const lastConsumedIndex = await buildLastConsumedIndex(projectRoot);
+  const candidates = [];
+  for (const entry of iterateCanonicalEntries(projectRoot, lastConsumedIndex)) {
+    const ageMs = entry.lastReferenceMs > 0 ? now - entry.lastReferenceMs : now;
+    const ageDays = Math.floor(ageMs / MS_PER_DAY);
+    const threshold = maturityThresholdDays(entry.maturity);
+    if (ageDays <= threshold) {
+      continue;
+    }
+    candidates.push({
+      stable_id: entry.stable_id,
+      path: entry.relPath,
+      age_days: ageDays,
+      maturity: entry.maturity,
+      next_maturity: nextLowerMaturity(entry.maturity)
+    });
+  }
+  candidates.sort((a, b) => a.path.localeCompare(b.path));
+  return { candidates };
+}
+async function inspectStaleArchive(projectRoot, now) {
+  const lastActiveIndex = await buildLastActiveIndex(projectRoot);
+  const candidates = [];
+  for (const entry of iterateCanonicalEntries(projectRoot, lastActiveIndex)) {
+    if (entry.maturity !== "draft") {
+      continue;
+    }
+    const ageMs = entry.lastReferenceMs > 0 ? now - entry.lastReferenceMs : now;
+    const ageDays = Math.floor(ageMs / MS_PER_DAY);
+    const requiredQuiet = ORPHAN_DEMOTE_THRESHOLD_DAYS.draft + STALE_ARCHIVE_ADDITIONAL_DAYS;
+    if (ageDays <= requiredQuiet) {
+      continue;
+    }
+    const filename = posix.basename(entry.relPath);
+    candidates.push({
+      stable_id: entry.stable_id,
+      path: entry.relPath,
+      age_days: ageDays,
+      archive_path: posix.join(".fabric/.archive", entry.type, filename)
+    });
+  }
+  candidates.sort((a, b) => a.path.localeCompare(b.path));
+  return { candidates };
+}
+function* iteratePendingFiles(projectRoot, now) {
+  const teamRoot = join5(projectRoot, ".fabric", "knowledge", "pending");
+  const personalRoot = join5(resolvePersonalRootForPending(), ".fabric", "knowledge", "pending");
+  for (const [layer, root, displayPrefix] of [
+    ["team", teamRoot, ".fabric/knowledge/pending"],
+    ["personal", personalRoot, "~/.fabric/knowledge/pending"]
+  ]) {
+    if (!existsSync4(root)) {
+      continue;
+    }
+    let typeDirs = [];
+    try {
+      typeDirs = readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    } catch {
+      continue;
+    }
+    for (const typeDir of typeDirs) {
+      const dir = join5(root, typeDir);
+      let entries;
+      try {
+        entries = readdirSync(dir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".md")) {
+          continue;
+        }
+        const absPath = join5(dir, entry.name);
+        let source = "";
+        try {
+          source = readFileSync(absPath, "utf8");
+        } catch {
+          continue;
+        }
+        const createdAt = extractKnowledgeFrontmatterCreatedAt(source);
+        let mtimeMs = 0;
+        try {
+          mtimeMs = statSync3(absPath).mtimeMs;
+        } catch {
+          mtimeMs = 0;
+        }
+        const referenceMs = createdAt ?? mtimeMs;
+        const displayPath = posix.join(displayPrefix, typeDir, entry.name);
+        if (referenceMs === 0) {
+          yield {
+            layer,
+            type: typeDir,
+            filename: entry.name,
+            pending_path: displayPath,
+            pending_path_abs: absPath,
+            stable_id: void 0,
+            age_days: PENDING_OVERDUE_THRESHOLD_DAYS + 1
+          };
+          continue;
+        }
+        const ageDays = Math.floor((now - referenceMs) / MS_PER_DAY);
+        const stableId = extractKnowledgeFrontmatterId(source) ?? void 0;
+        yield {
+          layer,
+          type: typeDir,
+          filename: entry.name,
+          pending_path: displayPath,
+          pending_path_abs: absPath,
+          stable_id: stableId,
+          age_days: ageDays
+        };
+      }
+    }
+  }
+}
+function resolvePersonalRootForPending() {
+  return process.env.FABRIC_HOME ?? homedir2();
+}
+function inspectPendingOverdue(projectRoot, now) {
+  const candidates = [];
+  for (const visit of iteratePendingFiles(projectRoot, now)) {
+    if (visit.age_days <= PENDING_OVERDUE_THRESHOLD_DAYS) {
+      continue;
+    }
+    candidates.push({
+      stable_id: visit.stable_id,
+      path: visit.pending_path,
+      age_days: visit.age_days
+    });
+  }
+  candidates.sort((a, b) => a.path.localeCompare(b.path));
+  return { candidates };
+}
+function inspectPendingAutoArchive(projectRoot, now) {
+  const candidates = [];
+  for (const visit of iteratePendingFiles(projectRoot, now)) {
+    if (visit.age_days <= PENDING_AUTO_ARCHIVE_THRESHOLD_DAYS) {
+      continue;
+    }
+    if (visit.layer === "team") {
+      const archivedToRel = posix.join(".fabric/.archive/pending", visit.type, visit.filename);
+      candidates.push({
+        layer: "team",
+        type: visit.type,
+        pending_path: visit.pending_path,
+        pending_path_abs: visit.pending_path_abs,
+        archived_to: archivedToRel,
+        archived_to_abs: join5(projectRoot, archivedToRel),
+        age_days: visit.age_days
+      });
+    } else {
+      const archivedToDisplay = posix.join(
+        "~/.fabric/.archive/pending",
+        visit.type,
+        visit.filename
+      );
+      const archivedToAbs = join5(
+        resolvePersonalRootForPending(),
+        ".fabric",
+        ".archive",
+        "pending",
+        visit.type,
+        visit.filename
+      );
+      candidates.push({
+        layer: "personal",
+        type: visit.type,
+        pending_path: visit.pending_path,
+        pending_path_abs: visit.pending_path_abs,
+        archived_to: archivedToDisplay,
+        archived_to_abs: archivedToAbs,
+        age_days: visit.age_days
+      });
+    }
+  }
+  candidates.sort((a, b) => a.pending_path.localeCompare(b.pending_path));
+  return { candidates };
+}
+function inspectUnderseeded(projectRoot) {
+  const threshold = readUnderseedThresholdFromConfig(projectRoot);
+  const knowledgeRoot = join5(projectRoot, ".fabric", "knowledge");
+  let nodeCount = 0;
+  if (existsSync4(knowledgeRoot)) {
+    for (const typeDir of KNOWLEDGE_CANONICAL_TYPE_DIRS) {
+      const dir = join5(knowledgeRoot, typeDir);
+      if (!existsSync4(dir)) continue;
+      let entries;
+      try {
+        entries = readdirSync(dir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith(".md")) {
+          nodeCount += 1;
+        }
+      }
+    }
+  }
+  return {
+    node_count: nodeCount,
+    threshold,
+    underseeded: nodeCount < threshold
+  };
+}
+function inspectSessionHintsStale(projectRoot, now) {
+  const cacheDir = join5(projectRoot, ".fabric", ".cache");
+  if (!existsSync4(cacheDir)) {
+    return { candidates: [] };
+  }
+  let entries;
+  try {
+    entries = readdirSync(cacheDir, { withFileTypes: true });
+  } catch {
+    return { candidates: [] };
+  }
+  const candidates = [];
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    if (!entry.name.startsWith(SESSION_HINTS_FILE_PREFIX)) continue;
+    if (!entry.name.endsWith(SESSION_HINTS_FILE_SUFFIX)) continue;
+    const absPath = join5(cacheDir, entry.name);
+    let mtimeMs = 0;
+    try {
+      mtimeMs = statSync3(absPath).mtimeMs;
+    } catch {
+      continue;
+    }
+    const ageDays = Math.floor((now - mtimeMs) / MS_PER_DAY);
+    if (ageDays < SESSION_HINTS_STALE_DAYS) continue;
+    candidates.push({
+      path: posix.join(".fabric", ".cache", entry.name),
+      age_days: ageDays
+    });
+  }
+  candidates.sort((a, b) => a.path.localeCompare(b.path));
+  return { candidates };
+}
+function inspectNarrowTooFew(projectRoot, now) {
+  let total = 0;
+  let narrowWithPaths = 0;
+  for (const { scope, paths } of iterateRelevanceFrontmatter(projectRoot)) {
+    total += 1;
+    if (scope === "narrow" && paths.length > 0) {
+      narrowWithPaths += 1;
+    }
+  }
+  const narrowRatio = total === 0 ? 0 : narrowWithPaths / total;
+  const structuralFlagged = total >= NARROW_MIN_TOTAL && narrowRatio < NARROW_RATIO_THRESHOLD;
+  const windowStartMs = now - SILENCE_WINDOW_DAYS * MS_PER_DAY;
+  const editFires = readCounterTimestamps(
+    join5(projectRoot, EDIT_COUNTER_FILE_REL),
+    windowStartMs
+  );
+  const silenceFires = readCounterTimestamps(
+    join5(projectRoot, HINT_SILENCE_COUNTER_FILE_REL),
+    windowStartMs
+  );
+  const telemetrySkipped = editFires === 0;
+  const silenceRate = editFires === 0 ? 0 : silenceFires / editFires;
+  const telemetryFlagged = !telemetrySkipped && silenceRate > SILENCE_RATE_THRESHOLD;
+  return {
+    total_canonical_entries: total,
+    narrow_with_paths_count: narrowWithPaths,
+    narrow_ratio: narrowRatio,
+    structural_flagged: structuralFlagged,
+    total_edit_fires_in_window: editFires,
+    silence_fires_in_window: silenceFires,
+    silence_rate: silenceRate,
+    telemetry_skipped: telemetrySkipped,
+    telemetry_flagged: telemetryFlagged
+  };
+}
+function readCounterTimestamps(absPath, windowStartMs) {
+  if (!existsSync4(absPath)) return 0;
+  let raw;
+  try {
+    raw = readFileSync(absPath, "utf8");
+  } catch {
+    return 0;
+  }
+  let count = 0;
+  for (const line of raw.split(/\r?\n/u)) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    const ts = Date.parse(trimmed);
+    if (!Number.isFinite(ts)) continue;
+    if (ts < windowStartMs) continue;
+    count += 1;
+  }
+  return count;
+}
+function readUnderseedThresholdFromConfig(projectRoot) {
+  const configPath = join5(projectRoot, ".fabric", "fabric-config.json");
+  if (!existsSync4(configPath)) return DEFAULT_UNDERSEED_NODE_THRESHOLD;
+  try {
+    const raw = readFileSync(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const v = parsed.underseed_node_threshold;
+      if (typeof v === "number" && Number.isFinite(v) && v > 0) {
+        return v;
+      }
+    }
+  } catch {
+  }
+  return DEFAULT_UNDERSEED_NODE_THRESHOLD;
+}
+function createOrphanDemoteCheck(inspection) {
+  if (inspection.candidates.length === 0) {
+    return okCheck(
+      "Knowledge orphan demote",
+      "No canonical knowledge entries exceed their maturity-keyed inactivity threshold."
+    );
+  }
+  const first = inspection.candidates[0];
+  const detail = `${first.stable_id} (${first.maturity}, ${first.age_days}d inactive at ${first.path})`;
+  return issueCheck(
+    "Knowledge orphan demote",
+    "warn",
+    "warning",
+    "knowledge_orphan_demote_required",
+    `${inspection.candidates.length} canonical knowledge entr${inspection.candidates.length === 1 ? "y exceeds" : "ies exceed"} their maturity-keyed inactivity threshold (stable=${ORPHAN_DEMOTE_THRESHOLD_DAYS.stable}d / endorsed=${ORPHAN_DEMOTE_THRESHOLD_DAYS.endorsed}d / draft=${ORPHAN_DEMOTE_THRESHOLD_DAYS.draft}d). First: ${detail}.`,
+    "Run `fab doctor --apply-lint` (rc.4 TASK-003) to demote orphan entries one maturity tier."
+  );
+}
+function createStaleArchiveCheck(inspection) {
+  if (inspection.candidates.length === 0) {
+    return okCheck(
+      "Knowledge stale archive",
+      "No draft knowledge entries exceed the additional stale-archive quiet window."
+    );
+  }
+  const first = inspection.candidates[0];
+  const detail = `${first.stable_id} (${first.age_days}d inactive at ${first.path}) \u2192 ${first.archive_path}`;
+  return issueCheck(
+    "Knowledge stale archive",
+    "warn",
+    "warning",
+    "knowledge_stale_archive_required",
+    `${inspection.candidates.length} draft knowledge entr${inspection.candidates.length === 1 ? "y is" : "ies are"} stale beyond the demote+${STALE_ARCHIVE_ADDITIONAL_DAYS}d additional quiet window. First: ${detail}.`,
+    "Run `fab doctor --apply-lint` (rc.4 TASK-003) to move stale entries into `.fabric/.archive/<type>/`."
+  );
+}
+function createPendingOverdueCheck(inspection) {
+  if (inspection.candidates.length === 0) {
+    return okCheck(
+      "Knowledge pending overdue",
+      "No pending knowledge entries exceed the 14-day review threshold."
+    );
+  }
+  const first = inspection.candidates[0];
+  const detail = `${first.path} (${first.age_days}d old)`;
+  return issueCheck(
+    "Knowledge pending overdue",
+    "warn",
+    "warning",
+    "knowledge_pending_overdue",
+    `${inspection.candidates.length} pending knowledge entr${inspection.candidates.length === 1 ? "y has" : "ies have"} been awaiting review for more than ${PENDING_OVERDUE_THRESHOLD_DAYS} days. First: ${detail}.`,
+    "Review pending entries via the fabric-review Skill (`/fabric-review`) and approve, reject, defer, or modify."
+  );
+}
+function createUnderseededCheck(inspection) {
+  if (!inspection.underseeded) {
+    return okCheck(
+      "Knowledge underseeded",
+      `Knowledge corpus has ${inspection.node_count} canonical entries (>= ${inspection.threshold}).`
+    );
+  }
+  return issueCheck(
+    "Knowledge underseeded",
+    "ok",
+    "info",
+    "knowledge_underseeded",
+    `Knowledge corpus has only ${inspection.node_count} canonical entr${inspection.node_count === 1 ? "y" : "ies"} (< ${inspection.threshold} threshold). The plan_context retrieval surface is below its useful floor.`,
+    "Run the fabric-import Skill (`/fabric-import`) to backfill knowledge from git history and existing docs."
+  );
+}
+function createSessionHintsStaleCheck(inspection) {
+  if (inspection.candidates.length === 0) {
+    return okCheck(
+      "Knowledge session-hints stale",
+      `No session-hints cache files older than ${SESSION_HINTS_STALE_DAYS} days under .fabric/.cache/.`
+    );
+  }
+  const first = inspection.candidates[0];
+  const detail = `${first.path} (${first.age_days}d old)`;
+  return issueCheck(
+    "Knowledge session-hints stale",
+    "ok",
+    "info",
+    "knowledge_session_hints_stale",
+    `${inspection.candidates.length} session-hints cache file${inspection.candidates.length === 1 ? "" : "s"} under .fabric/.cache/ ${inspection.candidates.length === 1 ? "is" : "are"} older than ${SESSION_HINTS_STALE_DAYS} days. First: ${detail}.`,
+    "Run `fab doctor --apply-lint` to delete stale session-hints cache files."
+  );
+}
+function extractKnowledgeFrontmatterRelevanceScope(source) {
+  const FM_PATTERN = /^(?:\uFEFF)?---\r?\n([\s\S]*?)\r?\n---/u;
+  const fm = FM_PATTERN.exec(source);
+  if (fm === null) {
+    return "broad";
+  }
+  const match = RELEVANCE_SCOPE_LINE_PATTERN.exec(fm[1]);
+  if (match === null) {
+    return "broad";
+  }
+  return match[2];
+}
+function extractKnowledgeFrontmatterRelevancePaths(source) {
+  const FM_PATTERN = /^(?:\uFEFF)?---\r?\n([\s\S]*?)\r?\n---/u;
+  const fm = FM_PATTERN.exec(source);
+  if (fm === null) {
+    return [];
+  }
+  const match = RELEVANCE_PATHS_LINE_PATTERN.exec(fm[1]);
+  if (match === null) {
+    return [];
+  }
+  const inner = match[1].trim();
+  if (inner.length === 0) {
+    return [];
+  }
+  return inner.split(",").map((token) => token.trim().replace(/^"(.*)"$/u, "$1")).filter((token) => token.length > 0);
+}
+function* iterateRelevanceFrontmatter(projectRoot) {
+  for (const visit of iterateCanonicalFilenames(projectRoot)) {
+    const layerRoot = visit.layer === "team" ? join5(projectRoot, ".fabric", "knowledge") : resolvePersonalKnowledgeRoot();
+    const absPath = join5(layerRoot, visit.type, visit.filename);
+    let source;
+    try {
+      source = readFileSync(absPath, "utf8");
+    } catch {
+      continue;
+    }
+    const scope = extractKnowledgeFrontmatterRelevanceScope(source);
+    const paths = extractKnowledgeFrontmatterRelevancePaths(source);
+    yield { visit, scope, paths, absPath };
+  }
+}
+function inspectNarrowNoPaths(projectRoot) {
+  const candidates = [];
+  for (const { visit, scope, paths } of iterateRelevanceFrontmatter(projectRoot)) {
+    if (scope !== "narrow") {
+      continue;
+    }
+    if (paths.length > 0) {
+      continue;
+    }
+    candidates.push({
+      stable_id: visit.parsed.stable_id,
+      path: visit.displayPath
+    });
+  }
+  candidates.sort((a, b) => a.path.localeCompare(b.path));
+  return { candidates };
+}
+function inspectRelevancePathsDangling(projectRoot) {
+  const entries = [];
+  const workspacePaths = collectWorkspacePathsForGlobMatch(projectRoot);
+  if (workspacePaths.length === 0) {
+    return { entries };
+  }
+  for (const { visit, paths } of iterateRelevanceFrontmatter(projectRoot)) {
+    if (paths.length === 0) {
+      continue;
+    }
+    for (const rawGlob of paths) {
+      const glob = rawGlob.endsWith("/") ? `${rawGlob}**` : rawGlob;
+      let matched = false;
+      for (const target of workspacePaths) {
+        if (minimatch(target, glob, { dot: true, matchBase: false })) {
+          matched = true;
+          break;
+        }
+      }
+      if (matched) {
+        continue;
+      }
+      entries.push({
+        stable_id: visit.parsed.stable_id,
+        path: visit.displayPath,
+        dangling_glob: rawGlob
+      });
+    }
+  }
+  entries.sort((a, b) => {
+    const byPath = a.path.localeCompare(b.path);
+    return byPath !== 0 ? byPath : a.dangling_glob.localeCompare(b.dangling_glob);
+  });
+  return { entries };
+}
+function collectWorkspacePathsForGlobMatch(projectRoot) {
+  if (!existsSync4(projectRoot)) {
+    return [];
+  }
+  let rootStat;
+  try {
+    rootStat = statSync3(projectRoot);
+  } catch {
+    return [];
+  }
+  if (!rootStat.isDirectory()) {
+    return [];
+  }
+  const paths = [];
+  const stack = [projectRoot];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === void 0) continue;
+    let entries;
+    try {
+      entries = readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const abs = join5(current, entry.name);
+      const rel = normalizePath(abs.slice(projectRoot.length + 1));
+      if (rel.length === 0) continue;
+      if (entry.isDirectory()) {
+        if (IGNORED_DIRECTORIES.has(entry.name)) {
+          continue;
+        }
+        paths.push(rel);
+        stack.push(abs);
+      } else if (entry.isFile()) {
+        paths.push(rel);
+      }
+    }
+  }
+  return paths;
+}
+function inspectRelevancePathsDrift(projectRoot) {
+  let recentPaths = null;
+  try {
+    recentPaths = readRecentGitTouchedPaths(projectRoot, RELEVANCE_PATHS_DRIFT_WINDOW_DAYS);
+  } catch {
+    recentPaths = null;
+  }
+  if (recentPaths === null) {
+    return { candidates: [], git_available: false };
+  }
+  const candidates = [];
+  for (const { visit, scope, paths } of iterateRelevanceFrontmatter(projectRoot)) {
+    if (scope !== "narrow") {
+      continue;
+    }
+    if (paths.length === 0) {
+      continue;
+    }
+    let anyMatch = false;
+    for (const rawGlob of paths) {
+      const glob = rawGlob.endsWith("/") ? `${rawGlob}**` : rawGlob;
+      for (const target of recentPaths) {
+        if (minimatch(target, glob, { dot: true, matchBase: false })) {
+          anyMatch = true;
+          break;
+        }
+      }
+      if (anyMatch) break;
+    }
+    if (anyMatch) {
+      continue;
+    }
+    candidates.push({
+      stable_id: visit.parsed.stable_id,
+      path: visit.displayPath,
+      globs: paths.slice()
+    });
+  }
+  candidates.sort((a, b) => a.path.localeCompare(b.path));
+  return { candidates, git_available: true };
+}
+function readRecentGitTouchedPaths(projectRoot, windowDays) {
+  const since = new Date(Date.now() - windowDays * MS_PER_DAY).toISOString();
+  const stdout = execFileSync(
+    "git",
+    ["log", `--since=${since}`, "--name-only", "--pretty=format:"],
+    {
+      cwd: projectRoot,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf8"
+    }
+  );
+  const set = /* @__PURE__ */ new Set();
+  for (const line of stdout.split(/\r?\n/u)) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    set.add(normalizePath(trimmed));
+  }
+  return Array.from(set);
+}
+function createNarrowNoPathsCheck(inspection) {
+  if (inspection.candidates.length === 0) {
+    return okCheck(
+      "Knowledge narrow without paths",
+      "No narrow-scope canonical entries have an empty relevance_paths array."
+    );
+  }
+  const first = inspection.candidates[0];
+  const detail = `${first.stable_id} (${first.path})`;
+  return issueCheck(
+    "Knowledge narrow without paths",
+    "warn",
+    "warning",
+    "knowledge_narrow_no_paths",
+    `${inspection.candidates.length} narrow-scope canonical entr${inspection.candidates.length === 1 ? "y has" : "ies have"} an empty relevance_paths array (silent recall risk \u2014 narrow without anchors can never match a target path). First: ${detail}.`,
+    "Either add path anchors to relevance_paths or widen the entry's relevance_scope to broad."
+  );
+}
+function createRelevancePathsDanglingCheck(inspection) {
+  if (inspection.entries.length === 0) {
+    return okCheck(
+      "Knowledge relevance_paths dangling",
+      "All relevance_paths globs resolve to at least one file under the workspace root."
+    );
+  }
+  const first = inspection.entries[0];
+  const detail = `${first.stable_id} at ${first.path} \u2192 \`${first.dangling_glob}\` (0 matches)`;
+  return issueCheck(
+    "Knowledge relevance_paths dangling",
+    "warn",
+    "warning",
+    "knowledge_relevance_paths_dangling",
+    `${inspection.entries.length} relevance_paths glob${inspection.entries.length === 1 ? " resolves" : "s resolve"} to zero files in the current workspace. First: ${detail}.`,
+    "Update the entry's relevance_paths to remove globs that no longer match any files, or use `fab_review.modify` to rewrite the anchor set."
+  );
+}
+function createRelevancePathsDriftCheck(inspection) {
+  if (!inspection.git_available) {
+    return okCheck(
+      "Knowledge relevance_paths drift",
+      `Skipped (git history unavailable; cannot evaluate ${RELEVANCE_PATHS_DRIFT_WINDOW_DAYS}d drift window).`
+    );
+  }
+  if (inspection.candidates.length === 0) {
+    return okCheck(
+      "Knowledge relevance_paths drift",
+      `All narrow-scope canonical entries have at least one relevance_path touched in the last ${RELEVANCE_PATHS_DRIFT_WINDOW_DAYS}d.`
+    );
+  }
+  const first = inspection.candidates[0];
+  const detail = `${first.stable_id} at ${first.path} (globs: ${first.globs.join(", ")})`;
+  return issueCheck(
+    "Knowledge relevance_paths drift",
+    "ok",
+    "info",
+    "knowledge_relevance_paths_drift",
+    `${inspection.candidates.length} narrow-scope canonical entr${inspection.candidates.length === 1 ? "y has" : "ies have"} relevance_paths whose globs match no file touched in the last ${RELEVANCE_PATHS_DRIFT_WINDOW_DAYS}d of git history. First: ${detail}.`,
+    "Review whether the entry is still relevant \u2014 use `fab_review.modify` to refresh the anchors or `fab_review.reject` to archive."
+  );
+}
+function inspectRelevanceFieldsMissing(projectRoot) {
+  const candidates = [];
+  let scannedCount = 0;
+  const FM_PATTERN = /^(?:\uFEFF)?---\r?\n([\s\S]*?)\r?\n---/u;
+  const teamRoot = join5(projectRoot, ".fabric", "knowledge", "pending");
+  const personalRoot = join5(
+    resolvePersonalRootForPending(),
+    ".fabric",
+    "knowledge",
+    "pending"
+  );
+  for (const [root, displayPrefix] of [
+    [teamRoot, ".fabric/knowledge/pending"],
+    [personalRoot, "~/.fabric/knowledge/pending"]
+  ]) {
+    if (!existsSync4(root)) {
+      continue;
+    }
+    let typeDirs = [];
+    try {
+      typeDirs = readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    } catch {
+      continue;
+    }
+    for (const typeDir of typeDirs) {
+      const dir = join5(root, typeDir);
+      let entries;
+      try {
+        entries = readdirSync(dir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".md")) {
+          continue;
+        }
+        const absPath = join5(dir, entry.name);
+        let source;
+        try {
+          source = readFileSync(absPath, "utf8");
+        } catch {
+          continue;
+        }
+        const fm = FM_PATTERN.exec(source);
+        if (fm === null) {
+          continue;
+        }
+        scannedCount += 1;
+        const block = fm[1];
+        const missingScope = !RELEVANCE_SCOPE_LINE_PATTERN.test(block);
+        const missingPaths = !RELEVANCE_PATHS_LINE_PATTERN.test(block);
+        if (!missingScope && !missingPaths) {
+          continue;
+        }
+        candidates.push({
+          pending_path: posix.join(displayPrefix, typeDir, entry.name),
+          pending_path_abs: absPath,
+          missing_scope: missingScope,
+          missing_paths: missingPaths
+        });
+      }
+    }
+  }
+  candidates.sort((a, b) => a.pending_path.localeCompare(b.pending_path));
+  return { candidates, scanned_count: scannedCount };
+}
+function appendRelevanceFieldsToFrontmatter(source, needsScope, needsPaths) {
+  const FM_PATTERN = /^(?:\uFEFF)?---\r?\n([\s\S]*?)\r?\n---/u;
+  const fm = FM_PATTERN.exec(source);
+  if (fm === null) {
+    return null;
+  }
+  const block = fm[1];
+  const actuallyNeedsScope = needsScope && !RELEVANCE_SCOPE_LINE_PATTERN.test(block);
+  const actuallyNeedsPaths = needsPaths && !RELEVANCE_PATHS_LINE_PATTERN.test(block);
+  if (!actuallyNeedsScope && !actuallyNeedsPaths) {
+    return source;
+  }
+  const additions = [];
+  if (actuallyNeedsScope) {
+    additions.push("relevance_scope: broad");
+  }
+  if (actuallyNeedsPaths) {
+    additions.push("relevance_paths: []");
+  }
+  const trailing = block.endsWith("\n") ? "" : "\n";
+  const replacedBlock = `${block}${trailing}${additions.join("\n")}`;
+  const blockStart = source.indexOf(block);
+  if (blockStart < 0) {
+    return null;
+  }
+  return source.slice(0, blockStart) + replacedBlock + source.slice(blockStart + block.length);
+}
+async function applyRelevanceFieldsMissing(candidate) {
+  const parts = [];
+  if (candidate.missing_scope) parts.push("relevance_scope: broad");
+  if (candidate.missing_paths) parts.push("relevance_paths: []");
+  const detail = `back-filled: ${parts.join(", ")}`;
+  try {
+    const source = await readFile5(candidate.pending_path_abs, "utf8");
+    const rewritten = appendRelevanceFieldsToFrontmatter(
+      source,
+      candidate.missing_scope,
+      candidate.missing_paths
+    );
+    if (rewritten === null) {
+      return {
+        kind: "knowledge_relevance_fields_missing",
+        path: candidate.pending_path,
+        detail,
+        applied: false,
+        error: "frontmatter not parseable; cannot back-fill"
+      };
+    }
+    if (rewritten === source) {
+      return {
+        kind: "knowledge_relevance_fields_missing",
+        path: candidate.pending_path,
+        detail,
+        applied: false,
+        error: "fields already present at write time (no diff)"
+      };
+    }
+    await atomicWriteText3(candidate.pending_path_abs, rewritten);
+    return {
+      kind: "knowledge_relevance_fields_missing",
+      path: candidate.pending_path,
+      detail,
+      applied: true
+    };
+  } catch (error) {
+    return {
+      kind: "knowledge_relevance_fields_missing",
+      path: candidate.pending_path,
+      detail,
+      applied: false,
+      error: truncateErrorMessage(error)
+    };
+  }
+}
+function createRelevanceFieldsMissingCheck(inspection) {
+  if (inspection.candidates.length === 0) {
+    return okCheck(
+      "Knowledge relevance fields missing",
+      "All pending entries declare both relevance_scope and relevance_paths."
+    );
+  }
+  const first = inspection.candidates[0];
+  const missingParts = [];
+  if (first.missing_scope) missingParts.push("relevance_scope");
+  if (first.missing_paths) missingParts.push("relevance_paths");
+  const detail = `${first.pending_path} (missing: ${missingParts.join(", ")})`;
+  return issueCheck(
+    "Knowledge relevance fields missing",
+    "ok",
+    "info",
+    "knowledge_relevance_fields_missing",
+    `${inspection.candidates.length} pending entr${inspection.candidates.length === 1 ? "y is" : "ies are"} missing relevance_scope and/or relevance_paths in frontmatter. First: ${detail}.`,
+    "Run `fab doctor --apply-lint` to back-fill the schema defaults (relevance_scope: broad, relevance_paths: [])."
+  );
+}
+function createNarrowTooFewCheck(inspection) {
+  const { structural_flagged, telemetry_flagged } = inspection;
+  if (!structural_flagged && !telemetry_flagged) {
+    const ratioPct = (inspection.narrow_ratio * 100).toFixed(0);
+    const teleNote = inspection.telemetry_skipped ? "telemetry skipped (no edit-counter fires in window)" : `silence rate ${(inspection.silence_rate * 100).toFixed(0)}% over ${SILENCE_WINDOW_DAYS}d`;
+    return okCheck(
+      "Knowledge narrow too few",
+      `Narrow-with-paths ratio ${ratioPct}% (${inspection.narrow_with_paths_count}/${inspection.total_canonical_entries}); ${teleNote}.`
+    );
+  }
+  const parts = [];
+  if (structural_flagged) {
+    const ratioPct = (inspection.narrow_ratio * 100).toFixed(0);
+    parts.push(
+      `narrow-with-paths share ${ratioPct}% (${inspection.narrow_with_paths_count}/${inspection.total_canonical_entries}) below ${(NARROW_RATIO_THRESHOLD * 100).toFixed(0)}% threshold`
+    );
+  }
+  if (telemetry_flagged) {
+    const silencePct = (inspection.silence_rate * 100).toFixed(0);
+    parts.push(
+      `narrow-hook silence rate ${silencePct}% (${inspection.silence_fires_in_window}/${inspection.total_edit_fires_in_window}) over ${SILENCE_WINDOW_DAYS}d above ${(SILENCE_RATE_THRESHOLD * 100).toFixed(0)}% threshold`
+    );
+  }
+  return issueCheck(
+    "Knowledge narrow too few",
+    "ok",
+    "info",
+    "knowledge_narrow_too_few",
+    `Narrow-scope KB coverage is below the useful floor: ${parts.join("; ")}.`,
+    "Run the fabric-import Skill (`/fabric-import`) to re-seed narrow anchors against the current codebase."
+  );
+}
+function resolvePersonalKnowledgeRoot() {
+  const home = process.env.FABRIC_HOME ?? homedir2();
+  return join5(home, ".fabric", "knowledge");
+}
+function parseStableIdFromCanonicalFilename(filename) {
+  const match = CANONICAL_KNOWLEDGE_FILENAME_PATTERN.exec(filename);
+  if (match === null) {
+    return null;
+  }
+  const stableId = match[1];
+  const inner = /^(K[PT])-(MOD|DEC|GLD|PIT|PRO)-(\d{4,})$/u.exec(stableId);
+  if (inner === null) {
+    return null;
+  }
+  return {
+    prefix: inner[1],
+    typeCode: inner[2],
+    counter: Number.parseInt(inner[3], 10),
+    stable_id: stableId
+  };
+}
+function* iterateCanonicalFilenames(projectRoot) {
+  const teamRoot = join5(projectRoot, ".fabric", "knowledge");
+  const personalRoot = resolvePersonalKnowledgeRoot();
+  for (const [layer, root, displayPrefix] of [
+    ["team", teamRoot, ".fabric/knowledge"],
+    ["personal", personalRoot, "~/.fabric/knowledge"]
+  ]) {
+    if (!existsSync4(root)) {
+      continue;
+    }
+    for (const typeDir of KNOWLEDGE_CANONICAL_TYPE_DIRS) {
+      const dir = join5(root, typeDir);
+      if (!existsSync4(dir)) {
+        continue;
+      }
+      let entries;
+      try {
+        entries = readdirSync(dir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        if (!entry.isFile()) {
+          continue;
+        }
+        const parsed = parseStableIdFromCanonicalFilename(entry.name);
+        if (parsed === null) {
+          continue;
+        }
+        const displayPath = posix.join(displayPrefix, typeDir, entry.name);
+        yield {
+          layer,
+          type: typeDir,
+          filename: entry.name,
+          displayPath,
+          parsed
+        };
+      }
+    }
+  }
+}
+function inspectStableIdDuplicate(projectRoot) {
+  const idToPaths = /* @__PURE__ */ new Map();
+  for (const visit of iterateCanonicalFilenames(projectRoot)) {
+    const existing = idToPaths.get(visit.parsed.stable_id) ?? [];
+    existing.push(visit.displayPath);
+    idToPaths.set(visit.parsed.stable_id, existing);
+  }
+  const duplicates = [];
+  for (const [stable_id, paths] of idToPaths) {
+    if (paths.length > 1) {
+      duplicates.push({ stable_id, paths: paths.slice().sort() });
+    }
+  }
+  duplicates.sort((a, b) => a.stable_id.localeCompare(b.stable_id));
+  return { duplicates };
+}
+function inspectLayerMismatch(projectRoot) {
+  const mismatches = [];
+  for (const visit of iterateCanonicalFilenames(projectRoot)) {
+    const expected_layer = visit.parsed.prefix === "KT" ? "team" : "personal";
+    if (expected_layer === visit.layer) {
+      continue;
+    }
+    mismatches.push({
+      path: visit.displayPath,
+      located_in: visit.layer,
+      expected_layer,
+      stable_id: visit.parsed.stable_id
+    });
+  }
+  mismatches.sort((a, b) => a.path.localeCompare(b.path));
+  return { mismatches };
+}
+function inspectIndexDrift(projectRoot, meta) {
+  if (!meta.valid || meta.meta === null) {
+    return { drifts: [] };
+  }
+  const counters = AgentsMetaCountersSchema.parse(meta.meta.counters ?? void 0);
+  const observed = {
+    KP: { MOD: 0, DEC: 0, GLD: 0, PIT: 0, PRO: 0 },
+    KT: { MOD: 0, DEC: 0, GLD: 0, PIT: 0, PRO: 0 }
+  };
+  for (const visit of iterateCanonicalFilenames(projectRoot)) {
+    const { prefix, typeCode, counter } = visit.parsed;
+    if (counter > observed[prefix][typeCode]) {
+      observed[prefix][typeCode] = counter;
+    }
+  }
+  const drifts = [];
+  for (const layer of ["KP", "KT"]) {
+    for (const code of COUNTER_TYPE_CODES) {
+      const max = observed[layer][code];
+      if (max === 0) {
+        continue;
+      }
+      const current = counters[layer][code];
+      if (current < max) {
+        drifts.push({
+          layer,
+          type: code,
+          counter: current,
+          max_observed: max,
+          proposed_after: max + 1
+        });
+      }
+    }
+  }
+  drifts.sort(
+    (a, b) => a.layer === b.layer ? a.type.localeCompare(b.type) : a.layer.localeCompare(b.layer)
+  );
+  return { drifts };
+}
+function createStableIdDuplicateCheck(inspection) {
+  if (inspection.duplicates.length === 0) {
+    return okCheck(
+      "Knowledge stable_id duplicate",
+      "No canonical knowledge files share a stable_id across team / personal trees."
+    );
+  }
+  const first = inspection.duplicates[0];
+  const detail = `${first.stable_id} appears in ${first.paths.length} files: ${first.paths.join(", ")}`;
+  return issueCheck(
+    "Knowledge stable_id duplicate",
+    "error",
+    "manual_error",
+    "knowledge_stable_id_duplicate",
+    `${inspection.duplicates.length} stable_id${inspection.duplicates.length === 1 ? "" : "s"} duplicated across canonical knowledge files (path-decoupled identity invariant). First: ${detail}.`,
+    "Manually rename one of the colliding files to a fresh `<prefix>-<type>-<counter>--<slug>.md` allocated via the canonical id allocator; do not edit by hand."
+  );
+}
+function createLayerMismatchCheck(inspection) {
+  if (inspection.mismatches.length === 0) {
+    return okCheck(
+      "Knowledge layer mismatch",
+      "All canonical knowledge files are physically located under the layer their stable_id prefix declares."
+    );
+  }
+  const first = inspection.mismatches[0];
+  const detail = `${first.stable_id} at ${first.path} (located in ${first.located_in}, expected ${first.expected_layer})`;
+  return issueCheck(
+    "Knowledge layer mismatch",
+    "error",
+    "manual_error",
+    "knowledge_layer_mismatch",
+    `${inspection.mismatches.length} canonical knowledge file${inspection.mismatches.length === 1 ? "" : "s"} are physically misaligned with their stable_id layer prefix (KT-* must live under team/, KP-* under personal/). First: ${detail}.`,
+    "Move the file to the correct layer root, or use the fabric-review modify flow to flip its layer (which renames the stable_id prefix accordingly)."
+  );
+}
+function createIndexDriftCheck(inspection) {
+  if (inspection.drifts.length === 0) {
+    return okCheck(
+      "Knowledge index drift",
+      "agents.meta.json counters envelope is at or above the highest existing canonical counter for every (layer, type) pair."
+    );
+  }
+  const first = inspection.drifts[0];
+  const detail = `${first.layer}.${first.type} counter=${first.counter} but max_observed=${first.max_observed} (would propose counters.${first.layer}.${first.type}=${first.proposed_after})`;
+  return issueCheck(
+    "Knowledge index drift",
+    "error",
+    "fixable_error",
+    "knowledge_index_drift",
+    `${inspection.drifts.length} (layer, type) counter slot${inspection.drifts.length === 1 ? "" : "s"} have drifted below the observed canonical maximum (next allocate would collide). First: ${detail}.`,
+    "Run `fab doctor --apply-lint` (rc.4 TASK-003) to bump agents.meta.json counters to max_observed + 1."
+  );
+}
+async function fixMcpConfigInWrongFile(projectRoot) {
+  const settingsPath = join5(projectRoot, ".claude", "settings.json");
+  if (!existsSync4(settingsPath)) {
+    return;
+  }
+  let settings;
+  try {
+    const parsed = JSON.parse(readFileSync(settingsPath, "utf8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return;
+    }
+    settings = parsed;
+  } catch {
+    return;
+  }
+  const mcpServers = settings.mcpServers;
+  if (mcpServers === null || typeof mcpServers !== "object" || Array.isArray(mcpServers)) {
+    return;
+  }
+  const { fabric: _removed, ...remainingServers } = mcpServers;
+  const cleaned = { ...settings };
+  if (Object.keys(remainingServers).length === 0) {
+    delete cleaned.mcpServers;
+  } else {
+    cleaned.mcpServers = remainingServers;
+  }
+  await atomicWriteJson2(settingsPath, cleaned, { indent: 2 });
+  await appendEventLedgerEvent(projectRoot, {
+    event_type: "mcp_config_migrated",
+    source: "doctor_fix",
+    removed_from: ".claude/settings.json"
+  });
+}
+async function ensureKnowledgeSubdirs(projectRoot) {
+  for (const sub of KNOWLEDGE_SUBDIRS2) {
+    await mkdir3(join5(projectRoot, ".fabric", "knowledge", sub), { recursive: true });
+  }
+}
+async function fixCounterDesync(projectRoot) {
+  const metaPath = join5(projectRoot, ".fabric", "agents.meta.json");
+  if (!existsSync4(metaPath)) {
+    return;
+  }
+  let meta;
+  try {
+    meta = agentsMetaSchema4.parse(JSON.parse(await readFile5(metaPath, "utf8")));
+  } catch {
+    return;
+  }
+  const synthetic = {
+    present: true,
+    valid: true,
+    meta,
+    revision: meta.revision,
+    computedRevision: null,
+    ruleCount: 0,
+    missingContentRefs: [],
+    invalidContentRefs: [],
+    stale: false,
+    changed: false
+  };
+  const desync = inspectCounterDesync(synthetic);
+  if (desync.desyncs.length === 0 || desync.correctedCounters === null) {
+    return;
+  }
+  const updated = { ...meta, counters: desync.correctedCounters };
+  await atomicWriteJson2(metaPath, updated, { indent: 2 });
+}
+async function ensureEventLedger(projectRoot) {
+  const path = getEventLedgerPath(projectRoot);
+  await ensureParentDirectory(path);
+  await writeFile2(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"}.`;
+  const manualText = report.manual_errors.length === 0 ? "No manual errors remain." : `${report.manual_errors.length} manual error${report.manual_errors.length === 1 ? "" : "s"} remain.`;
   return `${fixedText} ${manualText}`;
 }
 function isValidJsonLine(line) {
@@ -2246,141 +4023,35 @@ function isMissingFileError(error) {
   return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
 
-// src/services/get-rules.ts
+// src/services/get-knowledge.ts
 import { readFile as readFile6 } from "fs/promises";
-import { join as join7 } from "path";
-import { minimatch } from "minimatch";
-
-// src/services/audit-log.ts
-import { open, stat as stat2 } from "fs/promises";
-import { isAbsolute as isAbsolute3, join as join6, posix as posix2, relative as relative3, resolve as resolve4 } from "path";
-var AUDIT_LOG_FILE = `${FABRIC_DIR}/audit.jsonl`;
-var DEFAULT_AUDIT_WINDOW_MS = 5 * 60 * 1e3;
-async function appendGetRulesAuditEvent(projectRoot, input) {
-  const entry = {
-    kind: "audit-event",
-    event: "get_rules",
-    ts: input.ts ?? Date.now(),
-    path: normalizeAuditPath(projectRoot, input.path),
-    client_hash: input.client_hash
-  };
-  await appendAuditLogEventLedgerEvents(projectRoot, [entry], {
-    rule_context: {
-      required_stable_ids: input.required_stable_ids,
-      ai_selectable_stable_ids: input.ai_selectable_stable_ids,
-      final_stable_ids: input.final_stable_ids
-    },
-    correlation_id: input.correlation_id,
-    session_id: input.session_id
-  });
-  return entry;
-}
-async function appendRuleSelectionAuditEvent(projectRoot, input) {
-  const entry = {
-    kind: "audit-event",
-    event: "knowledge_selection",
-    ts: input.ts ?? Date.now(),
-    path: normalizeAuditPath(projectRoot, input.path),
-    selection_token: input.selection_token,
-    target_paths: input.target_paths.map((path) => normalizeAuditPath(projectRoot, path)),
-    required_stable_ids: input.required_stable_ids,
-    ai_selectable_stable_ids: input.ai_selectable_stable_ids,
-    ai_selected_stable_ids: input.ai_selected_stable_ids,
-    final_stable_ids: input.final_stable_ids,
-    ai_selection_reasons: input.ai_selection_reasons,
-    rejected_stable_ids: input.rejected_stable_ids,
-    ignored_stable_ids: input.ignored_stable_ids
-  };
-  await appendAuditLogEventLedgerEvents(projectRoot, [entry], {
-    correlation_id: input.correlation_id,
-    session_id: input.session_id
-  });
-  return entry;
-}
-function normalizeAuditPath(projectRoot, value) {
-  const normalizedProjectRoot = resolve4(projectRoot);
-  const candidate = isAbsolute3(value) ? resolve4(value) : resolve4(normalizedProjectRoot, value);
-  const relativePath = relative3(normalizedProjectRoot, candidate);
-  if (relativePath.length > 0 && relativePath !== "." && !relativePath.startsWith("..") && !isAbsolute3(relativePath)) {
-    return posix2.normalize(relativePath.split("\\").join("/"));
-  }
-  return posix2.normalize(value.replaceAll("\\", "/"));
-}
-async function appendAuditLogEventLedgerEvents(projectRoot, entries, metadata = {}) {
-  for (const entry of entries) {
-    if (entry.event === "get_rules") {
-      await appendEventLedgerEvent(projectRoot, {
-        event_type: "knowledge_context_planned",
-        ts: entry.ts,
-        target_paths: [entry.path],
-        required_stable_ids: metadata.rule_context?.required_stable_ids ?? [],
-        ai_selectable_stable_ids: metadata.rule_context?.ai_selectable_stable_ids ?? [],
-        final_stable_ids: metadata.rule_context?.final_stable_ids ?? [],
-        client_hash: entry.client_hash,
-        correlation_id: metadata.correlation_id,
-        session_id: metadata.session_id
-      });
-      continue;
-    }
-    if (entry.event === "knowledge_selection") {
-      await appendEventLedgerEvent(projectRoot, {
-        event_type: "knowledge_selection",
-        ts: entry.ts,
-        selection_token: entry.selection_token,
-        target_paths: entry.target_paths,
-        required_stable_ids: entry.required_stable_ids,
-        ai_selectable_stable_ids: entry.ai_selectable_stable_ids,
-        ai_selected_stable_ids: entry.ai_selected_stable_ids,
-        final_stable_ids: entry.final_stable_ids,
-        ai_selection_reasons: entry.ai_selection_reasons,
-        rejected_stable_ids: entry.rejected_stable_ids,
-        ignored_stable_ids: entry.ignored_stable_ids,
-        correlation_id: metadata.correlation_id,
-        session_id: metadata.session_id
-      });
-      continue;
-    }
-    await appendEventLedgerEvent(projectRoot, {
-      event_type: "edit_intent_checked",
-      ts: entry.ts,
-      path: entry.path,
-      compliant: entry.compliant,
-      intent: entry.intent,
-      ledger_entry_id: entry.ledger_entry_id,
-      ledger_source: "ai",
-      matched_rule_context_ts: entry.matched_get_rules_ts,
-      window_ms: entry.window_ms,
-      correlation_id: metadata.correlation_id,
-      session_id: metadata.session_id
-    });
-  }
-}
-
-// src/services/get-rules.ts
+import { join as join6 } from "path";
+import { minimatch as minimatch2 } from "minimatch";
 var PRIORITY_ORDER = {
   high: 0,
   medium: 1,
   low: 2
 };
-async function getRules(projectRoot, input) {
-  const context = await loadGetRulesContext(projectRoot);
+async function getKnowledge(projectRoot, input) {
+  const context = await loadGetKnowledgeContext(projectRoot);
   const stale = input.client_hash !== void 0 && input.client_hash !== context.meta.revision;
   const matchedNodes = matchRuleNodes(context.meta, input.path);
   const requiredStableIds = matchedNodes.filter((node) => node.level === "L2").map((node) => node.stable_id);
   const aiSelectableStableIds = matchedNodes.filter((node) => node.level === "L1").map((node) => node.stable_id);
-  const rules = await resolveRulesForPath(projectRoot, context, input.path);
+  const rules = await resolveKnowledgeForPath(projectRoot, context, input.path);
   const result = {
     revision_hash: context.meta.revision,
     stale,
     rules
   };
   try {
-    await appendGetRulesAuditEvent(projectRoot, {
-      path: input.path,
-      client_hash: input.client_hash,
+    await appendEventLedgerEvent(projectRoot, {
+      event_type: "knowledge_context_planned",
+      target_paths: [input.path],
       required_stable_ids: requiredStableIds,
       ai_selectable_stable_ids: aiSelectableStableIds,
       final_stable_ids: [...requiredStableIds, ...aiSelectableStableIds],
+      client_hash: input.client_hash,
       correlation_id: input.correlation_id,
       session_id: input.session_id
     });
@@ -2388,13 +4059,13 @@ async function getRules(projectRoot, input) {
   }
   return result;
 }
-async function loadGetRulesContext(projectRoot) {
+async function loadGetKnowledgeContext(projectRoot) {
   const cached = contextCache.get("context", projectRoot);
   if (cached !== void 0) {
     return cached;
   }
   const meta = await readAgentsMeta(projectRoot);
-  const l0Content = await readFile6(join7(projectRoot, ".fabric", "bootstrap", "README.md"), "utf8");
+  const l0Content = await readFile6(join6(projectRoot, ".fabric", "bootstrap", "README.md"), "utf8");
   const context = {
     meta,
     l0Content,
@@ -2403,20 +4074,20 @@ async function loadGetRulesContext(projectRoot) {
   contextCache.set("context", projectRoot, context);
   return context;
 }
-async function resolveRulesForPath(projectRoot, context, path, options = {}) {
+async function resolveKnowledgeForPath(projectRoot, context, path, options = {}) {
   const matchedNodes = matchRuleNodes(context.meta, path);
   const loaded = await loadMatchedRules(projectRoot, matchedNodes);
-  return buildRulesPayload(context, loaded, options);
+  return buildKnowledgePayload(context, loaded, options);
 }
-function normalizeRulesPath(value) {
+function normalizeKnowledgePath(value) {
   return value.replaceAll("\\", "/");
 }
 function matchRuleNodes(meta, path) {
-  const requestedPath = normalizeRulesPath(path);
+  const requestedPath = normalizeKnowledgePath(path);
   return Object.entries(meta.nodes).filter(([, node]) => shouldLoadNodeForPath(requestedPath, node)).sort((left, right) => {
     const [leftId, leftNode] = left;
     const [rightId, rightNode] = right;
-    const priorityDelta = PRIORITY_ORDER[leftNode.priority] - PRIORITY_ORDER[rightNode.priority];
+    const priorityDelta = PRIORITY_ORDER[leftNode.priority ?? "medium"] - PRIORITY_ORDER[rightNode.priority ?? "medium"];
     return priorityDelta !== 0 ? priorityDelta : leftId.localeCompare(rightId);
   }).map(([nodeId, node]) => ({
     node_id: nodeId,
@@ -2455,7 +4126,7 @@ async function loadMatchedRules(projectRoot, matchedNodes, fileContentCache = /*
   }
   return { rules, stubs };
 }
-function buildRulesPayload(context, loaded, options = {}) {
+function buildKnowledgePayload(context, loaded, options = {}) {
   const { L1, L2 } = partitionRulesByLevel(loaded.rules, options.dedupeByPath ?? false);
   return {
     L0: context.l0Content,
@@ -2472,7 +4143,7 @@ function classifyNode(nodeId, node) {
   if (nodeId.startsWith("L2/")) {
     return "L2";
   }
-  return node.layer === "L0" ? null : node.layer;
+  return node.layer === "L0" ? null : node.layer ?? null;
 }
 function partitionRulesByLevel(loadedRules, dedupeByPath) {
   const l1 = [];
@@ -2509,7 +4180,7 @@ function shouldLoadNodeForPath(requestedPath, node) {
       return true;
     case "path":
     case void 0:
-      return minimatch(requestedPath, normalizeRulesPath(node.scope_glob), { dot: true });
+      return minimatch2(requestedPath, normalizeKnowledgePath(node.scope_glob), { dot: true });
   }
 }
 function dedupeDescriptionStubsByPath(stubs) {
@@ -2533,7 +4204,7 @@ async function readRuleContent(projectRoot, file, fileContentCache) {
   if (cached !== void 0) {
     return await cached;
   }
-  const pending = readFile6(join7(projectRoot, file), "utf8");
+  const pending = readFile6(join6(projectRoot, file), "utf8");
   fileContentCache.set(file, pending);
   return await pending;
 }
@@ -2548,25 +4219,27 @@ export {
   getLedgerPath,
   getLegacyLedgerPath,
   getEventLedgerPath,
+  ensureParentDirectory,
   sha256,
   isNodeError,
+  atomicWriteText,
   appendEventLedgerEvent,
   readEventLedger,
   flushAndSyncEventLedger,
-  buildRuleMeta,
-  writeRuleMeta,
-  computeRulesBasedAgentsMeta,
-  computeRuleTestIndex,
-  deriveRuleMetaLayer,
-  deriveRuleMetaTopologyType,
-  isSameRuleTestIndex,
+  buildKnowledgeMeta,
+  writeKnowledgeMeta,
+  computeKnowledgeBasedAgentsMeta,
+  computeKnowledgeTestIndex,
+  deriveKnowledgeMetaLayer,
+  deriveKnowledgeMetaTopologyType,
+  isSameKnowledgeTestIndex,
   stableStringify,
-  invalidateRuleSyncCooldown,
-  ensureRulesFresh,
-  reconcileRules,
-  appendRuleSelectionAuditEvent,
-  getRules,
-  normalizeRulesPath,
+  invalidateKnowledgeSyncCooldown,
+  ensureKnowledgeFresh,
+  reconcileKnowledge,
+  getKnowledge,
+  normalizeKnowledgePath,
   runDoctorReport,
-  runDoctorFix
+  runDoctorFix,
+  runDoctorApplyLint
 };