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

package/dist/chunk-E3BHIUIW.js

@@ -0,0 +1,2903 @@
+// src/constants.ts
+var AGENTS_MD_RESOURCE_URI = "fabric://bootstrap-readme";
+
+// src/cache.ts
+var ContextCache = class {
+  constructor(defaultTtlMs = 5e3) {
+    this.defaultTtlMs = defaultTtlMs;
+  }
+  defaultTtlMs;
+  // Slot 1: raw AgentsMeta keyed by projectRoot
+  metaSlot = /* @__PURE__ */ new Map();
+  // Slot 2: GetRulesContext keyed by projectRoot
+  contextSlot = /* @__PURE__ */ new Map();
+  // Slot 3: audit sliding-window cursor keyed by projectRoot
+  auditSlot = /* @__PURE__ */ new Map();
+  // ---------------------------------------------------------------------------
+  // Generic get / set / invalidate
+  // ---------------------------------------------------------------------------
+  get(slot, key) {
+    const store = this.slotStore(slot);
+    const entry = store.get(key);
+    if (entry === void 0) {
+      return void 0;
+    }
+    if (entry.expiresAt !== 0 && Date.now() > entry.expiresAt) {
+      store.delete(key);
+      return void 0;
+    }
+    return entry.value;
+  }
+  set(slot, key, value, ttlMs) {
+    const store = this.slotStore(slot);
+    const resolvedTtl = ttlMs ?? this.defaultTtlMs;
+    const expiresAt = resolvedTtl > 0 ? Date.now() + resolvedTtl : 0;
+    store.set(key, { value, expiresAt });
+  }
+  // ---------------------------------------------------------------------------
+  // Audit cursor (separate API — not TTL-based)
+  // ---------------------------------------------------------------------------
+  getAuditCursor(projectRoot) {
+    return this.auditSlot.get(projectRoot);
+  }
+  setAuditCursor(projectRoot, cursor) {
+    this.auditSlot.set(projectRoot, cursor);
+  }
+  resetAuditCursor(projectRoot) {
+    this.auditSlot.delete(projectRoot);
+  }
+  // ---------------------------------------------------------------------------
+  // Invalidation
+  // ---------------------------------------------------------------------------
+  /**
+   * Invalidate cache slots based on what changed.
+   *
+   * @param reason  "meta_write"  — only the meta slot for this projectRoot
+   *                "file_watch"  — meta + context slots (AGENTS.md may have changed)
+   * @param projectRoot  Optional; if omitted, clears ALL keys in affected slots.
+   */
+  invalidate(reason, projectRoot) {
+    if (reason === "meta_write") {
+      if (projectRoot !== void 0) {
+        this.metaSlot.delete(projectRoot);
+      } else {
+        this.metaSlot.clear();
+      }
+      return;
+    }
+    if (projectRoot !== void 0) {
+      this.metaSlot.delete(projectRoot);
+      this.contextSlot.delete(projectRoot);
+    } else {
+      this.metaSlot.clear();
+      this.contextSlot.clear();
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+  slotStore(slot) {
+    return slot === "meta" ? this.metaSlot : this.contextSlot;
+  }
+};
+var contextCache = new ContextCache(5e3);
+
+// src/meta-reader.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+import { agentsMetaSchema } from "@fenglimg/fabric-shared";
+import { IOFabricError } from "@fenglimg/fabric-shared/errors";
+import { agentsMetaNodeSchema, agentsMetaSchema as agentsMetaSchema2 } from "@fenglimg/fabric-shared";
+var AgentsMetaFileMissingError = class extends IOFabricError {
+  constructor(metaPath, opts) {
+    super(`Fabric agents metadata file is missing: ${metaPath}`, {
+      actionHint: opts?.actionHint ?? "Run `fab init` to scaffold the .fabric/agents.meta.json file"
+    });
+    this.metaPath = metaPath;
+  }
+  metaPath;
+  code = "FABRIC_META_MISSING";
+  httpStatus = 404;
+};
+var AgentsMetaInvalidError = class extends IOFabricError {
+  constructor(metaPath, cause, opts) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    super(`Fabric agents metadata file is invalid: ${metaPath}. ${detail}`, {
+      actionHint: opts?.actionHint ?? "Check the agents.meta.json file for schema errors and regenerate if needed"
+    });
+    this.metaPath = metaPath;
+  }
+  metaPath;
+  code = "FABRIC_META_INVALID";
+  httpStatus = 500;
+};
+function getAgentsMetaPath(projectRoot) {
+  return join(projectRoot, ".fabric", "agents.meta.json");
+}
+function resolveProjectRoot() {
+  return process.env.FABRIC_PROJECT_ROOT ?? process.cwd();
+}
+async function readAgentsMeta(projectRoot) {
+  const cached = contextCache.get("meta", projectRoot);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const metaPath = getAgentsMetaPath(projectRoot);
+  let raw;
+  try {
+    raw = await readFile(metaPath, "utf8");
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      throw new AgentsMetaFileMissingError(metaPath);
+    }
+    throw error;
+  }
+  let parsed;
+  try {
+    parsed = agentsMetaSchema.parse(JSON.parse(raw));
+  } catch (error) {
+    throw new AgentsMetaInvalidError(metaPath, error);
+  }
+  contextCache.set("meta", projectRoot, parsed);
+  return parsed;
+}
+
+// src/services/_shared.ts
+import { dirname, join as join2, resolve, sep } from "path";
+import { createHash } from "crypto";
+import { mkdir } from "fs/promises";
+import { PathEscapeError } from "@fenglimg/fabric-shared/errors";
+import { atomicWriteText, atomicWriteJson } from "@fenglimg/fabric-shared/node/atomic-write";
+var FABRIC_DIR = ".fabric";
+var LEDGER_FILE = ".intent-ledger.jsonl";
+var LEDGER_PATH = `${FABRIC_DIR}/${LEDGER_FILE}`;
+var LEGACY_LEDGER_PATH = LEDGER_FILE;
+var EVENT_LEDGER_FILE = "events.jsonl";
+var EVENT_LEDGER_PATH = `${FABRIC_DIR}/${EVENT_LEDGER_FILE}`;
+function getLedgerPath(projectRoot) {
+  return join2(projectRoot, LEDGER_PATH);
+}
+function getLegacyLedgerPath(projectRoot) {
+  return join2(projectRoot, LEGACY_LEDGER_PATH);
+}
+function getEventLedgerPath(projectRoot) {
+  return join2(projectRoot, EVENT_LEDGER_PATH);
+}
+async function ensureParentDirectory(path) {
+  await mkdir(dirname(path), { recursive: true });
+}
+function sha256(content) {
+  return `sha256:${createHash("sha256").update(content).digest("hex")}`;
+}
+function isNodeError(error) {
+  return error instanceof Error;
+}
+
+// src/services/event-ledger.ts
+import { randomUUID } from "crypto";
+import { existsSync, fsyncSync, openSync, closeSync } from "fs";
+import { readFile as readFile2, truncate, writeFile } from "fs/promises";
+import {
+  eventLedgerEventSchema
+} from "@fenglimg/fabric-shared";
+import { createLedgerWriteQueue } from "@fenglimg/fabric-shared/node/atomic-write";
+var ledgerQueue = createLedgerWriteQueue();
+async function appendEventLedgerEvent(projectRoot, event) {
+  const eventPath = getEventLedgerPath(projectRoot);
+  const nextEvent = eventLedgerEventSchema.parse({
+    ...event,
+    kind: "fabric-event",
+    id: event.id ?? `event:${randomUUID()}`,
+    ts: event.ts ?? Date.now(),
+    schema_version: 1
+  });
+  await ensureParentDirectory(eventPath);
+  await ledgerQueue.append(eventPath, JSON.stringify(nextEvent));
+  return nextEvent;
+}
+async function readEventLedger(projectRoot, options = {}) {
+  const eventPath = getEventLedgerPath(projectRoot);
+  let raw;
+  try {
+    raw = await readFile2(eventPath, "utf8");
+  } catch (error) {
+    if (isNodeError2(error) && error.code === "ENOENT") {
+      return { events: [], warnings: [] };
+    }
+    throw error;
+  }
+  const warnings = [];
+  const lines = raw.split(/\r?\n/);
+  const hasTrailingNewline = raw.endsWith("\n");
+  let partialLine;
+  if (!hasTrailingNewline && lines.length > 0) {
+    partialLine = lines.pop();
+  }
+  if (partialLine !== void 0 && partialLine.trim().length > 0) {
+    const fullContentBeforePartial = raw.slice(0, raw.length - partialLine.length);
+    const byteOffset = Buffer.byteLength(fullContentBeforePartial, "utf8");
+    const byteLength = Buffer.byteLength(partialLine, "utf8");
+    warnings.push({
+      kind: "partial_write_at_tail",
+      byte_offset: byteOffset,
+      byte_length: byteLength,
+      snippet_first_120: partialLine.slice(0, 120)
+    });
+  }
+  const events = lines.map((line) => line.trim()).filter((line) => line.length > 0).map((line, index) => parseEventLedgerLine(line, index)).filter((entry) => entry !== null).filter((entry) => options.event_type === void 0 || entry.event_type === options.event_type).filter((entry) => options.since === void 0 || entry.ts >= options.since).filter((entry) => options.correlation_id === void 0 || entry.correlation_id === options.correlation_id).filter((entry) => options.session_id === void 0 || entry.session_id === options.session_id);
+  return { events, warnings };
+}
+async function truncateLedgerToLastNewline(path) {
+  const raw = await readFile2(path);
+  const content = raw.toString("utf8");
+  if (content.endsWith("\n") || content.length === 0) {
+    return { truncated_bytes: 0, corrupted_path: "" };
+  }
+  const lastNewlineIndex = content.lastIndexOf("\n");
+  if (lastNewlineIndex === -1) {
+    const corruptedPath2 = `${path}.corrupted.${Date.now()}`;
+    await writeFile(corruptedPath2, raw);
+    await truncate(path, 0);
+    return { truncated_bytes: raw.length, corrupted_path: corruptedPath2 };
+  }
+  const keepByteLength = Buffer.byteLength(content.slice(0, lastNewlineIndex + 1), "utf8");
+  const corruptedBytes = raw.slice(keepByteLength);
+  const corruptedPath = `${path}.corrupted.${Date.now()}`;
+  await writeFile(corruptedPath, corruptedBytes);
+  await truncate(path, keepByteLength);
+  return { truncated_bytes: corruptedBytes.length, corrupted_path: corruptedPath };
+}
+function parseEventLedgerLine(line, index) {
+  try {
+    const parsed = JSON.parse(line);
+    const result = eventLedgerEventSchema.safeParse(parsed);
+    if (!result.success) {
+      return null;
+    }
+    return {
+      ...result.data,
+      id: result.data.id || createDerivedId(index, line)
+    };
+  } catch {
+    return null;
+  }
+}
+function createDerivedId(index, line) {
+  return `event:${index + 1}:${sha256(line).slice("sha256:".length)}`;
+}
+function isNodeError2(error) {
+  return error instanceof Error;
+}
+function flushAndSyncEventLedger(projectRoot) {
+  const ledgerPath = getEventLedgerPath(projectRoot);
+  if (!existsSync(ledgerPath)) return;
+  const fd = openSync(ledgerPath, "r+");
+  try {
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+
+// src/services/rule-meta-builder.ts
+import { readdir, readFile as readFile3 } from "fs/promises";
+import { existsSync as existsSync2, statSync } from "fs";
+import { isAbsolute, join as join3, relative, resolve as resolve2, sep as sep2 } from "path";
+import {
+  RULE_TEST_INDEX_SCHEMA_VERSION,
+  agentsMetaSchema as agentsMetaSchema3,
+  deriveAgentsMetaLayer,
+  deriveAgentsMetaStableId,
+  deriveAgentsMetaTopologyType,
+  ruleTestIndexSchema
+} from "@fenglimg/fabric-shared";
+import { atomicWriteText as atomicWriteText2 } from "@fenglimg/fabric-shared/node/atomic-write";
+async function buildRuleMeta(projectRootInput) {
+  const projectRoot = normalizeProjectRoot(projectRootInput);
+  assertExistingDirectory(projectRoot);
+  const metaPath = join3(projectRoot, ".fabric", "agents.meta.json");
+  const ruleTestIndexPath = join3(projectRoot, ".fabric", "rule-test.index.json");
+  const existingMeta = await readExistingMeta(metaPath);
+  const existingRuleTestIndex = await readExistingRuleTestIndex(ruleTestIndexPath);
+  const meta = await computeRulesBasedAgentsMeta(projectRoot, existingMeta);
+  const ruleTestIndex = await computeRuleTestIndex(projectRoot, meta, existingRuleTestIndex);
+  return {
+    meta,
+    ruleTestIndex,
+    changed: existingMeta === void 0 || stableStringify(existingMeta) !== stableStringify(meta) || existingRuleTestIndex === void 0 || !isSameRuleTestIndex(existingRuleTestIndex, ruleTestIndex)
+  };
+}
+async function writeRuleMeta(projectRootInput, options) {
+  const projectRoot = normalizeProjectRoot(projectRootInput);
+  const metaPath = join3(projectRoot, ".fabric", "agents.meta.json");
+  const ruleTestIndexPath = join3(projectRoot, ".fabric", "rule-test.index.json");
+  const existingMeta = await readExistingMeta(metaPath);
+  const result = await buildRuleMeta(projectRoot);
+  if (!result.changed) {
+    return result;
+  }
+  await ensureParentDirectory(metaPath);
+  await atomicWriteText2(metaPath, `${JSON.stringify(result.meta, null, 2)}
+`);
+  await atomicWriteText2(ruleTestIndexPath, `${JSON.stringify(result.ruleTestIndex, null, 2)}
+`);
+  if (existingMeta === void 0 || stableStringify(existingMeta) !== stableStringify(result.meta)) {
+    await recordBaselineSynced(projectRoot, {
+      previousRevision: existingMeta?.revision,
+      revision: result.meta.revision,
+      syncedFiles: collectSyncedFiles(existingMeta, result.meta),
+      acceptedStableIds: collectStableIds(result.meta),
+      driftDetails: collectDriftDetails(existingMeta, result.meta),
+      source: options.source
+    });
+  }
+  return result;
+}
+async function computeRulesBasedAgentsMeta(projectRootInput, existingMeta) {
+  const projectRoot = normalizeProjectRoot(projectRootInput);
+  assertExistingDirectory(projectRoot);
+  const previousMeta = existingMeta ?? await readExistingMeta(join3(projectRoot, ".fabric", "agents.meta.json"));
+  const existingByContentRef = indexExistingNodesByContentRef(previousMeta);
+  const ruleFiles = await findFabricRuleFiles(projectRoot);
+  const nodes = {};
+  const bootstrapNode = await createBootstrapNode(projectRoot, existingByContentRef.get(".fabric/bootstrap/README.md")?.node);
+  if (bootstrapNode !== void 0) {
+    nodes.L0 = bootstrapNode;
+  }
+  for (const contentRef of ruleFiles) {
+    const source = await readFile3(join3(projectRoot, contentRef), "utf8");
+    const existing = existingByContentRef.get(contentRef);
+    const id = deriveNodeId(contentRef);
+    const hash = sha256(source);
+    const defaults = createDefaultNodeMeta(contentRef);
+    const identity = deriveRuleIdentity(contentRef, source, existing?.node);
+    nodes[id] = {
+      ...defaults,
+      ...existing?.node,
+      file: contentRef,
+      content_ref: contentRef,
+      hash,
+      stable_id: identity.stableId,
+      identity_source: identity.identitySource,
+      description: extractRuleDescription(source) ?? existing?.node.description,
+      sections: extractRuleSections(source)
+    };
+  }
+  return {
+    ...previousMeta ?? {},
+    revision: computeRevision(nodes),
+    nodes: sortNodes(nodes)
+  };
+}
+async function computeRuleTestIndex(projectRootInput, computedMeta, previousIndex) {
+  const projectRoot = normalizeProjectRoot(projectRootInput);
+  assertExistingDirectory(projectRoot);
+  const previousLinks = indexPreviousRuleTestEntries(previousIndex?.links ?? []);
+  const previousOrphans = indexPreviousRuleTestEntries(previousIndex?.orphan_annotations ?? []);
+  const rulesByStableId = indexRulesByStableId(computedMeta);
+  const links = [];
+  const orphanAnnotations = [];
+  for (const annotation of await findFabricVerifyAnnotations(projectRoot)) {
+    const rule = rulesByStableId.get(annotation.stableId);
+    const key = createRuleTestEntryKey(annotation.stableId, annotation.testFile, annotation.line);
+    if (rule === void 0) {
+      const previous2 = previousOrphans.get(key) ?? previousLinks.get(key);
+      orphanAnnotations.push({
+        rule_stable_id: annotation.stableId,
+        test_file: annotation.testFile,
+        test_hash: annotation.testHash,
+        previous_test_hash: getPreviousTestHash(previous2, annotation.testHash),
+        annotation_line: annotation.line
+      });
+      continue;
+    }
+    const previous = previousLinks.get(key) ?? previousOrphans.get(key);
+    const previousHashes = getPreviousRuleTestHashes(previous, rule.hash, annotation.testHash);
+    links.push({
+      rule_stable_id: annotation.stableId,
+      rule_file: rule.content_ref ?? rule.file,
+      rule_hash: rule.hash,
+      previous_rule_hash: previousHashes.previousRuleHash,
+      test_file: annotation.testFile,
+      test_hash: annotation.testHash,
+      previous_test_hash: previousHashes.previousTestHash,
+      annotation_line: annotation.line
+    });
+  }
+  return {
+    schema_version: RULE_TEST_INDEX_SCHEMA_VERSION,
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    revision: computedMeta.revision,
+    previous_revision: previousIndex?.revision !== void 0 && previousIndex.revision !== computedMeta.revision ? previousIndex.revision : previousIndex?.previous_revision,
+    links: links.sort(compareRuleTestEntries),
+    orphan_annotations: orphanAnnotations.sort(compareRuleTestEntries)
+  };
+}
+function deriveRuleMetaLayer(relativePath) {
+  return deriveAgentsMetaLayer(toAgentsCompatiblePath(relativePath));
+}
+function deriveRuleMetaTopologyType(relativePath) {
+  return deriveAgentsMetaTopologyType(toAgentsCompatiblePath(relativePath));
+}
+function isSameRuleTestIndex(left, right) {
+  return stableStringify(toComparableRuleTestIndex(left)) === stableStringify(toComparableRuleTestIndex(right));
+}
+function stableStringify(value) {
+  return JSON.stringify(value, Object.keys(flattenKeys(value)).sort());
+}
+function normalizeProjectRoot(projectRoot) {
+  return isAbsolute(projectRoot) ? projectRoot : resolve2(process.cwd(), projectRoot);
+}
+function assertExistingDirectory(projectRoot) {
+  if (!existsSync2(projectRoot) || !statSync(projectRoot).isDirectory()) {
+    throw new Error(`Target directory does not exist: ${projectRoot}`);
+  }
+}
+async function readExistingMeta(metaPath) {
+  let raw;
+  try {
+    raw = await readFile3(metaPath, "utf8");
+  } catch (error) {
+    if (isNodeError3(error) && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+  try {
+    return agentsMetaSchema3.parse(JSON.parse(raw));
+  } catch {
+    return void 0;
+  }
+}
+async function readExistingRuleTestIndex(indexPath) {
+  let raw;
+  try {
+    raw = await readFile3(indexPath, "utf8");
+  } catch (error) {
+    if (isNodeError3(error) && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+  try {
+    return ruleTestIndexSchema.parse(JSON.parse(raw));
+  } catch {
+    return void 0;
+  }
+}
+async function findFabricRuleFiles(projectRoot) {
+  const rulesRoot = join3(projectRoot, ".fabric", "rules");
+  if (!existsSync2(rulesRoot) || !statSync(rulesRoot).isDirectory()) {
+    return [];
+  }
+  const files = [];
+  const stack = [rulesRoot];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === void 0) {
+      continue;
+    }
+    for (const entry of await readdir(current, { withFileTypes: true })) {
+      const absolutePath = join3(current, entry.name);
+      const relativePath = toPosixPath(relative(projectRoot, absolutePath));
+      if (entry.isDirectory()) {
+        stack.push(absolutePath);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        files.push(relativePath);
+      }
+    }
+  }
+  return files.sort();
+}
+async function findFabricVerifyAnnotations(projectRoot) {
+  const files = await findTestFiles(projectRoot);
+  const annotations = [];
+  const annotationPattern = /^\s*\/\/\s*@fabric-verify\s+([A-Za-z0-9][A-Za-z0-9/_-]*)\s*$/u;
+  for (const testFile of files) {
+    const source = await readFile3(join3(projectRoot, testFile), "utf8");
+    const testHash = sha256(source);
+    const lines = source.split(/\r?\n/u);
+    for (const [index, line] of lines.entries()) {
+      const match = annotationPattern.exec(line);
+      if (match === null) {
+        continue;
+      }
+      annotations.push({
+        stableId: match[1],
+        testFile,
+        testHash,
+        line: index + 1
+      });
+    }
+  }
+  return annotations.sort(compareAnnotationEntries);
+}
+async function findTestFiles(projectRoot) {
+  const ignoredRootSegments = /* @__PURE__ */ new Set([".git", ".fabric", "node_modules", "dist", "build", "coverage"]);
+  const files = [];
+  const stack = [projectRoot];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === void 0) {
+      continue;
+    }
+    for (const entry of await readdir(current, { withFileTypes: true })) {
+      const absolutePath = join3(current, entry.name);
+      const relativePath = toPosixPath(relative(projectRoot, absolutePath));
+      const [rootSegment] = relativePath.split("/");
+      if (entry.isDirectory()) {
+        if (!ignoredRootSegments.has(rootSegment) && !ignoredRootSegments.has(entry.name)) {
+          stack.push(absolutePath);
+        }
+        continue;
+      }
+      if (entry.isFile() && isTestFile(relativePath)) {
+        files.push(relativePath);
+      }
+    }
+  }
+  return files.sort();
+}
+function isTestFile(relativePath) {
+  return /\.(?:test|spec)\.[cm]?[jt]sx?$/u.test(relativePath);
+}
+function indexRulesByStableId(meta) {
+  const rules = /* @__PURE__ */ new Map();
+  for (const node of Object.values(meta.nodes)) {
+    if (node.stable_id !== void 0) {
+      rules.set(node.stable_id, node);
+    }
+  }
+  return rules;
+}
+function indexPreviousRuleTestEntries(entries) {
+  const previous = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    previous.set(createRuleTestEntryKey(entry.rule_stable_id, entry.test_file, entry.annotation_line), {
+      rule_hash: entry.rule_hash,
+      previous_rule_hash: entry.previous_rule_hash,
+      test_hash: entry.test_hash,
+      previous_test_hash: entry.previous_test_hash
+    });
+  }
+  return previous;
+}
+function createRuleTestEntryKey(stableId, testFile, line) {
+  return `${stableId}\0${testFile}\0${line}`;
+}
+function getPreviousRuleTestHashes(previous, ruleHash, testHash) {
+  if (previous === void 0) {
+    return {};
+  }
+  return {
+    previousRuleHash: previous.rule_hash !== void 0 && previous.rule_hash !== ruleHash ? previous.rule_hash : previous.previous_rule_hash,
+    previousTestHash: previous.test_hash !== testHash ? previous.test_hash : previous.previous_test_hash
+  };
+}
+function getPreviousTestHash(previous, testHash) {
+  if (previous === void 0) {
+    return void 0;
+  }
+  return previous.test_hash !== testHash ? previous.test_hash : previous.previous_test_hash;
+}
+function compareRuleTestEntries(left, right) {
+  return left.rule_stable_id.localeCompare(right.rule_stable_id) || left.test_file.localeCompare(right.test_file) || left.annotation_line - right.annotation_line;
+}
+function compareAnnotationEntries(left, right) {
+  return left.stableId.localeCompare(right.stableId) || left.testFile.localeCompare(right.testFile) || left.line - right.line;
+}
+function toComparableRuleTestIndex(index) {
+  const { generated_at: _generatedAt, ...comparable } = index;
+  return comparable;
+}
+function indexExistingNodesByContentRef(existingMeta) {
+  const byContentRef = /* @__PURE__ */ new Map();
+  for (const [id, node] of Object.entries(existingMeta?.nodes ?? {})) {
+    byContentRef.set(toPosixPath(node.content_ref ?? node.file), { id, node });
+  }
+  return byContentRef;
+}
+function deriveNodeId(file) {
+  if (file === ".fabric/bootstrap/README.md") {
+    return "L0";
+  }
+  const layer = deriveRuleMetaLayer(file);
+  const relativeStem = getRuleRelativeStem(file);
+  return `${layer}/${relativeStem}`;
+}
+function createDefaultNodeMeta(contentRef) {
+  const layer = deriveRuleMetaLayer(contentRef);
+  const topologyType = deriveRuleMetaTopologyType(contentRef);
+  return {
+    file: contentRef,
+    content_ref: contentRef,
+    scope_glob: deriveScopeGlob(contentRef),
+    deps: layer === "L0" ? [] : ["L0"],
+    priority: layer === "L0" ? "high" : "medium",
+    level: layer,
+    layer,
+    topology_type: topologyType,
+    hash: ""
+  };
+}
+async function createBootstrapNode(projectRoot, existing) {
+  const contentRef = ".fabric/bootstrap/README.md";
+  const bootstrapPath = join3(projectRoot, contentRef);
+  if (!existsSync2(bootstrapPath)) {
+    return void 0;
+  }
+  const hash = sha256(await readFile3(bootstrapPath, "utf8"));
+  const identity = {
+    stableId: existing?.stable_id ?? deriveAgentsMetaStableId(contentRef),
+    identitySource: existing?.identity_source ?? "derived"
+  };
+  return {
+    ...createDefaultNodeMeta(contentRef),
+    ...existing,
+    file: contentRef,
+    content_ref: contentRef,
+    hash,
+    stable_id: identity.stableId,
+    identity_source: identity.identitySource
+  };
+}
+function deriveScopeGlob(contentRef) {
+  if (contentRef === ".fabric/bootstrap/README.md") {
+    return "**";
+  }
+  const stem = getRuleRelativeStem(contentRef);
+  const segments = stem.split("/").filter(Boolean);
+  if (segments.length === 0 || stem === "root") {
+    return "**";
+  }
+  if (segments[0] === "_cross") {
+    return "**";
+  }
+  if (segments.at(-1) === "rules") {
+    segments.pop();
+  }
+  const scopePath = segments.join("/");
+  return scopePath === "" ? "**" : `${scopePath}/**`;
+}
+function getRuleRelativeStem(contentRef) {
+  return contentRef.replace(/^\.fabric\/rules\//u, "").replace(/\.md$/u, "");
+}
+function toAgentsCompatiblePath(contentRef) {
+  return contentRef.replace(/^\.fabric\/rules\//u, ".fabric/agents/");
+}
+function sortNodes(nodes) {
+  return Object.fromEntries(Object.entries(nodes).sort(([left], [right]) => left.localeCompare(right)));
+}
+function computeRevision(nodes) {
+  const revisionSource = Object.entries(sortNodes(nodes)).map(([id, node]) => [id, node.hash, node.stable_id ?? "", node.identity_source ?? ""].join("|")).join("\n");
+  return sha256(revisionSource);
+}
+function collectSyncedFiles(existingMeta, computedMeta) {
+  if (existingMeta === void 0) {
+    return Object.values(computedMeta.nodes).map((node) => node.content_ref ?? node.file).sort();
+  }
+  const existingByContentRef = indexExistingNodesByContentRef(existingMeta);
+  return Object.values(computedMeta.nodes).filter((node) => {
+    const existing = existingByContentRef.get(node.content_ref ?? node.file)?.node;
+    return existing === void 0 || existing.hash !== node.hash || existing.stable_id !== node.stable_id || existing.identity_source !== node.identity_source;
+  }).map((node) => node.content_ref ?? node.file).sort();
+}
+function collectStableIds(meta) {
+  return Object.values(meta.nodes).map((node) => node.stable_id).filter((stableId) => stableId !== void 0).sort();
+}
+function collectDriftDetails(existingMeta, computedMeta) {
+  if (existingMeta === void 0) {
+    return [];
+  }
+  const computedByContentRef = indexExistingNodesByContentRef(computedMeta);
+  return Object.values(existingMeta.nodes).map((existingNode) => {
+    const contentRef = existingNode.content_ref ?? existingNode.file;
+    const computedNode = computedByContentRef.get(contentRef)?.node;
+    const stableId = existingNode.stable_id ?? computedNode?.stable_id;
+    if (computedNode === void 0 || stableId === void 0 || existingNode.hash === computedNode.hash) {
+      return null;
+    }
+    return {
+      file: contentRef,
+      stable_id: stableId,
+      expected_hash: existingNode.hash,
+      actual_hash: computedNode.hash
+    };
+  }).filter((detail) => detail !== null);
+}
+async function recordBaselineSynced(projectRoot, input) {
+  if (input.driftDetails.length > 0) {
+    await appendEventLedgerEvent(projectRoot, {
+      event_type: "rule_drift_detected",
+      revision: input.previousRevision ?? input.revision,
+      drifted_stable_ids: input.driftDetails.map((detail) => detail.stable_id),
+      missing_files: input.driftDetails.filter((detail) => detail.actual_hash === null).map((detail) => detail.file),
+      stale_files: input.driftDetails.filter((detail) => detail.actual_hash !== null).map((detail) => detail.file),
+      details: input.driftDetails
+    });
+  }
+  await appendEventLedgerEvent(projectRoot, {
+    event_type: "rule_baseline_accepted",
+    revision: input.revision,
+    previous_revision: input.previousRevision,
+    accepted_stable_ids: input.acceptedStableIds,
+    source: input.source
+  });
+  await appendEventLedgerEvent(projectRoot, {
+    event_type: "baseline_synced",
+    revision: input.revision,
+    previous_revision: input.previousRevision,
+    synced_files: input.syncedFiles,
+    accepted_stable_ids: input.acceptedStableIds,
+    source: input.source
+  });
+}
+function flattenKeys(value, keys = {}) {
+  if (value && typeof value === "object") {
+    for (const [key, child] of Object.entries(value)) {
+      keys[key] = true;
+      flattenKeys(child, keys);
+    }
+  }
+  return keys;
+}
+function toPosixPath(path) {
+  return path.split(sep2).join("/");
+}
+function deriveRuleIdentity(file, source, existing) {
+  const declaredStableId = extractDeclaredStableId(source);
+  const derivedStableId = deriveAgentsMetaStableId(toAgentsCompatiblePath(file));
+  if (declaredStableId !== void 0) {
+    return {
+      stableId: declaredStableId,
+      identitySource: "declared"
+    };
+  }
+  if (existing?.identity_source === "declared" && existing.stable_id !== void 0 && existing.stable_id !== derivedStableId) {
+    return {
+      stableId: existing.stable_id,
+      identitySource: "declared"
+    };
+  }
+  return {
+    stableId: derivedStableId,
+    identitySource: "derived"
+  };
+}
+function extractDeclaredStableId(source) {
+  const match = /^(?:\uFEFF)?(?:---\r?\n[\s\S]*?\r?\n---\s*(?:\r?\n|$))?<!--\s*fab:rule-id\s+([A-Za-z0-9][A-Za-z0-9/_-]*)\s*-->\s*(?:\r?\n|$)/u.exec(source);
+  return match?.[1];
+}
+function extractRuleDescription(source) {
+  const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---\s*(?:\r?\n|$)/u.exec(source);
+  const description = frontmatter === null ? void 0 : extractDescriptionFromFrontmatter(frontmatter[1]);
+  if (description !== void 0) {
+    return description;
+  }
+  const heading = /^#\s+(.+?)\s*$/mu.exec(source);
+  const summary = heading?.[1]?.trim();
+  if (summary === void 0 || summary.length === 0) {
+    return void 0;
+  }
+  return {
+    summary,
+    intent_clues: [],
+    tech_stack: [],
+    impact: [],
+    must_read_if: summary
+  };
+}
+function extractRuleSections(source) {
+  const sections = Array.from(source.matchAll(/^(?:#{2,6})\s+\[([A-Z_]+)\]\s*$/gmu)).map((match) => match[1]).filter((section, index, all) => all.indexOf(section) === index);
+  return sections.length > 0 ? sections : void 0;
+}
+function extractDescriptionFromFrontmatter(frontmatter) {
+  const summary = extractScalar(frontmatter, "summary") ?? extractScalar(frontmatter, "description");
+  if (summary === void 0) {
+    return void 0;
+  }
+  return {
+    summary,
+    intent_clues: extractInlineArray(frontmatter, "intent_clues"),
+    tech_stack: extractInlineArray(frontmatter, "tech_stack"),
+    impact: extractInlineArray(frontmatter, "impact"),
+    must_read_if: extractScalar(frontmatter, "must_read_if") ?? summary,
+    entities: extractInlineArray(frontmatter, "entities")
+  };
+}
+function extractScalar(frontmatter, key) {
+  const pattern = new RegExp(`^${escapeRegExp(key)}:\\s*(.+?)\\s*$`, "mu");
+  const match = pattern.exec(frontmatter);
+  if (match === null) {
+    return void 0;
+  }
+  return unquote(match[1].trim());
+}
+function extractInlineArray(frontmatter, key) {
+  const pattern = new RegExp(`^${escapeRegExp(key)}:\\s*\\[(.*?)\\]\\s*$`, "mu");
+  const match = pattern.exec(frontmatter);
+  if (match === null) {
+    return [];
+  }
+  return match[1].split(",").map((item) => unquote(item.trim())).filter((item) => item.length > 0);
+}
+function unquote(value) {
+  return value.replace(/^["'](.*)["']$/u, "$1");
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function isNodeError3(error) {
+  return error instanceof Error;
+}
+
+// src/services/rule-sync.ts
+import { readdir as readdir2, readFile as readFile4, stat } from "fs/promises";
+import { existsSync as existsSync3, statSync as statSync2 } from "fs";
+import { join as join4, relative as relative2, sep as sep3 } from "path";
+import { RuleValidationError } from "@fenglimg/fabric-shared/errors";
+var lastSyncState = /* @__PURE__ */ new Map();
+var freshSyncCooldown = /* @__PURE__ */ new Map();
+var SYNC_COOLDOWN_MS = 500;
+function invalidateRuleSyncCooldown(projectRoot) {
+  freshSyncCooldown.delete(projectRoot);
+}
+async function readMetaEntries(projectRoot) {
+  const metaPath = join4(projectRoot, ".fabric", "agents.meta.json");
+  const map = /* @__PURE__ */ new Map();
+  let raw;
+  try {
+    raw = await readFile4(metaPath, "utf8");
+  } catch {
+    return map;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return map;
+  }
+  for (const node of Object.values(parsed.nodes ?? {})) {
+    const path = node.content_ref ?? node.file;
+    const stable_id = node.stable_id;
+    const content_hash = node.hash;
+    if (path !== void 0 && stable_id !== void 0 && content_hash !== void 0) {
+      map.set(path, { stable_id, path, content_hash });
+    }
+  }
+  return map;
+}
+async function findRuleFiles(projectRoot) {
+  const rulesRoot = join4(projectRoot, ".fabric", "rules");
+  if (!existsSync3(rulesRoot) || !statSync2(rulesRoot).isDirectory()) {
+    return [];
+  }
+  const files = [];
+  const stack = [rulesRoot];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === void 0) {
+      continue;
+    }
+    for (const entry of await readdir2(current, { withFileTypes: true })) {
+      const absolutePath = join4(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(absolutePath);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        const rel = toPosixPath2(relative2(projectRoot, absolutePath));
+        files.push(rel);
+      }
+    }
+  }
+  return files.sort();
+}
+function toPosixPath2(p) {
+  return p.split(sep3).join("/");
+}
+function validateFrontmatter(source, filePath, throwOnInvalid) {
+  if (!source.startsWith("---")) {
+    return null;
+  }
+  const endIdx = source.indexOf("\n---", 3);
+  if (endIdx === -1) {
+    const msg = `Unterminated YAML frontmatter in ${filePath}`;
+    if (throwOnInvalid) {
+      throw new RuleValidationError(msg, {
+        actionHint: "Run `fab doctor --fix` to repair frontmatter",
+        fixable: true,
+        details: { file: filePath }
+      });
+    }
+    return {
+      code: "rule_frontmatter_invalid",
+      file: filePath,
+      action_hint: "Run `fab doctor --fix` to repair frontmatter"
+    };
+  }
+  const frontmatter = source.slice(3, endIdx).trim();
+  for (const line of frontmatter.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0 || trimmed.startsWith("#")) {
+      continue;
+    }
+    if (!trimmed.includes(":") && !trimmed.startsWith("-")) {
+      const msg = `Invalid YAML frontmatter line "${trimmed}" in ${filePath}`;
+      if (throwOnInvalid) {
+        throw new RuleValidationError(msg, {
+          actionHint: "Run `fab doctor --fix` to repair frontmatter",
+          fixable: true,
+          details: { file: filePath, line: trimmed }
+        });
+      }
+      return {
+        code: "rule_frontmatter_invalid",
+        file: filePath,
+        action_hint: "Run `fab doctor --fix` to repair frontmatter"
+      };
+    }
+  }
+  return null;
+}
+async function processSingleFile(projectRoot, relPath, metaEntry, source, throwOnInvalidFrontmatter) {
+  const absPath = join4(projectRoot, relPath);
+  try {
+    await stat(absPath);
+  } catch {
+    if (metaEntry !== void 0) {
+      return {
+        event: {
+          type: "rule_removed",
+          stable_id: metaEntry.stable_id,
+          path: relPath,
+          prev_hash: metaEntry.content_hash,
+          new_hash: null,
+          changed_fields: ["content"],
+          source
+        },
+        warning: null
+      };
+    }
+    return { event: null, warning: null };
+  }
+  let content;
+  try {
+    content = await readFile4(absPath, "utf8");
+  } catch {
+    return { event: null, warning: null };
+  }
+  const newHash = sha256(content);
+  const now = Date.now();
+  const debounce = lastSyncState.get(absPath);
+  if (debounce !== void 0 && newHash === debounce.hash && now - debounce.ts < 500) {
+    return { event: null, warning: null };
+  }
+  if (metaEntry !== void 0 && newHash === metaEntry.content_hash) {
+    lastSyncState.set(absPath, { ts: now, hash: newHash });
+    return { event: null, warning: null };
+  }
+  const warning = validateFrontmatter(content, relPath, throwOnInvalidFrontmatter);
+  if (warning !== null) {
+    lastSyncState.set(absPath, { ts: now, hash: newHash });
+    return { event: null, warning };
+  }
+  const prevHash = metaEntry?.content_hash ?? debounce?.hash ?? null;
+  const stableId = metaEntry?.stable_id ?? relPath;
+  const eventType = metaEntry === void 0 ? "rule_added" : "rule_content_changed";
+  lastSyncState.set(absPath, { ts: now, hash: newHash });
+  return {
+    event: {
+      type: eventType,
+      stable_id: stableId,
+      path: relPath,
+      prev_hash: prevHash,
+      new_hash: newHash,
+      changed_fields: ["content"],
+      source
+    },
+    warning: null
+  };
+}
+async function appendRuleSyncEvents(projectRoot, events) {
+  if (events.length === 0) {
+    return;
+  }
+  const driftedIds = events.map((e) => e.stable_id);
+  const missingFiles = events.filter((e) => e.type === "rule_removed").map((e) => e.path);
+  const staleFiles = events.filter((e) => e.type !== "rule_removed").map((e) => e.path);
+  if (missingFiles.length > 0 || staleFiles.length > 0) {
+    await appendEventLedgerEvent(projectRoot, {
+      event_type: "rule_drift_detected",
+      drifted_stable_ids: driftedIds,
+      missing_files: missingFiles,
+      stale_files: staleFiles
+    });
+  }
+}
+async function ensureRulesFresh(projectRoot, opts) {
+  const mode = opts?.mode ?? "incremental";
+  const cooldownExpiry = freshSyncCooldown.get(projectRoot);
+  if (cooldownExpiry !== void 0 && Date.now() < cooldownExpiry && mode !== "full") {
+    return { status: "fresh", events: [], warnings: [] };
+  }
+  const throwOnInvalidFrontmatter = opts?.throwOnInvalidFrontmatter ?? false;
+  const source = "ensureRulesFresh";
+  const events = [];
+  const warnings = [];
+  const metaEntries = await readMetaEntries(projectRoot);
+  const ruleFiles = await findRuleFiles(projectRoot);
+  const filesToCheck = ruleFiles;
+  for (const relPath of filesToCheck) {
+    const metaEntry = metaEntries.get(relPath);
+    const result = await processSingleFile(projectRoot, relPath, metaEntry, source, throwOnInvalidFrontmatter);
+    if (result.event !== null) {
+      events.push(result.event);
+    }
+    if (result.warning !== null) {
+      warnings.push(result.warning);
+    }
+  }
+  for (const [relPath, entry] of metaEntries) {
+    if (!ruleFiles.includes(relPath)) {
+      const absPath = join4(projectRoot, relPath);
+      if (!existsSync3(absPath)) {
+        events.push({
+          type: "rule_removed",
+          stable_id: entry.stable_id,
+          path: relPath,
+          prev_hash: entry.content_hash,
+          new_hash: null,
+          changed_fields: ["content"],
+          source
+        });
+      }
+    }
+  }
+  if (events.length === 0 && warnings.length === 0) {
+    freshSyncCooldown.set(projectRoot, Date.now() + SYNC_COOLDOWN_MS);
+    return { status: "fresh", events: [], warnings: [] };
+  }
+  if (events.length > 0) {
+    await appendRuleSyncEvents(projectRoot, events);
+    contextCache.invalidate("file_watch", projectRoot);
+  }
+  freshSyncCooldown.delete(projectRoot);
+  const status = warnings.length > 0 ? "errors" : "reconciled";
+  return {
+    status,
+    events,
+    warnings,
+    reconciled_files: events.map((e) => e.path)
+  };
+}
+async function reconcileRules(projectRoot, opts) {
+  freshSyncCooldown.delete(projectRoot);
+  const trigger = opts?.trigger;
+  const startTime = Date.now();
+  const source = "reconcileRules";
+  const events = [];
+  const warnings = [];
+  const metaEntries = await readMetaEntries(projectRoot);
+  const ruleFiles = await findRuleFiles(projectRoot);
+  for (const relPath of ruleFiles) {
+    const metaEntry = metaEntries.get(relPath);
+    const result = await processSingleFile(projectRoot, relPath, metaEntry, source, false);
+    if (result.event !== null) {
+      events.push(result.event);
+    }
+    if (result.warning !== null) {
+      warnings.push(result.warning);
+    }
+  }
+  for (const [relPath, entry] of metaEntries) {
+    if (!ruleFiles.includes(relPath)) {
+      const absPath = join4(projectRoot, relPath);
+      if (!existsSync3(absPath)) {
+        events.push({
+          type: "rule_removed",
+          stable_id: entry.stable_id,
+          path: relPath,
+          prev_hash: entry.content_hash,
+          new_hash: null,
+          changed_fields: ["content"],
+          source
+        });
+      }
+    }
+  }
+  if (events.length > 0) {
+    await writeRuleMeta(projectRoot, { source: "sync_meta" });
+    await appendRuleSyncEvents(projectRoot, events);
+    contextCache.invalidate("file_watch", projectRoot);
+  }
+  const duration_ms = Date.now() - startTime;
+  const reconciledFiles = events.map((e) => e.path);
+  if (trigger !== void 0 && events.length > 0) {
+    if (trigger === "startup") {
+      await appendEventLedgerEvent(projectRoot, {
+        event_type: "meta_reconciled_on_startup",
+        reconciled_files: reconciledFiles,
+        duration_ms,
+        source: "reconcileRules"
+      });
+    } else {
+      await appendEventLedgerEvent(projectRoot, {
+        event_type: "meta_reconciled",
+        reconciled_files: reconciledFiles,
+        duration_ms,
+        trigger,
+        source: "reconcileRules"
+      });
+    }
+  }
+  if (events.length === 0 && warnings.length === 0) {
+    return { status: "fresh", events: [], warnings: [] };
+  }
+  const status = warnings.length > 0 ? "errors" : "reconciled";
+  return {
+    status,
+    events,
+    warnings,
+    reconciled_files: reconciledFiles
+  };
+}
+
+// src/services/doctor.ts
+import { existsSync as existsSync4, mkdirSync, readdirSync, readFileSync, rmdirSync, renameSync, statSync as statSync3 } from "fs";
+import { access, readFile as readFile7, writeFile as writeFile2 } from "fs/promises";
+import { constants } from "fs";
+import { isAbsolute as isAbsolute3, join as join8, posix as posix2, resolve as resolve4 } from "path";
+import {
+  agentsMetaSchema as agentsMetaSchema4,
+  forensicReportSchema,
+  ruleTestIndexSchema as ruleTestIndexSchema2
+} from "@fenglimg/fabric-shared";
+import { detectFramework } from "@fenglimg/fabric-shared/node";
+
+// src/services/rule-sections.ts
+import { readFile as readFile6 } from "fs/promises";
+import { join as join7 } from "path";
+
+// src/services/audit-log.ts
+import { open, stat as stat2 } from "fs/promises";
+import { isAbsolute as isAbsolute2, join as join5, posix, relative as relative3, resolve as resolve3 } from "path";
+var AUDIT_LOG_FILE = `${FABRIC_DIR}/audit.jsonl`;
+var DEFAULT_AUDIT_WINDOW_MS = 5 * 60 * 1e3;
+async function appendGetRulesAuditEvent(projectRoot, input) {
+  const entry = {
+    kind: "audit-event",
+    event: "get_rules",
+    ts: input.ts ?? Date.now(),
+    path: normalizeAuditPath(projectRoot, input.path),
+    client_hash: input.client_hash
+  };
+  await appendAuditLogEventLedgerEvents(projectRoot, [entry], {
+    rule_context: {
+      required_stable_ids: input.required_stable_ids,
+      ai_selectable_stable_ids: input.ai_selectable_stable_ids,
+      final_stable_ids: input.final_stable_ids
+    },
+    correlation_id: input.correlation_id,
+    session_id: input.session_id
+  });
+  return entry;
+}
+async function appendRuleSelectionAuditEvent(projectRoot, input) {
+  const entry = {
+    kind: "audit-event",
+    event: "rule_selection",
+    ts: input.ts ?? Date.now(),
+    path: normalizeAuditPath(projectRoot, input.path),
+    selection_token: input.selection_token,
+    target_paths: input.target_paths.map((path) => normalizeAuditPath(projectRoot, path)),
+    required_stable_ids: input.required_stable_ids,
+    ai_selectable_stable_ids: input.ai_selectable_stable_ids,
+    ai_selected_stable_ids: input.ai_selected_stable_ids,
+    final_stable_ids: input.final_stable_ids,
+    ai_selection_reasons: input.ai_selection_reasons,
+    rejected_stable_ids: input.rejected_stable_ids,
+    ignored_stable_ids: input.ignored_stable_ids
+  };
+  await appendAuditLogEventLedgerEvents(projectRoot, [entry], {
+    correlation_id: input.correlation_id,
+    session_id: input.session_id
+  });
+  return entry;
+}
+function normalizeAuditPath(projectRoot, value) {
+  const normalizedProjectRoot = resolve3(projectRoot);
+  const candidate = isAbsolute2(value) ? resolve3(value) : resolve3(normalizedProjectRoot, value);
+  const relativePath = relative3(normalizedProjectRoot, candidate);
+  if (relativePath.length > 0 && relativePath !== "." && !relativePath.startsWith("..") && !isAbsolute2(relativePath)) {
+    return posix.normalize(relativePath.split("\\").join("/"));
+  }
+  return posix.normalize(value.replaceAll("\\", "/"));
+}
+async function appendAuditLogEventLedgerEvents(projectRoot, entries, metadata = {}) {
+  for (const entry of entries) {
+    if (entry.event === "get_rules") {
+      await appendEventLedgerEvent(projectRoot, {
+        event_type: "rule_context_planned",
+        ts: entry.ts,
+        target_paths: [entry.path],
+        required_stable_ids: metadata.rule_context?.required_stable_ids ?? [],
+        ai_selectable_stable_ids: metadata.rule_context?.ai_selectable_stable_ids ?? [],
+        final_stable_ids: metadata.rule_context?.final_stable_ids ?? [],
+        client_hash: entry.client_hash,
+        correlation_id: metadata.correlation_id,
+        session_id: metadata.session_id
+      });
+      continue;
+    }
+    if (entry.event === "rule_selection") {
+      await appendEventLedgerEvent(projectRoot, {
+        event_type: "rule_selection",
+        ts: entry.ts,
+        selection_token: entry.selection_token,
+        target_paths: entry.target_paths,
+        required_stable_ids: entry.required_stable_ids,
+        ai_selectable_stable_ids: entry.ai_selectable_stable_ids,
+        ai_selected_stable_ids: entry.ai_selected_stable_ids,
+        final_stable_ids: entry.final_stable_ids,
+        ai_selection_reasons: entry.ai_selection_reasons,
+        rejected_stable_ids: entry.rejected_stable_ids,
+        ignored_stable_ids: entry.ignored_stable_ids,
+        correlation_id: metadata.correlation_id,
+        session_id: metadata.session_id
+      });
+      continue;
+    }
+    await appendEventLedgerEvent(projectRoot, {
+      event_type: "edit_intent_checked",
+      ts: entry.ts,
+      path: entry.path,
+      compliant: entry.compliant,
+      intent: entry.intent,
+      ledger_entry_id: entry.ledger_entry_id,
+      ledger_source: "ai",
+      matched_rule_context_ts: entry.matched_get_rules_ts,
+      window_ms: entry.window_ms,
+      correlation_id: metadata.correlation_id,
+      session_id: metadata.session_id
+    });
+  }
+}
+
+// src/services/get-rules.ts
+import { readFile as readFile5 } from "fs/promises";
+import { join as join6 } from "path";
+import { minimatch } from "minimatch";
+var PRIORITY_ORDER = {
+  high: 0,
+  medium: 1,
+  low: 2
+};
+async function getRules(projectRoot, input) {
+  const context = await loadGetRulesContext(projectRoot);
+  const stale = input.client_hash !== void 0 && input.client_hash !== context.meta.revision;
+  const matchedNodes = matchRuleNodes(context.meta, input.path);
+  const requiredStableIds = matchedNodes.filter((node) => node.level === "L2").map((node) => node.stable_id);
+  const aiSelectableStableIds = matchedNodes.filter((node) => node.level === "L1").map((node) => node.stable_id);
+  const rules = await resolveRulesForPath(projectRoot, context, input.path);
+  const result = {
+    revision_hash: context.meta.revision,
+    stale,
+    rules
+  };
+  try {
+    await appendGetRulesAuditEvent(projectRoot, {
+      path: input.path,
+      client_hash: input.client_hash,
+      required_stable_ids: requiredStableIds,
+      ai_selectable_stable_ids: aiSelectableStableIds,
+      final_stable_ids: [...requiredStableIds, ...aiSelectableStableIds],
+      correlation_id: input.correlation_id,
+      session_id: input.session_id
+    });
+  } catch {
+  }
+  return result;
+}
+async function loadGetRulesContext(projectRoot) {
+  const cached = contextCache.get("context", projectRoot);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const meta = await readAgentsMeta(projectRoot);
+  const l0Content = await readFile5(join6(projectRoot, ".fabric", "bootstrap", "README.md"), "utf8");
+  const context = {
+    meta,
+    l0Content,
+    humanLockedNearby: []
+  };
+  contextCache.set("context", projectRoot, context);
+  return context;
+}
+async function resolveRulesForPath(projectRoot, context, path, options = {}) {
+  const matchedNodes = matchRuleNodes(context.meta, path);
+  const loaded = await loadMatchedRules(projectRoot, matchedNodes);
+  return buildRulesPayload(context, loaded, options);
+}
+function normalizeRulesPath(value) {
+  return value.replaceAll("\\", "/");
+}
+function matchRuleNodes(meta, path) {
+  const requestedPath = normalizeRulesPath(path);
+  return Object.entries(meta.nodes).filter(([, node]) => shouldLoadNodeForPath(requestedPath, node)).sort((left, right) => {
+    const [leftId, leftNode] = left;
+    const [rightId, rightNode] = right;
+    const priorityDelta = PRIORITY_ORDER[leftNode.priority] - PRIORITY_ORDER[rightNode.priority];
+    return priorityDelta !== 0 ? priorityDelta : leftId.localeCompare(rightId);
+  }).map(([nodeId, node]) => ({
+    node_id: nodeId,
+    level: classifyNode(nodeId, node),
+    stable_id: node.stable_id ?? nodeId,
+    identity_source: node.identity_source ?? "derived",
+    node
+  }));
+}
+async function loadMatchedRules(projectRoot, matchedNodes, fileContentCache = /* @__PURE__ */ new Map()) {
+  const rules = [];
+  const stubs = [];
+  for (const matchedNode of matchedNodes) {
+    if (matchedNode.level === null) {
+      continue;
+    }
+    if (matchedNode.node.activation?.tier === "description") {
+      stubs.push({
+        stable_id: matchedNode.stable_id,
+        identity_source: matchedNode.identity_source,
+        level: matchedNode.level,
+        path: matchedNode.node.file,
+        description: matchedNode.node.activation.description ?? ""
+      });
+      continue;
+    }
+    rules.push({
+      level: matchedNode.level,
+      stable_id: matchedNode.stable_id,
+      identity_source: matchedNode.identity_source,
+      entry: {
+        path: matchedNode.node.file,
+        content: await readRuleContent(projectRoot, matchedNode.node.file, fileContentCache)
+      }
+    });
+  }
+  return { rules, stubs };
+}
+function buildRulesPayload(context, loaded, options = {}) {
+  const { L1, L2 } = partitionRulesByLevel(loaded.rules, options.dedupeByPath ?? false);
+  return {
+    L0: context.l0Content,
+    L1,
+    L2,
+    human_locked_nearby: context.humanLockedNearby,
+    description_stubs: loaded.stubs.length > 0 ? dedupeDescriptionStubsByPath(loaded.stubs).map(toDescriptionStub) : void 0
+  };
+}
+function classifyNode(nodeId, node) {
+  if (nodeId.startsWith("L1/")) {
+    return "L1";
+  }
+  if (nodeId.startsWith("L2/")) {
+    return "L2";
+  }
+  return node.layer === "L0" ? null : node.layer;
+}
+function partitionRulesByLevel(loadedRules, dedupeByPath) {
+  const l1 = [];
+  const l2 = [];
+  for (const rule of loadedRules) {
+    if (rule.level === "L1") {
+      l1.push(rule.entry);
+      continue;
+    }
+    if (rule.level === "L2") {
+      l2.push(rule.entry);
+    }
+  }
+  return {
+    L1: dedupeByPath ? dedupeEntriesByPath(l1) : l1,
+    L2: dedupeByPath ? dedupeEntriesByPath(l2) : l2
+  };
+}
+function dedupeEntriesByPath(entries) {
+  const seenPaths = /* @__PURE__ */ new Set();
+  return entries.filter((entry) => {
+    if (seenPaths.has(entry.path)) {
+      return false;
+    }
+    seenPaths.add(entry.path);
+    return true;
+  });
+}
+function shouldLoadNodeForPath(requestedPath, node) {
+  switch (node.activation?.tier) {
+    case "always":
+      return true;
+    case "description":
+      return true;
+    case "path":
+    case void 0:
+      return minimatch(requestedPath, normalizeRulesPath(node.scope_glob), { dot: true });
+  }
+}
+function dedupeDescriptionStubsByPath(stubs) {
+  const seenPaths = /* @__PURE__ */ new Set();
+  return stubs.filter((stub) => {
+    if (seenPaths.has(stub.path)) {
+      return false;
+    }
+    seenPaths.add(stub.path);
+    return true;
+  });
+}
+function toDescriptionStub(stub) {
+  return {
+    path: stub.path,
+    description: stub.description
+  };
+}
+async function readRuleContent(projectRoot, file, fileContentCache) {
+  const cached = fileContentCache.get(file);
+  if (cached !== void 0) {
+    return await cached;
+  }
+  const pending = readFile5(join6(projectRoot, file), "utf8");
+  fileContentCache.set(file, pending);
+  return await pending;
+}
+
+// src/services/plan-context.ts
+var SELECTION_TOKEN_TTL_MS = 5 * 60 * 1e3;
+var selectionTokenCache = /* @__PURE__ */ new Map();
+async function planContext(projectRoot, input) {
+  const meta = await readAgentsMeta(projectRoot);
+  const stale = input.client_hash !== void 0 && input.client_hash !== meta.revision;
+  const uniquePaths = dedupePaths(input.paths);
+  const allDescriptions = buildDescriptionIndex(meta);
+  const entries = uniquePaths.map((path) => {
+    const profile = buildRequirementProfile(path, input);
+    const descriptionIndex = allDescriptions.filter((item) => shouldIncludeIndexItemForPath(item, meta, path));
+    const requiredStableIds2 = descriptionIndex.filter((item) => item.required).map((item) => item.stable_id);
+    const aiSelectableStableIds2 = descriptionIndex.filter((item) => item.selectable).map((item) => item.stable_id);
+    return {
+      path,
+      requirement_profile: profile,
+      description_index: descriptionIndex,
+      required_stable_ids: requiredStableIds2,
+      ai_selectable_stable_ids: aiSelectableStableIds2,
+      initial_selected_stable_ids: requiredStableIds2,
+      selection_policy: {
+        required_levels: ["L0", "L2"],
+        ai_selectable_levels: ["L1"],
+        final_fetch_rule: "required_stable_ids + ai_selected_l1_stable_ids"
+      }
+    };
+  });
+  const requiredStableIds = dedupeStableIds(entries.flatMap((entry) => entry.required_stable_ids));
+  const aiSelectableStableIds = dedupeStableIds(entries.flatMap((entry) => entry.ai_selectable_stable_ids));
+  const sharedDescriptionIndex = dedupeDescriptionIndex(entries.flatMap((entry) => entry.description_index));
+  const selectionToken = createSelectionToken(meta.revision, uniquePaths, requiredStableIds, aiSelectableStableIds);
+  const result = {
+    revision_hash: meta.revision,
+    stale,
+    selection_token: selectionToken,
+    entries,
+    shared: {
+      required_stable_ids: requiredStableIds,
+      ai_selectable_stable_ids: aiSelectableStableIds,
+      description_index: sharedDescriptionIndex,
+      preflight_diagnostics: buildPreflightDiagnostics(meta)
+    }
+  };
+  try {
+    await appendEventLedgerEvent(projectRoot, {
+      event_type: "rule_context_planned",
+      target_paths: uniquePaths,
+      required_stable_ids: requiredStableIds,
+      ai_selectable_stable_ids: aiSelectableStableIds,
+      final_stable_ids: requiredStableIds,
+      selection_token: selectionToken,
+      client_hash: input.client_hash,
+      intent: input.intent,
+      known_tech: input.known_tech,
+      diagnostics: result.shared.preflight_diagnostics,
+      correlation_id: input.correlation_id,
+      session_id: input.session_id
+    });
+  } catch {
+  }
+  return result;
+}
+function readSelectionToken(token, now = Date.now()) {
+  const state = selectionTokenCache.get(token);
+  if (state === void 0) {
+    return void 0;
+  }
+  if (state.expires_at <= now) {
+    selectionTokenCache.delete(token);
+    return void 0;
+  }
+  return state;
+}
+function createSelectionToken(revisionHash, targetPaths, requiredStableIds, aiSelectableStableIds, now = Date.now()) {
+  const token = `selection:${revisionHash}:${now.toString(36)}:${Math.random().toString(36).slice(2)}`;
+  selectionTokenCache.set(token, {
+    token,
+    revision_hash: revisionHash,
+    target_paths: targetPaths,
+    required_stable_ids: requiredStableIds,
+    ai_selectable_stable_ids: aiSelectableStableIds,
+    created_at: now,
+    expires_at: now + SELECTION_TOKEN_TTL_MS
+  });
+  return token;
+}
+function dedupePaths(paths) {
+  const seenPaths = /* @__PURE__ */ new Set();
+  return paths.flatMap((path) => {
+    const normalizedPath = normalizeRulesPath(path);
+    if (seenPaths.has(normalizedPath)) {
+      return [];
+    }
+    seenPaths.add(normalizedPath);
+    return [normalizedPath];
+  });
+}
+function buildRequirementProfile(path, input) {
+  const normalizedPath = normalizeRulesPath(path);
+  const extensionMatch = /(\.[^./\\]+)$/u.exec(normalizedPath);
+  const knownTech = dedupeStableIds([
+    ...input.known_tech ?? [],
+    ...extensionMatch?.[1] === ".ts" ? ["TypeScript"] : []
+  ]);
+  return {
+    target_path: normalizedPath,
+    path_segments: normalizedPath.split("/").filter(Boolean),
+    extension: extensionMatch?.[1] ?? "",
+    inferred_domain: inferDomains(normalizedPath),
+    known_tech: knownTech,
+    user_intent: input.intent ?? "",
+    intent_tokens: tokenizeIntent(input.intent ?? ""),
+    impact_hints: inferImpactHints(input.intent ?? ""),
+    detected_entities: input.detected_entities?.[normalizedPath] ?? input.detected_entities?.[path] ?? []
+  };
+}
+function buildDescriptionIndex(meta) {
+  return Object.entries(meta.nodes).flatMap(([nodeId, node]) => {
+    const level = node.level ?? node.layer;
+    const description = node.description ?? descriptionFromLegacyActivation(node.activation?.description);
+    if (description === void 0) {
+      return [];
+    }
+    return [{
+      stable_id: node.stable_id ?? nodeId,
+      level,
+      required: level === "L0" || level === "L2",
+      selectable: level === "L1",
+      description
+    }];
+  }).sort(compareDescriptionIndexItems);
+}
+function descriptionFromLegacyActivation(summary) {
+  if (summary === void 0) {
+    return void 0;
+  }
+  return {
+    summary,
+    intent_clues: [],
+    tech_stack: [],
+    impact: [],
+    must_read_if: summary
+  };
+}
+function shouldIncludeIndexItemForPath(item, meta, path) {
+  if (item.level === "L0" || item.level === "L1") {
+    return true;
+  }
+  const node = Object.values(meta.nodes).find((candidate) => candidate.stable_id === item.stable_id);
+  if (node === void 0) {
+    return false;
+  }
+  return node.scope_glob === path || minimatchSimple(path, node.scope_glob);
+}
+function minimatchSimple(path, glob) {
+  if (glob === "**") {
+    return true;
+  }
+  if (glob.endsWith("/**")) {
+    return path.startsWith(glob.slice(0, -3));
+  }
+  return path === glob;
+}
+function buildPreflightDiagnostics(meta) {
+  const missingDescriptionStableIds = Object.entries(meta.nodes).filter(([, node]) => node.description === void 0 && node.activation?.description === void 0).map(([nodeId, node]) => node.stable_id ?? nodeId).sort();
+  if (missingDescriptionStableIds.length === 0) {
+    return [];
+  }
+  return [{
+    code: "missing_description",
+    severity: "warn",
+    stable_ids: missingDescriptionStableIds,
+    message: `Resolved registry includes ${missingDescriptionStableIds.length} node(s) without structured descriptions.`
+  }];
+}
+function inferDomains(path) {
+  const domains = [];
+  if (path.includes("/ui/") || path.toLowerCase().includes("ui")) {
+    domains.push("UI");
+  }
+  if (path.includes("assets/scripts")) {
+    domains.push("Gameplay");
+  }
+  if (path.includes("resources") || path.includes("assets/resources")) {
+    domains.push("Asset");
+  }
+  return domains;
+}
+function tokenizeIntent(intent) {
+  const tokens = ["\u6027\u80FD", "\u4F18\u5316", "drawcall", "\u6E32\u67D3", "\u5361\u987F", "\u95EA\u70C1", "\u754C\u9762", "UI", "\u8D44\u6E90", "\u56FE\u96C6"].filter((token) => intent.toLowerCase().includes(token.toLowerCase()));
+  return dedupeStableIds(tokens);
+}
+function inferImpactHints(intent) {
+  return /性能|优化|drawcall|渲染|卡顿|闪烁/iu.test(intent) ? ["Performance"] : [];
+}
+function dedupeStableIds(stableIds) {
+  return Array.from(new Set(stableIds));
+}
+function dedupeDescriptionIndex(items) {
+  const seenStableIds = /* @__PURE__ */ new Set();
+  return items.filter((item) => {
+    if (seenStableIds.has(item.stable_id)) {
+      return false;
+    }
+    seenStableIds.add(item.stable_id);
+    return true;
+  });
+}
+function compareDescriptionIndexItems(left, right) {
+  const levelDelta = levelOrder(left.level) - levelOrder(right.level);
+  return levelDelta !== 0 ? levelDelta : left.stable_id.localeCompare(right.stable_id);
+}
+function levelOrder(level) {
+  switch (level) {
+    case "L0":
+      return 0;
+    case "L1":
+      return 1;
+    case "L2":
+      return 2;
+  }
+}
+
+// src/services/rule-sections.ts
+var RULE_SECTION_NAMES = [
+  "MISSION_STATEMENT",
+  "MANDATORY_INJECTION",
+  "BUSINESS_LOGIC_CHUNKS",
+  "CONTEXT_INFO"
+];
+var PRIORITY_ORDER2 = {
+  high: 0,
+  medium: 1,
+  low: 2
+};
+function parseRuleSections(content) {
+  const sections = /* @__PURE__ */ new Map();
+  const lines = content.split(/\r?\n/u);
+  let activeSection;
+  let activeSectionDepth = 0;
+  let buffer = [];
+  const flush = () => {
+    if (activeSection === void 0) {
+      return;
+    }
+    const text = buffer.join("\n").trim();
+    if (text.length === 0) {
+      buffer = [];
+      return;
+    }
+    sections.set(activeSection, [...sections.get(activeSection) ?? [], text]);
+    buffer = [];
+  };
+  for (const line of lines) {
+    const heading = /^(#{2,6})\s+\[([A-Z_]+)\]\s*$/u.exec(line.trim());
+    if (heading !== null) {
+      flush();
+      activeSection = isRuleSectionName(heading[2]) ? heading[2] : void 0;
+      activeSectionDepth = activeSection === void 0 ? 0 : heading[1].length;
+      continue;
+    }
+    const ordinaryHeading = /^(#{1,6})\s+/u.exec(line.trim());
+    if (ordinaryHeading !== null) {
+      if (activeSection !== void 0 && ordinaryHeading[1].length > activeSectionDepth) {
+        buffer.push(line);
+        continue;
+      }
+      flush();
+      activeSection = void 0;
+      activeSectionDepth = 0;
+      continue;
+    }
+    if (activeSection !== void 0) {
+      buffer.push(line);
+    }
+  }
+  flush();
+  return new Map(
+    Array.from(sections.entries()).map(([section, values]) => [section, values.join("\n\n")])
+  );
+}
+async function getRuleSections(projectRoot, input) {
+  const token = readSelectionToken(input.selection_token);
+  if (token === void 0) {
+    throw new Error("selection_token is missing or expired");
+  }
+  validateAiSelections(token.ai_selectable_stable_ids, input.ai_selected_stable_ids, input.ai_selection_reasons);
+  const meta = await readAgentsMeta(projectRoot);
+  const selectedStableIds = [...token.required_stable_ids, ...input.ai_selected_stable_ids];
+  const selectedRules = sortRuleNodes(selectedStableIds.map((stableId) => findRuleNode(meta, stableId)));
+  const diagnostics = [];
+  const rules = [];
+  for (const rule of selectedRules) {
+    const content = await readFile6(join7(projectRoot, rule.path), "utf8");
+    const parsedSections = parseRuleSections(content);
+    const sections = {};
+    for (const section of input.sections) {
+      const sectionContent = parsedSections.get(section);
+      sections[section] = sectionContent ?? "";
+      if (sectionContent === void 0) {
+        diagnostics.push({
+          code: "missing_section",
+          severity: "warn",
+          stable_id: rule.stable_id,
+          section,
+          message: `Rule ${rule.stable_id} does not define section ${section}.`
+        });
+      }
+    }
+    rules.push({
+      stable_id: rule.stable_id,
+      level: rule.level,
+      path: rule.path,
+      sections
+    });
+  }
+  const result = {
+    revision_hash: meta.revision,
+    precedence: ["L2", "L1", "L0"],
+    selected_stable_ids: rules.map((rule) => rule.stable_id),
+    rules,
+    diagnostics
+  };
+  await appendRuleSelectionAuditEvent(projectRoot, {
+    path: token.target_paths[0] ?? "",
+    selection_token: input.selection_token,
+    target_paths: token.target_paths,
+    required_stable_ids: token.required_stable_ids,
+    ai_selectable_stable_ids: token.ai_selectable_stable_ids,
+    ai_selected_stable_ids: input.ai_selected_stable_ids,
+    final_stable_ids: result.selected_stable_ids,
+    ai_selection_reasons: pickSelectionReasons(input.ai_selected_stable_ids, input.ai_selection_reasons),
+    rejected_stable_ids: [],
+    ignored_stable_ids: [],
+    correlation_id: input.correlation_id,
+    session_id: input.session_id
+  });
+  try {
+    await appendEventLedgerEvent(projectRoot, {
+      event_type: "rule_sections_fetched",
+      selection_token: input.selection_token,
+      target_paths: token.target_paths,
+      requested_sections: input.sections,
+      final_stable_ids: result.selected_stable_ids,
+      ai_selected_stable_ids: input.ai_selected_stable_ids,
+      diagnostics,
+      correlation_id: input.correlation_id,
+      session_id: input.session_id
+    });
+  } catch {
+  }
+  return result;
+}
+function validateAiSelections(aiSelectableStableIds, aiSelectedStableIds, aiSelectionReasons) {
+  const selectable = new Set(aiSelectableStableIds);
+  for (const stableId of aiSelectedStableIds) {
+    if (!selectable.has(stableId)) {
+      throw new Error(`Invalid L1 rule selection: ${stableId}`);
+    }
+    if (aiSelectionReasons[stableId]?.trim() === "") {
+      throw new Error(`Missing AI selection reason for ${stableId}`);
+    }
+    if (aiSelectionReasons[stableId] === void 0) {
+      throw new Error(`Missing AI selection reason for ${stableId}`);
+    }
+  }
+}
+function findRuleNode(meta, stableId) {
+  for (const [nodeId, node] of Object.entries(meta.nodes)) {
+    const nodeStableId = node.stable_id ?? nodeId;
+    if (nodeStableId !== stableId) {
+      continue;
+    }
+    const level = node.level ?? node.layer;
+    return {
+      stable_id: nodeStableId,
+      level,
+      path: normalizeRulesPath(node.content_ref ?? node.file),
+      priority: node.priority,
+      node
+    };
+  }
+  throw new Error(`Selected rule is not present in agents.meta.json: ${stableId}`);
+}
+function sortRuleNodes(rules) {
+  return [...rules].sort((left, right) => {
+    const levelDelta = outputLevelOrder(left.level) - outputLevelOrder(right.level);
+    if (levelDelta !== 0) {
+      return levelDelta;
+    }
+    const priorityDelta = PRIORITY_ORDER2[left.priority] - PRIORITY_ORDER2[right.priority];
+    if (priorityDelta !== 0) {
+      return priorityDelta;
+    }
+    return left.stable_id.localeCompare(right.stable_id);
+  });
+}
+function outputLevelOrder(level) {
+  switch (level) {
+    case "L0":
+      return 0;
+    case "L1":
+      return 1;
+    case "L2":
+      return 2;
+  }
+}
+function isRuleSectionName(value) {
+  return RULE_SECTION_NAMES.includes(value);
+}
+function pickSelectionReasons(selectedStableIds, reasons) {
+  return Object.fromEntries(selectedStableIds.map((stableId) => [stableId, reasons[stableId] ?? ""]));
+}
+
+// src/services/doctor.ts
+import { atomicWriteJson as atomicWriteJson2, atomicWriteText as atomicWriteText3 } from "@fenglimg/fabric-shared/node/atomic-write";
+import { buildBootstrapContent, FABRIC_BOOTSTRAP_PATH } from "@fenglimg/fabric-shared/node/bootstrap-guide";
+var LEGACY_CLIENT_PATH_KEYS = ["windsurf", "rooCode", "geminiCLI"];
+var SCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".ts", ".tsx"]);
+var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".fabric",
+  ".git",
+  ".next",
+  ".turbo",
+  "Library",
+  "Temp",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules"
+]);
+var TARGET_FILE_PATHS = [
+  ".fabric/bootstrap/README.md",
+  ".fabric/INITIAL_TAXONOMY.md",
+  ".fabric/forensic.json",
+  ".fabric/init-context.json",
+  ".fabric/agents.meta.json",
+  ".fabric/rule-test.index.json",
+  ".fabric/events.jsonl"
+];
+async function runDoctorReport(target) {
+  const projectRoot = normalizeTarget(target);
+  const framework = detectFramework(projectRoot);
+  const entryPoints = collectEntryPoints(projectRoot);
+  const [
+    forensic,
+    initContext,
+    meta,
+    eventLedger,
+    ruleSections,
+    ruleTestIndex
+  ] = await Promise.all([
+    inspectForensic(projectRoot),
+    inspectInitContext(projectRoot),
+    inspectMeta(projectRoot),
+    inspectEventLedger(projectRoot),
+    inspectRuleSections(projectRoot),
+    inspectRuleTestIndex(projectRoot)
+  ]);
+  const mcpConfigInWrongFile = inspectMcpConfigInWrongFile(projectRoot);
+  const metaManuallyDiverged = await inspectMetaManuallyDiverged(projectRoot);
+  const rulesDirUnindexed = inspectRulesDirUnindexed(projectRoot, meta);
+  const stableIdCollision = await inspectStableIdCollisions(projectRoot);
+  const claudeSkillLegacyPath = inspectClaudeSkillLegacyPath(projectRoot);
+  const preexistingRootFiles = inspectPreexistingRootFiles(projectRoot);
+  const legacyClientPaths = inspectLegacyClientPaths(projectRoot);
+  const taxonomyExists = existsSync4(join8(projectRoot, ".fabric", "INITIAL_TAXONOMY.md"));
+  const bootstrapExists = existsSync4(join8(projectRoot, ".fabric", "bootstrap", "README.md"));
+  const checks = [
+    createBootstrapCheck(bootstrapExists),
+    createTaxonomyCheck(taxonomyExists),
+    createForensicCheck(forensic, framework.kind, entryPoints.length),
+    createInitContextCheck(initContext),
+    createMetaCheck(meta),
+    createRuleContentRefCheck(meta),
+    createRuleSectionsCheck(ruleSections),
+    createRuleTestIndexCheck(ruleTestIndex),
+    createEventLedgerCheck(eventLedger),
+    createEventLedgerPartialWriteCheck(eventLedger),
+    createMcpConfigInWrongFileCheck(mcpConfigInWrongFile),
+    createMetaManuallyDivergedCheck(metaManuallyDiverged),
+    createRulesDirUnindexedCheck(rulesDirUnindexed),
+    createStableIdCollisionCheck(stableIdCollision),
+    createClaudeSkillLegacyPathCheck(claudeSkillLegacyPath),
+    createPreexistingRootFilesCheck(preexistingRootFiles),
+    createLegacyClientPathCheck(legacyClientPaths)
+  ];
+  const fixableErrors = collectIssues(checks, "fixable_error");
+  const manualErrors = collectIssues(checks, "manual_error");
+  const warnings = collectIssues(checks, "warning");
+  const infos = collectIssues(checks, "info");
+  return {
+    status: reduceStatus(checks.map((check) => check.status)),
+    checks,
+    fixable_errors: fixableErrors,
+    manual_errors: manualErrors,
+    warnings,
+    infos,
+    summary: {
+      target: projectRoot,
+      framework: {
+        kind: framework.kind,
+        version: framework.version,
+        subkind: framework.subkind
+      },
+      entryPoints,
+      metaRevision: meta.revision,
+      computedMetaRevision: meta.computedRevision,
+      ruleCount: meta.ruleCount,
+      eventLedgerPath: eventLedger.path,
+      fixableErrorCount: fixableErrors.length,
+      manualErrorCount: manualErrors.length,
+      warningCount: warnings.length,
+      infoCount: infos.length,
+      targetFiles: Object.fromEntries(
+        TARGET_FILE_PATHS.map((path) => [path, existsSync4(join8(projectRoot, path))])
+      )
+    }
+  };
+}
+async function runDoctorFix(target) {
+  const projectRoot = normalizeTarget(target);
+  const before = await runDoctorReport(projectRoot);
+  const fixed = [];
+  if (before.fixable_errors.some((issue) => issue.code === "bootstrap_missing")) {
+    await writeDefaultBootstrap(projectRoot);
+    fixed.push(findIssue(before.fixable_errors, "bootstrap_missing"));
+  }
+  if (before.fixable_errors.some((issue) => issue.code === "event_ledger_missing")) {
+    await ensureEventLedger(projectRoot);
+    fixed.push(findIssue(before.fixable_errors, "event_ledger_missing"));
+  }
+  if (before.fixable_errors.some(
+    (issue) => [
+      "agents_meta_missing",
+      "agents_meta_stale",
+      "rule_test_index_missing",
+      "rule_test_index_stale",
+      "content_ref_missing",
+      "rules_dir_unindexed"
+    ].includes(issue.code)
+  )) {
+    await reconcileRules(projectRoot, { trigger: "doctor" });
+    for (const issue of before.fixable_errors.filter(
+      (candidate) => [
+        "agents_meta_missing",
+        "agents_meta_stale",
+        "rule_test_index_missing",
+        "rule_test_index_stale",
+        "content_ref_missing",
+        "rules_dir_unindexed"
+      ].includes(candidate.code)
+    )) {
+      fixed.push(issue);
+    }
+    contextCache.invalidate("meta_write", projectRoot);
+  }
+  if (before.fixable_errors.some((issue) => issue.code === "event_ledger_partial_write")) {
+    const ledgerPath = getEventLedgerPath(projectRoot);
+    const truncResult = await truncateLedgerToLastNewline(ledgerPath);
+    await appendEventLedgerEvent(projectRoot, {
+      event_type: "event_ledger_truncated",
+      byte_offset: truncResult.truncated_bytes,
+      byte_length: truncResult.truncated_bytes,
+      corrupted_path: truncResult.corrupted_path
+    });
+    fixed.push(findIssue(before.fixable_errors, "event_ledger_partial_write"));
+  }
+  if (before.fixable_errors.some((issue) => issue.code === "mcp_config_in_wrong_file")) {
+    await fixMcpConfigInWrongFile(projectRoot);
+    fixed.push(findIssue(before.fixable_errors, "mcp_config_in_wrong_file"));
+  }
+  if (before.fixable_errors.some((issue) => issue.code === "claude_skill_legacy_path")) {
+    await fixClaudeSkillLegacyPath(projectRoot);
+    fixed.push(findIssue(before.fixable_errors, "claude_skill_legacy_path"));
+  }
+  if (before.warnings.some((issue) => issue.code === "legacy_client_path_present")) {
+    await fixLegacyClientPaths(projectRoot);
+    fixed.push(findIssue(before.warnings, "legacy_client_path_present"));
+  }
+  const report = await runDoctorReport(projectRoot);
+  return {
+    changed: fixed.length > 0,
+    fixed,
+    remaining_manual_errors: report.manual_errors,
+    warnings: report.warnings,
+    message: createFixMessage(fixed, report),
+    report
+  };
+}
+async function inspectForensic(projectRoot) {
+  const path = join8(projectRoot, ".fabric", "forensic.json");
+  try {
+    const parsed = forensicReportSchema.parse(JSON.parse(await readFile7(path, "utf8")));
+    return { present: true, valid: true, report: parsed };
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return { present: false, valid: false, report: null, error: ".fabric/forensic.json is missing." };
+    }
+    return { present: true, valid: false, report: null, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function inspectInitContext(projectRoot) {
+  const path = join8(projectRoot, ".fabric", "init-context.json");
+  try {
+    JSON.parse(await readFile7(path, "utf8"));
+    return { exists: true, validJson: true };
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return { exists: false, validJson: false, error: ".fabric/init-context.json is missing." };
+    }
+    return { exists: true, validJson: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function inspectMcpConfigInWrongFile(projectRoot) {
+  const settingsPath = join8(projectRoot, ".claude", "settings.json");
+  if (!existsSync4(settingsPath)) {
+    return { hasWrongEntry: false, settingsPath };
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(settingsPath, "utf8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { hasWrongEntry: false, settingsPath };
+    }
+    const settings = parsed;
+    const mcpServers = settings.mcpServers;
+    if (mcpServers === null || typeof mcpServers !== "object" || Array.isArray(mcpServers)) {
+      return { hasWrongEntry: false, settingsPath };
+    }
+    const hasWrongEntry = "fabric" in mcpServers;
+    return { hasWrongEntry, settingsPath };
+  } catch {
+    return { hasWrongEntry: false, settingsPath };
+  }
+}
+async function inspectMeta(projectRoot) {
+  const metaPath = join8(projectRoot, ".fabric", "agents.meta.json");
+  const built = await tryBuildRuleMeta(projectRoot);
+  try {
+    const raw = await readFile7(metaPath, "utf8");
+    const meta = agentsMetaSchema4.parse(JSON.parse(raw));
+    const contentRefIssues = inspectContentRefs(projectRoot, meta);
+    const changed = built === null ? false : built.changed;
+    return {
+      present: true,
+      valid: true,
+      meta,
+      revision: meta.revision,
+      computedRevision: built?.meta.revision ?? null,
+      ruleCount: Object.values(meta.nodes).filter((node) => (node.content_ref ?? node.file).startsWith(".fabric/rules/")).length,
+      missingContentRefs: contentRefIssues.missing,
+      invalidContentRefs: contentRefIssues.invalid,
+      stale: changed || built !== null && meta.revision !== built.meta.revision,
+      changed
+    };
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return {
+        present: false,
+        valid: false,
+        meta: null,
+        revision: null,
+        computedRevision: built?.meta.revision ?? null,
+        ruleCount: 0,
+        missingContentRefs: [],
+        invalidContentRefs: [],
+        stale: true,
+        changed: built?.changed ?? true
+      };
+    }
+    return {
+      present: true,
+      valid: false,
+      meta: null,
+      revision: null,
+      computedRevision: built?.meta.revision ?? null,
+      ruleCount: 0,
+      missingContentRefs: [],
+      invalidContentRefs: [],
+      stale: true,
+      changed: built?.changed ?? true,
+      readError: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function tryBuildRuleMeta(projectRoot) {
+  try {
+    return await buildRuleMeta(projectRoot);
+  } catch {
+    return null;
+  }
+}
+function inspectContentRefs(projectRoot, meta) {
+  const missing = [];
+  const invalid = [];
+  for (const node of Object.values(meta.nodes)) {
+    const contentRef = normalizePath(node.content_ref ?? node.file);
+    if (contentRef === ".fabric/bootstrap/README.md") {
+      if (!existsSync4(join8(projectRoot, contentRef))) {
+        missing.push(contentRef);
+      }
+      continue;
+    }
+    if (!contentRef.startsWith(".fabric/rules/")) {
+      invalid.push(contentRef);
+      continue;
+    }
+    if (!existsSync4(join8(projectRoot, contentRef))) {
+      missing.push(contentRef);
+    }
+  }
+  return { missing, invalid };
+}
+async function inspectEventLedger(projectRoot) {
+  const path = getEventLedgerPath(projectRoot);
+  const exists = existsSync4(path);
+  if (!exists) {
+    return { exists: false, writable: false, parseable: false, hasPartialWrite: false, partialWriteByteOffset: 0, partialWriteByteLength: 0, path };
+  }
+  try {
+    await access(path, constants.W_OK);
+    const { warnings } = await readEventLedger(projectRoot);
+    const raw = await readFile7(path, "utf8");
+    const invalidLine = raw.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean).find((line) => !isValidJsonLine(line));
+    const partialWarning = warnings.find((w) => w.kind === "partial_write_at_tail");
+    return {
+      exists: true,
+      writable: true,
+      parseable: invalidLine === void 0,
+      hasPartialWrite: partialWarning !== void 0,
+      partialWriteByteOffset: partialWarning?.byte_offset ?? 0,
+      partialWriteByteLength: partialWarning?.byte_length ?? 0,
+      path,
+      error: invalidLine === void 0 ? void 0 : "events.jsonl contains an invalid JSON line."
+    };
+  } catch (error) {
+    return {
+      exists: true,
+      writable: false,
+      parseable: false,
+      hasPartialWrite: false,
+      partialWriteByteOffset: 0,
+      partialWriteByteLength: 0,
+      path,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function inspectRuleSections(projectRoot) {
+  const invalidFiles = [];
+  const files = findRuleFiles2(projectRoot);
+  for (const file of files) {
+    try {
+      parseRuleSections(await readFile7(join8(projectRoot, file), "utf8"));
+    } catch (error) {
+      invalidFiles.push({
+        file,
+        reason: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return {
+    checkedCount: files.length,
+    invalidFiles
+  };
+}
+async function inspectRuleTestIndex(projectRoot) {
+  const path = join8(projectRoot, ".fabric", "rule-test.index.json");
+  const built = await tryBuildRuleMeta(projectRoot);
+  try {
+    const index = ruleTestIndexSchema2.parse(JSON.parse(await readFile7(path, "utf8")));
+    return {
+      present: true,
+      valid: true,
+      stale: built === null ? false : !isSameRuleTestIndex(index, built.ruleTestIndex),
+      linkCount: index.links.length,
+      orphanCount: index.orphan_annotations.length
+    };
+  } catch (error) {
+    return {
+      present: !isMissingFileError(error),
+      valid: false,
+      stale: true,
+      linkCount: 0,
+      orphanCount: 0,
+      error: isMissingFileError(error) ? ".fabric/rule-test.index.json is missing." : error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function createBootstrapCheck(exists) {
+  if (!exists) {
+    return issueCheck("Bootstrap README", "error", "fixable_error", "bootstrap_missing", ".fabric/bootstrap/README.md is missing.", "Run `fab doctor --fix` to generate the bootstrap guide.");
+  }
+  return okCheck("Bootstrap README", ".fabric/bootstrap/README.md exists.");
+}
+function createTaxonomyCheck(exists) {
+  if (!exists) {
+    return issueCheck("Initial taxonomy", "error", "manual_error", "taxonomy_missing", ".fabric/INITIAL_TAXONOMY.md is missing.", "Run `fab init` to regenerate project scaffolding including INITIAL_TAXONOMY.md.");
+  }
+  return okCheck("Initial taxonomy", ".fabric/INITIAL_TAXONOMY.md exists.");
+}
+function createForensicCheck(forensic, frameworkKind, entryPointCount) {
+  if (!forensic.present) {
+    return issueCheck(
+      "Scan evidence",
+      "error",
+      "manual_error",
+      "forensic_missing",
+      `${forensic.error ?? ".fabric/forensic.json is missing."} Live scan detects ${frameworkKind} with ${entryPointCount} entry point${entryPointCount === 1 ? "" : "s"}.`,
+      "Run `fab init` to regenerate .fabric/forensic.json."
+    );
+  }
+  if (!forensic.valid) {
+    return issueCheck("Scan evidence", "error", "manual_error", "forensic_invalid", forensic.error ?? ".fabric/forensic.json is invalid.", "Run `fab init` to regenerate .fabric/forensic.json.");
+  }
+  return okCheck("Scan evidence", `.fabric/forensic.json is valid for ${forensic.report?.framework.kind ?? "unknown"}.`);
+}
+function createInitContextCheck(initContext) {
+  if (!initContext.exists) {
+    return issueCheck("Init context", "error", "manual_error", "init_context_missing", initContext.error ?? ".fabric/init-context.json is missing.", "Run the fabric-init skill in Claude Code or Codex CLI to complete initialization. See docs/migration-1.8.md FAQ.");
+  }
+  if (!initContext.validJson) {
+    return issueCheck("Init context", "error", "manual_error", "init_context_invalid", initContext.error ?? ".fabric/init-context.json is invalid.", "Delete .fabric/init-context.json and run `fab init` to regenerate it.");
+  }
+  return okCheck("Init context", ".fabric/init-context.json is valid JSON.");
+}
+function createMetaCheck(meta) {
+  if (!meta.present) {
+    return issueCheck("Agents metadata", "error", "fixable_error", "agents_meta_missing", ".fabric/agents.meta.json is missing.", "Run `fab doctor --fix` to rebuild agents.meta.json from .fabric/rules/.");
+  }
+  if (!meta.valid) {
+    return issueCheck("Agents metadata", "error", "manual_error", "agents_meta_invalid", meta.readError ?? ".fabric/agents.meta.json is invalid.", "Delete .fabric/agents.meta.json and run `fab doctor --fix` to regenerate it.");
+  }
+  if (meta.stale) {
+    return issueCheck(
+      "Agents metadata",
+      "error",
+      "fixable_error",
+      "agents_meta_stale",
+      `.fabric/agents.meta.json revision ${meta.revision} does not match .fabric/rules derived revision ${meta.computedRevision ?? "<unknown>"}.`,
+      "Run `fab doctor --fix` to reconcile agents.meta.json with the current rule files."
+    );
+  }
+  return okCheck("Agents metadata", `.fabric/agents.meta.json revision ${meta.revision} is aligned with .fabric/rules.`);
+}
+function createRuleContentRefCheck(meta) {
+  if (!meta.valid) {
+    return issueCheck("Rule content refs", "error", "manual_error", "content_refs_unavailable", "Cannot inspect content_ref entries until agents.meta.json is valid.", "Fix agents.meta.json first: run `fab doctor --fix`.");
+  }
+  if (meta.invalidContentRefs.length > 0) {
+    return issueCheck(
+      "Rule content refs",
+      "error",
+      "manual_error",
+      "content_ref_outside_rules",
+      `${meta.invalidContentRefs.length} content_ref entr${meta.invalidContentRefs.length === 1 ? "y is" : "ies are"} outside .fabric/rules.`,
+      "Edit agents.meta.json to ensure all content_ref values point inside .fabric/rules/."
+    );
+  }
+  if (meta.missingContentRefs.length > 0) {
+    return issueCheck(
+      "Rule content refs",
+      "error",
+      "fixable_error",
+      "content_ref_missing",
+      `${meta.missingContentRefs.length} content_ref target${meta.missingContentRefs.length === 1 ? "" : "s"} are missing. Run \`fab doctor --fix\` to reconcile.`,
+      "Run `fab doctor --fix` to reconcile agents.meta.json with the files present in .fabric/rules/."
+    );
+  }
+  return okCheck("Rule content refs", "All content_ref entries resolve to .fabric/rules files or bootstrap README.");
+}
+function createRuleSectionsCheck(snapshot) {
+  if (snapshot.invalidFiles.length > 0) {
+    return issueCheck(
+      "Rule sections",
+      "error",
+      "manual_error",
+      "rule_sections_invalid",
+      `${snapshot.invalidFiles.length} rule file${snapshot.invalidFiles.length === 1 ? "" : "s"} could not be parsed.`,
+      "Edit the rule file(s) to fix the section structure, then re-run `fab doctor`."
+    );
+  }
+  return okCheck("Rule sections", `${snapshot.checkedCount} .fabric/rules file${snapshot.checkedCount === 1 ? "" : "s"} parsed.`);
+}
+function createRuleTestIndexCheck(index) {
+  if (!index.present) {
+    return issueCheck("Rule-test index", "error", "fixable_error", "rule_test_index_missing", index.error, "Run `fab doctor --fix` to rebuild .fabric/rule-test.index.json.");
+  }
+  if (!index.valid) {
+    return issueCheck("Rule-test index", "error", "manual_error", "rule_test_index_invalid", index.error, "Delete .fabric/rule-test.index.json and run `fab doctor --fix` to regenerate it.");
+  }
+  if (index.stale) {
+    return issueCheck("Rule-test index", "error", "fixable_error", "rule_test_index_stale", ".fabric/rule-test.index.json is stale.", "Run `fab doctor --fix` to rebuild the rule-test index.");
+  }
+  return okCheck("Rule-test index", `${index.linkCount} link${index.linkCount === 1 ? "" : "s"} and ${index.orphanCount} orphan annotation${index.orphanCount === 1 ? "" : "s"} indexed.`);
+}
+function createEventLedgerCheck(ledger) {
+  if (!ledger.exists) {
+    return issueCheck("Event ledger", "error", "fixable_error", "event_ledger_missing", ".fabric/events.jsonl is missing.", "Run `fab doctor --fix` to create .fabric/events.jsonl.");
+  }
+  if (!ledger.writable) {
+    return issueCheck("Event ledger", "error", "manual_error", "event_ledger_not_writable", ledger.error ?? ".fabric/events.jsonl is not writable.", "Check file permissions on .fabric/events.jsonl and ensure no other process holds a write lock.");
+  }
+  if (!ledger.parseable) {
+    return issueCheck("Event ledger", "error", "manual_error", "event_ledger_invalid", ledger.error ?? ".fabric/events.jsonl is invalid.", "Delete .fabric/events.jsonl and run `fab doctor --fix` to recreate it.");
+  }
+  return okCheck("Event ledger", ".fabric/events.jsonl exists, is writable, and is parseable.");
+}
+function createMcpConfigInWrongFileCheck(inspection) {
+  if (inspection.hasWrongEntry) {
+    return issueCheck(
+      "Claude MCP config location",
+      "error",
+      "fixable_error",
+      "mcp_config_in_wrong_file",
+      `.claude/settings.json contains mcpServers.fabric \u2014 this file is for hooks/permissions only. Run --fix to remove it, then re-run fab init to write .mcp.json.`,
+      "Run `fab doctor --fix` to remove mcpServers.fabric from .claude/settings.json, then run `fab init` to write .mcp.json."
+    );
+  }
+  return okCheck("Claude MCP config location", "mcpServers.fabric is not in .claude/settings.json.");
+}
+function createEventLedgerPartialWriteCheck(ledger) {
+  if (!ledger.exists || !ledger.writable) {
+    return okCheck("Event ledger partial write", "No partial-write check needed (ledger missing or not writable).");
+  }
+  if (ledger.hasPartialWrite) {
+    return issueCheck(
+      "Event ledger partial write",
+      "error",
+      "fixable_error",
+      "event_ledger_partial_write",
+      `events.jsonl has a partial write at byte offset ${ledger.partialWriteByteOffset} (${ledger.partialWriteByteLength} corrupted bytes). Run --fix to truncate and preserve corrupted bytes.`,
+      "Run `fab doctor --fix` to truncate the partial write and restore events.jsonl to a valid state."
+    );
+  }
+  return okCheck("Event ledger partial write", "events.jsonl has no partial trailing write.");
+}
+function okCheck(name, message) {
+  return { name, status: "ok", message };
+}
+function issueCheck(name, status, kind, code, message, actionHint) {
+  return {
+    name,
+    status,
+    kind,
+    code,
+    fixable: kind === "fixable_error",
+    message,
+    actionHint
+  };
+}
+function collectIssues(checks, kind) {
+  return checks.filter((check) => check.kind === kind).map((check) => ({
+    code: check.code ?? check.name,
+    name: check.name,
+    message: check.message
+  }));
+}
+function findIssue(issues, code) {
+  return issues.find((issue) => issue.code === code) ?? {
+    code,
+    name: code,
+    message: code
+  };
+}
+async function inspectMetaManuallyDiverged(projectRoot) {
+  const metaPath = join8(projectRoot, ".fabric", "agents.meta.json");
+  if (!existsSync4(metaPath)) {
+    return { extraMetaEntries: [], hashMismatchEntries: [], readable: false };
+  }
+  let meta;
+  try {
+    const raw = await readFile7(metaPath, "utf8");
+    meta = agentsMetaSchema4.parse(JSON.parse(raw));
+  } catch (error) {
+    return {
+      extraMetaEntries: [],
+      hashMismatchEntries: [],
+      readable: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+  const extraMetaEntries = [];
+  const hashMismatchEntries = [];
+  for (const node of Object.values(meta.nodes)) {
+    const contentRef = node.content_ref ?? node.file;
+    const absPath = join8(projectRoot, contentRef);
+    if (!existsSync4(absPath)) {
+      extraMetaEntries.push(contentRef);
+      continue;
+    }
+    try {
+      const content = readFileSync(absPath, "utf8");
+      const diskHash = sha256(content);
+      if (node.hash !== "" && node.hash !== diskHash) {
+        hashMismatchEntries.push(contentRef);
+      }
+    } catch {
+      extraMetaEntries.push(contentRef);
+    }
+  }
+  return { extraMetaEntries, hashMismatchEntries, readable: true };
+}
+function inspectRulesDirUnindexed(projectRoot, meta) {
+  const rulesDir = join8(projectRoot, ".fabric", "rules");
+  if (!existsSync4(rulesDir)) {
+    return { unindexedFiles: [] };
+  }
+  const physicalMdFiles = /* @__PURE__ */ new Set();
+  const stack = [rulesDir];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    if (dir === void 0) {
+      continue;
+    }
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const abs = join8(dir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(abs);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        const rel = posix2.join(".fabric/rules", abs.slice(rulesDir.length + 1).replace(/\\/gu, "/"));
+        physicalMdFiles.add(rel);
+      }
+    }
+  }
+  const indexedRefs = /* @__PURE__ */ new Set();
+  if (meta.valid && meta.meta !== null) {
+    for (const node of Object.values(meta.meta.nodes)) {
+      const ref = normalizePath(node.content_ref ?? node.file);
+      indexedRefs.add(ref);
+    }
+  }
+  const unindexedFiles = [...physicalMdFiles].filter((f) => !indexedRefs.has(f)).sort();
+  return { unindexedFiles };
+}
+function createRulesDirUnindexedCheck(inspection) {
+  if (inspection.unindexedFiles.length > 0) {
+    return issueCheck(
+      "Rules dir unindexed",
+      "error",
+      "fixable_error",
+      "rules_dir_unindexed",
+      `${inspection.unindexedFiles.length} .md file${inspection.unindexedFiles.length === 1 ? "" : "s"} in .fabric/rules/ not indexed in agents.meta.json. Run \`fab doctor --fix\` to index the missing rule files.`,
+      "Run `fab doctor --fix` to index the missing rule files."
+    );
+  }
+  return okCheck("Rules dir unindexed", "All .fabric/rules/ .md files are indexed in agents.meta.json.");
+}
+async function inspectStableIdCollisions(projectRoot) {
+  const rulesDir = join8(projectRoot, ".fabric", "rules");
+  if (!existsSync4(rulesDir)) {
+    return { collisions: [] };
+  }
+  const mdFiles = [];
+  const stack = [rulesDir];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    if (dir === void 0) {
+      continue;
+    }
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const abs = join8(dir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(abs);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        mdFiles.push(abs);
+      }
+    }
+  }
+  const stableIdToFiles = /* @__PURE__ */ new Map();
+  const DECLARED_ID_PATTERN = /^(?:\uFEFF)?(?:---\r?\n[\s\S]*?\r?\n---\s*(?:\r?\n|$))?<!--\s*fab:rule-id\s+([A-Za-z0-9][A-Za-z0-9/_-]*)\s*-->\s*(?:\r?\n|$)/u;
+  for (const absPath of mdFiles) {
+    let source;
+    try {
+      source = await readFile7(absPath, "utf8");
+    } catch {
+      continue;
+    }
+    const match = DECLARED_ID_PATTERN.exec(source);
+    if (match === null) {
+      continue;
+    }
+    const stableId = match[1];
+    const relPath = posix2.join(".fabric/rules", absPath.slice(rulesDir.length + 1).replace(/\\/gu, "/"));
+    const existing = stableIdToFiles.get(stableId) ?? [];
+    existing.push(relPath);
+    stableIdToFiles.set(stableId, existing);
+  }
+  const collisions = [];
+  for (const [stable_id, files] of stableIdToFiles) {
+    if (files.length > 1) {
+      collisions.push({ stable_id, files: files.sort() });
+    }
+  }
+  return { collisions: collisions.sort((a, b) => a.stable_id.localeCompare(b.stable_id)) };
+}
+function createStableIdCollisionCheck(inspection) {
+  if (inspection.collisions.length > 0) {
+    const first = inspection.collisions[0];
+    const detail = inspection.collisions.length === 1 ? `stable_id "${first.stable_id}" is declared in ${first.files.length} files: ${first.files.join(", ")}.` : `${inspection.collisions.length} stable_id collision${inspection.collisions.length === 1 ? "" : "s"} detected. First: "${first.stable_id}" in ${first.files.join(", ")}.`;
+    return issueCheck(
+      "Stable ID collision",
+      "warn",
+      "warning",
+      "stable_id_collision",
+      `${detail} Edit one of the rule files to use a unique stable_id.`,
+      "Edit one of the colliding rule files to declare a different `<!-- fab:rule-id X -->` value."
+    );
+  }
+  return okCheck("Stable ID collision", "No declared stable_id collisions found in .fabric/rules/.");
+}
+function createMetaManuallyDivergedCheck(inspection) {
+  if (!inspection.readable) {
+    return okCheck("Meta manual divergence", "agents.meta.json not readable; skipping divergence check.");
+  }
+  if (inspection.extraMetaEntries.length > 0) {
+    return issueCheck(
+      "Meta manual divergence",
+      "warn",
+      "warning",
+      "meta_manually_diverged",
+      `agents.meta.json has ${inspection.extraMetaEntries.length} entr${inspection.extraMetaEntries.length === 1 ? "y" : "ies"} with no backing file on disk. Run --fix to reconcile.`,
+      "Run `fab doctor --fix` to reconcile agents.meta.json with the rule files currently on disk."
+    );
+  }
+  if (inspection.hashMismatchEntries.length > 0) {
+    return issueCheck(
+      "Meta manual divergence",
+      "warn",
+      "warning",
+      "meta_manually_diverged",
+      `agents.meta.json has ${inspection.hashMismatchEntries.length} entr${inspection.hashMismatchEntries.length === 1 ? "y" : "ies"} whose hash does not match the file on disk. Run --fix to reconcile.`,
+      "Run `fab doctor --fix` to reconcile agents.meta.json with the current rule file contents."
+    );
+  }
+  return okCheck("Meta manual divergence", "agents.meta.json is consistent with rule files on disk.");
+}
+function inspectPreexistingRootFiles(projectRoot) {
+  const candidates = ["CLAUDE.md", "AGENTS.md"];
+  const detected = candidates.filter((name) => existsSync4(join8(projectRoot, name)));
+  return { detected };
+}
+function createPreexistingRootFilesCheck(inspection) {
+  if (inspection.detected.length === 0) {
+    return okCheck("Preexisting root markdown", "No CLAUDE.md or AGENTS.md detected at project root.");
+  }
+  return {
+    name: "Preexisting root markdown",
+    status: "ok",
+    kind: "info",
+    code: "preexisting_root_claude_md",
+    fixable: false,
+    message: `${inspection.detected.join(", ")} detected at project root. These root files are not auto-loaded by Fabric MCP.`,
+    actionHint: "Move rule content to `.fabric/rules/` if you want it available in MCP responses."
+  };
+}
+function inspectClaudeSkillLegacyPath(projectRoot) {
+  const legacyPath = join8(projectRoot, ".claude", "skills", "agents-md-init", "SKILL.md");
+  const newPath = join8(projectRoot, ".claude", "skills", "fabric-init", "SKILL.md");
+  const hasLegacy = existsSync4(legacyPath) && !existsSync4(newPath);
+  return { hasLegacy, legacyPath, newPath };
+}
+function createClaudeSkillLegacyPathCheck(inspection) {
+  if (inspection.hasLegacy) {
+    return issueCheck(
+      "Claude skill path",
+      "error",
+      "fixable_error",
+      "claude_skill_legacy_path",
+      `.claude/skills/agents-md-init/SKILL.md exists at the legacy path. Run --fix to migrate it to .claude/skills/fabric-init/SKILL.md (user edits preserved).`,
+      "Run `fab doctor --fix` to rename agents-md-init/ to fabric-init/, preserving any user edits to SKILL.md."
+    );
+  }
+  return okCheck("Claude skill path", ".claude/skills/fabric-init/SKILL.md is at the canonical path (or not present).");
+}
+async function fixClaudeSkillLegacyPath(projectRoot) {
+  const legacyPath = join8(projectRoot, ".claude", "skills", "agents-md-init", "SKILL.md");
+  const newPath = join8(projectRoot, ".claude", "skills", "fabric-init", "SKILL.md");
+  if (!existsSync4(legacyPath)) {
+    return;
+  }
+  mkdirSync(join8(newPath, ".."), { recursive: true });
+  renameSync(legacyPath, newPath);
+  const legacyDir = join8(legacyPath, "..");
+  try {
+    rmdirSync(legacyDir);
+  } catch {
+  }
+  await appendEventLedgerEvent(projectRoot, {
+    event_type: "claude_skill_path_migrated",
+    from: legacyPath,
+    to: newPath
+  });
+}
+function inspectLegacyClientPaths(projectRoot) {
+  const configPath = join8(projectRoot, "fabric.config.json");
+  if (!existsSync4(configPath)) {
+    return { presentKeys: [] };
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(configPath, "utf8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { presentKeys: [] };
+    }
+    const config = parsed;
+    const clientPaths = config.clientPaths;
+    if (clientPaths === null || typeof clientPaths !== "object" || Array.isArray(clientPaths)) {
+      return { presentKeys: [] };
+    }
+    const cp = clientPaths;
+    const presentKeys = LEGACY_CLIENT_PATH_KEYS.filter((key) => key in cp);
+    return { presentKeys };
+  } catch {
+    return { presentKeys: [] };
+  }
+}
+function createLegacyClientPathCheck(inspection) {
+  if (inspection.presentKeys.length > 0) {
+    return issueCheck(
+      "Legacy client paths",
+      "warn",
+      "warning",
+      "legacy_client_path_present",
+      `fabric.config.json contains deprecated clientPaths keys: ${inspection.presentKeys.join(", ")}. These clients are removed in 1.8.0; run --fix to clean now or accept the upcoming removal.`,
+      "Run `fab doctor --fix` to remove deprecated clientPaths keys (windsurf, rooCode, geminiCLI) from fabric.config.json."
+    );
+  }
+  return okCheck("Legacy client paths", "No deprecated clientPaths keys found in fabric.config.json.");
+}
+async function fixLegacyClientPaths(projectRoot) {
+  const configPath = join8(projectRoot, "fabric.config.json");
+  if (!existsSync4(configPath)) {
+    return;
+  }
+  let config;
+  try {
+    const parsed = JSON.parse(readFileSync(configPath, "utf8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return;
+    }
+    config = parsed;
+  } catch {
+    return;
+  }
+  const clientPaths = config.clientPaths;
+  if (clientPaths === null || typeof clientPaths !== "object" || Array.isArray(clientPaths)) {
+    return;
+  }
+  const cp = clientPaths;
+  const removed = [];
+  for (const key of LEGACY_CLIENT_PATH_KEYS) {
+    if (key in cp) {
+      delete cp[key];
+      removed.push(key);
+    }
+  }
+  if (removed.length === 0) {
+    return;
+  }
+  const updatedConfig = { ...config, clientPaths: cp };
+  await atomicWriteJson2(configPath, updatedConfig, { indent: 2 });
+  await appendEventLedgerEvent(projectRoot, {
+    event_type: "legacy_client_path_present",
+    removed
+  });
+}
+async function fixMcpConfigInWrongFile(projectRoot) {
+  const settingsPath = join8(projectRoot, ".claude", "settings.json");
+  if (!existsSync4(settingsPath)) {
+    return;
+  }
+  let settings;
+  try {
+    const parsed = JSON.parse(readFileSync(settingsPath, "utf8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return;
+    }
+    settings = parsed;
+  } catch {
+    return;
+  }
+  const mcpServers = settings.mcpServers;
+  if (mcpServers === null || typeof mcpServers !== "object" || Array.isArray(mcpServers)) {
+    return;
+  }
+  const { fabric: _removed, ...remainingServers } = mcpServers;
+  const cleaned = { ...settings };
+  if (Object.keys(remainingServers).length === 0) {
+    delete cleaned.mcpServers;
+  } else {
+    cleaned.mcpServers = remainingServers;
+  }
+  await atomicWriteJson2(settingsPath, cleaned, { indent: 2 });
+  await appendEventLedgerEvent(projectRoot, {
+    event_type: "mcp_config_migrated",
+    source: "doctor_fix",
+    removed_from: ".claude/settings.json"
+  });
+}
+async function writeDefaultBootstrap(projectRoot) {
+  const path = join8(projectRoot, FABRIC_BOOTSTRAP_PATH);
+  await ensureParentDirectory(path);
+  await atomicWriteText3(path, buildBootstrapContent(projectRoot));
+}
+async function ensureEventLedger(projectRoot) {
+  const path = getEventLedgerPath(projectRoot);
+  await ensureParentDirectory(path);
+  await writeFile2(path, "", { encoding: "utf8", flag: "a" });
+}
+function createFixMessage(fixed, report) {
+  const fixedText = fixed.length === 0 ? "No deterministic doctor fixes were needed." : `Applied ${fixed.length} deterministic doctor fix${fixed.length === 1 ? "" : "es"}.`;
+  const manualText = report.manual_errors.length === 0 ? "No manual errors remain." : `${report.manual_errors.length} manual error${report.manual_errors.length === 1 ? "" : "s"} remain.`;
+  return `${fixedText} ${manualText}`;
+}
+function findRuleFiles2(projectRoot) {
+  const rulesRoot = join8(projectRoot, ".fabric", "rules");
+  if (!existsSync4(rulesRoot) || !statSync3(rulesRoot).isDirectory()) {
+    return [];
+  }
+  const files = [];
+  const stack = [rulesRoot];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === void 0) {
+      continue;
+    }
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      const absolutePath = join8(current, entry.name);
+      const relativePath = normalizePath(absolutePath.slice(projectRoot.length + 1));
+      if (entry.isDirectory()) {
+        stack.push(absolutePath);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        files.push(relativePath);
+      }
+    }
+  }
+  return files.sort();
+}
+function isValidJsonLine(line) {
+  try {
+    JSON.parse(line);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeTarget(targetInput) {
+  return isAbsolute3(targetInput) ? targetInput : resolve4(process.cwd(), targetInput);
+}
+function normalizePath(path) {
+  return posix2.normalize(path.split("\\").join("/"));
+}
+function collectEntryPoints(root) {
+  if (!existsSync4(root) || !statSync3(root).isDirectory()) {
+    return [];
+  }
+  const entries = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === void 0) {
+      continue;
+    }
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      const absolutePath = join8(current, entry.name);
+      const relativePath = normalizePath(absolutePath.slice(root.length + 1));
+      if (relativePath.length === 0) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        if (!IGNORED_DIRECTORIES.has(entry.name)) {
+          stack.push(absolutePath);
+        }
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      const reason = getEntryPointReason(relativePath);
+      if (reason !== null) {
+        entries.push({ path: relativePath, reason });
+      }
+    }
+  }
+  return entries.sort((left, right) => left.path.localeCompare(right.path));
+}
+function getEntryPointReason(relativePath) {
+  const extension = relativePath.slice(relativePath.lastIndexOf("."));
+  if (!SCRIPT_EXTENSIONS.has(extension)) {
+    return null;
+  }
+  const directory = posix2.dirname(relativePath);
+  const fileName = posix2.basename(relativePath);
+  const fileBase = fileName.slice(0, Math.max(fileName.lastIndexOf("."), 0));
+  if (directory === "assets/scripts" || directory === "scripts") {
+    return "top-level script";
+  }
+  if (directory === "src" && /^(App|app|index|main)$/.test(fileBase)) {
+    return "application entry";
+  }
+  if ((directory === "app" || directory.startsWith("app/")) && /^(layout|page|route)$/.test(fileBase)) {
+    return "next app route";
+  }
+  if ((directory === "pages" || directory.startsWith("pages/")) && fileName !== "_app.d.ts") {
+    return "next page route";
+  }
+  return null;
+}
+function reduceStatus(statuses) {
+  if (statuses.includes("error")) {
+    return "error";
+  }
+  if (statuses.includes("warn")) {
+    return "warn";
+  }
+  return "ok";
+}
+function isMissingFileError(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+
+export {
+  AGENTS_MD_RESOURCE_URI,
+  contextCache,
+  resolveProjectRoot,
+  readAgentsMeta,
+  LEDGER_PATH,
+  LEGACY_LEDGER_PATH,
+  EVENT_LEDGER_PATH,
+  getLedgerPath,
+  getLegacyLedgerPath,
+  getEventLedgerPath,
+  sha256,
+  isNodeError,
+  appendEventLedgerEvent,
+  readEventLedger,
+  flushAndSyncEventLedger,
+  buildRuleMeta,
+  writeRuleMeta,
+  computeRulesBasedAgentsMeta,
+  computeRuleTestIndex,
+  deriveRuleMetaLayer,
+  deriveRuleMetaTopologyType,
+  isSameRuleTestIndex,
+  stableStringify,
+  invalidateRuleSyncCooldown,
+  ensureRulesFresh,
+  reconcileRules,
+  getRules,
+  planContext,
+  getRuleSections,
+  runDoctorReport,
+  runDoctorFix
+};