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

package/dist/index.js

@@ -1,8 +1,9 @@
 import {
-  AGENTS_MD_RESOURCE_URI,
   EVENT_LEDGER_PATH,
   LEDGER_PATH,
   LEGACY_LEDGER_PATH,
+  appendEventLedgerEvent,
+  appendRuleSelectionAuditEvent,
   buildRuleMeta,
   computeRuleTestIndex,
   computeRulesBasedAgentsMeta,
@@ -13,25 +14,28 @@ import {
   getEventLedgerPath,
   getLedgerPath,
   getLegacyLedgerPath,
-  getRuleSections,
   isSameRuleTestIndex,
-  planContext,
+  normalizeRulesPath,
+  readAgentsMeta,
   reconcileRules,
   resolveProjectRoot,
   runDoctorFix,
   runDoctorReport,
   stableStringify,
   writeRuleMeta
-} from "./chunk-EGGZFXMO.js";
+} from "./chunk-NRWDWAVO.js";
 
 // src/index.ts
 import { existsSync as existsSync2 } from "fs";
-import { readFile } from "fs/promises";
-import { join as join2, resolve } from "path";
+import { readFile as readFile3 } 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";
 
+// src/constants.ts
+var AGENTS_MD_RESOURCE_URI = "fabric://bootstrap-readme";
+
 // src/services/in-flight-tracker.ts
 function createInFlightTracker() {
   const active = /* @__PURE__ */ new Map();
@@ -95,6 +99,254 @@ function readPayloadLimits(projectRoot) {
   return readFabricConfig(projectRoot).mcpPayloadLimits;
 }
 
+// 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 includeDeprecated = input.include_deprecated === true;
+  const allDescriptions = buildDescriptionIndex(meta).filter(
+    (item) => includeDeprecated ? true : !isDeprecatedMaturity(item)
+  );
+  const entries = uniquePaths.map((path2) => {
+    const profile = buildRequirementProfile(path2, input);
+    const descriptionIndex = allDescriptions.filter((item) => shouldIncludeIndexItemForPath(item, meta, path2));
+    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: path2,
+      requirement_profile: profile,
+      description_index: descriptionIndex,
+      required_stable_ids: requiredStableIds2,
+      ai_selectable_stable_ids: aiSelectableStableIds2,
+      initial_selected_stable_ids: requiredStableIds2,
+      selection_policy: {
+        required_levels: ["L0", "L2"],
+        ai_selectable_levels: ["L1"],
+        final_fetch_rule: "required_stable_ids + ai_selected_l1_stable_ids"
+      }
+    };
+  });
+  const requiredStableIds = dedupeStableIds(entries.flatMap((entry) => entry.required_stable_ids));
+  const aiSelectableStableIds = dedupeStableIds(entries.flatMap((entry) => entry.ai_selectable_stable_ids));
+  const sharedDescriptionIndex = dedupeDescriptionIndex(entries.flatMap((entry) => entry.description_index));
+  const selectionToken = createSelectionToken(meta.revision, uniquePaths, requiredStableIds, aiSelectableStableIds);
+  const result = {
+    revision_hash: meta.revision,
+    stale,
+    selection_token: selectionToken,
+    entries,
+    shared: {
+      required_stable_ids: requiredStableIds,
+      ai_selectable_stable_ids: aiSelectableStableIds,
+      description_index: sharedDescriptionIndex,
+      preflight_diagnostics: buildPreflightDiagnostics(meta)
+    }
+  };
+  try {
+    await appendEventLedgerEvent(projectRoot, {
+      event_type: "knowledge_context_planned",
+      target_paths: uniquePaths,
+      required_stable_ids: requiredStableIds,
+      ai_selectable_stable_ids: aiSelectableStableIds,
+      final_stable_ids: requiredStableIds,
+      selection_token: selectionToken,
+      client_hash: input.client_hash,
+      intent: input.intent,
+      known_tech: input.known_tech,
+      diagnostics: result.shared.preflight_diagnostics,
+      correlation_id: input.correlation_id,
+      session_id: input.session_id
+    });
+  } catch {
+  }
+  return result;
+}
+function readSelectionToken(token, now = Date.now()) {
+  const state = selectionTokenCache.get(token);
+  if (state === void 0) {
+    return void 0;
+  }
+  if (state.expires_at <= now) {
+    selectionTokenCache.delete(token);
+    return void 0;
+  }
+  return state;
+}
+function createSelectionToken(revisionHash, targetPaths, requiredStableIds, aiSelectableStableIds, now = Date.now()) {
+  const token = `selection:${revisionHash}:${now.toString(36)}:${Math.random().toString(36).slice(2)}`;
+  selectionTokenCache.set(token, {
+    token,
+    revision_hash: revisionHash,
+    target_paths: targetPaths,
+    required_stable_ids: requiredStableIds,
+    ai_selectable_stable_ids: aiSelectableStableIds,
+    created_at: now,
+    expires_at: now + SELECTION_TOKEN_TTL_MS
+  });
+  return token;
+}
+function dedupePaths(paths) {
+  const seenPaths = /* @__PURE__ */ new Set();
+  return paths.flatMap((path2) => {
+    const normalizedPath = normalizeRulesPath(path2);
+    if (seenPaths.has(normalizedPath)) {
+      return [];
+    }
+    seenPaths.add(normalizedPath);
+    return [normalizedPath];
+  });
+}
+function buildRequirementProfile(path2, input) {
+  const normalizedPath = normalizeRulesPath(path2);
+  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?.[path2] ?? []
+  };
+}
+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 [];
+    }
+    const inferredLayer = inferKnowledgeLayerFromContentRef(node.content_ref ?? node.file);
+    return [{
+      stable_id: node.stable_id ?? nodeId,
+      level,
+      required: level === "L0" || level === "L2",
+      selectable: level === "L1",
+      description,
+      type: description.knowledge_type,
+      maturity: description.maturity,
+      layer: description.knowledge_layer ?? inferredLayer,
+      layer_reason: description.layer_reason
+    }];
+  }).sort(compareDescriptionIndexItems);
+}
+function inferKnowledgeLayerFromContentRef(contentRef) {
+  if (contentRef === void 0) {
+    return void 0;
+  }
+  if (contentRef.startsWith("~/.fabric/knowledge/")) {
+    return "personal";
+  }
+  if (contentRef.startsWith(".fabric/knowledge/")) {
+    return "team";
+  }
+  return void 0;
+}
+function isDeprecatedMaturity(item) {
+  const a = item.maturity;
+  const b = item.description.maturity;
+  return a === "deprecated" || b === "deprecated";
+}
+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, path2) {
+  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 === path2 || minimatchSimple(path2, node.scope_glob);
+}
+function minimatchSimple(path2, glob) {
+  if (glob === "**") {
+    return true;
+  }
+  if (glob.endsWith("/**")) {
+    return path2.startsWith(glob.slice(0, -3));
+  }
+  return path2 === 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(path2) {
+  const domains = [];
+  if (path2.includes("/ui/") || path2.toLowerCase().includes("ui")) {
+    domains.push("UI");
+  }
+  if (path2.includes("assets/scripts")) {
+    domains.push("Gameplay");
+  }
+  if (path2.includes("resources") || path2.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
 function registerPlanContext(server, tracker) {
   server.registerTool(
@@ -105,7 +357,7 @@ function registerPlanContext(server, tracker) {
       outputSchema: planContextOutputSchema,
       annotations: planContextAnnotations
     },
-    async ({ paths, intent, known_tech, detected_entities, client_hash, correlation_id, session_id }) => {
+    async ({ paths, intent, known_tech, detected_entities, client_hash, correlation_id, session_id, include_deprecated }) => {
       const requestId = randomUUID();
       tracker?.enter(requestId);
       try {
@@ -118,7 +370,8 @@ function registerPlanContext(server, tracker) {
           detected_entities,
           client_hash,
           correlation_id,
-          session_id
+          session_id,
+          include_deprecated
         });
         const response = {
           ...result,
@@ -156,6 +409,218 @@ import {
   ruleSectionsOutputSchema
 } from "@fenglimg/fabric-shared/schemas/api-contracts";
 import { enforcePayloadLimit as enforcePayloadLimit2 } from "@fenglimg/fabric-shared/node/mcp-payload-guard";
+
+// src/services/rule-sections.ts
+import { readFile } from "fs/promises";
+import { homedir } from "os";
+import { join as join2 } from "path";
+var RULE_SECTION_NAMES = [
+  "MISSION_STATEMENT",
+  "MANDATORY_INJECTION",
+  "BUSINESS_LOGIC_CHUNKS",
+  "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 activeSectionDepth = 0;
+  let buffer = [];
+  const flush = () => {
+    if (activeSection === void 0) {
+      return;
+    }
+    const text = buffer.join("\n").trim();
+    if (text.length === 0) {
+      buffer = [];
+      return;
+    }
+    sections.set(activeSection, [...sections.get(activeSection) ?? [], text]);
+    buffer = [];
+  };
+  for (const line of lines) {
+    const heading = /^(#{2,6})\s+\[([A-Z_]+)\]\s*$/u.exec(line.trim());
+    if (heading !== null) {
+      flush();
+      activeSection = isRuleSectionName(heading[2]) ? heading[2] : void 0;
+      activeSectionDepth = activeSection === void 0 ? 0 : heading[1].length;
+      continue;
+    }
+    const ordinaryHeading = /^(#{1,6})\s+/u.exec(line.trim());
+    if (ordinaryHeading !== null) {
+      if (activeSection !== void 0 && ordinaryHeading[1].length > activeSectionDepth) {
+        buffer.push(line);
+        continue;
+      }
+      flush();
+      activeSection = void 0;
+      activeSectionDepth = 0;
+      continue;
+    }
+    if (activeSection !== void 0) {
+      buffer.push(line);
+    }
+  }
+  flush();
+  return new Map(
+    Array.from(sections.entries()).map(([section, values]) => [section, values.join("\n\n")])
+  );
+}
+async function getRuleSections(projectRoot, input) {
+  const token = readSelectionToken(input.selection_token);
+  if (token === void 0) {
+    throw new Error("selection_token is missing or expired");
+  }
+  validateAiSelections(token.ai_selectable_stable_ids, input.ai_selected_stable_ids, input.ai_selection_reasons);
+  const meta = await readAgentsMeta(projectRoot);
+  const selectedStableIds = [...token.required_stable_ids, ...input.ai_selected_stable_ids];
+  const selectedRules = sortRuleNodes(selectedStableIds.map((stableId) => findRuleNode(meta, stableId)));
+  const diagnostics = [];
+  const rules = [];
+  for (const rule of selectedRules) {
+    const content = await readFile(resolveRuleSourcePath(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}.`
+        });
+      }
+    }
+    const description = rule.node.description;
+    if (description !== void 0 && description.knowledge_type === void 0 && description.knowledge_layer === void 0) {
+      diagnostics.push({
+        code: "missing_knowledge_metadata",
+        severity: "warn",
+        stable_id: rule.stable_id,
+        message: `Rule ${rule.stable_id} has no knowledge metadata (type/layer) \u2014 likely an un-migrated v1.x entry.`
+      });
+    }
+    rules.push({
+      stable_id: rule.stable_id,
+      level: rule.level,
+      path: rule.path,
+      sections
+    });
+  }
+  const result = {
+    revision_hash: meta.revision,
+    precedence: ["L2", "L1", "L0"],
+    selected_stable_ids: rules.map((rule) => rule.stable_id),
+    rules,
+    diagnostics
+  };
+  await appendRuleSelectionAuditEvent(projectRoot, {
+    path: token.target_paths[0] ?? "",
+    selection_token: input.selection_token,
+    target_paths: token.target_paths,
+    required_stable_ids: token.required_stable_ids,
+    ai_selectable_stable_ids: token.ai_selectable_stable_ids,
+    ai_selected_stable_ids: input.ai_selected_stable_ids,
+    final_stable_ids: result.selected_stable_ids,
+    ai_selection_reasons: pickSelectionReasons(input.ai_selected_stable_ids, input.ai_selection_reasons),
+    rejected_stable_ids: [],
+    ignored_stable_ids: [],
+    correlation_id: input.correlation_id,
+    session_id: input.session_id
+  });
+  try {
+    await appendEventLedgerEvent(projectRoot, {
+      event_type: "knowledge_sections_fetched",
+      selection_token: input.selection_token,
+      target_paths: token.target_paths,
+      requested_sections: input.sections,
+      final_stable_ids: result.selected_stable_ids,
+      ai_selected_stable_ids: input.ai_selected_stable_ids,
+      diagnostics,
+      correlation_id: input.correlation_id,
+      session_id: input.session_id
+    });
+  } catch {
+  }
+  return result;
+}
+function validateAiSelections(aiSelectableStableIds, aiSelectedStableIds, aiSelectionReasons) {
+  const selectable = new Set(aiSelectableStableIds);
+  for (const stableId of aiSelectedStableIds) {
+    if (!selectable.has(stableId)) {
+      throw new Error(`Invalid L1 rule selection: ${stableId}`);
+    }
+    if (aiSelectionReasons[stableId]?.trim() === "") {
+      throw new Error(`Missing AI selection reason for ${stableId}`);
+    }
+    if (aiSelectionReasons[stableId] === void 0) {
+      throw new Error(`Missing AI selection reason for ${stableId}`);
+    }
+  }
+}
+function findRuleNode(meta, stableId) {
+  for (const [nodeId, node] of Object.entries(meta.nodes)) {
+    const nodeStableId = node.stable_id ?? nodeId;
+    if (nodeStableId !== stableId) {
+      continue;
+    }
+    const level = node.level ?? node.layer;
+    return {
+      stable_id: nodeStableId,
+      level,
+      path: normalizeRulesPath(node.content_ref ?? node.file),
+      priority: node.priority,
+      node
+    };
+  }
+  throw new Error(`Selected rule is not present in agents.meta.json: ${stableId}`);
+}
+function sortRuleNodes(rules) {
+  return [...rules].sort((left, right) => {
+    const levelDelta = outputLevelOrder(left.level) - outputLevelOrder(right.level);
+    if (levelDelta !== 0) {
+      return levelDelta;
+    }
+    const priorityDelta = PRIORITY_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 resolveRuleSourcePath(projectRoot, contentRef) {
+  if (contentRef.startsWith("~/.fabric/knowledge/")) {
+    const home = process.env.FABRIC_HOME ?? homedir();
+    return join2(home, ".fabric", "knowledge", contentRef.slice("~/.fabric/knowledge/".length));
+  }
+  return join2(projectRoot, contentRef);
+}
+function pickSelectionReasons(selectedStableIds, reasons) {
+  return Object.fromEntries(selectedStableIds.map((stableId) => [stableId, reasons[stableId] ?? ""]));
+}
+
+// src/tools/rule-sections.ts
 function registerRuleSections(server, tracker) {
   server.registerTool(
     "fab_get_rule_sections",
@@ -200,6 +665,83 @@ function registerRuleSections(server, tracker) {
   );
 }
 
+// src/services/knowledge-id-allocator.ts
+import { readFile as readFile2 } from "fs/promises";
+import { dirname } from "path";
+import { mkdir } from "fs/promises";
+import {
+  AgentsMetaCountersSchema,
+  agentsMetaSchema,
+  allocateKnowledgeId,
+  defaultAgentsMetaCounters
+} from "@fenglimg/fabric-shared";
+import { atomicWriteJson } from "@fenglimg/fabric-shared/node/atomic-write";
+var KnowledgeIdAllocator = class {
+  constructor(metaPath) {
+    this.metaPath = metaPath;
+  }
+  metaPath;
+  /**
+   * Allocate the next stable_id for the given (layer, type) pair and persist
+   * the advanced counter to `agents.meta.json`.
+   */
+  async allocate(layer, type) {
+    const meta = await this.readMeta();
+    const counters = this.normalizeCounters(meta.counters);
+    const { id, nextCounters } = allocateKnowledgeId(layer, type, counters);
+    await this.writeMetaAtomic({ ...meta, counters: nextCounters });
+    return id;
+  }
+  /**
+   * Returns the current counters envelope, defaulting to all-zero slots when
+   * the meta file is absent or pre-v2.0 (counters key missing).
+   */
+  async getCounters() {
+    const meta = await this.readMeta();
+    return this.normalizeCounters(meta.counters);
+  }
+  // ---- internal helpers ------------------------------------------------
+  async readMeta() {
+    let raw;
+    try {
+      raw = await readFile2(this.metaPath, "utf8");
+    } catch (err) {
+      if (isNodeError(err) && err.code === "ENOENT") {
+        return { revision: "", nodes: {} };
+      }
+      throw err;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return { revision: "", nodes: {} };
+    }
+    const validation = agentsMetaSchema.safeParse(parsed);
+    if (validation.success) {
+      return validation.data;
+    }
+    return parsed && typeof parsed === "object" ? parsed : {};
+  }
+  normalizeCounters(input) {
+    if (input === void 0 || input === null) {
+      return defaultAgentsMetaCounters();
+    }
+    const parsed = AgentsMetaCountersSchema.safeParse(input);
+    return parsed.success ? parsed.data : defaultAgentsMetaCounters();
+  }
+  async writeMetaAtomic(meta) {
+    await ensureParentDirectory(this.metaPath);
+    await atomicWriteJson(this.metaPath, meta, { indent: 2 });
+  }
+};
+async function ensureParentDirectory(filePath) {
+  await mkdir(dirname(filePath), { recursive: true });
+}
+function isNodeError(err) {
+  return err instanceof Error && typeof err.code === "string";
+}
+
 // src/services/serve-lock.ts
 import fs from "fs";
 import path from "path";
@@ -304,15 +846,15 @@ function formatError(error) {
 }
 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 (existsSync2(join3(projectRoot, "CLAUDE.md"))) preexisting.push("CLAUDE.md");
+  if (existsSync2(join3(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.`;
+  return `[startup] info: detected ${preexisting.join(", ")} at project root. Note: Fabric serves knowledge from .fabric/knowledge/ 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.8.0-rc.2"
+    version: "2.0.0-rc.1"
   });
   registerPlanContext(server, tracker);
   registerRuleSections(server, tracker);
@@ -320,18 +862,22 @@ function createFabricServer(tracker) {
     "bootstrap README",
     AGENTS_MD_RESOURCE_URI,
     {
-      description: "L0 fabric bootstrap file \u2014 global agent instructions for this project",
+      description: "Legacy v1.x bootstrap anchor (deprecated in v2.0; kept as MCP contract shim)",
       mimeType: "text/markdown"
     },
     async (_uri) => {
       const projectRoot = process.env.FABRIC_PROJECT_ROOT ?? process.cwd();
-      const content = await readFile(join2(projectRoot, ".fabric", "bootstrap", "README.md"), "utf8");
+      const path2 = join3(projectRoot, ".fabric", "bootstrap", "README.md");
+      let text = "";
+      if (existsSync2(path2)) {
+        text = await readFile3(path2, "utf8");
+      }
       return {
         contents: [
           {
             uri: AGENTS_MD_RESOURCE_URI,
             mimeType: "text/markdown",
-            text: content
+            text
           }
         ]
       };
@@ -406,7 +952,7 @@ function createShutdownHandler(deps) {
   };
 }
 async function startHttpServer(options) {
-  const { createFabricHttpApp } = await import("./http-Q7GIL23Y.js");
+  const { createFabricHttpApp } = await import("./http-CHCOF6DJ.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) => {
@@ -434,10 +980,12 @@ if (isMainModule) {
 export {
   AGENTS_MD_RESOURCE_URI,
   EVENT_LEDGER_PATH,
+  KnowledgeIdAllocator,
   LEDGER_PATH,
   LEGACY_LEDGER_PATH,
   ServeLockHeldError,
   acquireLock,
+  appendEventLedgerEvent,
   buildRuleMeta,
   checkLockOrThrow,
   computeRuleTestIndex,