@fenglimg/fabric-server 1.6.0 → 1.8.0-rc.1

package/dist/index.js

@@ -1,727 +1,292 @@
 import {
   AGENTS_MD_RESOURCE_URI,
-  FABRIC_DIR,
+  EVENT_LEDGER_PATH,
   LEDGER_PATH,
   LEGACY_LEDGER_PATH,
-  appendEditIntentAuditEvents,
-  appendLedgerEntry,
-  appendRuleSelectionAuditEvent,
-  approveHumanLock,
-  atomicWriteText,
-  contextCache,
+  buildRuleMeta,
+  computeRuleTestIndex,
+  computeRulesBasedAgentsMeta,
+  deriveRuleMetaLayer,
+  deriveRuleMetaTopologyType,
+  ensureRulesFresh,
+  flushAndSyncEventLedger,
+  getEventLedgerPath,
   getLedgerPath,
   getLegacyLedgerPath,
-  normalizeRulesPath,
-  readAgentsMeta,
-  readHumanLock,
-  readHumanLockEntry,
+  getRuleSections,
+  isSameRuleTestIndex,
+  planContext,
+  reconcileRules,
   resolveProjectRoot,
-  runDoctorAuditReport,
   runDoctorFix,
   runDoctorReport,
-  sha256
-} from "./chunk-TZCE2K4D.js";
+  stableStringify,
+  writeRuleMeta
+} from "./chunk-E3BHIUIW.js";
 
 // src/index.ts
-import { readFile as readFile2 } from "fs/promises";
-import { join as join3, resolve } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { readFile } from "fs/promises";
+import { join as join2, 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";
-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 {
-  }
+// src/services/in-flight-tracker.ts
+function createInFlightTracker() {
+  const active = /* @__PURE__ */ new Map();
+  let resolveDrained = null;
   return {
-    success: true,
-    timestamp: ts,
-    entry,
-    compliance
-  };
-}
-
-// src/tools/append-intent.ts
-var inputSchema = {
-  entry: aiLedgerEntrySchema.omit({
-    id: true,
-    source: true,
-    ts: true
-  })
-};
-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()
-});
-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 }
+    enter(id) {
+      active.set(id, Date.now());
     },
-    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
-      };
+    exit(id) {
+      active.delete(id);
+      if (active.size === 0 && resolveDrained) {
+        resolveDrained();
+        resolveDrained = null;
+      }
+    },
+    drain(deadlineMs) {
+      const startedWith = active.size;
+      if (startedWith === 0) return Promise.resolve({ drained: 0, timed_out: 0 });
+      return new Promise((resolve2) => {
+        const timer = setTimeout(() => {
+          const drainedCount = startedWith - active.size;
+          resolveDrained = null;
+          resolve2({ drained: drainedCount, timed_out: active.size });
+        }, deadlineMs);
+        resolveDrained = () => {
+          clearTimeout(timer);
+          resolve2({ drained: startedWith, timed_out: 0 });
+        };
+      });
+    },
+    size() {
+      return active.size;
     }
-  );
+  };
 }
 
 // src/tools/plan-context.ts
-import { z as z2 } from "zod";
+import { randomUUID } from "crypto";
+import {
+  planContextAnnotations,
+  planContextInputSchema,
+  planContextOutputSchema
+} from "@fenglimg/fabric-shared/schemas/api-contracts";
+import { enforcePayloadLimit } from "@fenglimg/fabric-shared/node/mcp-payload-guard";
 
-// 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");
+// src/config-loader.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+function readFabricConfig(projectRoot) {
+  const configPath = join(projectRoot, "fabric.config.json");
+  if (!existsSync(configPath)) {
+    return {};
   }
-  if (path.includes("resources") || path.includes("assets/resources")) {
-    domains.push("Asset");
+  const parsed = JSON.parse(readFileSync(configPath, "utf8"));
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Expected object in ${configPath}`);
   }
-  return domains;
+  return parsed;
 }
-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;
-  }
+function readPayloadLimits(projectRoot) {
+  return readFabricConfig(projectRoot).mcpPayloadLimits;
 }
 
 // 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(),
-  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(),
-  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 registerPlanContext(server) {
+function registerPlanContext(server, tracker) {
   server.registerTool(
     "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,
-      annotations: { readOnlyHint: true }
+      inputSchema: planContextInputSchema,
+      outputSchema: planContextOutputSchema,
+      annotations: planContextAnnotations
     },
-    async ({ paths, intent, known_tech, detected_entities, client_hash }) => {
-      const projectRoot = resolveProjectRoot();
-      const result = await planContext(projectRoot, { paths, intent, known_tech, detected_entities, client_hash });
-      return {
-        content: [{ type: "text", text: JSON.stringify(result) }],
-        structuredContent: result
-      };
-    }
-  );
-}
-
-// 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}.`
+    async ({ paths, intent, known_tech, detected_entities, client_hash, correlation_id, session_id }) => {
+      const requestId = randomUUID();
+      tracker?.enter(requestId);
+      try {
+        const projectRoot = resolveProjectRoot();
+        const syncReport = await ensureRulesFresh(projectRoot);
+        const result = await planContext(projectRoot, {
+          paths,
+          intent,
+          known_tech,
+          detected_entities,
+          client_hash,
+          correlation_id,
+          session_id
         });
+        const response = {
+          ...result,
+          warnings: [...syncReport.warnings]
+        };
+        const payloadLimits = readPayloadLimits(projectRoot);
+        const serialized = JSON.stringify(response);
+        const guardResult = enforcePayloadLimit(serialized, payloadLimits);
+        if (guardResult.warning) {
+          response.warnings = [
+            ...response.warnings,
+            {
+              code: guardResult.warning.code,
+              file: "<response>",
+              action_hint: "Consider narrowing the request scope to reduce response size"
+            }
+          ];
+        }
+        return {
+          content: [{ type: "text", text: JSON.stringify(response) }],
+          structuredContent: response
+        };
+      } finally {
+        tracker?.exit(requestId);
       }
     }
-    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")
-};
-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())
-    })
-  ),
-  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 registerRuleSections(server) {
+import { randomUUID as randomUUID2 } from "crypto";
+import {
+  ruleSectionsAnnotations,
+  ruleSectionsInputSchema,
+  ruleSectionsOutputSchema
+} from "@fenglimg/fabric-shared/schemas/api-contracts";
+import { enforcePayloadLimit as enforcePayloadLimit2 } from "@fenglimg/fabric-shared/node/mcp-payload-guard";
+function registerRuleSections(server, tracker) {
   server.registerTool(
     "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,
-      annotations: { readOnlyHint: true }
+      inputSchema: ruleSectionsInputSchema,
+      outputSchema: ruleSectionsOutputSchema,
+      annotations: ruleSectionsAnnotations
     },
     async (input) => {
-      const projectRoot = resolveProjectRoot();
-      const result = await getRuleSections(projectRoot, input);
-      return {
-        content: [{ type: "text", text: JSON.stringify(result) }],
-        structuredContent: result
-      };
+      const requestId = randomUUID2();
+      tracker?.enter(requestId);
+      try {
+        const projectRoot = resolveProjectRoot();
+        const syncReport = await ensureRulesFresh(projectRoot);
+        const result = await getRuleSections(projectRoot, input);
+        const response = {
+          ...result,
+          warnings: [...syncReport.warnings]
+        };
+        const payloadLimits = readPayloadLimits(projectRoot);
+        const serialized = JSON.stringify(response);
+        const guardResult = enforcePayloadLimit2(serialized, payloadLimits);
+        if (guardResult.warning) {
+          response.warnings = [
+            ...response.warnings,
+            {
+              code: guardResult.warning.code,
+              file: "<response>",
+              action_hint: "Consider narrowing the request scope to reduce response size"
+            }
+          ];
+        }
+        return {
+          content: [{ type: "text", text: JSON.stringify(response) }],
+          structuredContent: response
+        };
+      } finally {
+        tracker?.exit(requestId);
+      }
     }
   );
 }
 
-// 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);
+// src/services/serve-lock.ts
+import fs from "fs";
+import path from "path";
+import { IOFabricError } from "@fenglimg/fabric-shared/errors";
+var LOCK_FILENAME = ".serve.lock";
+var ServeLockHeldError = class extends IOFabricError {
+  code = "SERVE_LOCK_HELD";
+  httpStatus = 423;
+};
+function lockPath(projectRoot) {
+  return path.join(projectRoot, ".fabric", LOCK_FILENAME);
 }
-function assertNodeData(data, message) {
-  if (data === void 0) {
-    throw new Error(message);
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    const err = e;
+    if (err.code === "ESRCH") return false;
+    if (err.code === "EPERM") return true;
+    throw e;
   }
-  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
-    };
+function acquireLock(projectRoot, opts) {
+  const p = lockPath(projectRoot);
+  if (fs.existsSync(p)) {
+    let state = null;
+    try {
+      state = JSON.parse(fs.readFileSync(p, "utf8"));
+    } catch {
+    }
+    if (state && state.pid && state.pid !== process.pid && isAlive(state.pid) && !opts?.force) {
+      throw new ServeLockHeldError(
+        `serve lock held by live PID ${state.pid}`,
+        {
+          actionHint: `Stop the other process (PID ${state.pid}) or run with --force to override`,
+          details: state
+        }
+      );
+    }
+    if (state && state.pid && !isAlive(state.pid)) {
+      process.stderr.write(`[serve-lock] stale lock from PID ${state.pid} \u2014 overwriting
+`);
+    }
   }
-  if (op === "add-node") {
-    nextNodes[nodeId] = assertNodeData(data, `fab_update_registry requires data for ${op}`);
-    return {
-      ...meta,
-      nodes: nextNodes
-    };
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(
+    p,
+    JSON.stringify({ pid: process.pid, acquiredAt: Date.now(), host: process.env.HOSTNAME })
+  );
+}
+function releaseLock(projectRoot) {
+  const p = lockPath(projectRoot);
+  try {
+    if (fs.existsSync(p)) {
+      const state = JSON.parse(fs.readFileSync(p, "utf8"));
+      if (state.pid === process.pid) {
+        fs.unlinkSync(p);
+      }
+    }
+  } catch {
   }
-  const currentNode = nextNodes[nodeId];
-  if (currentNode === void 0) {
-    throw new Error(`Cannot update missing Fabric registry node: ${nodeId}`);
+}
+function readLockState(projectRoot) {
+  const p = lockPath(projectRoot);
+  if (!fs.existsSync(p)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+  } catch {
+    return null;
   }
-  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",
+function checkLockOrThrow(projectRoot, opts) {
+  const state = readLockState(projectRoot);
+  if (state === null) return;
+  if (state.pid === process.pid) return;
+  if (!isAlive(state.pid)) {
+    process.stderr.write(`[serve-lock] stale lock from PID ${state.pid} \u2014 ignoring
+`);
+    return;
+  }
+  if (opts?.force) return;
+  throw new ServeLockHeldError(
+    `serve lock held by live PID ${state.pid}`,
     {
-      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
-      };
+      actionHint: `Stop the other serve process (PID ${state.pid}) before running this command, or pass --force to override`,
+      details: state
     }
   );
 }
@@ -737,15 +302,20 @@ function formatError(error) {
   }
   return `Unknown error: ${String(error)}`;
 }
-function createFabricServer() {
+function formatPreexistingRootMessage(projectRoot) {
+  const preexisting = [];
+  if (existsSync2(join2(projectRoot, "CLAUDE.md"))) preexisting.push("CLAUDE.md");
+  if (existsSync2(join2(projectRoot, "AGENTS.md"))) preexisting.push("AGENTS.md");
+  if (preexisting.length === 0) return null;
+  return `[startup] info: detected ${preexisting.join(", ")} at project root. Note: Fabric serves rules from .fabric/rules/ via MCP \u2014 root markdown files are not auto-loaded into the AI context.`;
+}
+function createFabricServer(tracker) {
   const server = new McpServer({
     name: "fabric-context-server",
-    version: "1.6.0"
+    version: "1.8.0-rc.1"
   });
-  registerPlanContext(server);
-  registerRuleSections(server);
-  registerAppendIntent(server);
-  registerUpdateRegistry(server);
+  registerPlanContext(server, tracker);
+  registerRuleSections(server, tracker);
   server.registerResource(
     "bootstrap README",
     AGENTS_MD_RESOURCE_URI,
@@ -755,7 +325,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(join2(projectRoot, ".fabric", "bootstrap", "README.md"), "utf8");
       return {
         contents: [
           {
@@ -770,12 +340,73 @@ function createFabricServer() {
   return server;
 }
 async function startStdioServer() {
-  const server = createFabricServer();
+  const tracker = createInFlightTracker();
+  const projectRoot = resolveProjectRoot();
+  const syncStart = Date.now();
+  const reconcileResult = await reconcileRules(projectRoot, { trigger: "startup" });
+  const syncDurationMs = Date.now() - syncStart;
+  process.stderr.write(
+    `[startup] rule sync: status=${reconcileResult.status}, events=${reconcileResult.events.length}, ${syncDurationMs}ms
+`
+  );
+  const rootMsg = formatPreexistingRootMessage(projectRoot);
+  if (rootMsg !== null) {
+    process.stderr.write(`${rootMsg}
+`);
+  }
+  const server = createFabricServer(tracker);
   const transport = new StdioServerTransport();
   await server.connect(transport);
+  const closeServer = async () => {
+    await server.close();
+  };
+  process.on(
+    "SIGINT",
+    createShutdownHandler({ signal: "SIGINT", tracker, projectRoot, closeServer })
+  );
+  process.on(
+    "SIGTERM",
+    createShutdownHandler({ signal: "SIGTERM", tracker, projectRoot, closeServer })
+  );
+  process.on(
+    "SIGHUP",
+    createShutdownHandler({ signal: "SIGHUP", tracker, projectRoot, closeServer })
+  );
+}
+function createShutdownHandler(deps) {
+  const exit = deps.exit ?? ((code) => process.exit(code));
+  const deadlineMs = deps.drainDeadlineMs ?? 5e3;
+  let invoked = false;
+  return () => {
+    void (async () => {
+      if (invoked) {
+        process.stderr.write(`
+[shutdown] ${deps.signal} repeated \u2014 forcing exit(1)
+`);
+        exit(1);
+        return;
+      }
+      invoked = true;
+      process.stderr.write(
+        `
+[shutdown] ${deps.signal} received \u2014 draining ${deps.tracker.size()} requests (${deadlineMs / 1e3}s deadline)
+`
+      );
+      const result = await deps.tracker.drain(deadlineMs);
+      process.stderr.write(`[shutdown] drained ${result.drained}, timed_out ${result.timed_out}
+`);
+      flushAndSyncEventLedger(deps.projectRoot);
+      process.stderr.write("[shutdown] ledger fsynced; closing server\n");
+      try {
+        await deps.closeServer();
+      } catch {
+      }
+      exit(0);
+    })();
+  };
 }
 async function startHttpServer(options) {
-  const { createFabricHttpApp } = await import("./http-DJCTLGF4.js");
+  const { createFabricHttpApp } = await import("./http-MEFXOG3L.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 +433,34 @@ if (isMainModule) {
 }
 export {
   AGENTS_MD_RESOURCE_URI,
+  EVENT_LEDGER_PATH,
   LEDGER_PATH,
   LEGACY_LEDGER_PATH,
-  approveHumanLock,
+  ServeLockHeldError,
+  acquireLock,
+  buildRuleMeta,
+  checkLockOrThrow,
+  computeRuleTestIndex,
+  computeRulesBasedAgentsMeta,
   createFabricServer,
+  createInFlightTracker,
+  createShutdownHandler,
+  deriveRuleMetaLayer,
+  deriveRuleMetaTopologyType,
+  ensureRulesFresh,
+  flushAndSyncEventLedger,
+  formatPreexistingRootMessage,
+  getEventLedgerPath,
   getLedgerPath,
   getLegacyLedgerPath,
-  readHumanLock,
-  readHumanLockEntry,
-  runDoctorAuditReport,
+  isSameRuleTestIndex,
+  readLockState,
+  reconcileRules,
+  releaseLock,
   runDoctorFix,
   runDoctorReport,
+  stableStringify,
   startHttpServer,
-  startStdioServer
+  startStdioServer,
+  writeRuleMeta
 };