@fenglimg/fabric-server 1.8.0-rc.3 → 2.0.0-rc.1

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

@@ -1,6 +1,3 @@
-// src/constants.ts
-var AGENTS_MD_RESOURCE_URI = "fabric://bootstrap-readme";
-
 // src/cache.ts
 var ContextCache = class {
   constructor(defaultTtlMs = 5e3) {
@@ -280,16 +277,24 @@ function flushAndSyncEventLedger(projectRoot) {
 }
 
 // src/services/rule-meta-builder.ts
-import { readdir, readFile as readFile3 } from "fs/promises";
+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,
   agentsMetaSchema as agentsMetaSchema3,
+  defaultAgentsMetaCounters,
   deriveAgentsMetaLayer,
   deriveAgentsMetaStableId,
   deriveAgentsMetaTopologyType,
-  ruleTestIndexSchema
+  isKnowledgeStableId,
+  ruleTestIndexSchema,
+  KnowledgeTypeSchema,
+  MaturitySchema,
+  LayerSchema,
+  StableIdSchema,
+  parseKnowledgeId
 } from "@fenglimg/fabric-shared";
 import { atomicWriteText as atomicWriteText2 } from "@fenglimg/fabric-shared/node/atomic-write";
 async function buildRuleMeta(projectRootInput) {
@@ -338,19 +343,15 @@ async function computeRulesBasedAgentsMeta(projectRootInput, existingMeta) {
   assertExistingDirectory(projectRoot);
   const previousMeta = existingMeta ?? await readExistingMeta(join3(projectRoot, ".fabric", "agents.meta.json"));
   const existingByContentRef = indexExistingNodesByContentRef(previousMeta);
-  const ruleFiles = await findFabricRuleFiles(projectRoot);
+  const ruleFiles = await findKnowledgeFiles(projectRoot);
   const nodes = {};
-  const bootstrapNode = await createBootstrapNode(projectRoot, existingByContentRef.get(".fabric/bootstrap/README.md")?.node);
-  if (bootstrapNode !== void 0) {
-    nodes.L0 = bootstrapNode;
-  }
   for (const contentRef of ruleFiles) {
-    const source = await readFile3(join3(projectRoot, contentRef), "utf8");
+    const source = await readFile3(resolveContentRefPath(projectRoot, contentRef), "utf8");
     const existing = existingByContentRef.get(contentRef);
-    const id = deriveNodeId(contentRef);
     const hash = sha256(source);
     const defaults = createDefaultNodeMeta(contentRef);
     const identity = deriveRuleIdentity(contentRef, source, existing?.node);
+    const id = isKnowledgeStableId(identity.stableId) ? identity.stableId : deriveNodeId(contentRef);
     nodes[id] = {
       ...defaults,
       ...existing?.node,
@@ -363,10 +364,12 @@ async function computeRulesBasedAgentsMeta(projectRootInput, existingMeta) {
       sections: extractRuleSections(source)
     };
   }
+  const counters = previousMeta?.counters ?? defaultAgentsMetaCounters();
   return {
     ...previousMeta ?? {},
     revision: computeRevision(nodes),
-    nodes: sortNodes(nodes)
+    nodes: sortNodes(nodes),
+    counters
   };
 }
 async function computeRuleTestIndex(projectRootInput, computedMeta, previousIndex) {
@@ -465,25 +468,51 @@ async function readExistingRuleTestIndex(indexPath) {
     return void 0;
   }
 }
-async function findFabricRuleFiles(projectRoot) {
-  const rulesRoot = join3(projectRoot, ".fabric", "rules");
-  if (!existsSync2(rulesRoot) || !statSync(rulesRoot).isDirectory()) {
-    return [];
+var KNOWLEDGE_SUBDIRS = ["decisions", "pitfalls", "guidelines", "models", "processes", "pending"];
+var PERSONAL_CONTENT_REF_PREFIX = "~/.fabric/knowledge/";
+var TEAM_CONTENT_REF_PREFIX = ".fabric/knowledge/";
+function resolvePersonalRoot() {
+  return process.env.FABRIC_HOME ?? homedir();
+}
+function resolveContentRefPath(projectRoot, contentRef) {
+  if (contentRef.startsWith(PERSONAL_CONTENT_REF_PREFIX)) {
+    return join3(resolvePersonalRoot(), ".fabric", "knowledge", contentRef.slice(PERSONAL_CONTENT_REF_PREFIX.length));
+  }
+  return join3(projectRoot, contentRef);
+}
+async function findKnowledgeFiles(projectRoot) {
+  const teamRoot = join3(projectRoot, ".fabric", "knowledge");
+  const personalRoot = join3(resolvePersonalRoot(), ".fabric", "knowledge");
+  try {
+    await mkdir2(personalRoot, { recursive: true });
+    for (const sub of KNOWLEDGE_SUBDIRS) {
+      await mkdir2(join3(personalRoot, sub), { recursive: true });
+    }
+  } catch {
   }
   const files = [];
-  const stack = [rulesRoot];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    if (current === void 0) {
+  for (const [root, prefix] of [
+    [teamRoot, TEAM_CONTENT_REF_PREFIX],
+    [personalRoot, PERSONAL_CONTENT_REF_PREFIX]
+  ]) {
+    if (!existsSync2(root) || !statSync(root).isDirectory()) {
       continue;
     }
-    for (const entry of await readdir(current, { withFileTypes: true })) {
-      const absolutePath = join3(current, entry.name);
-      const relativePath = toPosixPath(relative(projectRoot, absolutePath));
-      if (entry.isDirectory()) {
-        stack.push(absolutePath);
-      } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        files.push(relativePath);
+    for (const subdir of KNOWLEDGE_SUBDIRS) {
+      const dir = join3(root, subdir);
+      let entries;
+      try {
+        entries = await readdir(dir, { withFileTypes: true });
+      } catch (error) {
+        if (isNodeError3(error) && error.code === "ENOENT") {
+          continue;
+        }
+        throw error;
+      }
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith(".md")) {
+          files.push(`${prefix}${subdir}/${entry.name}`);
+        }
       }
     }
   }
@@ -598,11 +627,14 @@ function indexExistingNodesByContentRef(existingMeta) {
   return byContentRef;
 }
 function deriveNodeId(file) {
-  if (file === ".fabric/bootstrap/README.md") {
-    return "L0";
-  }
   const layer = deriveRuleMetaLayer(file);
   const relativeStem = getRuleRelativeStem(file);
+  if (file.startsWith(PERSONAL_CONTENT_REF_PREFIX)) {
+    return `${layer}/personal/${relativeStem}`;
+  }
+  if (file.startsWith(TEAM_CONTENT_REF_PREFIX)) {
+    return `${layer}/team/${relativeStem}`;
+  }
   return `${layer}/${relativeStem}`;
 }
 function createDefaultNodeMeta(contentRef) {
@@ -620,31 +652,7 @@ function createDefaultNodeMeta(contentRef) {
     hash: ""
   };
 }
-async function createBootstrapNode(projectRoot, existing) {
-  const contentRef = ".fabric/bootstrap/README.md";
-  const bootstrapPath = join3(projectRoot, contentRef);
-  if (!existsSync2(bootstrapPath)) {
-    return void 0;
-  }
-  const hash = sha256(await readFile3(bootstrapPath, "utf8"));
-  const identity = {
-    stableId: existing?.stable_id ?? deriveAgentsMetaStableId(contentRef),
-    identitySource: existing?.identity_source ?? "derived"
-  };
-  return {
-    ...createDefaultNodeMeta(contentRef),
-    ...existing,
-    file: contentRef,
-    content_ref: contentRef,
-    hash,
-    stable_id: identity.stableId,
-    identity_source: identity.identitySource
-  };
-}
 function deriveScopeGlob(contentRef) {
-  if (contentRef === ".fabric/bootstrap/README.md") {
-    return "**";
-  }
   const stem = getRuleRelativeStem(contentRef);
   const segments = stem.split("/").filter(Boolean);
   if (segments.length === 0 || stem === "root") {
@@ -660,10 +668,10 @@ function deriveScopeGlob(contentRef) {
   return scopePath === "" ? "**" : `${scopePath}/**`;
 }
 function getRuleRelativeStem(contentRef) {
-  return contentRef.replace(/^\.fabric\/rules\//u, "").replace(/\.md$/u, "");
+  return contentRef.replace(/^~\/\.fabric\/knowledge\//u, "").replace(/^\.fabric\/knowledge\//u, "").replace(/\.md$/u, "");
 }
 function toAgentsCompatiblePath(contentRef) {
-  return contentRef.replace(/^\.fabric\/rules\//u, ".fabric/agents/");
+  return contentRef.replace(/^~\/\.fabric\/knowledge\//u, ".fabric/agents/").replace(/^\.fabric\/knowledge\//u, ".fabric/agents/");
 }
 function sortNodes(nodes) {
   return Object.fromEntries(Object.entries(nodes).sort(([left], [right]) => left.localeCompare(right)));
@@ -708,7 +716,7 @@ function collectDriftDetails(existingMeta, computedMeta) {
 async function recordBaselineSynced(projectRoot, input) {
   if (input.driftDetails.length > 0) {
     await appendEventLedgerEvent(projectRoot, {
-      event_type: "rule_drift_detected",
+      event_type: "knowledge_drift_detected",
       revision: input.previousRevision ?? input.revision,
       drifted_stable_ids: input.driftDetails.map((detail) => detail.stable_id),
       missing_files: input.driftDetails.filter((detail) => detail.actual_hash === null).map((detail) => detail.file),
@@ -716,21 +724,6 @@ async function recordBaselineSynced(projectRoot, input) {
       details: input.driftDetails
     });
   }
-  await appendEventLedgerEvent(projectRoot, {
-    event_type: "rule_baseline_accepted",
-    revision: input.revision,
-    previous_revision: input.previousRevision,
-    accepted_stable_ids: input.acceptedStableIds,
-    source: input.source
-  });
-  await appendEventLedgerEvent(projectRoot, {
-    event_type: "baseline_synced",
-    revision: input.revision,
-    previous_revision: input.previousRevision,
-    synced_files: input.syncedFiles,
-    accepted_stable_ids: input.acceptedStableIds,
-    source: input.source
-  });
 }
 function flattenKeys(value, keys = {}) {
   if (value && typeof value === "object") {
@@ -745,6 +738,19 @@ function toPosixPath(path) {
   return path.split(sep2).join("/");
 }
 function deriveRuleIdentity(file, source, existing) {
+  const declaredKnowledgeId = extractDeclaredKnowledgeId(source);
+  if (declaredKnowledgeId !== void 0) {
+    return {
+      stableId: declaredKnowledgeId,
+      identitySource: "declared"
+    };
+  }
+  if (existing?.stable_id !== void 0 && isKnowledgeStableId(existing.stable_id)) {
+    return {
+      stableId: existing.stable_id,
+      identitySource: "declared"
+    };
+  }
   const declaredStableId = extractDeclaredStableId(source);
   const derivedStableId = deriveAgentsMetaStableId(toAgentsCompatiblePath(file));
   if (declaredStableId !== void 0) {
@@ -768,6 +774,18 @@ function extractDeclaredStableId(source) {
   const match = /^(?:\uFEFF)?(?:---\r?\n[\s\S]*?\r?\n---\s*(?:\r?\n|$))?<!--\s*fab:rule-id\s+([A-Za-z0-9][A-Za-z0-9/_-]*)\s*-->\s*(?:\r?\n|$)/u.exec(source);
   return match?.[1];
 }
+function extractDeclaredKnowledgeId(source) {
+  const frontmatter = /^(?:\uFEFF)?---\r?\n([\s\S]*?)\r?\n---\s*(?:\r?\n|$)/u.exec(source);
+  if (frontmatter === null) {
+    return void 0;
+  }
+  const idMatch = /^id:\s*(.+?)\s*$/mu.exec(frontmatter[1]);
+  if (idMatch === null) {
+    return void 0;
+  }
+  const candidate = idMatch[1].replace(/^["'](.*)["']$/u, "$1").trim();
+  return isKnowledgeStableId(candidate) ? candidate : void 0;
+}
 function extractRuleDescription(source) {
   const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---\s*(?:\r?\n|$)/u.exec(source);
   const description = frontmatter === null ? void 0 : extractDescriptionFromFrontmatter(frontmatter[1]);
@@ -784,7 +802,15 @@ function extractRuleDescription(source) {
     intent_clues: [],
     tech_stack: [],
     impact: [],
-    must_read_if: summary
+    must_read_if: summary,
+    // v2.0 knowledge fields are absent in heading-only fallback.
+    id: void 0,
+    knowledge_type: void 0,
+    maturity: void 0,
+    knowledge_layer: void 0,
+    layer_reason: void 0,
+    created_at: void 0,
+    tags: void 0
   };
 }
 function extractRuleSections(source) {
@@ -796,13 +822,99 @@ function extractDescriptionFromFrontmatter(frontmatter) {
   if (summary === void 0) {
     return void 0;
   }
+  const knowledge = extractKnowledgeFieldsFromFrontmatter(frontmatter);
   return {
     summary,
     intent_clues: extractInlineArray(frontmatter, "intent_clues"),
     tech_stack: extractInlineArray(frontmatter, "tech_stack"),
     impact: extractInlineArray(frontmatter, "impact"),
     must_read_if: extractScalar(frontmatter, "must_read_if") ?? summary,
-    entities: extractInlineArray(frontmatter, "entities")
+    entities: extractInlineArray(frontmatter, "entities"),
+    id: knowledge.id,
+    knowledge_type: knowledge.knowledge_type,
+    maturity: knowledge.maturity,
+    knowledge_layer: knowledge.knowledge_layer,
+    layer_reason: knowledge.layer_reason,
+    created_at: knowledge.created_at,
+    tags: knowledge.tags
+  };
+}
+function extractKnowledgeFieldsFromFrontmatter(frontmatter) {
+  const rawId = extractScalar(frontmatter, "id");
+  const rawType = extractScalar(frontmatter, "type");
+  const rawMaturity = extractScalar(frontmatter, "maturity");
+  const rawLayer = extractScalar(frontmatter, "layer");
+  const rawLayerReason = extractScalar(frontmatter, "layer_reason");
+  const rawCreatedAt = extractScalar(frontmatter, "created_at");
+  let id;
+  if (rawId !== void 0) {
+    const parsed = StableIdSchema.safeParse(rawId);
+    if (parsed.success) {
+      id = parsed.data;
+    } else {
+      process.stderr.write(`[fabric] frontmatter: invalid knowledge id format ${JSON.stringify(rawId)}; skipping
+`);
+    }
+  }
+  let knowledge_type;
+  if (rawType !== void 0) {
+    const parsed = KnowledgeTypeSchema.safeParse(rawType);
+    if (parsed.success) {
+      knowledge_type = parsed.data;
+    } else {
+      process.stderr.write(`[fabric] frontmatter: unknown knowledge type ${JSON.stringify(rawType)}; skipping
+`);
+    }
+  }
+  let maturity;
+  if (rawMaturity !== void 0) {
+    const parsed = MaturitySchema.safeParse(rawMaturity);
+    if (parsed.success) {
+      maturity = parsed.data;
+    } else {
+      process.stderr.write(`[fabric] frontmatter: unknown maturity ${JSON.stringify(rawMaturity)}; skipping
+`);
+    }
+  }
+  let knowledge_layer;
+  if (rawLayer !== void 0) {
+    const parsed = LayerSchema.safeParse(rawLayer);
+    if (parsed.success) {
+      knowledge_layer = parsed.data;
+    } else {
+      process.stderr.write(`[fabric] frontmatter: unknown layer ${JSON.stringify(rawLayer)}; skipping
+`);
+    }
+  }
+  let created_at;
+  if (rawCreatedAt !== void 0) {
+    if (!Number.isNaN(Date.parse(rawCreatedAt))) {
+      created_at = rawCreatedAt;
+    } else {
+      process.stderr.write(`[fabric] frontmatter: malformed created_at ${JSON.stringify(rawCreatedAt)}; skipping
+`);
+    }
+  }
+  if (id !== void 0 && knowledge_layer !== void 0) {
+    const decoded = parseKnowledgeId(id);
+    if (decoded !== null && decoded.layer !== knowledge_layer) {
+      process.stderr.write(
+        `[fabric] frontmatter: id ${id} encodes layer ${decoded.layer} but layer field says ${knowledge_layer}; dropping both
+`
+      );
+      id = void 0;
+      knowledge_layer = void 0;
+    }
+  }
+  const tags = extractInlineArray(frontmatter, "tags");
+  return {
+    id,
+    knowledge_type,
+    maturity,
+    knowledge_layer,
+    layer_reason: rawLayerReason,
+    created_at,
+    tags: tags.length > 0 ? tags : void 0
   };
 }
 function extractScalar(frontmatter, key) {
@@ -868,12 +980,12 @@ async function readMetaEntries(projectRoot) {
   return map;
 }
 async function findRuleFiles(projectRoot) {
-  const rulesRoot = join4(projectRoot, ".fabric", "rules");
-  if (!existsSync3(rulesRoot) || !statSync2(rulesRoot).isDirectory()) {
+  const knowledgeRoot = join4(projectRoot, ".fabric", "knowledge");
+  if (!existsSync3(knowledgeRoot) || !statSync2(knowledgeRoot).isDirectory()) {
     return [];
   }
   const files = [];
-  const stack = [rulesRoot];
+  const stack = [knowledgeRoot];
   while (stack.length > 0) {
     const current = stack.pop();
     if (current === void 0) {
@@ -1006,7 +1118,7 @@ async function appendRuleSyncEvents(projectRoot, events) {
   const staleFiles = events.filter((e) => e.type !== "rule_removed").map((e) => e.path);
   if (missingFiles.length > 0 || staleFiles.length > 0) {
     await appendEventLedgerEvent(projectRoot, {
-      event_type: "rule_drift_detected",
+      event_type: "knowledge_drift_detected",
       drifted_stable_ids: driftedIds,
       missing_files: missingFiles,
       stale_files: staleFiles
@@ -1142,846 +1254,148 @@ async function reconcileRules(projectRoot, opts) {
 }
 
 // src/services/doctor.ts
-import { existsSync as existsSync4, mkdirSync, readdirSync, readFileSync, rmdirSync, renameSync, statSync as statSync3, unlinkSync } from "fs";
-import { access, readFile as readFile7, writeFile as writeFile2 } from "fs/promises";
+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 { constants } from "fs";
-import { isAbsolute as isAbsolute3, join as join8, posix as posix2, resolve as resolve4 } from "path";
+import { isAbsolute as isAbsolute2, join as join5, posix, resolve as resolve3 } from "path";
 import {
   agentsMetaSchema as agentsMetaSchema4,
+  AgentsMetaCountersSchema,
   forensicReportSchema,
+  parseKnowledgeId as parseKnowledgeId2,
   ruleTestIndexSchema as ruleTestIndexSchema2
 } from "@fenglimg/fabric-shared";
 import { detectFramework } from "@fenglimg/fabric-shared/node";
-
-// src/services/rule-sections.ts
-import { readFile as readFile6 } from "fs/promises";
-import { join as join7 } from "path";
-
-// src/services/audit-log.ts
-import { open, stat as stat2 } from "fs/promises";
-import { isAbsolute as isAbsolute2, join as join5, posix, relative as relative3, resolve as resolve3 } 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: "rule_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
+import { atomicWriteJson as atomicWriteJson2 } from "@fenglimg/fabric-shared/node/atomic-write";
+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"]);
+var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".fabric",
+  ".git",
+  ".next",
+  ".turbo",
+  "Library",
+  "Temp",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules"
+]);
+var TARGET_FILE_PATHS = [
+  ".fabric/forensic.json",
+  ".fabric/agents.meta.json",
+  ".fabric/rule-test.index.json",
+  ".fabric/events.jsonl",
+  ".fabric/knowledge"
+];
+async function runDoctorReport(target) {
+  const projectRoot = normalizeTarget(target);
+  const framework = detectFramework(projectRoot);
+  const entryPoints = collectEntryPoints(projectRoot);
+  const [
+    forensic,
+    meta,
+    eventLedger,
+    ruleTestIndex
+  ] = await Promise.all([
+    inspectForensic(projectRoot),
+    inspectMeta(projectRoot),
+    inspectEventLedger(projectRoot),
+    inspectRuleTestIndex(projectRoot)
+  ]);
+  const mcpConfigInWrongFile = inspectMcpConfigInWrongFile(projectRoot);
+  const metaManuallyDiverged = await inspectMetaManuallyDiverged(projectRoot);
+  const knowledgeDirUnindexed = inspectKnowledgeDirUnindexed(projectRoot, meta);
+  const knowledgeDirMissing = inspectKnowledgeDirMissing(projectRoot);
+  const stableIdCollision = await inspectStableIdCollisions(projectRoot);
+  const counterDesync = inspectCounterDesync(meta);
+  const preexistingRootFiles = inspectPreexistingRootFiles(projectRoot);
+  const bootstrapAnchor = inspectBootstrapAnchor(projectRoot);
+  const checks = [
+    createBootstrapAnchorCheck(bootstrapAnchor),
+    createKnowledgeDirMissingCheck(knowledgeDirMissing),
+    createForensicCheck(forensic, framework.kind, entryPoints.length),
+    // v2.0: removed `createInitContextCheck` — `.fabric/init-context.json`
+    // is owned by the AI-side client init skill, not by `fabric init` CLI.
+    // The file's absence is a legitimate post-init state when the skill has
+    // not yet run, so flagging it as a doctor manual_error misrepresents
+    // ownership.
+    createMetaCheck(meta),
+    createRuleContentRefCheck(meta),
+    // v2.0 / rc.2: `createRuleSectionsCheck` removed — it parsed v1.x
+    // [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),
+    createEventLedgerCheck(eventLedger),
+    createEventLedgerPartialWriteCheck(eventLedger),
+    createMcpConfigInWrongFileCheck(mcpConfigInWrongFile),
+    createMetaManuallyDivergedCheck(metaManuallyDiverged),
+    createKnowledgeDirUnindexedCheck(knowledgeDirUnindexed),
+    createStableIdCollisionCheck(stableIdCollision),
+    createCounterDesyncCheck(counterDesync),
+    createPreexistingRootFilesCheck(preexistingRootFiles)
+    // v2.0 / rc.2: `createLegacyClientPathCheck` removed. The schema now
+    // rejects retired clientPaths keys (windsurf/rooCode/geminiCLI) at Zod
+    // parse time, so the soft-deprecation warn-and-fix path no longer has a
+    // reachable input — fabric.config.json with a retired key fails before
+    // doctor ever inspects it.
+    // v2.0 / rc.2: `createLegacyV1ArtifactsCheck` removed alongside its
+    // path-list constant. The visibility-only warning referenced v1.x
+    // artifacts that are now archaeology. rc.4 owns v2 lint coverage; on a
+    // clean v2 install nothing is lost since the check fired only when v1
+    // artifacts remained.
+  ];
+  const fixableErrors = collectIssues(checks, "fixable_error");
+  const manualErrors = collectIssues(checks, "manual_error");
+  const warnings = collectIssues(checks, "warning");
+  const infos = collectIssues(checks, "info");
+  return {
+    status: reduceStatus(checks.map((check) => check.status)),
+    checks,
+    fixable_errors: fixableErrors,
+    manual_errors: manualErrors,
+    warnings,
+    infos,
+    summary: {
+      target: projectRoot,
+      framework: {
+        kind: framework.kind,
+        version: framework.version,
+        subkind: framework.subkind
+      },
+      entryPoints,
+      metaRevision: meta.revision,
+      computedMetaRevision: meta.computedRevision,
+      ruleCount: meta.ruleCount,
+      eventLedgerPath: eventLedger.path,
+      fixableErrorCount: fixableErrors.length,
+      manualErrorCount: manualErrors.length,
+      warningCount: warnings.length,
+      infoCount: infos.length,
+      targetFiles: Object.fromEntries(
+        TARGET_FILE_PATHS.map((path) => [path, existsSync4(join5(projectRoot, path))])
+      )
+    }
   };
-  await appendAuditLogEventLedgerEvents(projectRoot, [entry], {
-    correlation_id: input.correlation_id,
-    session_id: input.session_id
-  });
-  return entry;
 }
-function normalizeAuditPath(projectRoot, value) {
-  const normalizedProjectRoot = resolve3(projectRoot);
-  const candidate = isAbsolute2(value) ? resolve3(value) : resolve3(normalizedProjectRoot, value);
-  const relativePath = relative3(normalizedProjectRoot, candidate);
-  if (relativePath.length > 0 && relativePath !== "." && !relativePath.startsWith("..") && !isAbsolute2(relativePath)) {
-    return posix.normalize(relativePath.split("\\").join("/"));
+async function runDoctorFix(target) {
+  const projectRoot = normalizeTarget(target);
+  const before = await runDoctorReport(projectRoot);
+  const fixed = [];
+  if (before.fixable_errors.some((issue) => issue.code === "knowledge_dir_missing")) {
+    await ensureKnowledgeSubdirs(projectRoot);
+    fixed.push(findIssue(before.fixable_errors, "knowledge_dir_missing"));
   }
-  return posix.normalize(value.replaceAll("\\", "/"));
-}
-async function appendAuditLogEventLedgerEvents(projectRoot, entries, metadata = {}) {
-  for (const entry of entries) {
-    if (entry.event === "get_rules") {
-      await appendEventLedgerEvent(projectRoot, {
-        event_type: "rule_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 === "rule_selection") {
-      await appendEventLedgerEvent(projectRoot, {
-        event_type: "rule_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
-    });
+  if (before.fixable_errors.some((issue) => issue.code === "event_ledger_missing")) {
+    await ensureEventLedger(projectRoot);
+    fixed.push(findIssue(before.fixable_errors, "event_ledger_missing"));
   }
-}
-
-// src/services/get-rules.ts
-import { readFile as readFile5 } from "fs/promises";
-import { join as join6 } from "path";
-import { minimatch } from "minimatch";
-var PRIORITY_ORDER = {
-  high: 0,
-  medium: 1,
-  low: 2
-};
-async function getRules(projectRoot, input) {
-  const context = await loadGetRulesContext(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 result = {
-    revision_hash: context.meta.revision,
-    stale,
-    rules
-  };
-  try {
-    await appendGetRulesAuditEvent(projectRoot, {
-      path: input.path,
-      client_hash: input.client_hash,
-      required_stable_ids: requiredStableIds,
-      ai_selectable_stable_ids: aiSelectableStableIds,
-      final_stable_ids: [...requiredStableIds, ...aiSelectableStableIds],
-      correlation_id: input.correlation_id,
-      session_id: input.session_id
-    });
-  } catch {
-  }
-  return result;
-}
-async function loadGetRulesContext(projectRoot) {
-  const cached = contextCache.get("context", projectRoot);
-  if (cached !== void 0) {
-    return cached;
-  }
-  const meta = await readAgentsMeta(projectRoot);
-  const l0Content = await readFile5(join6(projectRoot, ".fabric", "bootstrap", "README.md"), "utf8");
-  const context = {
-    meta,
-    l0Content,
-    humanLockedNearby: []
-  };
-  contextCache.set("context", projectRoot, context);
-  return context;
-}
-async function resolveRulesForPath(projectRoot, context, path, options = {}) {
-  const matchedNodes = matchRuleNodes(context.meta, path);
-  const loaded = await loadMatchedRules(projectRoot, matchedNodes);
-  return buildRulesPayload(context, loaded, options);
-}
-function normalizeRulesPath(value) {
-  return value.replaceAll("\\", "/");
-}
-function matchRuleNodes(meta, path) {
-  const requestedPath = normalizeRulesPath(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];
-    return priorityDelta !== 0 ? priorityDelta : leftId.localeCompare(rightId);
-  }).map(([nodeId, node]) => ({
-    node_id: nodeId,
-    level: classifyNode(nodeId, node),
-    stable_id: node.stable_id ?? nodeId,
-    identity_source: node.identity_source ?? "derived",
-    node
-  }));
-}
-async function loadMatchedRules(projectRoot, matchedNodes, fileContentCache = /* @__PURE__ */ new Map()) {
-  const rules = [];
-  const stubs = [];
-  for (const matchedNode of matchedNodes) {
-    if (matchedNode.level === null) {
-      continue;
-    }
-    if (matchedNode.node.activation?.tier === "description") {
-      stubs.push({
-        stable_id: matchedNode.stable_id,
-        identity_source: matchedNode.identity_source,
-        level: matchedNode.level,
-        path: matchedNode.node.file,
-        description: matchedNode.node.activation.description ?? ""
-      });
-      continue;
-    }
-    rules.push({
-      level: matchedNode.level,
-      stable_id: matchedNode.stable_id,
-      identity_source: matchedNode.identity_source,
-      entry: {
-        path: matchedNode.node.file,
-        content: await readRuleContent(projectRoot, matchedNode.node.file, fileContentCache)
-      }
-    });
-  }
-  return { rules, stubs };
-}
-function buildRulesPayload(context, loaded, options = {}) {
-  const { L1, L2 } = partitionRulesByLevel(loaded.rules, options.dedupeByPath ?? false);
-  return {
-    L0: context.l0Content,
-    L1,
-    L2,
-    human_locked_nearby: context.humanLockedNearby,
-    description_stubs: loaded.stubs.length > 0 ? dedupeDescriptionStubsByPath(loaded.stubs).map(toDescriptionStub) : void 0
-  };
-}
-function classifyNode(nodeId, node) {
-  if (nodeId.startsWith("L1/")) {
-    return "L1";
-  }
-  if (nodeId.startsWith("L2/")) {
-    return "L2";
-  }
-  return node.layer === "L0" ? null : node.layer;
-}
-function partitionRulesByLevel(loadedRules, dedupeByPath) {
-  const l1 = [];
-  const l2 = [];
-  for (const rule of loadedRules) {
-    if (rule.level === "L1") {
-      l1.push(rule.entry);
-      continue;
-    }
-    if (rule.level === "L2") {
-      l2.push(rule.entry);
-    }
-  }
-  return {
-    L1: dedupeByPath ? dedupeEntriesByPath(l1) : l1,
-    L2: dedupeByPath ? dedupeEntriesByPath(l2) : l2
-  };
-}
-function dedupeEntriesByPath(entries) {
-  const seenPaths = /* @__PURE__ */ new Set();
-  return entries.filter((entry) => {
-    if (seenPaths.has(entry.path)) {
-      return false;
-    }
-    seenPaths.add(entry.path);
-    return true;
-  });
-}
-function shouldLoadNodeForPath(requestedPath, node) {
-  switch (node.activation?.tier) {
-    case "always":
-      return true;
-    case "description":
-      return true;
-    case "path":
-    case void 0:
-      return minimatch(requestedPath, normalizeRulesPath(node.scope_glob), { dot: true });
-  }
-}
-function dedupeDescriptionStubsByPath(stubs) {
-  const seenPaths = /* @__PURE__ */ new Set();
-  return stubs.filter((stub) => {
-    if (seenPaths.has(stub.path)) {
-      return false;
-    }
-    seenPaths.add(stub.path);
-    return true;
-  });
-}
-function toDescriptionStub(stub) {
-  return {
-    path: stub.path,
-    description: stub.description
-  };
-}
-async function readRuleContent(projectRoot, file, fileContentCache) {
-  const cached = fileContentCache.get(file);
-  if (cached !== void 0) {
-    return await cached;
-  }
-  const pending = readFile5(join6(projectRoot, file), "utf8");
-  fileContentCache.set(file, pending);
-  return await pending;
-}
-
-// src/services/plan-context.ts
-var SELECTION_TOKEN_TTL_MS = 5 * 60 * 1e3;
-var selectionTokenCache = /* @__PURE__ */ new Map();
-async function planContext(projectRoot, input) {
-  const meta = await readAgentsMeta(projectRoot);
-  const stale = input.client_hash !== void 0 && input.client_hash !== meta.revision;
-  const uniquePaths = dedupePaths(input.paths);
-  const allDescriptions = buildDescriptionIndex(meta);
-  const entries = uniquePaths.map((path) => {
-    const profile = buildRequirementProfile(path, input);
-    const descriptionIndex = allDescriptions.filter((item) => shouldIncludeIndexItemForPath(item, meta, path));
-    const requiredStableIds2 = descriptionIndex.filter((item) => item.required).map((item) => item.stable_id);
-    const aiSelectableStableIds2 = descriptionIndex.filter((item) => item.selectable).map((item) => item.stable_id);
-    return {
-      path,
-      requirement_profile: profile,
-      description_index: descriptionIndex,
-      required_stable_ids: requiredStableIds2,
-      ai_selectable_stable_ids: aiSelectableStableIds2,
-      initial_selected_stable_ids: requiredStableIds2,
-      selection_policy: {
-        required_levels: ["L0", "L2"],
-        ai_selectable_levels: ["L1"],
-        final_fetch_rule: "required_stable_ids + ai_selected_l1_stable_ids"
-      }
-    };
-  });
-  const requiredStableIds = dedupeStableIds(entries.flatMap((entry) => entry.required_stable_ids));
-  const aiSelectableStableIds = dedupeStableIds(entries.flatMap((entry) => entry.ai_selectable_stable_ids));
-  const sharedDescriptionIndex = dedupeDescriptionIndex(entries.flatMap((entry) => entry.description_index));
-  const selectionToken = createSelectionToken(meta.revision, uniquePaths, requiredStableIds, aiSelectableStableIds);
-  const result = {
-    revision_hash: meta.revision,
-    stale,
-    selection_token: selectionToken,
-    entries,
-    shared: {
-      required_stable_ids: requiredStableIds,
-      ai_selectable_stable_ids: aiSelectableStableIds,
-      description_index: sharedDescriptionIndex,
-      preflight_diagnostics: buildPreflightDiagnostics(meta)
-    }
-  };
-  try {
-    await appendEventLedgerEvent(projectRoot, {
-      event_type: "rule_context_planned",
-      target_paths: uniquePaths,
-      required_stable_ids: requiredStableIds,
-      ai_selectable_stable_ids: aiSelectableStableIds,
-      final_stable_ids: requiredStableIds,
-      selection_token: selectionToken,
-      client_hash: input.client_hash,
-      intent: input.intent,
-      known_tech: input.known_tech,
-      diagnostics: result.shared.preflight_diagnostics,
-      correlation_id: input.correlation_id,
-      session_id: input.session_id
-    });
-  } catch {
-  }
-  return result;
-}
-function readSelectionToken(token, now = Date.now()) {
-  const state = selectionTokenCache.get(token);
-  if (state === void 0) {
-    return void 0;
-  }
-  if (state.expires_at <= now) {
-    selectionTokenCache.delete(token);
-    return void 0;
-  }
-  return state;
-}
-function createSelectionToken(revisionHash, targetPaths, requiredStableIds, aiSelectableStableIds, now = Date.now()) {
-  const token = `selection:${revisionHash}:${now.toString(36)}:${Math.random().toString(36).slice(2)}`;
-  selectionTokenCache.set(token, {
-    token,
-    revision_hash: revisionHash,
-    target_paths: targetPaths,
-    required_stable_ids: requiredStableIds,
-    ai_selectable_stable_ids: aiSelectableStableIds,
-    created_at: now,
-    expires_at: now + SELECTION_TOKEN_TTL_MS
-  });
-  return token;
-}
-function dedupePaths(paths) {
-  const seenPaths = /* @__PURE__ */ new Set();
-  return paths.flatMap((path) => {
-    const normalizedPath = normalizeRulesPath(path);
-    if (seenPaths.has(normalizedPath)) {
-      return [];
-    }
-    seenPaths.add(normalizedPath);
-    return [normalizedPath];
-  });
-}
-function buildRequirementProfile(path, input) {
-  const normalizedPath = normalizeRulesPath(path);
-  const extensionMatch = /(\.[^./\\]+)$/u.exec(normalizedPath);
-  const knownTech = dedupeStableIds([
-    ...input.known_tech ?? [],
-    ...extensionMatch?.[1] === ".ts" ? ["TypeScript"] : []
-  ]);
-  return {
-    target_path: normalizedPath,
-    path_segments: normalizedPath.split("/").filter(Boolean),
-    extension: extensionMatch?.[1] ?? "",
-    inferred_domain: inferDomains(normalizedPath),
-    known_tech: knownTech,
-    user_intent: input.intent ?? "",
-    intent_tokens: tokenizeIntent(input.intent ?? ""),
-    impact_hints: inferImpactHints(input.intent ?? ""),
-    detected_entities: input.detected_entities?.[normalizedPath] ?? input.detected_entities?.[path] ?? []
-  };
-}
-function buildDescriptionIndex(meta) {
-  return Object.entries(meta.nodes).flatMap(([nodeId, node]) => {
-    const level = node.level ?? node.layer;
-    const description = node.description ?? descriptionFromLegacyActivation(node.activation?.description);
-    if (description === void 0) {
-      return [];
-    }
-    return [{
-      stable_id: node.stable_id ?? nodeId,
-      level,
-      required: level === "L0" || level === "L2",
-      selectable: level === "L1",
-      description
-    }];
-  }).sort(compareDescriptionIndexItems);
-}
-function descriptionFromLegacyActivation(summary) {
-  if (summary === void 0) {
-    return void 0;
-  }
-  return {
-    summary,
-    intent_clues: [],
-    tech_stack: [],
-    impact: [],
-    must_read_if: summary
-  };
-}
-function shouldIncludeIndexItemForPath(item, meta, path) {
-  if (item.level === "L0" || item.level === "L1") {
-    return true;
-  }
-  const node = Object.values(meta.nodes).find((candidate) => candidate.stable_id === item.stable_id);
-  if (node === void 0) {
-    return false;
-  }
-  return node.scope_glob === path || minimatchSimple(path, node.scope_glob);
-}
-function minimatchSimple(path, glob) {
-  if (glob === "**") {
-    return true;
-  }
-  if (glob.endsWith("/**")) {
-    return path.startsWith(glob.slice(0, -3));
-  }
-  return path === glob;
-}
-function buildPreflightDiagnostics(meta) {
-  const missingDescriptionStableIds = Object.entries(meta.nodes).filter(([, node]) => node.description === void 0 && node.activation?.description === void 0).map(([nodeId, node]) => node.stable_id ?? nodeId).sort();
-  if (missingDescriptionStableIds.length === 0) {
-    return [];
-  }
-  return [{
-    code: "missing_description",
-    severity: "warn",
-    stable_ids: missingDescriptionStableIds,
-    message: `Resolved registry includes ${missingDescriptionStableIds.length} node(s) without structured descriptions.`
-  }];
-}
-function inferDomains(path) {
-  const domains = [];
-  if (path.includes("/ui/") || path.toLowerCase().includes("ui")) {
-    domains.push("UI");
-  }
-  if (path.includes("assets/scripts")) {
-    domains.push("Gameplay");
-  }
-  if (path.includes("resources") || path.includes("assets/resources")) {
-    domains.push("Asset");
-  }
-  return domains;
-}
-function tokenizeIntent(intent) {
-  const tokens = ["\u6027\u80FD", "\u4F18\u5316", "drawcall", "\u6E32\u67D3", "\u5361\u987F", "\u95EA\u70C1", "\u754C\u9762", "UI", "\u8D44\u6E90", "\u56FE\u96C6"].filter((token) => intent.toLowerCase().includes(token.toLowerCase()));
-  return dedupeStableIds(tokens);
-}
-function inferImpactHints(intent) {
-  return /性能|优化|drawcall|渲染|卡顿|闪烁/iu.test(intent) ? ["Performance"] : [];
-}
-function dedupeStableIds(stableIds) {
-  return Array.from(new Set(stableIds));
-}
-function dedupeDescriptionIndex(items) {
-  const seenStableIds = /* @__PURE__ */ new Set();
-  return items.filter((item) => {
-    if (seenStableIds.has(item.stable_id)) {
-      return false;
-    }
-    seenStableIds.add(item.stable_id);
-    return true;
-  });
-}
-function compareDescriptionIndexItems(left, right) {
-  const levelDelta = levelOrder(left.level) - levelOrder(right.level);
-  return levelDelta !== 0 ? levelDelta : left.stable_id.localeCompare(right.stable_id);
-}
-function levelOrder(level) {
-  switch (level) {
-    case "L0":
-      return 0;
-    case "L1":
-      return 1;
-    case "L2":
-      return 2;
-  }
-}
-
-// src/services/rule-sections.ts
-var RULE_SECTION_NAMES = [
-  "MISSION_STATEMENT",
-  "MANDATORY_INJECTION",
-  "BUSINESS_LOGIC_CHUNKS",
-  "CONTEXT_INFO"
-];
-var PRIORITY_ORDER2 = {
-  high: 0,
-  medium: 1,
-  low: 2
-};
-function parseRuleSections(content) {
-  const sections = /* @__PURE__ */ new Map();
-  const lines = content.split(/\r?\n/u);
-  let activeSection;
-  let activeSectionDepth = 0;
-  let buffer = [];
-  const flush = () => {
-    if (activeSection === void 0) {
-      return;
-    }
-    const text = buffer.join("\n").trim();
-    if (text.length === 0) {
-      buffer = [];
-      return;
-    }
-    sections.set(activeSection, [...sections.get(activeSection) ?? [], text]);
-    buffer = [];
-  };
-  for (const line of lines) {
-    const heading = /^(#{2,6})\s+\[([A-Z_]+)\]\s*$/u.exec(line.trim());
-    if (heading !== null) {
-      flush();
-      activeSection = isRuleSectionName(heading[2]) ? heading[2] : void 0;
-      activeSectionDepth = activeSection === void 0 ? 0 : heading[1].length;
-      continue;
-    }
-    const ordinaryHeading = /^(#{1,6})\s+/u.exec(line.trim());
-    if (ordinaryHeading !== null) {
-      if (activeSection !== void 0 && ordinaryHeading[1].length > activeSectionDepth) {
-        buffer.push(line);
-        continue;
-      }
-      flush();
-      activeSection = void 0;
-      activeSectionDepth = 0;
-      continue;
-    }
-    if (activeSection !== void 0) {
-      buffer.push(line);
-    }
-  }
-  flush();
-  return new Map(
-    Array.from(sections.entries()).map(([section, values]) => [section, values.join("\n\n")])
-  );
-}
-async function getRuleSections(projectRoot, input) {
-  const token = readSelectionToken(input.selection_token);
-  if (token === void 0) {
-    throw new Error("selection_token is missing or expired");
-  }
-  validateAiSelections(token.ai_selectable_stable_ids, input.ai_selected_stable_ids, input.ai_selection_reasons);
-  const meta = await readAgentsMeta(projectRoot);
-  const selectedStableIds = [...token.required_stable_ids, ...input.ai_selected_stable_ids];
-  const selectedRules = sortRuleNodes(selectedStableIds.map((stableId) => findRuleNode(meta, stableId)));
-  const diagnostics = [];
-  const rules = [];
-  for (const rule of selectedRules) {
-    const content = await readFile6(join7(projectRoot, rule.path), "utf8");
-    const parsedSections = parseRuleSections(content);
-    const sections = {};
-    for (const section of input.sections) {
-      const sectionContent = parsedSections.get(section);
-      sections[section] = sectionContent ?? "";
-      if (sectionContent === void 0) {
-        diagnostics.push({
-          code: "missing_section",
-          severity: "warn",
-          stable_id: rule.stable_id,
-          section,
-          message: `Rule ${rule.stable_id} does not define section ${section}.`
-        });
-      }
-    }
-    rules.push({
-      stable_id: rule.stable_id,
-      level: rule.level,
-      path: rule.path,
-      sections
-    });
-  }
-  const result = {
-    revision_hash: meta.revision,
-    precedence: ["L2", "L1", "L0"],
-    selected_stable_ids: rules.map((rule) => rule.stable_id),
-    rules,
-    diagnostics
-  };
-  await appendRuleSelectionAuditEvent(projectRoot, {
-    path: token.target_paths[0] ?? "",
-    selection_token: input.selection_token,
-    target_paths: token.target_paths,
-    required_stable_ids: token.required_stable_ids,
-    ai_selectable_stable_ids: token.ai_selectable_stable_ids,
-    ai_selected_stable_ids: input.ai_selected_stable_ids,
-    final_stable_ids: result.selected_stable_ids,
-    ai_selection_reasons: pickSelectionReasons(input.ai_selected_stable_ids, input.ai_selection_reasons),
-    rejected_stable_ids: [],
-    ignored_stable_ids: [],
-    correlation_id: input.correlation_id,
-    session_id: input.session_id
-  });
-  try {
-    await appendEventLedgerEvent(projectRoot, {
-      event_type: "rule_sections_fetched",
-      selection_token: input.selection_token,
-      target_paths: token.target_paths,
-      requested_sections: input.sections,
-      final_stable_ids: result.selected_stable_ids,
-      ai_selected_stable_ids: input.ai_selected_stable_ids,
-      diagnostics,
-      correlation_id: input.correlation_id,
-      session_id: input.session_id
-    });
-  } catch {
-  }
-  return result;
-}
-function validateAiSelections(aiSelectableStableIds, aiSelectedStableIds, aiSelectionReasons) {
-  const selectable = new Set(aiSelectableStableIds);
-  for (const stableId of aiSelectedStableIds) {
-    if (!selectable.has(stableId)) {
-      throw new Error(`Invalid L1 rule selection: ${stableId}`);
-    }
-    if (aiSelectionReasons[stableId]?.trim() === "") {
-      throw new Error(`Missing AI selection reason for ${stableId}`);
-    }
-    if (aiSelectionReasons[stableId] === void 0) {
-      throw new Error(`Missing AI selection reason for ${stableId}`);
-    }
-  }
-}
-function findRuleNode(meta, stableId) {
-  for (const [nodeId, node] of Object.entries(meta.nodes)) {
-    const nodeStableId = node.stable_id ?? nodeId;
-    if (nodeStableId !== stableId) {
-      continue;
-    }
-    const level = node.level ?? node.layer;
-    return {
-      stable_id: nodeStableId,
-      level,
-      path: normalizeRulesPath(node.content_ref ?? node.file),
-      priority: node.priority,
-      node
-    };
-  }
-  throw new Error(`Selected rule is not present in agents.meta.json: ${stableId}`);
-}
-function sortRuleNodes(rules) {
-  return [...rules].sort((left, right) => {
-    const levelDelta = outputLevelOrder(left.level) - outputLevelOrder(right.level);
-    if (levelDelta !== 0) {
-      return levelDelta;
-    }
-    const priorityDelta = PRIORITY_ORDER2[left.priority] - PRIORITY_ORDER2[right.priority];
-    if (priorityDelta !== 0) {
-      return priorityDelta;
-    }
-    return left.stable_id.localeCompare(right.stable_id);
-  });
-}
-function outputLevelOrder(level) {
-  switch (level) {
-    case "L0":
-      return 0;
-    case "L1":
-      return 1;
-    case "L2":
-      return 2;
-  }
-}
-function isRuleSectionName(value) {
-  return RULE_SECTION_NAMES.includes(value);
-}
-function pickSelectionReasons(selectedStableIds, reasons) {
-  return Object.fromEntries(selectedStableIds.map((stableId) => [stableId, reasons[stableId] ?? ""]));
-}
-
-// src/services/doctor.ts
-import { atomicWriteJson as atomicWriteJson2, atomicWriteText as atomicWriteText3 } from "@fenglimg/fabric-shared/node/atomic-write";
-import { buildBootstrapContent, FABRIC_BOOTSTRAP_PATH } from "@fenglimg/fabric-shared/node/bootstrap-guide";
-var LEGACY_CLIENT_PATH_KEYS = ["windsurf", "rooCode", "geminiCLI"];
-var SCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".ts", ".tsx"]);
-var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
-  ".fabric",
-  ".git",
-  ".next",
-  ".turbo",
-  "Library",
-  "Temp",
-  "build",
-  "coverage",
-  "dist",
-  "node_modules"
-]);
-var TARGET_FILE_PATHS = [
-  ".fabric/bootstrap/README.md",
-  ".fabric/INITIAL_TAXONOMY.md",
-  ".fabric/forensic.json",
-  ".fabric/init-context.json",
-  ".fabric/agents.meta.json",
-  ".fabric/rule-test.index.json",
-  ".fabric/events.jsonl"
-];
-async function runDoctorReport(target) {
-  const projectRoot = normalizeTarget(target);
-  const framework = detectFramework(projectRoot);
-  const entryPoints = collectEntryPoints(projectRoot);
-  const [
-    forensic,
-    initContext,
-    meta,
-    eventLedger,
-    ruleSections,
-    ruleTestIndex
-  ] = await Promise.all([
-    inspectForensic(projectRoot),
-    inspectInitContext(projectRoot),
-    inspectMeta(projectRoot),
-    inspectEventLedger(projectRoot),
-    inspectRuleSections(projectRoot),
-    inspectRuleTestIndex(projectRoot)
-  ]);
-  const mcpConfigInWrongFile = inspectMcpConfigInWrongFile(projectRoot);
-  const metaManuallyDiverged = await inspectMetaManuallyDiverged(projectRoot);
-  const rulesDirUnindexed = inspectRulesDirUnindexed(projectRoot, meta);
-  const stableIdCollision = await inspectStableIdCollisions(projectRoot);
-  const claudeSkillLegacyPath = inspectClaudeSkillLegacyPath(projectRoot);
-  const claudeHookLegacyPath = inspectClaudeHookLegacyPath(projectRoot);
-  const codexSkillLegacyPath = inspectCodexSkillLegacyPath(projectRoot);
-  const preexistingRootFiles = inspectPreexistingRootFiles(projectRoot);
-  const legacyClientPaths = inspectLegacyClientPaths(projectRoot);
-  const taxonomyExists = existsSync4(join8(projectRoot, ".fabric", "INITIAL_TAXONOMY.md"));
-  const bootstrapExists = existsSync4(join8(projectRoot, ".fabric", "bootstrap", "README.md"));
-  const checks = [
-    createBootstrapCheck(bootstrapExists),
-    createTaxonomyCheck(taxonomyExists),
-    createForensicCheck(forensic, framework.kind, entryPoints.length),
-    createInitContextCheck(initContext),
-    createMetaCheck(meta),
-    createRuleContentRefCheck(meta),
-    createRuleSectionsCheck(ruleSections),
-    createRuleTestIndexCheck(ruleTestIndex),
-    createEventLedgerCheck(eventLedger),
-    createEventLedgerPartialWriteCheck(eventLedger),
-    createMcpConfigInWrongFileCheck(mcpConfigInWrongFile),
-    createMetaManuallyDivergedCheck(metaManuallyDiverged),
-    createRulesDirUnindexedCheck(rulesDirUnindexed),
-    createStableIdCollisionCheck(stableIdCollision),
-    createClaudeSkillLegacyPathCheck(claudeSkillLegacyPath),
-    createClaudeHookLegacyPathCheck(claudeHookLegacyPath),
-    createCodexSkillLegacyPathCheck(codexSkillLegacyPath),
-    createPreexistingRootFilesCheck(preexistingRootFiles),
-    createLegacyClientPathCheck(legacyClientPaths)
-  ];
-  const fixableErrors = collectIssues(checks, "fixable_error");
-  const manualErrors = collectIssues(checks, "manual_error");
-  const warnings = collectIssues(checks, "warning");
-  const infos = collectIssues(checks, "info");
-  return {
-    status: reduceStatus(checks.map((check) => check.status)),
-    checks,
-    fixable_errors: fixableErrors,
-    manual_errors: manualErrors,
-    warnings,
-    infos,
-    summary: {
-      target: projectRoot,
-      framework: {
-        kind: framework.kind,
-        version: framework.version,
-        subkind: framework.subkind
-      },
-      entryPoints,
-      metaRevision: meta.revision,
-      computedMetaRevision: meta.computedRevision,
-      ruleCount: meta.ruleCount,
-      eventLedgerPath: eventLedger.path,
-      fixableErrorCount: fixableErrors.length,
-      manualErrorCount: manualErrors.length,
-      warningCount: warnings.length,
-      infoCount: infos.length,
-      targetFiles: Object.fromEntries(
-        TARGET_FILE_PATHS.map((path) => [path, existsSync4(join8(projectRoot, path))])
-      )
-    }
-  };
-}
-async function runDoctorFix(target) {
-  const projectRoot = normalizeTarget(target);
-  const before = await runDoctorReport(projectRoot);
-  const fixed = [];
-  if (before.fixable_errors.some((issue) => issue.code === "bootstrap_missing")) {
-    await writeDefaultBootstrap(projectRoot);
-    fixed.push(findIssue(before.fixable_errors, "bootstrap_missing"));
-  }
-  if (before.fixable_errors.some((issue) => issue.code === "event_ledger_missing")) {
-    await ensureEventLedger(projectRoot);
-    fixed.push(findIssue(before.fixable_errors, "event_ledger_missing"));
+  if (before.fixable_errors.some((issue) => issue.code === "counter_desync")) {
+    await fixCounterDesync(projectRoot);
+    fixed.push(findIssue(before.fixable_errors, "counter_desync"));
+    contextCache.invalidate("meta_write", projectRoot);
   }
   if (before.fixable_errors.some(
     (issue) => [
@@ -1990,7 +1404,7 @@ async function runDoctorFix(target) {
       "rule_test_index_missing",
       "rule_test_index_stale",
       "content_ref_missing",
-      "rules_dir_unindexed"
+      "knowledge_dir_unindexed"
     ].includes(issue.code)
   )) {
     await reconcileRules(projectRoot, { trigger: "doctor" });
@@ -2001,12 +1415,14 @@ async function runDoctorFix(target) {
         "rule_test_index_missing",
         "rule_test_index_stale",
         "content_ref_missing",
-        "rules_dir_unindexed"
+        "knowledge_dir_unindexed"
       ].includes(candidate.code)
     )) {
       fixed.push(issue);
     }
     contextCache.invalidate("meta_write", projectRoot);
+    await fixCounterDesync(projectRoot);
+    contextCache.invalidate("meta_write", projectRoot);
   }
   if (before.fixable_errors.some((issue) => issue.code === "event_ledger_partial_write")) {
     const ledgerPath = getEventLedgerPath(projectRoot);
@@ -2023,22 +1439,6 @@ async function runDoctorFix(target) {
     await fixMcpConfigInWrongFile(projectRoot);
     fixed.push(findIssue(before.fixable_errors, "mcp_config_in_wrong_file"));
   }
-  if (before.fixable_errors.some((issue) => issue.code === "claude_skill_legacy_path")) {
-    await fixClaudeSkillLegacyPath(projectRoot);
-    fixed.push(findIssue(before.fixable_errors, "claude_skill_legacy_path"));
-  }
-  if (before.fixable_errors.some((issue) => issue.code === "claude_hook_legacy_path")) {
-    await fixClaudeHookLegacyPath(projectRoot);
-    fixed.push(findIssue(before.fixable_errors, "claude_hook_legacy_path"));
-  }
-  if (before.fixable_errors.some((issue) => issue.code === "codex_skill_legacy_path")) {
-    await fixCodexSkillLegacyPath(projectRoot);
-    fixed.push(findIssue(before.fixable_errors, "codex_skill_legacy_path"));
-  }
-  if (before.warnings.some((issue) => issue.code === "legacy_client_path_present")) {
-    await fixLegacyClientPaths(projectRoot);
-    fixed.push(findIssue(before.warnings, "legacy_client_path_present"));
-  }
   const report = await runDoctorReport(projectRoot);
   return {
     changed: fixed.length > 0,
@@ -2050,9 +1450,9 @@ async function runDoctorFix(target) {
   };
 }
 async function inspectForensic(projectRoot) {
-  const path = join8(projectRoot, ".fabric", "forensic.json");
+  const path = join5(projectRoot, ".fabric", "forensic.json");
   try {
-    const parsed = forensicReportSchema.parse(JSON.parse(await readFile7(path, "utf8")));
+    const parsed = forensicReportSchema.parse(JSON.parse(await readFile5(path, "utf8")));
     return { present: true, valid: true, report: parsed };
   } catch (error) {
     if (isMissingFileError(error)) {
@@ -2061,20 +1461,8 @@ async function inspectForensic(projectRoot) {
     return { present: true, valid: false, report: null, error: error instanceof Error ? error.message : String(error) };
   }
 }
-async function inspectInitContext(projectRoot) {
-  const path = join8(projectRoot, ".fabric", "init-context.json");
-  try {
-    JSON.parse(await readFile7(path, "utf8"));
-    return { exists: true, validJson: true };
-  } catch (error) {
-    if (isMissingFileError(error)) {
-      return { exists: false, validJson: false, error: ".fabric/init-context.json is missing." };
-    }
-    return { exists: true, validJson: false, error: error instanceof Error ? error.message : String(error) };
-  }
-}
 function inspectMcpConfigInWrongFile(projectRoot) {
-  const settingsPath = join8(projectRoot, ".claude", "settings.json");
+  const settingsPath = join5(projectRoot, ".claude", "settings.json");
   if (!existsSync4(settingsPath)) {
     return { hasWrongEntry: false, settingsPath };
   }
@@ -2095,10 +1483,10 @@ function inspectMcpConfigInWrongFile(projectRoot) {
   }
 }
 async function inspectMeta(projectRoot) {
-  const metaPath = join8(projectRoot, ".fabric", "agents.meta.json");
+  const metaPath = join5(projectRoot, ".fabric", "agents.meta.json");
   const built = await tryBuildRuleMeta(projectRoot);
   try {
-    const raw = await readFile7(metaPath, "utf8");
+    const raw = await readFile5(metaPath, "utf8");
     const meta = agentsMetaSchema4.parse(JSON.parse(raw));
     const contentRefIssues = inspectContentRefs(projectRoot, meta);
     const changed = built === null ? false : built.changed;
@@ -2108,7 +1496,10 @@ async function inspectMeta(projectRoot) {
       meta,
       revision: meta.revision,
       computedRevision: built?.meta.revision ?? null,
-      ruleCount: Object.values(meta.nodes).filter((node) => (node.content_ref ?? node.file).startsWith(".fabric/rules/")).length,
+      ruleCount: Object.values(meta.nodes).filter((node) => {
+        const ref = node.content_ref ?? node.file;
+        return ref.startsWith(".fabric/knowledge/") || ref.startsWith("~/.fabric/knowledge/");
+      }).length,
       missingContentRefs: contentRefIssues.missing,
       invalidContentRefs: contentRefIssues.invalid,
       stale: changed || built !== null && meta.revision !== built.meta.revision,
@@ -2156,17 +1547,16 @@ function inspectContentRefs(projectRoot, meta) {
   const invalid = [];
   for (const node of Object.values(meta.nodes)) {
     const contentRef = normalizePath(node.content_ref ?? node.file);
-    if (contentRef === ".fabric/bootstrap/README.md") {
-      if (!existsSync4(join8(projectRoot, contentRef))) {
-        missing.push(contentRef);
-      }
+    const isPersonalKnowledge = contentRef.startsWith("~/.fabric/knowledge/");
+    const isTeamKnowledge = contentRef.startsWith(".fabric/knowledge/");
+    if (!isPersonalKnowledge && !isTeamKnowledge) {
+      invalid.push(contentRef);
       continue;
     }
-    if (!contentRef.startsWith(".fabric/rules/")) {
-      invalid.push(contentRef);
+    if (isPersonalKnowledge) {
       continue;
     }
-    if (!existsSync4(join8(projectRoot, contentRef))) {
+    if (!existsSync4(join5(projectRoot, contentRef))) {
       missing.push(contentRef);
     }
   }
@@ -2181,7 +1571,7 @@ async function inspectEventLedger(projectRoot) {
   try {
     await access(path, constants.W_OK);
     const { warnings } = await readEventLedger(projectRoot);
-    const raw = await readFile7(path, "utf8");
+    const raw = await readFile5(path, "utf8");
     const invalidLine = raw.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean).find((line) => !isValidJsonLine(line));
     const partialWarning = warnings.find((w) => w.kind === "partial_write_at_tail");
     return {
@@ -2207,29 +1597,11 @@ async function inspectEventLedger(projectRoot) {
     };
   }
 }
-async function inspectRuleSections(projectRoot) {
-  const invalidFiles = [];
-  const files = findRuleFiles2(projectRoot);
-  for (const file of files) {
-    try {
-      parseRuleSections(await readFile7(join8(projectRoot, file), "utf8"));
-    } catch (error) {
-      invalidFiles.push({
-        file,
-        reason: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  return {
-    checkedCount: files.length,
-    invalidFiles
-  };
-}
 async function inspectRuleTestIndex(projectRoot) {
-  const path = join8(projectRoot, ".fabric", "rule-test.index.json");
+  const path = join5(projectRoot, ".fabric", "rule-test.index.json");
   const built = await tryBuildRuleMeta(projectRoot);
   try {
-    const index = ruleTestIndexSchema2.parse(JSON.parse(await readFile7(path, "utf8")));
+    const index = ruleTestIndexSchema2.parse(JSON.parse(await readFile5(path, "utf8")));
     return {
       present: true,
       valid: true,
@@ -2248,17 +1620,56 @@ async function inspectRuleTestIndex(projectRoot) {
     };
   }
 }
-function createBootstrapCheck(exists) {
-  if (!exists) {
-    return issueCheck("Bootstrap README", "error", "fixable_error", "bootstrap_missing", ".fabric/bootstrap/README.md is missing.", "Run `fab doctor --fix` to generate the bootstrap guide.");
+function inspectBootstrapAnchor(projectRoot) {
+  return {
+    hasAgentsMd: existsSync4(join5(projectRoot, "AGENTS.md")),
+    hasClaudeMd: existsSync4(join5(projectRoot, "CLAUDE.md"))
+  };
+}
+function createBootstrapAnchorCheck(inspection) {
+  if (!inspection.hasAgentsMd && !inspection.hasClaudeMd) {
+    return issueCheck(
+      "Bootstrap anchor",
+      "error",
+      "fixable_error",
+      "bootstrap_anchor_missing",
+      "Neither AGENTS.md nor CLAUDE.md exists at the repo root. Fabric requires a bootstrap anchor file at the project root.",
+      "Run `fabric init` to generate the AGENTS.md / CLAUDE.md bootstrap anchor at the repo root."
+    );
   }
-  return okCheck("Bootstrap README", ".fabric/bootstrap/README.md exists.");
+  const present = [
+    inspection.hasAgentsMd ? "AGENTS.md" : null,
+    inspection.hasClaudeMd ? "CLAUDE.md" : null
+  ].filter((entry) => entry !== null).join(", ");
+  return okCheck("Bootstrap anchor", `Bootstrap anchor present at repo root: ${present}.`);
 }
-function createTaxonomyCheck(exists) {
-  if (!exists) {
-    return issueCheck("Initial taxonomy", "error", "manual_error", "taxonomy_missing", ".fabric/INITIAL_TAXONOMY.md is missing.", "Run `fab init` to regenerate project scaffolding including INITIAL_TAXONOMY.md.");
+function inspectKnowledgeDirMissing(projectRoot) {
+  const knowledgeRoot = join5(projectRoot, ".fabric", "knowledge");
+  const missingSubdirs = [];
+  for (const sub of KNOWLEDGE_SUBDIRS2) {
+    const path = join5(knowledgeRoot, sub);
+    if (!existsSync4(path)) {
+      missingSubdirs.push(`.fabric/knowledge/${sub}`);
+    }
   }
-  return okCheck("Initial taxonomy", ".fabric/INITIAL_TAXONOMY.md exists.");
+  return { missingSubdirs };
+}
+function createKnowledgeDirMissingCheck(inspection) {
+  if (inspection.missingSubdirs.length > 0) {
+    const list = inspection.missingSubdirs.join(", ");
+    return issueCheck(
+      "Knowledge layout",
+      "error",
+      "fixable_error",
+      "knowledge_dir_missing",
+      `${inspection.missingSubdirs.length} required knowledge subdir${inspection.missingSubdirs.length === 1 ? " is" : "s are"} missing: ${list}.`,
+      "Run `fab doctor --fix` to create the missing .fabric/knowledge/* subdirectories."
+    );
+  }
+  return okCheck(
+    "Knowledge layout",
+    `All ${KNOWLEDGE_SUBDIRS2.length} required .fabric/knowledge/* subdirectories exist.`
+  );
 }
 function createForensicCheck(forensic, frameworkKind, entryPointCount) {
   if (!forensic.present) {
@@ -2276,18 +1687,9 @@ function createForensicCheck(forensic, frameworkKind, entryPointCount) {
   }
   return okCheck("Scan evidence", `.fabric/forensic.json is valid for ${forensic.report?.framework.kind ?? "unknown"}.`);
 }
-function createInitContextCheck(initContext) {
-  if (!initContext.exists) {
-    return issueCheck("Init context", "error", "manual_error", "init_context_missing", initContext.error ?? ".fabric/init-context.json is missing.", "Run the fabric-init skill in Claude Code or Codex CLI to complete initialization. See docs/migration-1.8.md FAQ.");
-  }
-  if (!initContext.validJson) {
-    return issueCheck("Init context", "error", "manual_error", "init_context_invalid", initContext.error ?? ".fabric/init-context.json is invalid.", "Delete .fabric/init-context.json and run `fab init` to regenerate it.");
-  }
-  return okCheck("Init context", ".fabric/init-context.json is valid JSON.");
-}
 function createMetaCheck(meta) {
   if (!meta.present) {
-    return issueCheck("Agents metadata", "error", "fixable_error", "agents_meta_missing", ".fabric/agents.meta.json is missing.", "Run `fab doctor --fix` to rebuild agents.meta.json from .fabric/rules/.");
+    return issueCheck("Agents metadata", "error", "fixable_error", "agents_meta_missing", ".fabric/agents.meta.json is missing.", "Run `fab doctor --fix` to rebuild agents.meta.json from .fabric/knowledge/.");
   }
   if (!meta.valid) {
     return issueCheck("Agents metadata", "error", "manual_error", "agents_meta_invalid", meta.readError ?? ".fabric/agents.meta.json is invalid.", "Delete .fabric/agents.meta.json and run `fab doctor --fix` to regenerate it.");
@@ -2298,11 +1700,11 @@ function createMetaCheck(meta) {
       "error",
       "fixable_error",
       "agents_meta_stale",
-      `.fabric/agents.meta.json revision ${meta.revision} does not match .fabric/rules derived revision ${meta.computedRevision ?? "<unknown>"}.`,
-      "Run `fab doctor --fix` to reconcile agents.meta.json with the current rule files."
+      `.fabric/agents.meta.json revision ${meta.revision} does not match .fabric/knowledge derived revision ${meta.computedRevision ?? "<unknown>"}.`,
+      "Run `fab doctor --fix` to reconcile agents.meta.json with the current knowledge files."
     );
   }
-  return okCheck("Agents metadata", `.fabric/agents.meta.json revision ${meta.revision} is aligned with .fabric/rules.`);
+  return okCheck("Agents metadata", `.fabric/agents.meta.json revision ${meta.revision} is aligned with .fabric/knowledge.`);
 }
 function createRuleContentRefCheck(meta) {
   if (!meta.valid) {
@@ -2314,8 +1716,8 @@ function createRuleContentRefCheck(meta) {
       "error",
       "manual_error",
       "content_ref_outside_rules",
-      `${meta.invalidContentRefs.length} content_ref entr${meta.invalidContentRefs.length === 1 ? "y is" : "ies are"} outside .fabric/rules.`,
-      "Edit agents.meta.json to ensure all content_ref values point inside .fabric/rules/."
+      `${meta.invalidContentRefs.length} content_ref entr${meta.invalidContentRefs.length === 1 ? "y is" : "ies are"} outside .fabric/knowledge.`,
+      "Edit agents.meta.json to ensure all content_ref values point inside .fabric/knowledge/{type}/ (team) or ~/.fabric/knowledge/{type}/ (personal)."
     );
   }
   if (meta.missingContentRefs.length > 0) {
@@ -2325,23 +1727,10 @@ function createRuleContentRefCheck(meta) {
       "fixable_error",
       "content_ref_missing",
       `${meta.missingContentRefs.length} content_ref target${meta.missingContentRefs.length === 1 ? "" : "s"} are missing. Run \`fab doctor --fix\` to reconcile.`,
-      "Run `fab doctor --fix` to reconcile agents.meta.json with the files present in .fabric/rules/."
-    );
-  }
-  return okCheck("Rule content refs", "All content_ref entries resolve to .fabric/rules files or bootstrap README.");
-}
-function createRuleSectionsCheck(snapshot) {
-  if (snapshot.invalidFiles.length > 0) {
-    return issueCheck(
-      "Rule sections",
-      "error",
-      "manual_error",
-      "rule_sections_invalid",
-      `${snapshot.invalidFiles.length} rule file${snapshot.invalidFiles.length === 1 ? "" : "s"} could not be parsed.`,
-      "Edit the rule file(s) to fix the section structure, then re-run `fab doctor`."
+      "Run `fab doctor --fix` to reconcile agents.meta.json with the files present in .fabric/knowledge/."
     );
   }
-  return okCheck("Rule sections", `${snapshot.checkedCount} .fabric/rules file${snapshot.checkedCount === 1 ? "" : "s"} parsed.`);
+  return okCheck("Rule content refs", "All content_ref entries resolve to .fabric/knowledge files.");
 }
 function createRuleTestIndexCheck(index) {
   if (!index.present) {
@@ -2425,13 +1814,13 @@ function findIssue(issues, code) {
   };
 }
 async function inspectMetaManuallyDiverged(projectRoot) {
-  const metaPath = join8(projectRoot, ".fabric", "agents.meta.json");
+  const metaPath = join5(projectRoot, ".fabric", "agents.meta.json");
   if (!existsSync4(metaPath)) {
     return { extraMetaEntries: [], hashMismatchEntries: [], readable: false };
   }
   let meta;
   try {
-    const raw = await readFile7(metaPath, "utf8");
+    const raw = await readFile5(metaPath, "utf8");
     meta = agentsMetaSchema4.parse(JSON.parse(raw));
   } catch (error) {
     return {
@@ -2445,7 +1834,7 @@ async function inspectMetaManuallyDiverged(projectRoot) {
   const hashMismatchEntries = [];
   for (const node of Object.values(meta.nodes)) {
     const contentRef = node.content_ref ?? node.file;
-    const absPath = join8(projectRoot, contentRef);
+    const absPath = join5(projectRoot, contentRef);
     if (!existsSync4(absPath)) {
       extraMetaEntries.push(contentRef);
       continue;
@@ -2462,87 +1851,89 @@ async function inspectMetaManuallyDiverged(projectRoot) {
   }
   return { extraMetaEntries, hashMismatchEntries, readable: true };
 }
-function inspectRulesDirUnindexed(projectRoot, meta) {
-  const rulesDir = join8(projectRoot, ".fabric", "rules");
-  if (!existsSync4(rulesDir)) {
+function inspectKnowledgeDirUnindexed(projectRoot, meta) {
+  const physicalMdFiles = /* @__PURE__ */ new Set();
+  collectMdFilesUnder(physicalMdFiles, projectRoot, join5(projectRoot, ".fabric", "knowledge"), ".fabric/knowledge");
+  if (physicalMdFiles.size === 0) {
     return { unindexedFiles: [] };
   }
-  const physicalMdFiles = /* @__PURE__ */ new Set();
-  const stack = [rulesDir];
+  const indexedRefs = /* @__PURE__ */ new Set();
+  if (meta.valid && meta.meta !== null) {
+    for (const node of Object.values(meta.meta.nodes)) {
+      const ref = normalizePath(node.content_ref ?? node.file);
+      indexedRefs.add(ref);
+    }
+  }
+  const unindexedFiles = [...physicalMdFiles].filter((f) => !indexedRefs.has(f)).sort();
+  return { unindexedFiles };
+}
+function collectMdFilesUnder(out, projectRoot, rootDir, relPrefix) {
+  if (!existsSync4(rootDir)) {
+    return;
+  }
+  const stack = [rootDir];
   while (stack.length > 0) {
     const dir = stack.pop();
     if (dir === void 0) {
       continue;
     }
     for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      const abs = join8(dir, entry.name);
+      const abs = join5(dir, entry.name);
       if (entry.isDirectory()) {
         stack.push(abs);
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        const rel = posix2.join(".fabric/rules", abs.slice(rulesDir.length + 1).replace(/\\/gu, "/"));
-        physicalMdFiles.add(rel);
+        const rel = posix.join(relPrefix, abs.slice(rootDir.length + 1).replace(/\\/gu, "/"));
+        out.add(rel);
       }
     }
   }
-  const indexedRefs = /* @__PURE__ */ new Set();
-  if (meta.valid && meta.meta !== null) {
-    for (const node of Object.values(meta.meta.nodes)) {
-      const ref = normalizePath(node.content_ref ?? node.file);
-      indexedRefs.add(ref);
-    }
-  }
-  const unindexedFiles = [...physicalMdFiles].filter((f) => !indexedRefs.has(f)).sort();
-  return { unindexedFiles };
 }
-function createRulesDirUnindexedCheck(inspection) {
+function createKnowledgeDirUnindexedCheck(inspection) {
   if (inspection.unindexedFiles.length > 0) {
     return issueCheck(
-      "Rules dir unindexed",
+      "Knowledge dir unindexed",
       "error",
       "fixable_error",
-      "rules_dir_unindexed",
-      `${inspection.unindexedFiles.length} .md file${inspection.unindexedFiles.length === 1 ? "" : "s"} in .fabric/rules/ not indexed in agents.meta.json. Run \`fab doctor --fix\` to index the missing rule files.`,
-      "Run `fab doctor --fix` to index the missing rule files."
+      "knowledge_dir_unindexed",
+      `${inspection.unindexedFiles.length} .md file${inspection.unindexedFiles.length === 1 ? "" : "s"} in .fabric/knowledge/ not indexed in agents.meta.json. Run \`fab doctor --fix\` to index the missing knowledge files.`,
+      "Run `fab doctor --fix` to index the missing knowledge files."
     );
   }
-  return okCheck("Rules dir unindexed", "All .fabric/rules/ .md files are indexed in agents.meta.json.");
+  return okCheck("Knowledge dir unindexed", "All .fabric/knowledge/ .md files are indexed in agents.meta.json.");
 }
 async function inspectStableIdCollisions(projectRoot) {
-  const rulesDir = join8(projectRoot, ".fabric", "rules");
-  if (!existsSync4(rulesDir)) {
-    return { collisions: [] };
-  }
-  const mdFiles = [];
-  const stack = [rulesDir];
-  while (stack.length > 0) {
-    const dir = stack.pop();
-    if (dir === void 0) {
-      continue;
-    }
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      const abs = join8(dir, entry.name);
-      if (entry.isDirectory()) {
-        stack.push(abs);
-      } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        mdFiles.push(abs);
+  const found = [];
+  const knowledgeDir = join5(projectRoot, ".fabric", "knowledge");
+  if (existsSync4(knowledgeDir)) {
+    const stack = [knowledgeDir];
+    while (stack.length > 0) {
+      const dir = stack.pop();
+      if (dir === void 0) {
+        continue;
+      }
+      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const abs = join5(dir, entry.name);
+        if (entry.isDirectory()) {
+          stack.push(abs);
+        } else if (entry.isFile() && entry.name.endsWith(".md")) {
+          let source;
+          try {
+            source = await readFile5(abs, "utf8");
+          } catch {
+            continue;
+          }
+          const id = extractKnowledgeFrontmatterId(source);
+          if (id === null) {
+            continue;
+          }
+          const relPath = posix.join(".fabric/knowledge", abs.slice(knowledgeDir.length + 1).replace(/\\/gu, "/"));
+          found.push({ stableId: id, relPath });
+        }
       }
     }
   }
   const stableIdToFiles = /* @__PURE__ */ new Map();
-  const DECLARED_ID_PATTERN = /^(?:\uFEFF)?(?:---\r?\n[\s\S]*?\r?\n---\s*(?:\r?\n|$))?<!--\s*fab:rule-id\s+([A-Za-z0-9][A-Za-z0-9/_-]*)\s*-->\s*(?:\r?\n|$)/u;
-  for (const absPath of mdFiles) {
-    let source;
-    try {
-      source = await readFile7(absPath, "utf8");
-    } catch {
-      continue;
-    }
-    const match = DECLARED_ID_PATTERN.exec(source);
-    if (match === null) {
-      continue;
-    }
-    const stableId = match[1];
-    const relPath = posix2.join(".fabric/rules", absPath.slice(rulesDir.length + 1).replace(/\\/gu, "/"));
+  for (const { stableId, relPath } of found) {
     const existing = stableIdToFiles.get(stableId) ?? [];
     existing.push(relPath);
     stableIdToFiles.set(stableId, existing);
@@ -2555,6 +1946,85 @@ async function inspectStableIdCollisions(projectRoot) {
   }
   return { collisions: collisions.sort((a, b) => a.stable_id.localeCompare(b.stable_id)) };
 }
+function extractKnowledgeFrontmatterId(source) {
+  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 ID_LINE = /^id:\s*("?)(K[PT]-(?:MOD|DEC|GLD|PIT|PRO)-\d{4,})\1\s*$/mu;
+  const idMatch = ID_LINE.exec(block);
+  return idMatch === null ? null : idMatch[2];
+}
+function inspectCounterDesync(meta) {
+  if (!meta.valid || meta.meta === null) {
+    return { desyncs: [], correctedCounters: null };
+  }
+  const current = 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 node of Object.values(meta.meta.nodes)) {
+    const id = node.stable_id;
+    if (id === void 0) {
+      continue;
+    }
+    const parsed = parseKnowledgeId2(id);
+    if (parsed === null) {
+      continue;
+    }
+    const layer = parsed.layer === "personal" ? "KP" : "KT";
+    const typeCode = [
+      ["model", "MOD"],
+      ["decision", "DEC"],
+      ["guideline", "GLD"],
+      ["pitfall", "PIT"],
+      ["process", "PRO"]
+    ].find(([t]) => t === parsed.type)?.[1];
+    if (typeCode === void 0) {
+      continue;
+    }
+    if (parsed.counter > observed[layer][typeCode]) {
+      observed[layer][typeCode] = parsed.counter;
+    }
+  }
+  const desyncs = [];
+  const corrected = {
+    KP: { ...current.KP },
+    KT: { ...current.KT }
+  };
+  for (const layer of ["KP", "KT"]) {
+    for (const code of COUNTER_TYPE_CODES) {
+      const obs = observed[layer][code];
+      const cur = current[layer][code];
+      if (obs > cur) {
+        desyncs.push({ layer, type: code, observed: obs, current: cur });
+        corrected[layer][code] = obs;
+      }
+    }
+  }
+  return {
+    desyncs,
+    correctedCounters: desyncs.length === 0 ? null : corrected
+  };
+}
+function createCounterDesyncCheck(inspection) {
+  if (inspection.desyncs.length > 0) {
+    const first = inspection.desyncs[0];
+    const detail = `counters.${first.layer}.${first.type} = ${first.current} but observed K${first.layer === "KP" ? "P" : "T"}-${first.type}-${String(first.observed).padStart(4, "0")}`;
+    return issueCheck(
+      "Knowledge counter desync",
+      "error",
+      "fixable_error",
+      "counter_desync",
+      `${inspection.desyncs.length} knowledge counter${inspection.desyncs.length === 1 ? "" : "s"} desynced from observed stable_ids. ${detail}. Run \`fab doctor --fix\` to bump counters.`,
+      "Run `fab doctor --fix` to bump agents.meta.json counters to the maximum observed counter value."
+    );
+  }
+  return okCheck("Knowledge counter desync", "agents.meta.json counters envelope is consistent with observed stable_ids.");
+}
 function createStableIdCollisionCheck(inspection) {
   if (inspection.collisions.length > 0) {
     const first = inspection.collisions[0];
@@ -2564,11 +2034,11 @@ function createStableIdCollisionCheck(inspection) {
       "warn",
       "warning",
       "stable_id_collision",
-      `${detail} Edit one of the rule files to use a unique stable_id.`,
-      "Edit one of the colliding rule files to declare a different `<!-- fab:rule-id X -->` value."
+      `${detail} Edit one of the knowledge files to use a unique stable_id.`,
+      "Edit one of the colliding knowledge files to declare a different `id: K[PT]-XXX-NNNN` frontmatter value."
     );
   }
-  return okCheck("Stable ID collision", "No declared stable_id collisions found in .fabric/rules/.");
+  return okCheck("Stable ID collision", "No declared stable_id collisions found in .fabric/knowledge/.");
 }
 function createMetaManuallyDivergedCheck(inspection) {
   if (!inspection.readable) {
@@ -2598,7 +2068,7 @@ function createMetaManuallyDivergedCheck(inspection) {
 }
 function inspectPreexistingRootFiles(projectRoot) {
   const candidates = ["CLAUDE.md", "AGENTS.md"];
-  const detected = candidates.filter((name) => existsSync4(join8(projectRoot, name)));
+  const detected = candidates.filter((name) => existsSync4(join5(projectRoot, name)));
   return { detected };
 }
 function createPreexistingRootFilesCheck(inspection) {
@@ -2612,380 +2082,463 @@ function createPreexistingRootFilesCheck(inspection) {
     code: "preexisting_root_claude_md",
     fixable: false,
     message: `${inspection.detected.join(", ")} detected at project root. These root files are not auto-loaded by Fabric MCP.`,
-    actionHint: "Move rule content to `.fabric/rules/` if you want it available in MCP responses."
+    actionHint: "Move knowledge content to `.fabric/knowledge/{type}/` if you want it available in MCP responses."
   };
 }
-function inspectClaudeSkillLegacyPath(projectRoot) {
-  const legacyPath = join8(projectRoot, ".claude", "skills", "agents-md-init", "SKILL.md");
-  const newPath = join8(projectRoot, ".claude", "skills", "fabric-init", "SKILL.md");
-  const hasLegacy = existsSync4(legacyPath) && !existsSync4(newPath);
-  return { hasLegacy, legacyPath, newPath };
-}
-function createClaudeSkillLegacyPathCheck(inspection) {
-  if (inspection.hasLegacy) {
-    return issueCheck(
-      "Claude skill path",
-      "error",
-      "fixable_error",
-      "claude_skill_legacy_path",
-      `.claude/skills/agents-md-init/SKILL.md exists at the legacy path. Run --fix to migrate it to .claude/skills/fabric-init/SKILL.md (user edits preserved).`,
-      "Run `fab doctor --fix` to rename agents-md-init/ to fabric-init/, preserving any user edits to SKILL.md."
-    );
-  }
-  return okCheck("Claude skill path", ".claude/skills/fabric-init/SKILL.md is at the canonical path (or not present).");
-}
-async function fixClaudeSkillLegacyPath(projectRoot) {
-  const legacyPath = join8(projectRoot, ".claude", "skills", "agents-md-init", "SKILL.md");
-  const newPath = join8(projectRoot, ".claude", "skills", "fabric-init", "SKILL.md");
-  if (!existsSync4(legacyPath)) {
-    return;
-  }
-  mkdirSync(join8(newPath, ".."), { recursive: true });
-  renameSync(legacyPath, newPath);
-  const legacyDir = join8(legacyPath, "..");
-  try {
-    rmdirSync(legacyDir);
-  } catch {
-  }
-  await appendEventLedgerEvent(projectRoot, {
-    event_type: "claude_skill_path_migrated",
-    from: legacyPath,
-    to: newPath
-  });
-}
-var LEGACY_HOOK_FILENAME = "agents-md-init-reminder.cjs";
-var NEW_HOOK_FILENAME = "fabric-init-reminder.cjs";
-function inspectClaudeHookLegacyPath(projectRoot) {
-  const legacyHookPath = join8(projectRoot, ".claude", "hooks", LEGACY_HOOK_FILENAME);
-  const newHookPath = join8(projectRoot, ".claude", "hooks", NEW_HOOK_FILENAME);
-  const settingsPath = join8(projectRoot, ".claude", "settings.json");
-  const hasLegacyFile = existsSync4(legacyHookPath);
-  let hasLegacySettingsCommand = false;
-  if (existsSync4(settingsPath)) {
-    try {
-      const raw = readFileSync(settingsPath, "utf8");
-      hasLegacySettingsCommand = raw.includes(LEGACY_HOOK_FILENAME);
-    } catch {
-    }
-  }
-  return { hasLegacyFile, hasLegacySettingsCommand, legacyHookPath, newHookPath, settingsPath };
-}
-function createClaudeHookLegacyPathCheck(inspection) {
-  if (inspection.hasLegacyFile || inspection.hasLegacySettingsCommand) {
-    return issueCheck(
-      "Claude hook path",
-      "error",
-      "fixable_error",
-      "claude_hook_legacy_path",
-      `.claude/hooks/${LEGACY_HOOK_FILENAME} (or its reference in .claude/settings.json) exists at the legacy path. Run --fix to migrate to ${NEW_HOOK_FILENAME}.`,
-      `Run \`fab doctor --fix\` to rename ${LEGACY_HOOK_FILENAME} to ${NEW_HOOK_FILENAME} and update .claude/settings.json hook commands.`
-    );
+async function fixMcpConfigInWrongFile(projectRoot) {
+  const settingsPath = join5(projectRoot, ".claude", "settings.json");
+  if (!existsSync4(settingsPath)) {
+    return;
   }
-  return okCheck("Claude hook path", `.claude/hooks/${NEW_HOOK_FILENAME} is at the canonical path (or not present).`);
-}
-async function fixClaudeHookLegacyPath(projectRoot) {
-  const { hasLegacyFile, hasLegacySettingsCommand, legacyHookPath, newHookPath, settingsPath } = inspectClaudeHookLegacyPath(projectRoot);
-  if (hasLegacyFile) {
-    if (existsSync4(newHookPath)) {
-      unlinkSync(legacyHookPath);
-    } else {
-      mkdirSync(join8(newHookPath, ".."), { recursive: true });
-      renameSync(legacyHookPath, newHookPath);
+  let settings;
+  try {
+    const parsed = JSON.parse(readFileSync(settingsPath, "utf8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return;
     }
+    settings = parsed;
+  } catch {
+    return;
   }
-  if (hasLegacySettingsCommand) {
-    try {
-      const raw = readFileSync(settingsPath, "utf8");
-      const updated = raw.split(LEGACY_HOOK_FILENAME).join(NEW_HOOK_FILENAME);
-      if (updated !== raw) {
-        const parsed = JSON.parse(updated);
-        await atomicWriteJson2(settingsPath, parsed);
-      }
-    } catch {
-    }
+  const mcpServers = settings.mcpServers;
+  if (mcpServers === null || typeof mcpServers !== "object" || Array.isArray(mcpServers)) {
+    return;
   }
-  if (hasLegacyFile || hasLegacySettingsCommand) {
-    await appendEventLedgerEvent(projectRoot, {
-      event_type: "claude_hook_path_migrated",
-      from: legacyHookPath,
-      to: newHookPath
-    });
+  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"
+  });
 }
-function inspectCodexSkillLegacyPath(projectRoot) {
-  const legacyPath = join8(projectRoot, ".agents", "skills", "fabric-init", "SKILL.md");
-  const newPath = join8(projectRoot, ".codex", "skills", "fabric-init", "SKILL.md");
-  const hasLegacy = existsSync4(legacyPath) && !existsSync4(newPath);
-  return { hasLegacy, legacyPath, newPath };
-}
-function createCodexSkillLegacyPathCheck(inspection) {
-  if (inspection.hasLegacy) {
-    return issueCheck(
-      "Codex skill path",
-      "error",
-      "fixable_error",
-      "codex_skill_legacy_path",
-      `.agents/skills/fabric-init/SKILL.md exists at the legacy path. Codex CLI reads repo skills from .codex/skills/, not .agents/skills/. Run --fix to migrate it to .codex/skills/fabric-init/SKILL.md (user edits preserved).`,
-      "Run `fab doctor --fix` to move .agents/skills/fabric-init/ to .codex/skills/fabric-init/, preserving any user edits to SKILL.md."
-    );
+async function ensureKnowledgeSubdirs(projectRoot) {
+  for (const sub of KNOWLEDGE_SUBDIRS2) {
+    await mkdir3(join5(projectRoot, ".fabric", "knowledge", sub), { recursive: true });
   }
-  return okCheck("Codex skill path", ".codex/skills/fabric-init/SKILL.md is at the canonical path (or not present).");
 }
-async function fixCodexSkillLegacyPath(projectRoot) {
-  const { hasLegacy, legacyPath, newPath } = inspectCodexSkillLegacyPath(projectRoot);
-  if (!hasLegacy) {
+async function fixCounterDesync(projectRoot) {
+  const metaPath = join5(projectRoot, ".fabric", "agents.meta.json");
+  if (!existsSync4(metaPath)) {
     return;
   }
-  mkdirSync(join8(newPath, ".."), { recursive: true });
-  renameSync(legacyPath, newPath);
-  const legacyDir = join8(legacyPath, "..");
+  let meta;
   try {
-    rmdirSync(legacyDir);
+    meta = agentsMetaSchema4.parse(JSON.parse(await readFile5(metaPath, "utf8")));
   } catch {
+    return;
   }
-  try {
-    rmdirSync(join8(legacyDir, ".."));
-  } catch {
+  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) {
   try {
-    rmdirSync(join8(legacyDir, "..", ".."));
+    JSON.parse(line);
+    return true;
   } catch {
+    return false;
   }
-  await appendEventLedgerEvent(projectRoot, {
-    event_type: "codex_skill_path_migrated",
-    from: legacyPath,
-    to: newPath
-  });
 }
-function inspectLegacyClientPaths(projectRoot) {
-  const configPath = join8(projectRoot, "fabric.config.json");
-  if (!existsSync4(configPath)) {
-    return { presentKeys: [] };
+function normalizeTarget(targetInput) {
+  return isAbsolute2(targetInput) ? targetInput : resolve3(process.cwd(), targetInput);
+}
+function normalizePath(path) {
+  return posix.normalize(path.split("\\").join("/"));
+}
+function collectEntryPoints(root) {
+  if (!existsSync4(root) || !statSync3(root).isDirectory()) {
+    return [];
   }
-  try {
-    const parsed = JSON.parse(readFileSync(configPath, "utf8"));
-    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return { presentKeys: [] };
+  const entries = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === void 0) {
+      continue;
     }
-    const config = parsed;
-    const clientPaths = config.clientPaths;
-    if (clientPaths === null || typeof clientPaths !== "object" || Array.isArray(clientPaths)) {
-      return { presentKeys: [] };
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      const absolutePath = join5(current, entry.name);
+      const relativePath = normalizePath(absolutePath.slice(root.length + 1));
+      if (relativePath.length === 0) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        if (!IGNORED_DIRECTORIES.has(entry.name)) {
+          stack.push(absolutePath);
+        }
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      const reason = getEntryPointReason(relativePath);
+      if (reason !== null) {
+        entries.push({ path: relativePath, reason });
+      }
     }
-    const cp = clientPaths;
-    const presentKeys = LEGACY_CLIENT_PATH_KEYS.filter((key) => key in cp);
-    return { presentKeys };
-  } catch {
-    return { presentKeys: [] };
   }
+  return entries.sort((left, right) => left.path.localeCompare(right.path));
 }
-function createLegacyClientPathCheck(inspection) {
-  if (inspection.presentKeys.length > 0) {
-    return issueCheck(
-      "Legacy client paths",
-      "warn",
-      "warning",
-      "legacy_client_path_present",
-      `fabric.config.json contains deprecated clientPaths keys: ${inspection.presentKeys.join(", ")}. These clients are removed in 1.8.0; run --fix to clean now or accept the upcoming removal.`,
-      "Run `fab doctor --fix` to remove deprecated clientPaths keys (windsurf, rooCode, geminiCLI) from fabric.config.json."
-    );
+function getEntryPointReason(relativePath) {
+  const extension = relativePath.slice(relativePath.lastIndexOf("."));
+  if (!SCRIPT_EXTENSIONS.has(extension)) {
+    return null;
   }
-  return okCheck("Legacy client paths", "No deprecated clientPaths keys found in fabric.config.json.");
-}
-async function fixLegacyClientPaths(projectRoot) {
-  const configPath = join8(projectRoot, "fabric.config.json");
-  if (!existsSync4(configPath)) {
-    return;
+  const directory = posix.dirname(relativePath);
+  const fileName = posix.basename(relativePath);
+  const fileBase = fileName.slice(0, Math.max(fileName.lastIndexOf("."), 0));
+  if (directory === "assets/scripts" || directory === "scripts") {
+    return "top-level script";
   }
-  let config;
-  try {
-    const parsed = JSON.parse(readFileSync(configPath, "utf8"));
-    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return;
-    }
-    config = parsed;
-  } catch {
-    return;
+  if (directory === "src" && /^(App|app|index|main)$/.test(fileBase)) {
+    return "application entry";
   }
-  const clientPaths = config.clientPaths;
-  if (clientPaths === null || typeof clientPaths !== "object" || Array.isArray(clientPaths)) {
-    return;
+  if ((directory === "app" || directory.startsWith("app/")) && /^(layout|page|route)$/.test(fileBase)) {
+    return "next app route";
   }
-  const cp = clientPaths;
-  const removed = [];
-  for (const key of LEGACY_CLIENT_PATH_KEYS) {
-    if (key in cp) {
-      delete cp[key];
-      removed.push(key);
-    }
+  if ((directory === "pages" || directory.startsWith("pages/")) && fileName !== "_app.d.ts") {
+    return "next page route";
   }
-  if (removed.length === 0) {
-    return;
+  return null;
+}
+function reduceStatus(statuses) {
+  if (statuses.includes("error")) {
+    return "error";
   }
-  const updatedConfig = { ...config, clientPaths: cp };
-  await atomicWriteJson2(configPath, updatedConfig, { indent: 2 });
-  await appendEventLedgerEvent(projectRoot, {
-    event_type: "legacy_client_path_present",
-    removed
+  if (statuses.includes("warn")) {
+    return "warn";
+  }
+  return "ok";
+}
+function isMissingFileError(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+
+// src/services/get-rules.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 fixMcpConfigInWrongFile(projectRoot) {
-  const settingsPath = join8(projectRoot, ".claude", "settings.json");
-  if (!existsSync4(settingsPath)) {
-    return;
+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("/"));
   }
-  let settings;
+  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
+var PRIORITY_ORDER = {
+  high: 0,
+  medium: 1,
+  low: 2
+};
+async function getRules(projectRoot, input) {
+  const context = await loadGetRulesContext(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 result = {
+    revision_hash: context.meta.revision,
+    stale,
+    rules
+  };
   try {
-    const parsed = JSON.parse(readFileSync(settingsPath, "utf8"));
-    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return;
-    }
-    settings = parsed;
+    await appendGetRulesAuditEvent(projectRoot, {
+      path: input.path,
+      client_hash: input.client_hash,
+      required_stable_ids: requiredStableIds,
+      ai_selectable_stable_ids: aiSelectableStableIds,
+      final_stable_ids: [...requiredStableIds, ...aiSelectableStableIds],
+      correlation_id: input.correlation_id,
+      session_id: input.session_id
+    });
   } 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 result;
+}
+async function loadGetRulesContext(projectRoot) {
+  const cached = contextCache.get("context", projectRoot);
+  if (cached !== void 0) {
+    return cached;
   }
-  await atomicWriteJson2(settingsPath, cleaned, { indent: 2 });
-  await appendEventLedgerEvent(projectRoot, {
-    event_type: "mcp_config_migrated",
-    source: "doctor_fix",
-    removed_from: ".claude/settings.json"
-  });
+  const meta = await readAgentsMeta(projectRoot);
+  const l0Content = await readFile6(join7(projectRoot, ".fabric", "bootstrap", "README.md"), "utf8");
+  const context = {
+    meta,
+    l0Content,
+    humanLockedNearby: []
+  };
+  contextCache.set("context", projectRoot, context);
+  return context;
 }
-async function writeDefaultBootstrap(projectRoot) {
-  const path = join8(projectRoot, FABRIC_BOOTSTRAP_PATH);
-  await ensureParentDirectory(path);
-  await atomicWriteText3(path, buildBootstrapContent(projectRoot));
+async function resolveRulesForPath(projectRoot, context, path, options = {}) {
+  const matchedNodes = matchRuleNodes(context.meta, path);
+  const loaded = await loadMatchedRules(projectRoot, matchedNodes);
+  return buildRulesPayload(context, loaded, options);
 }
-async function ensureEventLedger(projectRoot) {
-  const path = getEventLedgerPath(projectRoot);
-  await ensureParentDirectory(path);
-  await writeFile2(path, "", { encoding: "utf8", flag: "a" });
+function normalizeRulesPath(value) {
+  return value.replaceAll("\\", "/");
 }
-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 matchRuleNodes(meta, path) {
+  const requestedPath = normalizeRulesPath(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];
+    return priorityDelta !== 0 ? priorityDelta : leftId.localeCompare(rightId);
+  }).map(([nodeId, node]) => ({
+    node_id: nodeId,
+    level: classifyNode(nodeId, node),
+    stable_id: node.stable_id ?? nodeId,
+    identity_source: node.identity_source ?? "derived",
+    node
+  }));
 }
-function findRuleFiles2(projectRoot) {
-  const rulesRoot = join8(projectRoot, ".fabric", "rules");
-  if (!existsSync4(rulesRoot) || !statSync3(rulesRoot).isDirectory()) {
-    return [];
-  }
-  const files = [];
-  const stack = [rulesRoot];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    if (current === void 0) {
+async function loadMatchedRules(projectRoot, matchedNodes, fileContentCache = /* @__PURE__ */ new Map()) {
+  const rules = [];
+  const stubs = [];
+  for (const matchedNode of matchedNodes) {
+    if (matchedNode.level === null) {
       continue;
     }
-    for (const entry of readdirSync(current, { withFileTypes: true })) {
-      const absolutePath = join8(current, entry.name);
-      const relativePath = normalizePath(absolutePath.slice(projectRoot.length + 1));
-      if (entry.isDirectory()) {
-        stack.push(absolutePath);
-      } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        files.push(relativePath);
-      }
+    if (matchedNode.node.activation?.tier === "description") {
+      stubs.push({
+        stable_id: matchedNode.stable_id,
+        identity_source: matchedNode.identity_source,
+        level: matchedNode.level,
+        path: matchedNode.node.file,
+        description: matchedNode.node.activation.description ?? ""
+      });
+      continue;
     }
+    rules.push({
+      level: matchedNode.level,
+      stable_id: matchedNode.stable_id,
+      identity_source: matchedNode.identity_source,
+      entry: {
+        path: matchedNode.node.file,
+        content: await readRuleContent(projectRoot, matchedNode.node.file, fileContentCache)
+      }
+    });
   }
-  return files.sort();
-}
-function isValidJsonLine(line) {
-  try {
-    JSON.parse(line);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function normalizeTarget(targetInput) {
-  return isAbsolute3(targetInput) ? targetInput : resolve4(process.cwd(), targetInput);
+  return { rules, stubs };
 }
-function normalizePath(path) {
-  return posix2.normalize(path.split("\\").join("/"));
+function buildRulesPayload(context, loaded, options = {}) {
+  const { L1, L2 } = partitionRulesByLevel(loaded.rules, options.dedupeByPath ?? false);
+  return {
+    L0: context.l0Content,
+    L1,
+    L2,
+    human_locked_nearby: context.humanLockedNearby,
+    description_stubs: loaded.stubs.length > 0 ? dedupeDescriptionStubsByPath(loaded.stubs).map(toDescriptionStub) : void 0
+  };
 }
-function collectEntryPoints(root) {
-  if (!existsSync4(root) || !statSync3(root).isDirectory()) {
-    return [];
+function classifyNode(nodeId, node) {
+  if (nodeId.startsWith("L1/")) {
+    return "L1";
   }
-  const entries = [];
-  const stack = [root];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    if (current === void 0) {
+  if (nodeId.startsWith("L2/")) {
+    return "L2";
+  }
+  return node.layer === "L0" ? null : node.layer;
+}
+function partitionRulesByLevel(loadedRules, dedupeByPath) {
+  const l1 = [];
+  const l2 = [];
+  for (const rule of loadedRules) {
+    if (rule.level === "L1") {
+      l1.push(rule.entry);
       continue;
     }
-    for (const entry of readdirSync(current, { withFileTypes: true })) {
-      const absolutePath = join8(current, entry.name);
-      const relativePath = normalizePath(absolutePath.slice(root.length + 1));
-      if (relativePath.length === 0) {
-        continue;
-      }
-      if (entry.isDirectory()) {
-        if (!IGNORED_DIRECTORIES.has(entry.name)) {
-          stack.push(absolutePath);
-        }
-        continue;
-      }
-      if (!entry.isFile()) {
-        continue;
-      }
-      const reason = getEntryPointReason(relativePath);
-      if (reason !== null) {
-        entries.push({ path: relativePath, reason });
-      }
+    if (rule.level === "L2") {
+      l2.push(rule.entry);
     }
   }
-  return entries.sort((left, right) => left.path.localeCompare(right.path));
+  return {
+    L1: dedupeByPath ? dedupeEntriesByPath(l1) : l1,
+    L2: dedupeByPath ? dedupeEntriesByPath(l2) : l2
+  };
 }
-function getEntryPointReason(relativePath) {
-  const extension = relativePath.slice(relativePath.lastIndexOf("."));
-  if (!SCRIPT_EXTENSIONS.has(extension)) {
-    return null;
-  }
-  const directory = posix2.dirname(relativePath);
-  const fileName = posix2.basename(relativePath);
-  const fileBase = fileName.slice(0, Math.max(fileName.lastIndexOf("."), 0));
-  if (directory === "assets/scripts" || directory === "scripts") {
-    return "top-level script";
-  }
-  if (directory === "src" && /^(App|app|index|main)$/.test(fileBase)) {
-    return "application entry";
-  }
-  if ((directory === "app" || directory.startsWith("app/")) && /^(layout|page|route)$/.test(fileBase)) {
-    return "next app route";
-  }
-  if ((directory === "pages" || directory.startsWith("pages/")) && fileName !== "_app.d.ts") {
-    return "next page route";
-  }
-  return null;
+function dedupeEntriesByPath(entries) {
+  const seenPaths = /* @__PURE__ */ new Set();
+  return entries.filter((entry) => {
+    if (seenPaths.has(entry.path)) {
+      return false;
+    }
+    seenPaths.add(entry.path);
+    return true;
+  });
 }
-function reduceStatus(statuses) {
-  if (statuses.includes("error")) {
-    return "error";
-  }
-  if (statuses.includes("warn")) {
-    return "warn";
+function shouldLoadNodeForPath(requestedPath, node) {
+  switch (node.activation?.tier) {
+    case "always":
+      return true;
+    case "description":
+      return true;
+    case "path":
+    case void 0:
+      return minimatch(requestedPath, normalizeRulesPath(node.scope_glob), { dot: true });
   }
-  return "ok";
 }
-function isMissingFileError(error) {
-  return error instanceof Error && "code" in error && error.code === "ENOENT";
+function dedupeDescriptionStubsByPath(stubs) {
+  const seenPaths = /* @__PURE__ */ new Set();
+  return stubs.filter((stub) => {
+    if (seenPaths.has(stub.path)) {
+      return false;
+    }
+    seenPaths.add(stub.path);
+    return true;
+  });
+}
+function toDescriptionStub(stub) {
+  return {
+    path: stub.path,
+    description: stub.description
+  };
+}
+async function readRuleContent(projectRoot, file, fileContentCache) {
+  const cached = fileContentCache.get(file);
+  if (cached !== void 0) {
+    return await cached;
+  }
+  const pending = readFile6(join7(projectRoot, file), "utf8");
+  fileContentCache.set(file, pending);
+  return await pending;
 }
 
 export {
-  AGENTS_MD_RESOURCE_URI,
   contextCache,
   resolveProjectRoot,
   readAgentsMeta,
@@ -3011,9 +2564,9 @@ export {
   invalidateRuleSyncCooldown,
   ensureRulesFresh,
   reconcileRules,
+  appendRuleSelectionAuditEvent,
   getRules,
-  planContext,
-  getRuleSections,
+  normalizeRulesPath,
   runDoctorReport,
   runDoctorFix
 };