@fenglimg/fabric-server 1.6.0 → 1.7.0

package/dist/index.js

@@ -1,382 +1,102 @@
 import {
   AGENTS_MD_RESOURCE_URI,
-  FABRIC_DIR,
+  EVENT_LEDGER_PATH,
   LEDGER_PATH,
   LEGACY_LEDGER_PATH,
-  appendEditIntentAuditEvents,
-  appendLedgerEntry,
-  appendRuleSelectionAuditEvent,
-  approveHumanLock,
-  atomicWriteText,
-  contextCache,
+  RULE_SECTION_NAMES,
+  buildRuleMeta,
+  computeRuleTestIndex,
+  computeRulesBasedAgentsMeta,
+  deriveRuleMetaLayer,
+  deriveRuleMetaTopologyType,
+  getEventLedgerPath,
   getLedgerPath,
   getLegacyLedgerPath,
-  normalizeRulesPath,
-  readAgentsMeta,
-  readHumanLock,
-  readHumanLockEntry,
+  getRuleSections,
+  isSameRuleTestIndex,
+  planContext,
   resolveProjectRoot,
-  runDoctorAuditReport,
   runDoctorFix,
   runDoctorReport,
-  sha256
-} from "./chunk-TZCE2K4D.js";
+  stableStringify,
+  writeRuleMeta
+} from "./chunk-PTFSYO4Y.js";
 
 // src/index.ts
-import { readFile as readFile2 } from "fs/promises";
-import { join as join3, resolve } from "path";
+import { readFile } from "fs/promises";
+import { join, resolve } from "path";
 import { fileURLToPath } from "url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
-// src/tools/append-intent.ts
-import { aiLedgerEntrySchema } from "@fenglimg/fabric-shared";
+// src/tools/plan-context.ts
 import { z } from "zod";
-
-// src/services/append-intent.ts
-async function appendIntent(projectRoot, input) {
-  const ts = Date.now();
-  const entry = await appendLedgerEntry(projectRoot, {
-    ...input.entry,
-    ts,
-    source: "ai"
-  });
-  let compliance;
-  try {
-    const auditResult = await appendEditIntentAuditEvents(projectRoot, {
-      affected_paths: entry.affected_paths,
-      intent: entry.intent,
-      ledger_entry_id: entry.id,
-      ts
-    });
-    compliance = auditResult.compliance;
-  } catch {
-  }
-  return {
-    success: true,
-    timestamp: ts,
-    entry,
-    compliance
-  };
-}
-
-// src/tools/append-intent.ts
 var inputSchema = {
-  entry: aiLedgerEntrySchema.omit({
-    id: true,
-    source: true,
-    ts: true
-  })
+  paths: z.array(z.string()).min(1).describe("Candidate file paths to build neutral rule selection context for"),
+  intent: z.string().optional().describe("User-stated requirement or implementation intent; used only to build a neutral requirement profile"),
+  known_tech: z.array(z.string()).optional().describe("Known technologies involved in the requirement profile"),
+  detected_entities: z.record(z.array(z.string())).optional().describe("Optional path-keyed detected entities for the requirement profile"),
+  client_hash: z.string().optional().describe("Revision hash from a prior fab_plan_context response; enables stale detection"),
+  correlation_id: z.string().optional().describe("Optional caller-provided correlation id for Event Ledger records"),
+  session_id: z.string().optional().describe("Optional caller-provided session id for Event Ledger records")
 };
-var outputSchema = z.object({
-  success: z.boolean(),
-  timestamp: z.number(),
-  entry: z.record(z.unknown()),
-  compliance: z.object({
-    compliant: z.boolean(),
-    matched_get_rules_ts: z.string().nullable(),
-    window_ms: z.number()
-  }).optional()
+var ruleDescriptionSchema = z.object({
+  summary: z.string(),
+  intent_clues: z.array(z.string()),
+  tech_stack: z.array(z.string()),
+  impact: z.array(z.string()),
+  must_read_if: z.string(),
+  entities: z.array(z.string()).optional()
 });
-function registerAppendIntent(server) {
-  server.registerTool(
-    "fab_append_intent",
-    {
-      description: "Call after a completed task to append an intent ledger entry for Fabric.",
-      inputSchema,
-      outputSchema,
-      annotations: { readOnlyHint: false }
-    },
-    async ({ entry }) => {
-      const projectRoot = resolveProjectRoot();
-      const result = await appendIntent(projectRoot, { entry });
-      const structuredContent = {
-        success: result.success,
-        timestamp: result.timestamp,
-        entry: { ...result.entry },
-        compliance: result.compliance
-      };
-      return {
-        content: [{ type: "text", text: JSON.stringify(result) }],
-        structuredContent
-      };
-    }
-  );
-}
-
-// 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 = {
-  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 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(),
+var descriptionIndexItemSchema = z.object({
+  stable_id: z.string(),
+  level: z.enum(["L0", "L1", "L2"]),
+  required: z.boolean(),
+  selectable: z.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 requirementProfileSchema = z.object({
+  target_path: z.string(),
+  path_segments: z.array(z.string()),
+  extension: z.string(),
+  inferred_domain: z.array(z.string()),
+  known_tech: z.array(z.string()),
+  user_intent: z.string(),
+  intent_tokens: z.array(z.string()),
+  impact_hints: z.array(z.string()),
+  detected_entities: z.array(z.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 selectionPolicySchema = z.object({
+  required_levels: z.tuple([z.literal("L0"), z.literal("L2")]),
+  ai_selectable_levels: z.tuple([z.literal("L1")]),
+  final_fetch_rule: z.literal("required_stable_ids + ai_selected_l1_stable_ids")
 });
-var outputSchema2 = z2.object({
-  revision_hash: z2.string(),
-  stale: z2.boolean(),
-  selection_token: z2.string(),
-  entries: z2.array(
-    z2.object({
-      path: z2.string(),
+var outputSchema = z.object({
+  revision_hash: z.string(),
+  stale: z.boolean(),
+  selection_token: z.string(),
+  entries: z.array(
+    z.object({
+      path: z.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()),
+      description_index: z.array(descriptionIndexItemSchema),
+      required_stable_ids: z.array(z.string()),
+      ai_selectable_stable_ids: z.array(z.string()),
+      initial_selected_stable_ids: z.array(z.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()
+  shared: z.object({
+    required_stable_ids: z.array(z.string()),
+    ai_selectable_stable_ids: z.array(z.string()),
+    description_index: z.array(descriptionIndexItemSchema),
+    preflight_diagnostics: z.array(
+      z.object({
+        code: z.literal("missing_description"),
+        severity: z.literal("warn"),
+        message: z.string(),
+        stable_ids: z.array(z.string()).optional(),
+        path: z.string().optional()
       })
     )
   })
@@ -386,13 +106,21 @@ function registerPlanContext(server) {
     "fab_plan_context",
     {
       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,
+      inputSchema,
+      outputSchema,
       annotations: { readOnlyHint: true }
     },
-    async ({ paths, intent, known_tech, detected_entities, client_hash }) => {
+    async ({ paths, intent, known_tech, detected_entities, client_hash, correlation_id, session_id }) => {
       const projectRoot = resolveProjectRoot();
-      const result = await planContext(projectRoot, { paths, intent, known_tech, detected_entities, client_hash });
+      const result = await planContext(projectRoot, {
+        paths,
+        intent,
+        known_tech,
+        detected_entities,
+        client_hash,
+        correlation_id,
+        session_id
+      });
       return {
         content: [{ type: "text", text: JSON.stringify(result) }],
         structuredContent: result
@@ -402,198 +130,34 @@ function registerPlanContext(server) {
 }
 
 // src/tools/rule-sections.ts
-import { z as z3 } from "zod";
-
-// 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")])
-  );
-}
-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 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_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/rule-sections.ts
-var inputSchema3 = {
-  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")
+import { z as z2 } from "zod";
+var inputSchema2 = {
+  selection_token: z2.string().min(1).describe("Selection token returned by fab_plan_context"),
+  sections: z2.array(z2.enum(RULE_SECTION_NAMES)).min(1).describe("Structured rule sections to fetch"),
+  ai_selected_stable_ids: z2.array(z2.string()).describe("AI-selected L1 stable_ids chosen from fab_plan_context ai_selectable_stable_ids"),
+  ai_selection_reasons: z2.record(z2.string().min(1)).describe("Reason for each AI-selected L1 stable_id"),
+  correlation_id: z2.string().optional().describe("Optional caller-provided correlation id for Event Ledger records"),
+  session_id: z2.string().optional().describe("Optional caller-provided session id for Event Ledger records")
 };
-var outputSchema3 = z3.object({
-  revision_hash: z3.string(),
-  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(),
-      sections: z3.record(z3.string())
+var outputSchema2 = z2.object({
+  revision_hash: z2.string(),
+  precedence: z2.tuple([z2.literal("L2"), z2.literal("L1"), z2.literal("L0")]),
+  selected_stable_ids: z2.array(z2.string()),
+  rules: z2.array(
+    z2.object({
+      stable_id: z2.string(),
+      level: z2.enum(["L0", "L1", "L2"]),
+      path: z2.string(),
+      sections: z2.record(z2.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()
+  diagnostics: z2.array(
+    z2.object({
+      code: z2.literal("missing_section"),
+      severity: z2.literal("warn"),
+      stable_id: z2.string(),
+      section: z2.enum(RULE_SECTION_NAMES),
+      message: z2.string()
     })
   )
 });
@@ -602,8 +166,8 @@ function registerRuleSections(server) {
     "fab_get_rule_sections",
     {
       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,
+      inputSchema: inputSchema2,
+      outputSchema: outputSchema2,
       annotations: { readOnlyHint: true }
     },
     async (input) => {
@@ -617,115 +181,6 @@ function registerRuleSections(server) {
   );
 }
 
-// src/tools/update-registry.ts
-import { agentsLayerSchema, agentsTopologyTypeSchema } from "@fenglimg/fabric-shared";
-import { z as z4 } from "zod";
-
-// src/services/update-registry.ts
-import { agentsMetaNodeSchema } from "@fenglimg/fabric-shared";
-import { join as join2 } from "path";
-async function updateRegistry(projectRoot, input) {
-  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);
-  await atomicWriteText(
-    metaPath,
-    `${JSON.stringify(
-      {
-        ...nextMeta,
-        revision: newRevision
-      },
-      null,
-      2
-    )}
-`
-  );
-  contextCache.invalidate("meta_write", projectRoot);
-  return {
-    revision_hash: newRevision,
-    success: true
-  };
-}
-function computeRevision(meta) {
-  const joinedHashes = Object.entries(meta.nodes).sort(([leftId], [rightId]) => leftId.localeCompare(rightId)).map(([, node]) => node.hash).join("");
-  return sha256(joinedHashes);
-}
-function assertNodeData(data, message) {
-  if (data === void 0) {
-    throw new Error(message);
-  }
-  return agentsMetaNodeSchema.parse(data);
-}
-function applyRegistryOperation(meta, op, nodeId, data) {
-  const nextNodes = { ...meta.nodes };
-  if (op === "remove-node") {
-    delete nextNodes[nodeId];
-    return {
-      ...meta,
-      nodes: nextNodes
-    };
-  }
-  if (op === "add-node") {
-    nextNodes[nodeId] = assertNodeData(data, `fab_update_registry requires data for ${op}`);
-    return {
-      ...meta,
-      nodes: nextNodes
-    };
-  }
-  const currentNode = nextNodes[nodeId];
-  if (currentNode === void 0) {
-    throw new Error(`Cannot update missing Fabric registry node: ${nodeId}`);
-  }
-  nextNodes[nodeId] = agentsMetaNodeSchema.parse({
-    ...currentNode,
-    ...data
-  });
-  return {
-    ...meta,
-    nodes: nextNodes
-  };
-}
-
-// src/tools/update-registry.ts
-var nodeInputSchema = z4.object({
-  file: z4.string().optional(),
-  scope_glob: z4.string().optional(),
-  deps: z4.array(z4.string()).optional(),
-  priority: z4.enum(["high", "medium", "low"]).optional(),
-  layer: agentsLayerSchema.optional(),
-  topology_type: agentsTopologyTypeSchema.optional(),
-  hash: z4.string().optional()
-});
-var inputSchema4 = {
-  op: z4.enum(["add-node", "remove-node", "update-node"]),
-  node_id: z4.string(),
-  data: nodeInputSchema.optional()
-};
-var outputSchema4 = z4.object({
-  success: z4.boolean(),
-  revision_hash: z4.string()
-});
-function registerUpdateRegistry(server) {
-  server.registerTool(
-    "fab_update_registry",
-    {
-      description: "Call to add, remove, or update Fabric registry nodes. Use instead of editing .fabric/agents.meta.json directly.",
-      inputSchema: inputSchema4,
-      outputSchema: outputSchema4,
-      annotations: { destructiveHint: true }
-    },
-    async ({ op, node_id, data }) => {
-      const projectRoot = resolveProjectRoot();
-      const result = await updateRegistry(projectRoot, { op, node_id, data });
-      return {
-        content: [{ type: "text", text: JSON.stringify(result) }],
-        structuredContent: result
-      };
-    }
-  );
-}
-
 // src/index.ts
 function writeStderr(message) {
   process.stderr.write(`${message}
@@ -740,12 +195,10 @@ function formatError(error) {
 function createFabricServer() {
   const server = new McpServer({
     name: "fabric-context-server",
-    version: "1.6.0"
+    version: "1.7.0"
   });
   registerPlanContext(server);
   registerRuleSections(server);
-  registerAppendIntent(server);
-  registerUpdateRegistry(server);
   server.registerResource(
     "bootstrap README",
     AGENTS_MD_RESOURCE_URI,
@@ -755,7 +208,7 @@ function createFabricServer() {
     },
     async (_uri) => {
       const projectRoot = process.env.FABRIC_PROJECT_ROOT ?? process.cwd();
-      const content = await readFile2(join3(projectRoot, ".fabric", "bootstrap", "README.md"), "utf8");
+      const content = await readFile(join(projectRoot, ".fabric", "bootstrap", "README.md"), "utf8");
       return {
         contents: [
           {
@@ -775,7 +228,7 @@ async function startStdioServer() {
   await server.connect(transport);
 }
 async function startHttpServer(options) {
-  const { createFabricHttpApp } = await import("./http-DJCTLGF4.js");
+  const { createFabricHttpApp } = await import("./http-6LFZLHCN.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) => {
@@ -802,17 +255,23 @@ if (isMainModule) {
 }
 export {
   AGENTS_MD_RESOURCE_URI,
+  EVENT_LEDGER_PATH,
   LEDGER_PATH,
   LEGACY_LEDGER_PATH,
-  approveHumanLock,
+  buildRuleMeta,
+  computeRuleTestIndex,
+  computeRulesBasedAgentsMeta,
   createFabricServer,
+  deriveRuleMetaLayer,
+  deriveRuleMetaTopologyType,
+  getEventLedgerPath,
   getLedgerPath,
   getLegacyLedgerPath,
-  readHumanLock,
-  readHumanLockEntry,
-  runDoctorAuditReport,
+  isSameRuleTestIndex,
   runDoctorFix,
   runDoctorReport,
+  stableStringify,
   startHttpServer,
-  startStdioServer
+  startStdioServer,
+  writeRuleMeta
 };