@fenglimg/fabric-server 1.5.2 → 1.7.0

package/dist/chunk-PTFSYO4Y.js

@@ -0,0 +1,2083 @@
+// 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/services/_shared.ts
+import { dirname, join, resolve, sep } from "path";
+import { createHash } from "crypto";
+import { mkdir, rename, writeFile } from "fs/promises";
+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}`;
+async function atomicWriteText(path, content) {
+  const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(tempPath, content, "utf8");
+  await rename(tempPath, path);
+}
+function getLedgerPath(projectRoot) {
+  return join(projectRoot, LEDGER_PATH);
+}
+function getLegacyLedgerPath(projectRoot) {
+  return join(projectRoot, LEGACY_LEDGER_PATH);
+}
+function getEventLedgerPath(projectRoot) {
+  return join(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 { appendFile, readFile } from "fs/promises";
+import {
+  eventLedgerEventSchema
+} from "@fenglimg/fabric-shared";
+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 appendFile(eventPath, `${JSON.stringify(nextEvent)}
+`, "utf8");
+  return nextEvent;
+}
+async function readEventLedger(projectRoot, options = {}) {
+  const eventPath = getEventLedgerPath(projectRoot);
+  let raw;
+  try {
+    raw = await readFile(eventPath, "utf8");
+  } catch (error) {
+    if (isNodeError2(error) && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+  return raw.split(/\r?\n/).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);
+}
+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;
+}
+
+// src/services/rule-meta-builder.ts
+import { readdir, readFile as readFile2 } from "fs/promises";
+import { existsSync, statSync } from "fs";
+import { isAbsolute, join as join2, relative, resolve as resolve2, sep as sep2 } from "path";
+import {
+  RULE_TEST_INDEX_SCHEMA_VERSION,
+  agentsMetaSchema,
+  deriveAgentsMetaLayer,
+  deriveAgentsMetaStableId,
+  deriveAgentsMetaTopologyType,
+  ruleTestIndexSchema
+} from "@fenglimg/fabric-shared";
+async function buildRuleMeta(projectRootInput) {
+  const projectRoot = normalizeProjectRoot(projectRootInput);
+  assertExistingDirectory(projectRoot);
+  const metaPath = join2(projectRoot, ".fabric", "agents.meta.json");
+  const ruleTestIndexPath = join2(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 = join2(projectRoot, ".fabric", "agents.meta.json");
+  const ruleTestIndexPath = join2(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 atomicWriteText(metaPath, `${JSON.stringify(result.meta, null, 2)}
+`);
+  await atomicWriteText(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(join2(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 readFile2(join2(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 (!existsSync(projectRoot) || !statSync(projectRoot).isDirectory()) {
+    throw new Error(`Target directory does not exist: ${projectRoot}`);
+  }
+}
+async function readExistingMeta(metaPath) {
+  let raw;
+  try {
+    raw = await readFile2(metaPath, "utf8");
+  } catch (error) {
+    if (isNodeError3(error) && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+  try {
+    return agentsMetaSchema.parse(JSON.parse(raw));
+  } catch {
+    return void 0;
+  }
+}
+async function readExistingRuleTestIndex(indexPath) {
+  let raw;
+  try {
+    raw = await readFile2(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 = join2(projectRoot, ".fabric", "rules");
+  if (!existsSync(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 = join2(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 readFile2(join2(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 = join2(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 = join2(projectRoot, contentRef);
+  if (!existsSync(bootstrapPath)) {
+    return void 0;
+  }
+  const hash = sha256(await readFile2(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/doctor.ts
+import { existsSync as existsSync2, readdirSync, statSync as statSync2 } from "fs";
+import { access, readFile as readFile6, writeFile as writeFile2 } from "fs/promises";
+import { constants } from "fs";
+import { isAbsolute as isAbsolute3, join as join7, 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 readFile5 } from "fs/promises";
+import { join as join6 } from "path";
+
+// src/meta-reader.ts
+import { readFile as readFile3 } from "fs/promises";
+import { join as join3 } from "path";
+import { agentsMetaSchema as agentsMetaSchema2 } from "@fenglimg/fabric-shared";
+import { agentsMetaNodeSchema, agentsMetaSchema as agentsMetaSchema3 } from "@fenglimg/fabric-shared";
+var AgentsMetaFileMissingError = class extends Error {
+  constructor(metaPath) {
+    super(`Fabric agents metadata file is missing: ${metaPath}`);
+    this.metaPath = metaPath;
+    this.name = "AgentsMetaFileMissingError";
+  }
+  metaPath;
+  code = "FABRIC_META_MISSING";
+};
+var AgentsMetaInvalidError = class extends Error {
+  constructor(metaPath, cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    super(`Fabric agents metadata file is invalid: ${metaPath}. ${detail}`);
+    this.metaPath = metaPath;
+    this.name = "AgentsMetaInvalidError";
+  }
+  metaPath;
+  code = "FABRIC_META_INVALID";
+};
+function getAgentsMetaPath(projectRoot) {
+  return join3(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 readFile3(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 = agentsMetaSchema2.parse(JSON.parse(raw));
+  } catch (error) {
+    throw new AgentsMetaInvalidError(metaPath, error);
+  }
+  contextCache.set("meta", projectRoot, parsed);
+  return parsed;
+}
+
+// src/services/audit-log.ts
+import { open, stat } from "fs/promises";
+import { isAbsolute as isAbsolute2, join as join4, posix, relative as relative2, 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 = relative2(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 readFile4 } from "fs/promises";
+import { join as join5 } 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 readFile4(join5(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 = readFile4(join5(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 readFile5(join6(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
+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 taxonomyExists = existsSync2(join7(projectRoot, ".fabric", "INITIAL_TAXONOMY.md"));
+  const bootstrapExists = existsSync2(join7(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)
+  ];
+  const fixableErrors = collectIssues(checks, "fixable_error");
+  const manualErrors = collectIssues(checks, "manual_error");
+  const warnings = collectIssues(checks, "warning");
+  return {
+    status: reduceStatus(checks.map((check) => check.status)),
+    checks,
+    fixable_errors: fixableErrors,
+    manual_errors: manualErrors,
+    warnings,
+    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,
+      targetFiles: Object.fromEntries(
+        TARGET_FILE_PATHS.map((path) => [path, existsSync2(join7(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"].includes(issue.code)
+  )) {
+    await writeRuleMeta(projectRoot, { source: "doctor_fix" });
+    for (const issue of before.fixable_errors.filter(
+      (candidate) => ["agents_meta_missing", "agents_meta_stale", "rule_test_index_missing", "rule_test_index_stale"].includes(candidate.code)
+    )) {
+      fixed.push(issue);
+    }
+    contextCache.invalidate("meta_write", projectRoot);
+  }
+  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 = join7(projectRoot, ".fabric", "forensic.json");
+  try {
+    const parsed = forensicReportSchema.parse(JSON.parse(await readFile6(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 = join7(projectRoot, ".fabric", "init-context.json");
+  try {
+    JSON.parse(await readFile6(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) };
+  }
+}
+async function inspectMeta(projectRoot) {
+  const metaPath = join7(projectRoot, ".fabric", "agents.meta.json");
+  const built = await tryBuildRuleMeta(projectRoot);
+  try {
+    const raw = await readFile6(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 (!existsSync2(join7(projectRoot, contentRef))) {
+        missing.push(contentRef);
+      }
+      continue;
+    }
+    if (!contentRef.startsWith(".fabric/rules/")) {
+      invalid.push(contentRef);
+      continue;
+    }
+    if (!existsSync2(join7(projectRoot, contentRef))) {
+      missing.push(contentRef);
+    }
+  }
+  return { missing, invalid };
+}
+async function inspectEventLedger(projectRoot) {
+  const path = getEventLedgerPath(projectRoot);
+  const exists = existsSync2(path);
+  if (!exists) {
+    return { exists: false, writable: false, parseable: false, path };
+  }
+  try {
+    await access(path, constants.W_OK);
+    await readEventLedger(projectRoot);
+    const raw = await readFile6(path, "utf8");
+    const invalidLine = raw.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean).find((line) => !isValidJsonLine(line));
+    return {
+      exists: true,
+      writable: true,
+      parseable: invalidLine === void 0,
+      path,
+      error: invalidLine === void 0 ? void 0 : "events.jsonl contains an invalid JSON line."
+    };
+  } catch (error) {
+    return {
+      exists: true,
+      writable: false,
+      parseable: false,
+      path,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function inspectRuleSections(projectRoot) {
+  const invalidFiles = [];
+  const files = findRuleFiles(projectRoot);
+  for (const file of files) {
+    try {
+      parseRuleSections(await readFile6(join7(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 = join7(projectRoot, ".fabric", "rule-test.index.json");
+  const built = await tryBuildRuleMeta(projectRoot);
+  try {
+    const index = ruleTestIndexSchema2.parse(JSON.parse(await readFile6(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.");
+  }
+  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.");
+  }
+  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"}.`
+    );
+  }
+  if (!forensic.valid) {
+    return issueCheck("Scan evidence", "error", "manual_error", "forensic_invalid", forensic.error ?? ".fabric/forensic.json is invalid.");
+  }
+  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.");
+  }
+  if (!initContext.validJson) {
+    return issueCheck("Init context", "error", "manual_error", "init_context_invalid", initContext.error ?? ".fabric/init-context.json is invalid.");
+  }
+  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.");
+  }
+  if (!meta.valid) {
+    return issueCheck("Agents metadata", "error", "manual_error", "agents_meta_invalid", meta.readError ?? ".fabric/agents.meta.json is invalid.");
+  }
+  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>"}.`
+    );
+  }
+  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.");
+  }
+  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.`
+    );
+  }
+  if (meta.missingContentRefs.length > 0) {
+    return issueCheck(
+      "Rule content refs",
+      "error",
+      "manual_error",
+      "content_ref_missing",
+      `${meta.missingContentRefs.length} content_ref target${meta.missingContentRefs.length === 1 ? "" : "s"} are missing.`
+    );
+  }
+  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.`
+    );
+  }
+  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);
+  }
+  if (!index.valid) {
+    return issueCheck("Rule-test index", "error", "manual_error", "rule_test_index_invalid", index.error);
+  }
+  if (index.stale) {
+    return issueCheck("Rule-test index", "error", "fixable_error", "rule_test_index_stale", ".fabric/rule-test.index.json is stale.");
+  }
+  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.");
+  }
+  if (!ledger.writable) {
+    return issueCheck("Event ledger", "error", "manual_error", "event_ledger_not_writable", ledger.error ?? ".fabric/events.jsonl is not writable.");
+  }
+  if (!ledger.parseable) {
+    return issueCheck("Event ledger", "error", "manual_error", "event_ledger_invalid", ledger.error ?? ".fabric/events.jsonl is invalid.");
+  }
+  return okCheck("Event ledger", ".fabric/events.jsonl exists, is writable, and is parseable.");
+}
+function okCheck(name, message) {
+  return { name, status: "ok", message };
+}
+function issueCheck(name, status, kind, code, message) {
+  return {
+    name,
+    status,
+    kind,
+    code,
+    fixable: kind === "fixable_error",
+    message
+  };
+}
+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 writeDefaultBootstrap(projectRoot) {
+  const path = join7(projectRoot, ".fabric", "bootstrap", "README.md");
+  await ensureParentDirectory(path);
+  await atomicWriteText(path, "# Fabric Bootstrap\n\nProject-specific Fabric bootstrap notes.\n");
+}
+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 findRuleFiles(projectRoot) {
+  const rulesRoot = join7(projectRoot, ".fabric", "rules");
+  if (!existsSync2(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 readdirSync(current, { withFileTypes: true })) {
+      const absolutePath = join7(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 (!existsSync2(root) || !statSync2(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 = join7(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,
+  AgentsMetaFileMissingError,
+  AgentsMetaInvalidError,
+  resolveProjectRoot,
+  readAgentsMeta,
+  LEDGER_PATH,
+  LEGACY_LEDGER_PATH,
+  EVENT_LEDGER_PATH,
+  getLedgerPath,
+  getLegacyLedgerPath,
+  getEventLedgerPath,
+  sha256,
+  isNodeError,
+  appendEventLedgerEvent,
+  readEventLedger,
+  getRules,
+  planContext,
+  RULE_SECTION_NAMES,
+  getRuleSections,
+  buildRuleMeta,
+  writeRuleMeta,
+  computeRulesBasedAgentsMeta,
+  computeRuleTestIndex,
+  deriveRuleMetaLayer,
+  deriveRuleMetaTopologyType,
+  isSameRuleTestIndex,
+  stableStringify,
+  runDoctorReport,
+  runDoctorFix
+};