@fenglimg/fabric-server 1.5.1 → 1.6.0

package/dist/index.js

@@ -1,27 +1,30 @@
 import {
   AGENTS_MD_RESOURCE_URI,
   FABRIC_DIR,
+  LEDGER_PATH,
+  LEGACY_LEDGER_PATH,
   appendEditIntentAuditEvents,
   appendLedgerEntry,
+  appendRuleSelectionAuditEvent,
   approveHumanLock,
   atomicWriteText,
   contextCache,
-  getRules,
-  loadGetRulesContext,
+  getLedgerPath,
+  getLegacyLedgerPath,
   normalizeRulesPath,
   readAgentsMeta,
   readHumanLock,
   readHumanLockEntry,
   resolveProjectRoot,
-  resolveRulesForPath,
   runDoctorAuditReport,
+  runDoctorFix,
   runDoctorReport,
   sha256
-} from "./chunk-E3RZ276F.js";
+} from "./chunk-TZCE2K4D.js";
 
 // src/index.ts
-import { readFile } from "fs/promises";
-import { join as join2, resolve } from "path";
+import { readFile as readFile2 } from "fs/promises";
+import { join as join3, resolve } from "path";
 import { fileURLToPath } from "url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -101,38 +104,295 @@ function registerAppendIntent(server) {
   );
 }
 
-// src/tools/get-rules.ts
+// src/tools/plan-context.ts
 import { z as z2 } from "zod";
+
+// 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);
+  return {
+    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)
+    }
+  };
+}
+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/tools/plan-context.ts
 var inputSchema2 = {
-  path: z2.string().describe("Target file path to query rules for"),
-  client_hash: z2.string().optional().describe("Revision hash from prior fab_get_rules response; enables stale detection")
+  paths: z2.array(z2.string()).min(1).describe("Candidate file paths to build neutral rule selection context for"),
+  intent: z2.string().optional().describe("User-stated requirement or implementation intent; used only to build a neutral requirement profile"),
+  known_tech: z2.array(z2.string()).optional().describe("Known technologies involved in the requirement profile"),
+  detected_entities: z2.record(z2.array(z2.string())).optional().describe("Optional path-keyed detected entities for the requirement profile"),
+  client_hash: z2.string().optional().describe("Revision hash from a prior fab_plan_context response; enables stale detection")
 };
-var rulesEntrySchema = z2.object({ path: z2.string(), content: z2.string() });
-var humanLockedSchema = z2.object({ file: z2.string(), excerpt: z2.string() });
-var descriptionStubSchema = z2.object({ path: z2.string(), description: z2.string() });
+var ruleDescriptionSchema = z2.object({
+  summary: z2.string(),
+  intent_clues: z2.array(z2.string()),
+  tech_stack: z2.array(z2.string()),
+  impact: z2.array(z2.string()),
+  must_read_if: z2.string(),
+  entities: z2.array(z2.string()).optional()
+});
+var descriptionIndexItemSchema = z2.object({
+  stable_id: z2.string(),
+  level: z2.enum(["L0", "L1", "L2"]),
+  required: z2.boolean(),
+  selectable: z2.boolean(),
+  description: ruleDescriptionSchema
+});
+var requirementProfileSchema = z2.object({
+  target_path: z2.string(),
+  path_segments: z2.array(z2.string()),
+  extension: z2.string(),
+  inferred_domain: z2.array(z2.string()),
+  known_tech: z2.array(z2.string()),
+  user_intent: z2.string(),
+  intent_tokens: z2.array(z2.string()),
+  impact_hints: z2.array(z2.string()),
+  detected_entities: z2.array(z2.string())
+});
+var selectionPolicySchema = z2.object({
+  required_levels: z2.tuple([z2.literal("L0"), z2.literal("L2")]),
+  ai_selectable_levels: z2.tuple([z2.literal("L1")]),
+  final_fetch_rule: z2.literal("required_stable_ids + ai_selected_l1_stable_ids")
+});
 var outputSchema2 = z2.object({
   revision_hash: z2.string(),
   stale: z2.boolean(),
-  rules: z2.object({
-    L0: z2.string(),
-    L1: z2.array(rulesEntrySchema),
-    L2: z2.array(rulesEntrySchema),
-    human_locked_nearby: z2.array(humanLockedSchema),
-    description_stubs: z2.array(descriptionStubSchema).optional()
+  selection_token: z2.string(),
+  entries: z2.array(
+    z2.object({
+      path: z2.string(),
+      requirement_profile: requirementProfileSchema,
+      description_index: z2.array(descriptionIndexItemSchema),
+      required_stable_ids: z2.array(z2.string()),
+      ai_selectable_stable_ids: z2.array(z2.string()),
+      initial_selected_stable_ids: z2.array(z2.string()),
+      selection_policy: selectionPolicySchema
+    })
+  ),
+  shared: z2.object({
+    required_stable_ids: z2.array(z2.string()),
+    ai_selectable_stable_ids: z2.array(z2.string()),
+    description_index: z2.array(descriptionIndexItemSchema),
+    preflight_diagnostics: z2.array(
+      z2.object({
+        code: z2.literal("missing_description"),
+        severity: z2.literal("warn"),
+        message: z2.string(),
+        stable_ids: z2.array(z2.string()).optional(),
+        path: z2.string().optional()
+      })
+    )
   })
 });
-function registerGetRules(server) {
+function registerPlanContext(server) {
   server.registerTool(
-    "fab_get_rules",
+    "fab_plan_context",
     {
-      description: "Call before modifying any file to retrieve Fabric rules for a target path.",
+      description: "Use during plan or architecture phases to build a neutral Fabric rule description index and selection token before fetching rule sections.",
       inputSchema: inputSchema2,
       outputSchema: outputSchema2,
       annotations: { readOnlyHint: true }
     },
-    async ({ path, client_hash }) => {
+    async ({ paths, intent, known_tech, detected_entities, client_hash }) => {
       const projectRoot = resolveProjectRoot();
-      const result = await getRules(projectRoot, { path, client_hash });
+      const result = await planContext(projectRoot, { paths, intent, known_tech, detected_entities, client_hash });
       return {
         content: [{ type: "text", text: JSON.stringify(result) }],
         structuredContent: result
@@ -141,73 +401,214 @@ function registerGetRules(server) {
   );
 }
 
-// src/tools/plan-context.ts
+// src/tools/rule-sections.ts
 import { z as z3 } from "zod";
 
-// src/services/plan-context.ts
-async function planContext(projectRoot, input) {
-  const context = await loadGetRulesContext(projectRoot);
-  const stale = input.client_hash !== void 0 && input.client_hash !== context.meta.revision;
-  const uniquePaths = dedupePaths(input.paths);
-  const entries = await Promise.all(
-    uniquePaths.map(async (path) => ({
-      path,
-      rules: await resolveRulesForPath(projectRoot, context, path, { dedupeByPath: true })
-    }))
+// src/services/rule-sections.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+var RULE_SECTION_NAMES = ["MANDATORY_INJECTION", "CONTEXT_INFO"];
+var PRIORITY_ORDER = {
+  high: 0,
+  medium: 1,
+  low: 2
+};
+function parseRuleSections(content) {
+  const sections = /* @__PURE__ */ new Map();
+  const lines = content.split(/\r?\n/u);
+  let activeSection;
+  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;
+      continue;
+    }
+    if (/^#{1,6}\s+/u.test(line)) {
+      flush();
+      activeSection = void 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")])
   );
-  return {
-    revision_hash: context.meta.revision,
-    stale,
-    entries
+}
+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 readFile(join(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: []
+  });
+  return result;
 }
-function dedupePaths(paths) {
-  const seenPaths = /* @__PURE__ */ new Set();
-  return paths.flatMap((path) => {
-    const normalizedPath = normalizeRulesPath(path);
-    if (seenPaths.has(normalizedPath)) {
-      return [];
+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}`);
     }
-    seenPaths.add(normalizedPath);
-    return [normalizedPath];
+    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_ORDER[left.priority] - PRIORITY_ORDER[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/tools/plan-context.ts
+// src/tools/rule-sections.ts
 var inputSchema3 = {
-  paths: z3.array(z3.string()).min(2).describe("Candidate file paths to query rules for during planning or architecture review"),
-  client_hash: z3.string().optional().describe("Revision hash from a prior fab_plan_context response; enables stale detection")
+  selection_token: z3.string().min(1).describe("Selection token returned by fab_plan_context"),
+  sections: z3.array(z3.enum(RULE_SECTION_NAMES)).min(1).describe("Structured rule sections to fetch"),
+  ai_selected_stable_ids: z3.array(z3.string()).describe("AI-selected L1 stable_ids chosen from fab_plan_context ai_selectable_stable_ids"),
+  ai_selection_reasons: z3.record(z3.string().min(1)).describe("Reason for each AI-selected L1 stable_id")
 };
-var rulesEntrySchema2 = z3.object({ path: z3.string(), content: z3.string() });
-var humanLockedSchema2 = z3.object({ file: z3.string(), excerpt: z3.string() });
-var rulesPayloadSchema = z3.object({
-  L0: z3.string(),
-  L1: z3.array(rulesEntrySchema2),
-  L2: z3.array(rulesEntrySchema2),
-  human_locked_nearby: z3.array(humanLockedSchema2)
-});
 var outputSchema3 = z3.object({
   revision_hash: z3.string(),
-  stale: z3.boolean(),
-  entries: z3.array(
+  precedence: z3.tuple([z3.literal("L2"), z3.literal("L1"), z3.literal("L0")]),
+  selected_stable_ids: z3.array(z3.string()),
+  rules: z3.array(
     z3.object({
+      stable_id: z3.string(),
+      level: z3.enum(["L0", "L1", "L2"]),
       path: z3.string(),
-      rules: rulesPayloadSchema
+      sections: z3.record(z3.string())
+    })
+  ),
+  diagnostics: z3.array(
+    z3.object({
+      code: z3.literal("missing_section"),
+      severity: z3.literal("warn"),
+      stable_id: z3.string(),
+      section: z3.enum(RULE_SECTION_NAMES),
+      message: z3.string()
     })
   )
 });
-function registerPlanContext(server) {
+function registerRuleSections(server) {
   server.registerTool(
-    "fab_plan_context",
+    "fab_get_rule_sections",
     {
-      description: "Use during plan or architecture phases to batch-query Fabric rules for multiple candidate paths in one round-trip. Use fab_get_rules for single-file queries; use fab_plan_context for 2+ files.",
+      description: "Fetch structured Fabric rule sections after fab_plan_context. Required L0/L2 rules are merged with AI-selected L1 rules server-side.",
       inputSchema: inputSchema3,
       outputSchema: outputSchema3,
       annotations: { readOnlyHint: true }
     },
-    async ({ paths, client_hash }) => {
+    async (input) => {
       const projectRoot = resolveProjectRoot();
-      const result = await planContext(projectRoot, { paths, client_hash });
+      const result = await getRuleSections(projectRoot, input);
       return {
         content: [{ type: "text", text: JSON.stringify(result) }],
         structuredContent: result
@@ -222,9 +623,9 @@ import { z as z4 } from "zod";
 
 // src/services/update-registry.ts
 import { agentsMetaNodeSchema } from "@fenglimg/fabric-shared";
-import { join } from "path";
+import { join as join2 } from "path";
 async function updateRegistry(projectRoot, input) {
-  const metaPath = join(projectRoot, FABRIC_DIR, "agents.meta.json");
+  const metaPath = join2(projectRoot, FABRIC_DIR, "agents.meta.json");
   const currentMeta = await readAgentsMeta(projectRoot);
   const nextMeta = applyRegistryOperation(currentMeta, input.op, input.node_id, input.data);
   const newRevision = computeRevision(nextMeta);
@@ -339,10 +740,10 @@ function formatError(error) {
 function createFabricServer() {
   const server = new McpServer({
     name: "fabric-context-server",
-    version: "1.5.1"
+    version: "1.6.0"
   });
-  registerGetRules(server);
   registerPlanContext(server);
+  registerRuleSections(server);
   registerAppendIntent(server);
   registerUpdateRegistry(server);
   server.registerResource(
@@ -354,7 +755,7 @@ function createFabricServer() {
     },
     async (_uri) => {
       const projectRoot = process.env.FABRIC_PROJECT_ROOT ?? process.cwd();
-      const content = await readFile(join2(projectRoot, ".fabric", "bootstrap", "README.md"), "utf8");
+      const content = await readFile2(join3(projectRoot, ".fabric", "bootstrap", "README.md"), "utf8");
       return {
         contents: [
           {
@@ -374,7 +775,7 @@ async function startStdioServer() {
   await server.connect(transport);
 }
 async function startHttpServer(options) {
-  const { createFabricHttpApp } = await import("./http-BVF4GWIM.js");
+  const { createFabricHttpApp } = await import("./http-DJCTLGF4.js");
   const { port, projectRoot, host = "127.0.0.1", authToken, dashboardDistPath, dev } = options;
   const app = createFabricHttpApp({ projectRoot, host, authToken, dashboardDistPath, dev });
   return await new Promise((resolveServer, rejectServer) => {
@@ -401,11 +802,16 @@ if (isMainModule) {
 }
 export {
   AGENTS_MD_RESOURCE_URI,
+  LEDGER_PATH,
+  LEGACY_LEDGER_PATH,
   approveHumanLock,
   createFabricServer,
+  getLedgerPath,
+  getLegacyLedgerPath,
   readHumanLock,
   readHumanLockEntry,
   runDoctorAuditReport,
+  runDoctorFix,
   runDoctorReport,
   startHttpServer,
   startStdioServer