@fenglimg/fabric-server 2.0.0 → 2.1.0-rc.2

package/dist/chunk-AR2HV5JT.js

@@ -1,4061 +0,0 @@
-// 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: GetKnowledgeContext 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/knowledge-meta-builder.ts
-import { mkdir as mkdir2, readdir, readFile as readFile3 } from "fs/promises";
-import { existsSync as existsSync2, statSync } from "fs";
-import { homedir } from "os";
-import { isAbsolute, join as join3, relative, resolve as resolve2, sep as sep2 } from "path";
-import {
-  KNOWLEDGE_TEST_INDEX_SCHEMA_VERSION,
-  agentsMetaSchema as agentsMetaSchema3,
-  defaultAgentsMetaCounters,
-  deriveAgentsMetaLayer,
-  deriveAgentsMetaStableId,
-  deriveAgentsMetaTopologyType,
-  isKnowledgeStableId,
-  knowledgeTestIndexSchema,
-  KnowledgeTypeSchema,
-  MaturitySchema,
-  LayerSchema,
-  StableIdSchema,
-  parseKnowledgeId
-} from "@fenglimg/fabric-shared";
-import { atomicWriteText as atomicWriteText2 } from "@fenglimg/fabric-shared/node/atomic-write";
-async function buildKnowledgeMeta(projectRootInput) {
-  const projectRoot = normalizeProjectRoot(projectRootInput);
-  assertExistingDirectory(projectRoot);
-  const metaPath = join3(projectRoot, ".fabric", "agents.meta.json");
-  const knowledgeTestIndexPath = join3(projectRoot, ".fabric", ".cache", "knowledge-test.index.json");
-  const existingMeta = await readExistingMeta(metaPath);
-  const existingKnowledgeTestIndex = await readExistingKnowledgeTestIndex(knowledgeTestIndexPath);
-  const meta = await computeKnowledgeBasedAgentsMeta(projectRoot, existingMeta);
-  const knowledgeTestIndex = await computeKnowledgeTestIndex(projectRoot, meta, existingKnowledgeTestIndex);
-  return {
-    meta,
-    knowledgeTestIndex,
-    changed: existingMeta === void 0 || stableStringify(existingMeta) !== stableStringify(meta) || existingKnowledgeTestIndex === void 0 || !isSameKnowledgeTestIndex(existingKnowledgeTestIndex, knowledgeTestIndex)
-  };
-}
-async function writeKnowledgeMeta(projectRootInput, options) {
-  const projectRoot = normalizeProjectRoot(projectRootInput);
-  const metaPath = join3(projectRoot, ".fabric", "agents.meta.json");
-  const knowledgeTestIndexPath = join3(projectRoot, ".fabric", ".cache", "knowledge-test.index.json");
-  const existingMeta = await readExistingMeta(metaPath);
-  const result = await buildKnowledgeMeta(projectRoot);
-  if (!result.changed) {
-    return result;
-  }
-  await ensureParentDirectory(metaPath);
-  await atomicWriteText2(metaPath, `${JSON.stringify(result.meta, null, 2)}
-`);
-  await ensureParentDirectory(knowledgeTestIndexPath);
-  await atomicWriteText2(knowledgeTestIndexPath, `${JSON.stringify(result.knowledgeTestIndex, 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 computeKnowledgeBasedAgentsMeta(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 findKnowledgeFiles(projectRoot);
-  const nodes = {};
-  for (const contentRef of ruleFiles) {
-    const source = await readFile3(resolveContentRefPath(projectRoot, contentRef), "utf8");
-    const existing = existingByContentRef.get(contentRef);
-    const hash = sha256(source);
-    const defaults = createDefaultNodeMeta(contentRef);
-    const identity = deriveRuleIdentity(contentRef, source, existing?.node);
-    const id = isKnowledgeStableId(identity.stableId) ? identity.stableId : deriveNodeId(contentRef);
-    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)
-    };
-  }
-  const counters = previousMeta?.counters ?? defaultAgentsMetaCounters();
-  return {
-    ...previousMeta ?? {},
-    revision: computeRevision(nodes),
-    nodes: sortNodes(nodes),
-    counters
-  };
-}
-async function computeKnowledgeTestIndex(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: KNOWLEDGE_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 deriveKnowledgeMetaLayer(relativePath) {
-  return deriveAgentsMetaLayer(toAgentsCompatiblePath(relativePath));
-}
-function deriveKnowledgeMetaTopologyType(relativePath) {
-  return deriveAgentsMetaTopologyType(toAgentsCompatiblePath(relativePath));
-}
-function isSameKnowledgeTestIndex(left, right) {
-  return stableStringify(toComparableKnowledgeTestIndex(left)) === stableStringify(toComparableKnowledgeTestIndex(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 readExistingKnowledgeTestIndex(indexPath) {
-  let raw;
-  try {
-    raw = await readFile3(indexPath, "utf8");
-  } catch (error) {
-    if (isNodeError3(error) && error.code === "ENOENT") {
-      return void 0;
-    }
-    throw error;
-  }
-  try {
-    return knowledgeTestIndexSchema.parse(JSON.parse(raw));
-  } catch {
-    return void 0;
-  }
-}
-var KNOWLEDGE_SUBDIRS = ["decisions", "pitfalls", "guidelines", "models", "processes", "pending"];
-var PERSONAL_CONTENT_REF_PREFIX = "~/.fabric/knowledge/";
-var TEAM_CONTENT_REF_PREFIX = ".fabric/knowledge/";
-function resolvePersonalRoot() {
-  return process.env.FABRIC_HOME ?? homedir();
-}
-function resolveContentRefPath(projectRoot, contentRef) {
-  if (contentRef.startsWith(PERSONAL_CONTENT_REF_PREFIX)) {
-    return join3(resolvePersonalRoot(), ".fabric", "knowledge", contentRef.slice(PERSONAL_CONTENT_REF_PREFIX.length));
-  }
-  return join3(projectRoot, contentRef);
-}
-async function findKnowledgeFiles(projectRoot) {
-  const teamRoot = join3(projectRoot, ".fabric", "knowledge");
-  const personalRoot = join3(resolvePersonalRoot(), ".fabric", "knowledge");
-  try {
-    await mkdir2(personalRoot, { recursive: true });
-    for (const sub of KNOWLEDGE_SUBDIRS) {
-      await mkdir2(join3(personalRoot, sub), { recursive: true });
-    }
-  } catch {
-  }
-  const files = [];
-  for (const [root, prefix] of [
-    [teamRoot, TEAM_CONTENT_REF_PREFIX],
-    [personalRoot, PERSONAL_CONTENT_REF_PREFIX]
-  ]) {
-    if (!existsSync2(root) || !statSync(root).isDirectory()) {
-      continue;
-    }
-    for (const subdir of KNOWLEDGE_SUBDIRS) {
-      const dir = join3(root, subdir);
-      let entries;
-      try {
-        entries = await readdir(dir, { withFileTypes: true });
-      } catch (error) {
-        if (isNodeError3(error) && error.code === "ENOENT") {
-          continue;
-        }
-        throw error;
-      }
-      for (const entry of entries) {
-        if (entry.isFile() && entry.name.endsWith(".md")) {
-          files.push(`${prefix}${subdir}/${entry.name}`);
-        }
-      }
-    }
-  }
-  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 toComparableKnowledgeTestIndex(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) {
-  const layer = deriveKnowledgeMetaLayer(file);
-  const relativeStem = getRuleRelativeStem(file);
-  if (file.startsWith(PERSONAL_CONTENT_REF_PREFIX)) {
-    return `${layer}/personal/${relativeStem}`;
-  }
-  if (file.startsWith(TEAM_CONTENT_REF_PREFIX)) {
-    return `${layer}/team/${relativeStem}`;
-  }
-  return `${layer}/${relativeStem}`;
-}
-function createDefaultNodeMeta(contentRef) {
-  const layer = deriveKnowledgeMetaLayer(contentRef);
-  const topologyType = deriveKnowledgeMetaTopologyType(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: ""
-  };
-}
-function deriveScopeGlob(contentRef) {
-  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\/knowledge\//u, "").replace(/^\.fabric\/knowledge\//u, "").replace(/\.md$/u, "");
-}
-function toAgentsCompatiblePath(contentRef) {
-  return contentRef.replace(/^~\/\.fabric\/knowledge\//u, ".fabric/agents/").replace(/^\.fabric\/knowledge\//u, ".fabric/agents/");
-}
-function sortNodes(nodes) {
-  return Object.fromEntries(Object.entries(nodes).sort(([left], [right]) => left.localeCompare(right)));
-}
-function isPendingNode(node) {
-  const ref = node.content_ref ?? node.file ?? "";
-  return ref.startsWith(".fabric/knowledge/pending/") || ref.startsWith("~/.fabric/knowledge/pending/");
-}
-function computeRevision(nodes) {
-  const revisionSource = Object.entries(sortNodes(nodes)).filter(([, node]) => !isPendingNode(node)).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: "knowledge_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
-    });
-  }
-}
-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 declaredKnowledgeId = extractDeclaredKnowledgeId(source);
-  if (declaredKnowledgeId !== void 0) {
-    return {
-      stableId: declaredKnowledgeId,
-      identitySource: "declared"
-    };
-  }
-  if (existing?.stable_id !== void 0 && isKnowledgeStableId(existing.stable_id)) {
-    return {
-      stableId: existing.stable_id,
-      identitySource: "declared"
-    };
-  }
-  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 extractDeclaredKnowledgeId(source) {
-  const frontmatter = /^(?:\uFEFF)?---\r?\n([\s\S]*?)\r?\n---\s*(?:\r?\n|$)/u.exec(source);
-  if (frontmatter === null) {
-    return void 0;
-  }
-  const idMatch = /^id:\s*(.+?)\s*$/mu.exec(frontmatter[1]);
-  if (idMatch === null) {
-    return void 0;
-  }
-  const candidate = idMatch[1].replace(/^["'](.*)["']$/u, "$1").trim();
-  return isKnowledgeStableId(candidate) ? candidate : void 0;
-}
-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,
-    // v2.0 knowledge fields are absent in heading-only fallback.
-    id: void 0,
-    knowledge_type: void 0,
-    maturity: void 0,
-    knowledge_layer: void 0,
-    layer_reason: void 0,
-    created_at: void 0,
-    tags: void 0,
-    // v2.0-rc.5 (C1): default-safe values when there is no frontmatter at all.
-    relevance_scope: "broad",
-    relevance_paths: []
-  };
-}
-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;
-  }
-  const knowledge = extractKnowledgeFieldsFromFrontmatter(frontmatter);
-  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"),
-    id: knowledge.id,
-    knowledge_type: knowledge.knowledge_type,
-    maturity: knowledge.maturity,
-    knowledge_layer: knowledge.knowledge_layer,
-    layer_reason: knowledge.layer_reason,
-    created_at: knowledge.created_at,
-    tags: knowledge.tags,
-    relevance_scope: knowledge.relevance_scope,
-    relevance_paths: knowledge.relevance_paths
-  };
-}
-function extractKnowledgeFieldsFromFrontmatter(frontmatter) {
-  const rawId = extractScalar(frontmatter, "id");
-  const rawType = extractScalar(frontmatter, "type");
-  const rawMaturity = extractScalar(frontmatter, "maturity");
-  const rawLayer = extractScalar(frontmatter, "layer");
-  const rawLayerReason = extractScalar(frontmatter, "layer_reason");
-  const rawCreatedAt = extractScalar(frontmatter, "created_at");
-  let id;
-  if (rawId !== void 0) {
-    const parsed = StableIdSchema.safeParse(rawId);
-    if (parsed.success) {
-      id = parsed.data;
-    } else {
-      process.stderr.write(`[fabric] frontmatter: invalid knowledge id format ${JSON.stringify(rawId)}; skipping
-`);
-    }
-  }
-  let knowledge_type;
-  if (rawType !== void 0) {
-    const parsed = KnowledgeTypeSchema.safeParse(rawType);
-    if (parsed.success) {
-      knowledge_type = parsed.data;
-    } else {
-      process.stderr.write(`[fabric] frontmatter: unknown knowledge type ${JSON.stringify(rawType)}; skipping
-`);
-    }
-  }
-  let maturity;
-  if (rawMaturity !== void 0) {
-    const parsed = MaturitySchema.safeParse(rawMaturity);
-    if (parsed.success) {
-      maturity = parsed.data;
-    } else {
-      process.stderr.write(`[fabric] frontmatter: unknown maturity ${JSON.stringify(rawMaturity)}; skipping
-`);
-    }
-  }
-  let knowledge_layer;
-  if (rawLayer !== void 0) {
-    const parsed = LayerSchema.safeParse(rawLayer);
-    if (parsed.success) {
-      knowledge_layer = parsed.data;
-    } else {
-      process.stderr.write(`[fabric] frontmatter: unknown layer ${JSON.stringify(rawLayer)}; skipping
-`);
-    }
-  }
-  let created_at;
-  if (rawCreatedAt !== void 0) {
-    if (!Number.isNaN(Date.parse(rawCreatedAt))) {
-      created_at = rawCreatedAt;
-    } else {
-      process.stderr.write(`[fabric] frontmatter: malformed created_at ${JSON.stringify(rawCreatedAt)}; skipping
-`);
-    }
-  }
-  if (id !== void 0 && knowledge_layer !== void 0) {
-    const decoded = parseKnowledgeId(id);
-    if (decoded !== null && decoded.layer !== knowledge_layer) {
-      process.stderr.write(
-        `[fabric] frontmatter: id ${id} encodes layer ${decoded.layer} but layer field says ${knowledge_layer}; dropping both
-`
-      );
-      id = void 0;
-      knowledge_layer = void 0;
-    }
-  }
-  const tags = extractInlineArray(frontmatter, "tags");
-  const rawRelevanceScope = extractScalar(frontmatter, "relevance_scope");
-  const relevance_scope = rawRelevanceScope === "narrow" || rawRelevanceScope === "broad" ? rawRelevanceScope : "broad";
-  const relevance_paths = extractInlineArray(frontmatter, "relevance_paths");
-  return {
-    id,
-    knowledge_type,
-    maturity,
-    knowledge_layer,
-    layer_reason: rawLayerReason,
-    created_at,
-    tags: tags.length > 0 ? tags : void 0,
-    relevance_scope,
-    relevance_paths
-  };
-}
-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/knowledge-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 invalidateKnowledgeSyncCooldown(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 knowledgeRoot = join4(projectRoot, ".fabric", "knowledge");
-  if (!existsSync3(knowledgeRoot) || !statSync2(knowledgeRoot).isDirectory()) {
-    return [];
-  }
-  const files = [];
-  const stack = [knowledgeRoot];
-  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: "knowledge_drift_detected",
-      drifted_stable_ids: driftedIds,
-      missing_files: missingFiles,
-      stale_files: staleFiles
-    });
-  }
-}
-async function ensureKnowledgeFresh(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 = "ensureKnowledgeFresh";
-  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 reconcileKnowledge(projectRoot, opts) {
-  freshSyncCooldown.delete(projectRoot);
-  const trigger = opts?.trigger;
-  const startTime = Date.now();
-  const source = "reconcileKnowledge";
-  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 writeKnowledgeMeta(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: "reconcileKnowledge"
-      });
-    } else {
-      await appendEventLedgerEvent(projectRoot, {
-        event_type: "meta_reconciled",
-        reconciled_files: reconciledFiles,
-        duration_ms,
-        trigger,
-        source: "reconcileKnowledge"
-      });
-    }
-  }
-  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 { execFileSync } from "child_process";
-import { existsSync as existsSync4, readdirSync, readFileSync, statSync as statSync3 } from "fs";
-import { access, mkdir as mkdir3, readFile as readFile5, rename, writeFile as writeFile2 } from "fs/promises";
-import { constants } from "fs";
-import { homedir as homedir2 } from "os";
-import { isAbsolute as isAbsolute2, join as join5, posix, relative as nodeRelative, resolve as resolve3, sep as sep4 } from "path";
-import { minimatch } from "minimatch";
-import {
-  agentsMetaSchema as agentsMetaSchema4,
-  AgentsMetaCountersSchema,
-  forensicReportSchema,
-  parseKnowledgeId as parseKnowledgeId2,
-  knowledgeTestIndexSchema as knowledgeTestIndexSchema2
-} from "@fenglimg/fabric-shared";
-import { detectFramework } from "@fenglimg/fabric-shared/node";
-import { atomicWriteJson as atomicWriteJson2, atomicWriteText as atomicWriteText3 } from "@fenglimg/fabric-shared/node/atomic-write";
-var ORPHAN_DEMOTE_THRESHOLD_DAYS = {
-  stable: 90,
-  endorsed: 30,
-  draft: 14
-};
-var STALE_ARCHIVE_ADDITIONAL_DAYS = 90;
-var PENDING_OVERDUE_THRESHOLD_DAYS = 14;
-var PENDING_AUTO_ARCHIVE_THRESHOLD_DAYS = 30;
-var DEFAULT_UNDERSEED_NODE_THRESHOLD = 10;
-var SESSION_HINTS_STALE_DAYS = 7;
-var SESSION_HINTS_FILE_PREFIX = "session-hints-";
-var SESSION_HINTS_FILE_SUFFIX = ".json";
-var NARROW_RATIO_THRESHOLD = 0.2;
-var NARROW_MIN_TOTAL = 10;
-var SILENCE_RATE_THRESHOLD = 0.95;
-var SILENCE_WINDOW_DAYS = 30;
-var EDIT_COUNTER_FILE_REL = posix.join(".fabric", ".cache", "edit-counter");
-var HINT_SILENCE_COUNTER_FILE_REL = posix.join(
-  ".fabric",
-  ".cache",
-  "hint-silence-counter"
-);
-var MS_PER_DAY = 24 * 60 * 60 * 1e3;
-var MATURITY_LINE_PATTERN = /^maturity:\s*("?)(stable|endorsed|draft)\1\s*$/mu;
-var CREATED_AT_LINE_PATTERN = /^created_at:\s*("?)([^"\n]+)\1\s*$/mu;
-var RELEVANCE_SCOPE_LINE_PATTERN = /^relevance_scope:\s*("?)(narrow|broad)\1\s*$/mu;
-var RELEVANCE_PATHS_LINE_PATTERN = /^relevance_paths:\s*\[([^\]]*)\]\s*$/mu;
-var RELEVANCE_PATHS_DRIFT_WINDOW_DAYS = 90;
-var SYNTHESIZED_PROMOTED_REASON = "[synthesized] filesystem-edit-fallback";
-var KNOWLEDGE_CANONICAL_TYPE_DIRS = [
-  "decisions",
-  "pitfalls",
-  "guidelines",
-  "models",
-  "processes"
-];
-var CANONICAL_KNOWLEDGE_FILENAME_PATTERN = /^(K[PT]-(?:MOD|DEC|GLD|PIT|PRO)-\d{4,})--[a-z0-9][a-z0-9-]*\.md$/u;
-var KNOWLEDGE_SUBDIRS2 = ["decisions", "pitfalls", "guidelines", "models", "processes", "pending"];
-var COUNTER_TYPE_CODES = ["MOD", "DEC", "GLD", "PIT", "PRO"];
-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/forensic.json",
-  ".fabric/agents.meta.json",
-  ".fabric/.cache/knowledge-test.index.json",
-  ".fabric/events.jsonl",
-  ".fabric/knowledge"
-];
-async function runDoctorReport(target) {
-  const projectRoot = normalizeTarget(target);
-  const framework = detectFramework(projectRoot);
-  const entryPoints = collectEntryPoints(projectRoot);
-  const [
-    forensic,
-    meta,
-    eventLedger,
-    knowledgeTestIndex
-  ] = await Promise.all([
-    inspectForensic(projectRoot),
-    inspectMeta(projectRoot),
-    inspectEventLedger(projectRoot),
-    inspectKnowledgeTestIndex(projectRoot)
-  ]);
-  const mcpConfigInWrongFile = inspectMcpConfigInWrongFile(projectRoot);
-  const metaManuallyDiverged = await inspectMetaManuallyDiverged(projectRoot);
-  const knowledgeDirUnindexed = inspectKnowledgeDirUnindexed(projectRoot, meta);
-  const knowledgeDirMissing = inspectKnowledgeDirMissing(projectRoot);
-  const stableIdCollision = await inspectStableIdCollisions(projectRoot);
-  const counterDesync = inspectCounterDesync(meta);
-  const preexistingRootFiles = inspectPreexistingRootFiles(projectRoot);
-  const bootstrapAnchor = inspectBootstrapAnchor(projectRoot);
-  const filesystemEditFallback = eventLedger.exists && eventLedger.writable && eventLedger.parseable ? await inspectFilesystemEditFallback(projectRoot) : { synthesized: 0, synthesizedStableIds: [] };
-  const lintNow = Date.now();
-  const orphanDemote = await inspectOrphanDemote(projectRoot, lintNow);
-  const staleArchive = await inspectStaleArchive(projectRoot, lintNow);
-  const pendingOverdue = inspectPendingOverdue(projectRoot, lintNow);
-  const stableIdDuplicate = inspectStableIdDuplicate(projectRoot);
-  const layerMismatch = inspectLayerMismatch(projectRoot);
-  const indexDrift = inspectIndexDrift(projectRoot, meta);
-  const underseeded = inspectUnderseeded(projectRoot);
-  const narrowNoPaths = inspectNarrowNoPaths(projectRoot);
-  const relevancePathsDangling = inspectRelevancePathsDangling(projectRoot);
-  const relevancePathsDrift = inspectRelevancePathsDrift(projectRoot);
-  const narrowTooFew = inspectNarrowTooFew(projectRoot, lintNow);
-  const sessionHintsStale = inspectSessionHintsStale(projectRoot, lintNow);
-  const checks = [
-    createBootstrapAnchorCheck(bootstrapAnchor),
-    createKnowledgeDirMissingCheck(knowledgeDirMissing),
-    createForensicCheck(forensic, framework.kind, entryPoints.length),
-    // v2.0: removed `createInitContextCheck` — `.fabric/init-context.json`
-    // is owned by the AI-side client init skill, not by `fabric init` CLI.
-    // The file's absence is a legitimate post-init state when the skill has
-    // not yet run, so flagging it as a doctor manual_error misrepresents
-    // ownership.
-    createMetaCheck(meta),
-    createRuleContentRefCheck(meta),
-    // v2.0 / rc.2: `createRuleSectionsCheck` removed — it parsed v1.x
-    // [MANDATORY_INJECTION] sections out of legacy rule files, a structural
-    // concept that has no v2 equivalent. rc.4 will introduce a dedicated v2
-    // lint suite for the new knowledge frontmatter contract.
-    createKnowledgeTestIndexCheck(knowledgeTestIndex),
-    createEventLedgerCheck(eventLedger),
-    createEventLedgerPartialWriteCheck(eventLedger),
-    createMcpConfigInWrongFileCheck(mcpConfigInWrongFile),
-    createMetaManuallyDivergedCheck(metaManuallyDiverged),
-    createKnowledgeDirUnindexedCheck(knowledgeDirUnindexed),
-    createStableIdCollisionCheck(stableIdCollision),
-    createCounterDesyncCheck(counterDesync),
-    createFilesystemEditFallbackCheck(filesystemEditFallback),
-    // rc.4 TASK-001: read-side lint checks #16-18. Findings only — mutation
-    // + event emission lands in TASK-003 behind --apply-lint.
-    createOrphanDemoteCheck(orphanDemote),
-    createStaleArchiveCheck(staleArchive),
-    createPendingOverdueCheck(pendingOverdue),
-    // rc.4 TASK-002: read-side integrity checks #19-21. Stable_id duplicate
-    // runs first in this trio — it is the most critical integrity break and
-    // surfaces ahead of layer-mismatch / index-drift in the report so a
-    // human operator triages the collision before reasoning about counter
-    // state. Index drift is the only fixable_error of the three; stable_id
-    // duplicate and layer mismatch require manual triage (rename / move).
-    createStableIdDuplicateCheck(stableIdDuplicate),
-    createLayerMismatchCheck(layerMismatch),
-    createIndexDriftCheck(indexDrift),
-    // rc.5 TASK-010: read-side underseeded-corpus check (#22). Info kind —
-    // does not bump report status. Recommends running the fabric-import skill
-    // to backfill knowledge when the corpus is below the threshold floor.
-    createUnderseededCheck(underseeded),
-    // rc.5 TASK-013 (C4): relevance_paths hygiene checks #23/#24/#25.
-    // All three are flag-only in rc.5 (no apply-lint mutations).
-    //   #23 narrow_no_paths        — warning kind (silent recall risk)
-    //   #24 relevance_paths_dangling — warning kind (glob → zero matches)
-    //   #25 relevance_paths_drift  — info kind (git-log heuristic; noisy)
-    createNarrowNoPathsCheck(narrowNoPaths),
-    createRelevancePathsDanglingCheck(relevancePathsDangling),
-    createRelevancePathsDriftCheck(relevancePathsDrift),
-    // rc.6 TASK-023 (E6): narrow_too_few (lint #26). Info kind; both arms
-    // (structural + telemetry) recommend the same fabric-import action.
-    createNarrowTooFewCheck(narrowTooFew),
-    // rc.6 TASK-021 (E3): session-hints cache hygiene (lint #27). Info kind.
-    createSessionHintsStaleCheck(sessionHintsStale),
-    createPreexistingRootFilesCheck(preexistingRootFiles)
-    // v2.0 / rc.2: `createLegacyClientPathCheck` removed. The schema now
-    // rejects retired clientPaths keys (windsurf/rooCode/geminiCLI) at Zod
-    // parse time, so the soft-deprecation warn-and-fix path no longer has a
-    // reachable input — fabric.config.json with a retired key fails before
-    // doctor ever inspects it.
-    // v2.0 / rc.2: `createLegacyV1ArtifactsCheck` removed alongside its
-    // path-list constant. The visibility-only warning referenced v1.x
-    // artifacts that are now archaeology. rc.4 owns v2 lint coverage; on a
-    // clean v2 install nothing is lost since the check fired only when v1
-    // artifacts remained.
-  ];
-  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(join5(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 === "knowledge_dir_missing")) {
-    await ensureKnowledgeSubdirs(projectRoot);
-    fixed.push(findIssue(before.fixable_errors, "knowledge_dir_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) => issue.code === "counter_desync")) {
-    await fixCounterDesync(projectRoot);
-    fixed.push(findIssue(before.fixable_errors, "counter_desync"));
-    contextCache.invalidate("meta_write", projectRoot);
-  }
-  if (before.fixable_errors.some(
-    (issue) => [
-      "agents_meta_missing",
-      "agents_meta_stale",
-      "knowledge_test_index_missing",
-      "knowledge_test_index_stale",
-      "content_ref_missing",
-      "knowledge_dir_unindexed"
-    ].includes(issue.code)
-  )) {
-    await reconcileKnowledge(projectRoot, { trigger: "doctor" });
-    for (const issue of before.fixable_errors.filter(
-      (candidate) => [
-        "agents_meta_missing",
-        "agents_meta_stale",
-        "knowledge_test_index_missing",
-        "knowledge_test_index_stale",
-        "content_ref_missing",
-        "knowledge_dir_unindexed"
-      ].includes(candidate.code)
-    )) {
-      fixed.push(issue);
-    }
-    contextCache.invalidate("meta_write", projectRoot);
-    await fixCounterDesync(projectRoot);
-    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"));
-  }
-  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
-  };
-}
-var MANUAL_LINT_ERROR_CODES = /* @__PURE__ */ new Set([
-  "knowledge_stable_id_duplicate",
-  "knowledge_layer_mismatch"
-]);
-async function runDoctorApplyLint(target) {
-  const projectRoot = normalizeTarget(target);
-  const before = await runDoctorReport(projectRoot);
-  const mutations = [];
-  const blockingManual = before.manual_errors.find(
-    (issue) => MANUAL_LINT_ERROR_CODES.has(issue.code)
-  );
-  if (blockingManual !== void 0) {
-    return {
-      changed: false,
-      mutations: [],
-      manual_errors: before.manual_errors,
-      aborted: true,
-      abort_reason: `Manual repair required for ${blockingManual.code}: ${blockingManual.message} - apply-lint cannot resolve this safely; triage by hand.`,
-      message: `apply-lint aborted: ${blockingManual.code} requires manual repair.`,
-      report: before
-    };
-  }
-  const now = Date.now();
-  const orphanDemote = await inspectOrphanDemote(projectRoot, now);
-  for (const candidate of orphanDemote.candidates) {
-    if (candidate.next_maturity === null) {
-      continue;
-    }
-    mutations.push(await applyOrphanDemote(projectRoot, candidate, now));
-  }
-  const staleArchive = await inspectStaleArchive(projectRoot, now);
-  for (const candidate of staleArchive.candidates) {
-    mutations.push(await applyStaleArchive(projectRoot, candidate, now));
-  }
-  const pendingAutoArchive = inspectPendingAutoArchive(projectRoot, now);
-  for (const candidate of pendingAutoArchive.candidates) {
-    mutations.push(await applyPendingAutoArchive(projectRoot, candidate, now));
-  }
-  const sessionHintsStale = inspectSessionHintsStale(projectRoot, now);
-  for (const candidate of sessionHintsStale.candidates) {
-    mutations.push(await applySessionHintsStaleCleanup(projectRoot, candidate));
-  }
-  const meta = await inspectMeta(projectRoot);
-  const indexDrift = inspectIndexDrift(projectRoot, meta);
-  if (indexDrift.drifts.length > 0) {
-    mutations.push(await applyIndexDriftFix(projectRoot, indexDrift));
-  }
-  contextCache.invalidate("meta_write", projectRoot);
-  const after = await runDoctorReport(projectRoot);
-  const successCount = mutations.filter((m) => m.applied).length;
-  const failureCount = mutations.length - successCount;
-  return {
-    changed: successCount > 0,
-    mutations,
-    manual_errors: after.manual_errors,
-    aborted: false,
-    message: createApplyLintMessage(successCount, failureCount, after.manual_errors.length),
-    report: after
-  };
-}
-function createApplyLintMessage(succeeded, failed, manualErrorCount) {
-  const parts = [];
-  if (succeeded === 0 && failed === 0) {
-    parts.push("No apply-lint mutations were needed.");
-  } else {
-    parts.push(`Applied ${succeeded} apply-lint mutation${succeeded === 1 ? "" : "s"}.`);
-    if (failed > 0) {
-      parts.push(`${failed} mutation${failed === 1 ? "" : "s"} failed.`);
-    }
-  }
-  parts.push(
-    manualErrorCount === 0 ? "No manual errors remain." : `${manualErrorCount} manual error${manualErrorCount === 1 ? "" : "s"} remain.`
-  );
-  return parts.join(" ");
-}
-function rewriteFrontmatterMaturity(source, newMaturity) {
-  const FM_PATTERN = /^(?:\uFEFF)?---\r?\n([\s\S]*?)\r?\n---/u;
-  const fm = FM_PATTERN.exec(source);
-  if (fm === null) {
-    return null;
-  }
-  const block = fm[1];
-  if (!MATURITY_LINE_PATTERN.test(block)) {
-    return null;
-  }
-  const replacedBlock = block.replace(
-    MATURITY_LINE_PATTERN,
-    (line) => line.replace(/(stable|endorsed|draft)/u, newMaturity)
-  );
-  const blockStart = source.indexOf(block);
-  if (blockStart < 0) {
-    return null;
-  }
-  return source.slice(0, blockStart) + replacedBlock + source.slice(blockStart + block.length);
-}
-async function applyOrphanDemote(projectRoot, candidate, now) {
-  const next = candidate.next_maturity;
-  if (next === null) {
-    return {
-      kind: "knowledge_orphan_demote_required",
-      path: candidate.path,
-      detail: `${candidate.maturity} -> (none, already at terminal tier)`,
-      applied: false,
-      error: "next_maturity is null; orphan-demote not applicable"
-    };
-  }
-  const detail = `${candidate.maturity} -> ${next}`;
-  const absPath = join5(projectRoot, candidate.path);
-  try {
-    const source = await readFile5(absPath, "utf8");
-    const rewritten = rewriteFrontmatterMaturity(source, next);
-    if (rewritten === null) {
-      return {
-        kind: "knowledge_orphan_demote_required",
-        path: candidate.path,
-        detail,
-        applied: false,
-        error: "frontmatter missing maturity field; cannot rewrite"
-      };
-    }
-    if (rewritten === source) {
-      return {
-        kind: "knowledge_orphan_demote_required",
-        path: candidate.path,
-        detail,
-        applied: false,
-        error: "rewrite produced byte-identical output"
-      };
-    }
-    await atomicWriteText3(absPath, rewritten);
-    try {
-      await appendEventLedgerEvent(projectRoot, {
-        event_type: "knowledge_demoted",
-        stable_id: candidate.stable_id,
-        timestamp: new Date(now).toISOString(),
-        reason: `lint:orphan_demote ${candidate.maturity}->${next} after ${candidate.age_days}d inactive`
-      });
-    } catch (ledgerError) {
-      try {
-        await atomicWriteText3(absPath, source);
-      } catch (rollbackError) {
-        return {
-          kind: "knowledge_orphan_demote_required",
-          path: candidate.path,
-          detail,
-          applied: false,
-          error: `ledger append failed (${truncateErrorMessage(ledgerError)}); rollback also failed (${truncateErrorMessage(rollbackError)}); disk may be in inconsistent state`
-        };
-      }
-      return {
-        kind: "knowledge_orphan_demote_required",
-        path: candidate.path,
-        detail,
-        applied: false,
-        error: `ledger append failed (${truncateErrorMessage(ledgerError)}); frontmatter rolled back`
-      };
-    }
-    return {
-      kind: "knowledge_orphan_demote_required",
-      path: candidate.path,
-      detail,
-      applied: true
-    };
-  } catch (error) {
-    return {
-      kind: "knowledge_orphan_demote_required",
-      path: candidate.path,
-      detail,
-      applied: false,
-      error: truncateErrorMessage(error)
-    };
-  }
-}
-async function applyStaleArchive(projectRoot, candidate, now) {
-  const sourceAbs = join5(projectRoot, candidate.path);
-  const destAbs = join5(projectRoot, candidate.archive_path);
-  const detail = `${candidate.path} -> ${candidate.archive_path}`;
-  try {
-    await mkdir3(join5(destAbs, ".."), { recursive: true });
-    try {
-      await rename(sourceAbs, destAbs);
-    } catch (renameError) {
-      if (renameError instanceof Error && "code" in renameError && renameError.code === "EXDEV") {
-        const data = await readFile5(sourceAbs);
-        await writeFile2(destAbs, data);
-        const { unlink } = await import("fs/promises");
-        await unlink(sourceAbs);
-      } else {
-        throw renameError;
-      }
-    }
-    try {
-      await appendEventLedgerEvent(projectRoot, {
-        event_type: "knowledge_archived",
-        stable_id: candidate.stable_id,
-        timestamp: new Date(now).toISOString(),
-        reason: `lint:stale_archive ${candidate.path} -> ${candidate.archive_path} after ${candidate.age_days}d inactive`
-      });
-    } catch (ledgerError) {
-      try {
-        await rename(destAbs, sourceAbs);
-      } catch (rollbackError) {
-        return {
-          kind: "knowledge_stale_archive_required",
-          path: candidate.path,
-          detail,
-          applied: false,
-          error: `ledger append failed (${truncateErrorMessage(ledgerError)}); rollback also failed (${truncateErrorMessage(rollbackError)}); file may be stranded at ${candidate.archive_path}`
-        };
-      }
-      return {
-        kind: "knowledge_stale_archive_required",
-        path: candidate.path,
-        detail,
-        applied: false,
-        error: `ledger append failed (${truncateErrorMessage(ledgerError)}); archive rolled back`
-      };
-    }
-    return {
-      kind: "knowledge_stale_archive_required",
-      path: candidate.path,
-      detail,
-      applied: true
-    };
-  } catch (error) {
-    return {
-      kind: "knowledge_stale_archive_required",
-      path: candidate.path,
-      detail,
-      applied: false,
-      error: truncateErrorMessage(error)
-    };
-  }
-}
-async function applyPendingAutoArchive(projectRoot, candidate, now) {
-  const detail = `${candidate.pending_path} -> ${candidate.archived_to}`;
-  try {
-    await mkdir3(join5(candidate.archived_to_abs, ".."), { recursive: true });
-    let moved = false;
-    if (candidate.layer === "team") {
-      try {
-        const relSource = relativePosix(projectRoot, candidate.pending_path_abs);
-        const relDest = relativePosix(projectRoot, candidate.archived_to_abs);
-        execFileSync("git", ["mv", "-f", relSource, relDest], {
-          cwd: projectRoot,
-          stdio: ["ignore", "pipe", "pipe"]
-        });
-        moved = true;
-      } catch {
-      }
-    }
-    if (!moved) {
-      try {
-        await rename(candidate.pending_path_abs, candidate.archived_to_abs);
-      } catch (renameError) {
-        if (renameError instanceof Error && "code" in renameError && renameError.code === "EXDEV") {
-          const data = await readFile5(candidate.pending_path_abs);
-          await writeFile2(candidate.archived_to_abs, data);
-          const { unlink } = await import("fs/promises");
-          await unlink(candidate.pending_path_abs);
-        } else {
-          throw renameError;
-        }
-      }
-    }
-    try {
-      await appendEventLedgerEvent(projectRoot, {
-        event_type: "pending_auto_archived",
-        pending_path: candidate.pending_path,
-        archived_to: candidate.archived_to,
-        reason: "auto_archive_30d"
-      });
-    } catch (ledgerError) {
-      try {
-        await rename(candidate.archived_to_abs, candidate.pending_path_abs);
-      } catch (rollbackError) {
-        return {
-          kind: "knowledge_pending_auto_archive",
-          path: candidate.pending_path,
-          detail,
-          applied: false,
-          error: `ledger append failed (${truncateErrorMessage(ledgerError)}); rollback also failed (${truncateErrorMessage(rollbackError)}); file may be stranded at ${candidate.archived_to}`
-        };
-      }
-      return {
-        kind: "knowledge_pending_auto_archive",
-        path: candidate.pending_path,
-        detail,
-        applied: false,
-        error: `ledger append failed (${truncateErrorMessage(ledgerError)}); archive rolled back`
-      };
-    }
-    return {
-      kind: "knowledge_pending_auto_archive",
-      path: candidate.pending_path,
-      detail,
-      applied: true
-    };
-  } catch (error) {
-    return {
-      kind: "knowledge_pending_auto_archive",
-      path: candidate.pending_path,
-      detail,
-      applied: false,
-      error: truncateErrorMessage(error)
-    };
-  }
-}
-function relativePosix(projectRoot, absolutePath) {
-  const rel = nodeRelative(projectRoot, absolutePath);
-  return rel.split(sep4).join("/");
-}
-async function applySessionHintsStaleCleanup(projectRoot, candidate) {
-  const detail = `deleted (${candidate.age_days}d old)`;
-  const absPath = join5(projectRoot, candidate.path);
-  try {
-    const { unlink } = await import("fs/promises");
-    await unlink(absPath);
-    return {
-      kind: "knowledge_session_hints_stale_cleanup",
-      path: candidate.path,
-      detail,
-      applied: true
-    };
-  } catch (error) {
-    return {
-      kind: "knowledge_session_hints_stale_cleanup",
-      path: candidate.path,
-      detail,
-      applied: false,
-      error: truncateErrorMessage(error)
-    };
-  }
-}
-async function applyIndexDriftFix(projectRoot, inspection) {
-  const metaPath = join5(projectRoot, ".fabric", "agents.meta.json");
-  const detailParts = [];
-  try {
-    const meta = agentsMetaSchema4.parse(JSON.parse(await readFile5(metaPath, "utf8")));
-    const baseCounters = AgentsMetaCountersSchema.parse(meta.counters ?? void 0);
-    const updatedCounters = {
-      KP: { ...baseCounters.KP },
-      KT: { ...baseCounters.KT }
-    };
-    for (const drift of inspection.drifts) {
-      updatedCounters[drift.layer][drift.type] = drift.proposed_after;
-      detailParts.push(`${drift.layer}.${drift.type}: ${drift.counter} -> ${drift.proposed_after}`);
-    }
-    const updated = { ...meta, counters: updatedCounters };
-    await atomicWriteJson2(metaPath, updated, { indent: 2 });
-    return {
-      kind: "knowledge_index_drift",
-      path: "agents.meta.json#counters",
-      detail: detailParts.join("; "),
-      applied: true
-    };
-  } catch (error) {
-    return {
-      kind: "knowledge_index_drift",
-      path: "agents.meta.json#counters",
-      detail: detailParts.join("; ") || "(no counters processed)",
-      applied: false,
-      error: truncateErrorMessage(error)
-    };
-  }
-}
-function truncateErrorMessage(error) {
-  const raw = error instanceof Error ? error.message : String(error);
-  return raw.length > 240 ? `${raw.slice(0, 237)}...` : raw;
-}
-async function inspectForensic(projectRoot) {
-  const path = join5(projectRoot, ".fabric", "forensic.json");
-  try {
-    const parsed = forensicReportSchema.parse(JSON.parse(await readFile5(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) };
-  }
-}
-function inspectMcpConfigInWrongFile(projectRoot) {
-  const settingsPath = join5(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 = join5(projectRoot, ".fabric", "agents.meta.json");
-  const built = await tryBuildRuleMeta(projectRoot);
-  try {
-    const raw = await readFile5(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) => {
-        const ref = node.content_ref ?? node.file;
-        return ref.startsWith(".fabric/knowledge/") || ref.startsWith("~/.fabric/knowledge/");
-      }).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 buildKnowledgeMeta(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);
-    const isPersonalKnowledge = contentRef.startsWith("~/.fabric/knowledge/");
-    const isTeamKnowledge = contentRef.startsWith(".fabric/knowledge/");
-    if (!isPersonalKnowledge && !isTeamKnowledge) {
-      invalid.push(contentRef);
-      continue;
-    }
-    if (isPersonalKnowledge) {
-      continue;
-    }
-    if (!existsSync4(join5(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 readFile5(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 inspectKnowledgeTestIndex(projectRoot) {
-  const path = join5(projectRoot, ".fabric", ".cache", "knowledge-test.index.json");
-  const built = await tryBuildRuleMeta(projectRoot);
-  try {
-    const index = knowledgeTestIndexSchema2.parse(JSON.parse(await readFile5(path, "utf8")));
-    return {
-      present: true,
-      valid: true,
-      stale: built === null ? false : !isSameKnowledgeTestIndex(index, built.knowledgeTestIndex),
-      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/.cache/knowledge-test.index.json is missing." : error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-function inspectBootstrapAnchor(projectRoot) {
-  return {
-    hasAgentsMd: existsSync4(join5(projectRoot, "AGENTS.md")),
-    hasClaudeMd: existsSync4(join5(projectRoot, "CLAUDE.md"))
-  };
-}
-function createBootstrapAnchorCheck(inspection) {
-  if (!inspection.hasAgentsMd && !inspection.hasClaudeMd) {
-    return issueCheck(
-      "Bootstrap anchor",
-      "error",
-      "fixable_error",
-      "bootstrap_anchor_missing",
-      "Neither AGENTS.md nor CLAUDE.md exists at the repo root. Fabric requires a bootstrap anchor file at the project root.",
-      "Run `fabric init` to generate the AGENTS.md / CLAUDE.md bootstrap anchor at the repo root."
-    );
-  }
-  const present = [
-    inspection.hasAgentsMd ? "AGENTS.md" : null,
-    inspection.hasClaudeMd ? "CLAUDE.md" : null
-  ].filter((entry) => entry !== null).join(", ");
-  return okCheck("Bootstrap anchor", `Bootstrap anchor present at repo root: ${present}.`);
-}
-function inspectKnowledgeDirMissing(projectRoot) {
-  const knowledgeRoot = join5(projectRoot, ".fabric", "knowledge");
-  const missingSubdirs = [];
-  for (const sub of KNOWLEDGE_SUBDIRS2) {
-    const path = join5(knowledgeRoot, sub);
-    if (!existsSync4(path)) {
-      missingSubdirs.push(`.fabric/knowledge/${sub}`);
-    }
-  }
-  return { missingSubdirs };
-}
-function createKnowledgeDirMissingCheck(inspection) {
-  if (inspection.missingSubdirs.length > 0) {
-    const list = inspection.missingSubdirs.join(", ");
-    return issueCheck(
-      "Knowledge layout",
-      "error",
-      "fixable_error",
-      "knowledge_dir_missing",
-      `${inspection.missingSubdirs.length} required knowledge subdir${inspection.missingSubdirs.length === 1 ? " is" : "s are"} missing: ${list}.`,
-      "Run `fab doctor --fix` to create the missing .fabric/knowledge/* subdirectories."
-    );
-  }
-  return okCheck(
-    "Knowledge layout",
-    `All ${KNOWLEDGE_SUBDIRS2.length} required .fabric/knowledge/* subdirectories exist.`
-  );
-}
-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 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/knowledge/.");
-  }
-  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/knowledge derived revision ${meta.computedRevision ?? "<unknown>"}.`,
-      "Run `fab doctor --fix` to reconcile agents.meta.json with the current knowledge files."
-    );
-  }
-  return okCheck("Agents metadata", `.fabric/agents.meta.json revision ${meta.revision} is aligned with .fabric/knowledge.`);
-}
-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/knowledge.`,
-      "Edit agents.meta.json to ensure all content_ref values point inside .fabric/knowledge/{type}/ (team) or ~/.fabric/knowledge/{type}/ (personal)."
-    );
-  }
-  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/knowledge/."
-    );
-  }
-  return okCheck("Rule content refs", "All content_ref entries resolve to .fabric/knowledge files.");
-}
-function createKnowledgeTestIndexCheck(index) {
-  if (!index.present) {
-    return issueCheck("Knowledge-test index", "error", "fixable_error", "knowledge_test_index_missing", index.error, "Run `fab doctor --fix` to rebuild .fabric/.cache/knowledge-test.index.json.");
-  }
-  if (!index.valid) {
-    return issueCheck("Knowledge-test index", "error", "manual_error", "knowledge_test_index_invalid", index.error, "Delete .fabric/.cache/knowledge-test.index.json and run `fab doctor --fix` to regenerate it.");
-  }
-  if (index.stale) {
-    return issueCheck("Knowledge-test index", "error", "fixable_error", "knowledge_test_index_stale", ".fabric/.cache/knowledge-test.index.json is stale.", "Run `fab doctor --fix` to rebuild the knowledge-test index.");
-  }
-  return okCheck("Knowledge-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 = join5(projectRoot, ".fabric", "agents.meta.json");
-  if (!existsSync4(metaPath)) {
-    return { extraMetaEntries: [], hashMismatchEntries: [], readable: false };
-  }
-  let meta;
-  try {
-    const raw = await readFile5(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 = join5(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 inspectKnowledgeDirUnindexed(projectRoot, meta) {
-  const physicalMdFiles = /* @__PURE__ */ new Set();
-  collectMdFilesUnder(physicalMdFiles, projectRoot, join5(projectRoot, ".fabric", "knowledge"), ".fabric/knowledge");
-  if (physicalMdFiles.size === 0) {
-    return { unindexedFiles: [] };
-  }
-  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 collectMdFilesUnder(out, projectRoot, rootDir, relPrefix) {
-  if (!existsSync4(rootDir)) {
-    return;
-  }
-  const stack = [rootDir];
-  while (stack.length > 0) {
-    const dir = stack.pop();
-    if (dir === void 0) {
-      continue;
-    }
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      const abs = join5(dir, entry.name);
-      if (entry.isDirectory()) {
-        stack.push(abs);
-      } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        const rel = posix.join(relPrefix, abs.slice(rootDir.length + 1).replace(/\\/gu, "/"));
-        out.add(rel);
-      }
-    }
-  }
-}
-function createKnowledgeDirUnindexedCheck(inspection) {
-  if (inspection.unindexedFiles.length > 0) {
-    return issueCheck(
-      "Knowledge dir unindexed",
-      "error",
-      "fixable_error",
-      "knowledge_dir_unindexed",
-      `${inspection.unindexedFiles.length} .md file${inspection.unindexedFiles.length === 1 ? "" : "s"} in .fabric/knowledge/ not indexed in agents.meta.json. Run \`fab doctor --fix\` to index the missing knowledge files.`,
-      "Run `fab doctor --fix` to index the missing knowledge files."
-    );
-  }
-  return okCheck("Knowledge dir unindexed", "All .fabric/knowledge/ .md files are indexed in agents.meta.json.");
-}
-async function inspectStableIdCollisions(projectRoot) {
-  const found = [];
-  const knowledgeDir = join5(projectRoot, ".fabric", "knowledge");
-  if (existsSync4(knowledgeDir)) {
-    const stack = [knowledgeDir];
-    while (stack.length > 0) {
-      const dir = stack.pop();
-      if (dir === void 0) {
-        continue;
-      }
-      for (const entry of readdirSync(dir, { withFileTypes: true })) {
-        const abs = join5(dir, entry.name);
-        if (entry.isDirectory()) {
-          stack.push(abs);
-        } else if (entry.isFile() && entry.name.endsWith(".md")) {
-          let source;
-          try {
-            source = await readFile5(abs, "utf8");
-          } catch {
-            continue;
-          }
-          const id = extractKnowledgeFrontmatterId(source);
-          if (id === null) {
-            continue;
-          }
-          const relPath = posix.join(".fabric/knowledge", abs.slice(knowledgeDir.length + 1).replace(/\\/gu, "/"));
-          found.push({ stableId: id, relPath });
-        }
-      }
-    }
-  }
-  const stableIdToFiles = /* @__PURE__ */ new Map();
-  for (const { stableId, relPath } of found) {
-    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 extractKnowledgeFrontmatterId(source) {
-  const FM_PATTERN = /^(?:\uFEFF)?---\r?\n([\s\S]*?)\r?\n---/u;
-  const fm = FM_PATTERN.exec(source);
-  if (fm === null) {
-    return null;
-  }
-  const block = fm[1];
-  const ID_LINE = /^id:\s*("?)(K[PT]-(?:MOD|DEC|GLD|PIT|PRO)-\d{4,})\1\s*$/mu;
-  const idMatch = ID_LINE.exec(block);
-  return idMatch === null ? null : idMatch[2];
-}
-function inspectCounterDesync(meta) {
-  if (!meta.valid || meta.meta === null) {
-    return { desyncs: [], correctedCounters: null };
-  }
-  const current = AgentsMetaCountersSchema.parse(meta.meta.counters ?? void 0);
-  const observed = {
-    KP: { MOD: 0, DEC: 0, GLD: 0, PIT: 0, PRO: 0 },
-    KT: { MOD: 0, DEC: 0, GLD: 0, PIT: 0, PRO: 0 }
-  };
-  for (const node of Object.values(meta.meta.nodes)) {
-    const id = node.stable_id;
-    if (id === void 0) {
-      continue;
-    }
-    const parsed = parseKnowledgeId2(id);
-    if (parsed === null) {
-      continue;
-    }
-    const layer = parsed.layer === "personal" ? "KP" : "KT";
-    const typeCode = [
-      ["model", "MOD"],
-      ["decision", "DEC"],
-      ["guideline", "GLD"],
-      ["pitfall", "PIT"],
-      ["process", "PRO"]
-    ].find(([t]) => t === parsed.type)?.[1];
-    if (typeCode === void 0) {
-      continue;
-    }
-    if (parsed.counter > observed[layer][typeCode]) {
-      observed[layer][typeCode] = parsed.counter;
-    }
-  }
-  const desyncs = [];
-  const corrected = {
-    KP: { ...current.KP },
-    KT: { ...current.KT }
-  };
-  for (const layer of ["KP", "KT"]) {
-    for (const code of COUNTER_TYPE_CODES) {
-      const obs = observed[layer][code];
-      const cur = current[layer][code];
-      if (obs > cur) {
-        desyncs.push({ layer, type: code, observed: obs, current: cur });
-        corrected[layer][code] = obs;
-      }
-    }
-  }
-  return {
-    desyncs,
-    correctedCounters: desyncs.length === 0 ? null : corrected
-  };
-}
-function createCounterDesyncCheck(inspection) {
-  if (inspection.desyncs.length > 0) {
-    const first = inspection.desyncs[0];
-    const detail = `counters.${first.layer}.${first.type} = ${first.current} but observed K${first.layer === "KP" ? "P" : "T"}-${first.type}-${String(first.observed).padStart(4, "0")}`;
-    return issueCheck(
-      "Knowledge counter desync",
-      "error",
-      "fixable_error",
-      "counter_desync",
-      `${inspection.desyncs.length} knowledge counter${inspection.desyncs.length === 1 ? "" : "s"} desynced from observed stable_ids. ${detail}. Run \`fab doctor --fix\` to bump counters.`,
-      "Run `fab doctor --fix` to bump agents.meta.json counters to the maximum observed counter value."
-    );
-  }
-  return okCheck("Knowledge counter desync", "agents.meta.json counters envelope is consistent with observed stable_ids.");
-}
-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 knowledge files to use a unique stable_id.`,
-      "Edit one of the colliding knowledge files to declare a different `id: K[PT]-XXX-NNNN` frontmatter value."
-    );
-  }
-  return okCheck("Stable ID collision", "No declared stable_id collisions found in .fabric/knowledge/.");
-}
-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(join5(projectRoot, name)));
-  return { detected };
-}
-async function inspectFilesystemEditFallback(projectRoot) {
-  const knowledgeRoot = join5(projectRoot, ".fabric", "knowledge");
-  if (!existsSync4(knowledgeRoot)) {
-    return { synthesized: 0, synthesizedStableIds: [] };
-  }
-  const canonicalIds = /* @__PURE__ */ new Set();
-  for (const typeDir of KNOWLEDGE_CANONICAL_TYPE_DIRS) {
-    const dir = join5(knowledgeRoot, typeDir);
-    if (!existsSync4(dir)) {
-      continue;
-    }
-    let entries;
-    try {
-      entries = readdirSync(dir, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      if (!entry.isFile()) {
-        continue;
-      }
-      const match = CANONICAL_KNOWLEDGE_FILENAME_PATTERN.exec(entry.name);
-      if (match === null) {
-        continue;
-      }
-      canonicalIds.add(match[1]);
-    }
-  }
-  if (canonicalIds.size === 0) {
-    return { synthesized: 0, synthesizedStableIds: [] };
-  }
-  let promotedIds = /* @__PURE__ */ new Set();
-  try {
-    const { events } = await readEventLedger(projectRoot, { event_type: "knowledge_promoted" });
-    promotedIds = new Set(
-      events.map((event) => event.event_type === "knowledge_promoted" ? event.stable_id : void 0).filter((id) => typeof id === "string")
-    );
-  } catch {
-    promotedIds = /* @__PURE__ */ new Set();
-  }
-  const orphanIds = [];
-  for (const id of canonicalIds) {
-    if (!promotedIds.has(id)) {
-      orphanIds.push(id);
-    }
-  }
-  orphanIds.sort();
-  for (const stable_id of orphanIds) {
-    await appendEventLedgerEvent(projectRoot, {
-      event_type: "knowledge_promoted",
-      stable_id,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      reason: SYNTHESIZED_PROMOTED_REASON,
-      correlation_id: "doctor-synthesized",
-      session_id: "doctor-synthesized"
-    });
-  }
-  return { synthesized: orphanIds.length, synthesizedStableIds: orphanIds };
-}
-function createFilesystemEditFallbackCheck(inspection) {
-  if (inspection.synthesized === 0) {
-    return okCheck(
-      "Filesystem-edit fallback",
-      "No orphan canonical knowledge entries detected; events.jsonl promotion trail is complete."
-    );
-  }
-  const sample = inspection.synthesizedStableIds.slice(0, 3).join(", ");
-  return {
-    name: "Filesystem-edit fallback",
-    status: "ok",
-    kind: "info",
-    code: "knowledge_promoted_synthesized",
-    fixable: false,
-    message: `Synthesized ${inspection.synthesized} knowledge_promoted event${inspection.synthesized === 1 ? "" : "s"} for orphan canonical entries (${sample}${inspection.synthesizedStableIds.length > 3 ? ", ..." : ""}). Reason='${SYNTHESIZED_PROMOTED_REASON}'.`,
-    actionHint: "These entries were moved into .fabric/knowledge/<type>/ outside fab_review.approve. The synthesized events restore audit-trail completeness."
-  };
-}
-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 knowledge content to `.fabric/knowledge/{type}/` if you want it available in MCP responses."
-  };
-}
-async function buildLastConsumedIndex(projectRoot) {
-  const map = /* @__PURE__ */ new Map();
-  let events;
-  try {
-    ({ events } = await readEventLedger(projectRoot));
-  } catch {
-    return map;
-  }
-  for (const event of events) {
-    if (event.event_type !== "knowledge_consumed" && event.event_type !== "knowledge_demoted" && event.event_type !== "knowledge_archived") {
-      continue;
-    }
-    const ts = event.ts;
-    if (typeof ts !== "number" || !Number.isFinite(ts)) {
-      continue;
-    }
-    const stableId = event.stable_id;
-    if (typeof stableId !== "string" || stableId.length === 0) {
-      continue;
-    }
-    const prev = map.get(stableId);
-    if (prev === void 0 || ts > prev) {
-      map.set(stableId, ts);
-    }
-  }
-  return map;
-}
-async function buildLastActiveIndex(projectRoot) {
-  const map = /* @__PURE__ */ new Map();
-  let events;
-  try {
-    ({ events } = await readEventLedger(projectRoot));
-  } catch {
-    return map;
-  }
-  for (const event of events) {
-    const ts = event.ts;
-    if (typeof ts !== "number" || !Number.isFinite(ts)) {
-      continue;
-    }
-    const ids = [];
-    switch (event.event_type) {
-      case "knowledge_proposed":
-      case "knowledge_promote_started":
-      case "knowledge_promoted":
-      case "knowledge_promote_failed":
-      case "knowledge_layer_changed":
-      case "knowledge_slug_renamed":
-      case "knowledge_demoted":
-      case "knowledge_archived":
-      case "knowledge_archive_attempted":
-      case "knowledge_deferred":
-      case "knowledge_rejected": {
-        if (typeof event.stable_id === "string" && event.stable_id.length > 0) {
-          ids.push(event.stable_id);
-        }
-        break;
-      }
-      case "knowledge_context_planned": {
-        ids.push(...event.required_stable_ids, ...event.ai_selectable_stable_ids, ...event.final_stable_ids);
-        break;
-      }
-      case "knowledge_selection": {
-        ids.push(
-          ...event.required_stable_ids,
-          ...event.ai_selectable_stable_ids,
-          ...event.ai_selected_stable_ids,
-          ...event.final_stable_ids
-        );
-        break;
-      }
-      case "knowledge_sections_fetched": {
-        ids.push(...event.final_stable_ids, ...event.ai_selected_stable_ids);
-        break;
-      }
-      default:
-        break;
-    }
-    for (const id of ids) {
-      const prev = map.get(id);
-      if (prev === void 0 || ts > prev) {
-        map.set(id, ts);
-      }
-    }
-  }
-  return map;
-}
-function maturityThresholdDays(maturity) {
-  return ORPHAN_DEMOTE_THRESHOLD_DAYS[maturity];
-}
-function nextLowerMaturity(current) {
-  if (current === "stable") return "endorsed";
-  if (current === "endorsed") return "draft";
-  return null;
-}
-function extractKnowledgeFrontmatterMaturity(source) {
-  const FM_PATTERN = /^(?:\uFEFF)?---\r?\n([\s\S]*?)\r?\n---/u;
-  const fm = FM_PATTERN.exec(source);
-  if (fm === null) {
-    return null;
-  }
-  const match = MATURITY_LINE_PATTERN.exec(fm[1]);
-  return match === null ? null : match[2];
-}
-function extractKnowledgeFrontmatterCreatedAt(source) {
-  const FM_PATTERN = /^(?:\uFEFF)?---\r?\n([\s\S]*?)\r?\n---/u;
-  const fm = FM_PATTERN.exec(source);
-  if (fm === null) {
-    return null;
-  }
-  const match = CREATED_AT_LINE_PATTERN.exec(fm[1]);
-  if (match === null) {
-    return null;
-  }
-  const parsed = Date.parse(match[2]);
-  return Number.isFinite(parsed) ? parsed : null;
-}
-function* iterateCanonicalEntries(projectRoot, lastActiveIndex) {
-  const knowledgeRoot = join5(projectRoot, ".fabric", "knowledge");
-  if (!existsSync4(knowledgeRoot)) {
-    return;
-  }
-  for (const typeDir of KNOWLEDGE_CANONICAL_TYPE_DIRS) {
-    const dir = join5(knowledgeRoot, typeDir);
-    if (!existsSync4(dir)) {
-      continue;
-    }
-    let entries;
-    try {
-      entries = readdirSync(dir, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      if (!entry.isFile()) {
-        continue;
-      }
-      const match = CANONICAL_KNOWLEDGE_FILENAME_PATTERN.exec(entry.name);
-      if (match === null) {
-        continue;
-      }
-      const stableId = match[1];
-      const absPath = join5(dir, entry.name);
-      let source;
-      try {
-        source = readFileSync(absPath, "utf8");
-      } catch {
-        continue;
-      }
-      const maturity = extractKnowledgeFrontmatterMaturity(source);
-      if (maturity === null) {
-        continue;
-      }
-      const createdAt = extractKnowledgeFrontmatterCreatedAt(source);
-      const eventTs = lastActiveIndex.get(stableId) ?? 0;
-      let lastReferenceMs = Math.max(createdAt ?? 0, eventTs);
-      if (lastReferenceMs === 0) {
-        try {
-          lastReferenceMs = statSync3(absPath).mtimeMs;
-        } catch {
-          lastReferenceMs = 0;
-        }
-      }
-      const relPath = posix.join(
-        ".fabric/knowledge",
-        typeDir,
-        entry.name
-      );
-      yield { stable_id: stableId, maturity, type: typeDir, absPath, relPath, lastReferenceMs };
-    }
-  }
-}
-async function inspectOrphanDemote(projectRoot, now) {
-  const lastConsumedIndex = await buildLastConsumedIndex(projectRoot);
-  const candidates = [];
-  for (const entry of iterateCanonicalEntries(projectRoot, lastConsumedIndex)) {
-    const ageMs = entry.lastReferenceMs > 0 ? now - entry.lastReferenceMs : now;
-    const ageDays = Math.floor(ageMs / MS_PER_DAY);
-    const threshold = maturityThresholdDays(entry.maturity);
-    if (ageDays <= threshold) {
-      continue;
-    }
-    candidates.push({
-      stable_id: entry.stable_id,
-      path: entry.relPath,
-      age_days: ageDays,
-      maturity: entry.maturity,
-      next_maturity: nextLowerMaturity(entry.maturity)
-    });
-  }
-  candidates.sort((a, b) => a.path.localeCompare(b.path));
-  return { candidates };
-}
-async function inspectStaleArchive(projectRoot, now) {
-  const lastActiveIndex = await buildLastActiveIndex(projectRoot);
-  const candidates = [];
-  for (const entry of iterateCanonicalEntries(projectRoot, lastActiveIndex)) {
-    if (entry.maturity !== "draft") {
-      continue;
-    }
-    const ageMs = entry.lastReferenceMs > 0 ? now - entry.lastReferenceMs : now;
-    const ageDays = Math.floor(ageMs / MS_PER_DAY);
-    const requiredQuiet = ORPHAN_DEMOTE_THRESHOLD_DAYS.draft + STALE_ARCHIVE_ADDITIONAL_DAYS;
-    if (ageDays <= requiredQuiet) {
-      continue;
-    }
-    const filename = posix.basename(entry.relPath);
-    candidates.push({
-      stable_id: entry.stable_id,
-      path: entry.relPath,
-      age_days: ageDays,
-      archive_path: posix.join(".fabric/.archive", entry.type, filename)
-    });
-  }
-  candidates.sort((a, b) => a.path.localeCompare(b.path));
-  return { candidates };
-}
-function* iteratePendingFiles(projectRoot, now) {
-  const teamRoot = join5(projectRoot, ".fabric", "knowledge", "pending");
-  const personalRoot = join5(resolvePersonalRootForPending(), ".fabric", "knowledge", "pending");
-  for (const [layer, root, displayPrefix] of [
-    ["team", teamRoot, ".fabric/knowledge/pending"],
-    ["personal", personalRoot, "~/.fabric/knowledge/pending"]
-  ]) {
-    if (!existsSync4(root)) {
-      continue;
-    }
-    let typeDirs = [];
-    try {
-      typeDirs = readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-    } catch {
-      continue;
-    }
-    for (const typeDir of typeDirs) {
-      const dir = join5(root, typeDir);
-      let entries;
-      try {
-        entries = readdirSync(dir, { withFileTypes: true });
-      } catch {
-        continue;
-      }
-      for (const entry of entries) {
-        if (!entry.isFile() || !entry.name.endsWith(".md")) {
-          continue;
-        }
-        const absPath = join5(dir, entry.name);
-        let source = "";
-        try {
-          source = readFileSync(absPath, "utf8");
-        } catch {
-          continue;
-        }
-        const createdAt = extractKnowledgeFrontmatterCreatedAt(source);
-        let mtimeMs = 0;
-        try {
-          mtimeMs = statSync3(absPath).mtimeMs;
-        } catch {
-          mtimeMs = 0;
-        }
-        const referenceMs = createdAt ?? mtimeMs;
-        const displayPath = posix.join(displayPrefix, typeDir, entry.name);
-        if (referenceMs === 0) {
-          yield {
-            layer,
-            type: typeDir,
-            filename: entry.name,
-            pending_path: displayPath,
-            pending_path_abs: absPath,
-            stable_id: void 0,
-            age_days: PENDING_OVERDUE_THRESHOLD_DAYS + 1
-          };
-          continue;
-        }
-        const ageDays = Math.floor((now - referenceMs) / MS_PER_DAY);
-        const stableId = extractKnowledgeFrontmatterId(source) ?? void 0;
-        yield {
-          layer,
-          type: typeDir,
-          filename: entry.name,
-          pending_path: displayPath,
-          pending_path_abs: absPath,
-          stable_id: stableId,
-          age_days: ageDays
-        };
-      }
-    }
-  }
-}
-function resolvePersonalRootForPending() {
-  return process.env.FABRIC_HOME ?? homedir2();
-}
-function inspectPendingOverdue(projectRoot, now) {
-  const candidates = [];
-  for (const visit of iteratePendingFiles(projectRoot, now)) {
-    if (visit.age_days <= PENDING_OVERDUE_THRESHOLD_DAYS) {
-      continue;
-    }
-    candidates.push({
-      stable_id: visit.stable_id,
-      path: visit.pending_path,
-      age_days: visit.age_days
-    });
-  }
-  candidates.sort((a, b) => a.path.localeCompare(b.path));
-  return { candidates };
-}
-function inspectPendingAutoArchive(projectRoot, now) {
-  const candidates = [];
-  for (const visit of iteratePendingFiles(projectRoot, now)) {
-    if (visit.age_days <= PENDING_AUTO_ARCHIVE_THRESHOLD_DAYS) {
-      continue;
-    }
-    if (visit.layer === "team") {
-      const archivedToRel = posix.join(".fabric/.archive/pending", visit.type, visit.filename);
-      candidates.push({
-        layer: "team",
-        type: visit.type,
-        pending_path: visit.pending_path,
-        pending_path_abs: visit.pending_path_abs,
-        archived_to: archivedToRel,
-        archived_to_abs: join5(projectRoot, archivedToRel),
-        age_days: visit.age_days
-      });
-    } else {
-      const archivedToDisplay = posix.join(
-        "~/.fabric/.archive/pending",
-        visit.type,
-        visit.filename
-      );
-      const archivedToAbs = join5(
-        resolvePersonalRootForPending(),
-        ".fabric",
-        ".archive",
-        "pending",
-        visit.type,
-        visit.filename
-      );
-      candidates.push({
-        layer: "personal",
-        type: visit.type,
-        pending_path: visit.pending_path,
-        pending_path_abs: visit.pending_path_abs,
-        archived_to: archivedToDisplay,
-        archived_to_abs: archivedToAbs,
-        age_days: visit.age_days
-      });
-    }
-  }
-  candidates.sort((a, b) => a.pending_path.localeCompare(b.pending_path));
-  return { candidates };
-}
-function inspectUnderseeded(projectRoot) {
-  const threshold = readUnderseedThresholdFromConfig(projectRoot);
-  const knowledgeRoot = join5(projectRoot, ".fabric", "knowledge");
-  let nodeCount = 0;
-  if (existsSync4(knowledgeRoot)) {
-    for (const typeDir of KNOWLEDGE_CANONICAL_TYPE_DIRS) {
-      const dir = join5(knowledgeRoot, typeDir);
-      if (!existsSync4(dir)) continue;
-      let entries;
-      try {
-        entries = readdirSync(dir, { withFileTypes: true });
-      } catch {
-        continue;
-      }
-      for (const entry of entries) {
-        if (entry.isFile() && entry.name.endsWith(".md")) {
-          nodeCount += 1;
-        }
-      }
-    }
-  }
-  return {
-    node_count: nodeCount,
-    threshold,
-    underseeded: nodeCount < threshold
-  };
-}
-function inspectSessionHintsStale(projectRoot, now) {
-  const cacheDir = join5(projectRoot, ".fabric", ".cache");
-  if (!existsSync4(cacheDir)) {
-    return { candidates: [] };
-  }
-  let entries;
-  try {
-    entries = readdirSync(cacheDir, { withFileTypes: true });
-  } catch {
-    return { candidates: [] };
-  }
-  const candidates = [];
-  for (const entry of entries) {
-    if (!entry.isFile()) continue;
-    if (!entry.name.startsWith(SESSION_HINTS_FILE_PREFIX)) continue;
-    if (!entry.name.endsWith(SESSION_HINTS_FILE_SUFFIX)) continue;
-    const absPath = join5(cacheDir, entry.name);
-    let mtimeMs = 0;
-    try {
-      mtimeMs = statSync3(absPath).mtimeMs;
-    } catch {
-      continue;
-    }
-    const ageDays = Math.floor((now - mtimeMs) / MS_PER_DAY);
-    if (ageDays < SESSION_HINTS_STALE_DAYS) continue;
-    candidates.push({
-      path: posix.join(".fabric", ".cache", entry.name),
-      age_days: ageDays
-    });
-  }
-  candidates.sort((a, b) => a.path.localeCompare(b.path));
-  return { candidates };
-}
-function inspectNarrowTooFew(projectRoot, now) {
-  let total = 0;
-  let narrowWithPaths = 0;
-  for (const { scope, paths } of iterateRelevanceFrontmatter(projectRoot)) {
-    total += 1;
-    if (scope === "narrow" && paths.length > 0) {
-      narrowWithPaths += 1;
-    }
-  }
-  const narrowRatio = total === 0 ? 0 : narrowWithPaths / total;
-  const structuralFlagged = total >= NARROW_MIN_TOTAL && narrowRatio < NARROW_RATIO_THRESHOLD;
-  const windowStartMs = now - SILENCE_WINDOW_DAYS * MS_PER_DAY;
-  const editFires = readCounterTimestamps(
-    join5(projectRoot, EDIT_COUNTER_FILE_REL),
-    windowStartMs
-  );
-  const silenceFires = readCounterTimestamps(
-    join5(projectRoot, HINT_SILENCE_COUNTER_FILE_REL),
-    windowStartMs
-  );
-  const telemetrySkipped = editFires === 0;
-  const silenceRate = editFires === 0 ? 0 : silenceFires / editFires;
-  const telemetryFlagged = !telemetrySkipped && silenceRate > SILENCE_RATE_THRESHOLD;
-  return {
-    total_canonical_entries: total,
-    narrow_with_paths_count: narrowWithPaths,
-    narrow_ratio: narrowRatio,
-    structural_flagged: structuralFlagged,
-    total_edit_fires_in_window: editFires,
-    silence_fires_in_window: silenceFires,
-    silence_rate: silenceRate,
-    telemetry_skipped: telemetrySkipped,
-    telemetry_flagged: telemetryFlagged
-  };
-}
-function readCounterTimestamps(absPath, windowStartMs) {
-  if (!existsSync4(absPath)) return 0;
-  let raw;
-  try {
-    raw = readFileSync(absPath, "utf8");
-  } catch {
-    return 0;
-  }
-  let count = 0;
-  for (const line of raw.split(/\r?\n/u)) {
-    const trimmed = line.trim();
-    if (trimmed.length === 0) continue;
-    const ts = Date.parse(trimmed);
-    if (!Number.isFinite(ts)) continue;
-    if (ts < windowStartMs) continue;
-    count += 1;
-  }
-  return count;
-}
-function readUnderseedThresholdFromConfig(projectRoot) {
-  const configPath = join5(projectRoot, ".fabric", "fabric-config.json");
-  if (!existsSync4(configPath)) return DEFAULT_UNDERSEED_NODE_THRESHOLD;
-  try {
-    const raw = readFileSync(configPath, "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      const v = parsed.underseed_node_threshold;
-      if (typeof v === "number" && Number.isFinite(v) && v > 0) {
-        return v;
-      }
-    }
-  } catch {
-  }
-  return DEFAULT_UNDERSEED_NODE_THRESHOLD;
-}
-function createOrphanDemoteCheck(inspection) {
-  if (inspection.candidates.length === 0) {
-    return okCheck(
-      "Knowledge orphan demote",
-      "No canonical knowledge entries exceed their maturity-keyed inactivity threshold."
-    );
-  }
-  const first = inspection.candidates[0];
-  const detail = `${first.stable_id} (${first.maturity}, ${first.age_days}d inactive at ${first.path})`;
-  return issueCheck(
-    "Knowledge orphan demote",
-    "warn",
-    "warning",
-    "knowledge_orphan_demote_required",
-    `${inspection.candidates.length} canonical knowledge entr${inspection.candidates.length === 1 ? "y exceeds" : "ies exceed"} their maturity-keyed inactivity threshold (stable=${ORPHAN_DEMOTE_THRESHOLD_DAYS.stable}d / endorsed=${ORPHAN_DEMOTE_THRESHOLD_DAYS.endorsed}d / draft=${ORPHAN_DEMOTE_THRESHOLD_DAYS.draft}d). First: ${detail}.`,
-    "Run `fab doctor --apply-lint` (rc.4 TASK-003) to demote orphan entries one maturity tier."
-  );
-}
-function createStaleArchiveCheck(inspection) {
-  if (inspection.candidates.length === 0) {
-    return okCheck(
-      "Knowledge stale archive",
-      "No draft knowledge entries exceed the additional stale-archive quiet window."
-    );
-  }
-  const first = inspection.candidates[0];
-  const detail = `${first.stable_id} (${first.age_days}d inactive at ${first.path}) \u2192 ${first.archive_path}`;
-  return issueCheck(
-    "Knowledge stale archive",
-    "warn",
-    "warning",
-    "knowledge_stale_archive_required",
-    `${inspection.candidates.length} draft knowledge entr${inspection.candidates.length === 1 ? "y is" : "ies are"} stale beyond the demote+${STALE_ARCHIVE_ADDITIONAL_DAYS}d additional quiet window. First: ${detail}.`,
-    "Run `fab doctor --apply-lint` (rc.4 TASK-003) to move stale entries into `.fabric/.archive/<type>/`."
-  );
-}
-function createPendingOverdueCheck(inspection) {
-  if (inspection.candidates.length === 0) {
-    return okCheck(
-      "Knowledge pending overdue",
-      "No pending knowledge entries exceed the 14-day review threshold."
-    );
-  }
-  const first = inspection.candidates[0];
-  const detail = `${first.path} (${first.age_days}d old)`;
-  return issueCheck(
-    "Knowledge pending overdue",
-    "warn",
-    "warning",
-    "knowledge_pending_overdue",
-    `${inspection.candidates.length} pending knowledge entr${inspection.candidates.length === 1 ? "y has" : "ies have"} been awaiting review for more than ${PENDING_OVERDUE_THRESHOLD_DAYS} days. First: ${detail}.`,
-    "Review pending entries via the fabric-review Skill (`/fabric-review`) and approve, reject, defer, or modify."
-  );
-}
-function createUnderseededCheck(inspection) {
-  if (!inspection.underseeded) {
-    return okCheck(
-      "Knowledge underseeded",
-      `Knowledge corpus has ${inspection.node_count} canonical entries (>= ${inspection.threshold}).`
-    );
-  }
-  return issueCheck(
-    "Knowledge underseeded",
-    "ok",
-    "info",
-    "knowledge_underseeded",
-    `Knowledge corpus has only ${inspection.node_count} canonical entr${inspection.node_count === 1 ? "y" : "ies"} (< ${inspection.threshold} threshold). The plan_context retrieval surface is below its useful floor.`,
-    "Run the fabric-import Skill (`/fabric-import`) to backfill knowledge from git history and existing docs."
-  );
-}
-function createSessionHintsStaleCheck(inspection) {
-  if (inspection.candidates.length === 0) {
-    return okCheck(
-      "Knowledge session-hints stale",
-      `No session-hints cache files older than ${SESSION_HINTS_STALE_DAYS} days under .fabric/.cache/.`
-    );
-  }
-  const first = inspection.candidates[0];
-  const detail = `${first.path} (${first.age_days}d old)`;
-  return issueCheck(
-    "Knowledge session-hints stale",
-    "ok",
-    "info",
-    "knowledge_session_hints_stale",
-    `${inspection.candidates.length} session-hints cache file${inspection.candidates.length === 1 ? "" : "s"} under .fabric/.cache/ ${inspection.candidates.length === 1 ? "is" : "are"} older than ${SESSION_HINTS_STALE_DAYS} days. First: ${detail}.`,
-    "Run `fab doctor --apply-lint` to delete stale session-hints cache files."
-  );
-}
-function extractKnowledgeFrontmatterRelevanceScope(source) {
-  const FM_PATTERN = /^(?:\uFEFF)?---\r?\n([\s\S]*?)\r?\n---/u;
-  const fm = FM_PATTERN.exec(source);
-  if (fm === null) {
-    return "broad";
-  }
-  const match = RELEVANCE_SCOPE_LINE_PATTERN.exec(fm[1]);
-  if (match === null) {
-    return "broad";
-  }
-  return match[2];
-}
-function extractKnowledgeFrontmatterRelevancePaths(source) {
-  const FM_PATTERN = /^(?:\uFEFF)?---\r?\n([\s\S]*?)\r?\n---/u;
-  const fm = FM_PATTERN.exec(source);
-  if (fm === null) {
-    return [];
-  }
-  const match = RELEVANCE_PATHS_LINE_PATTERN.exec(fm[1]);
-  if (match === null) {
-    return [];
-  }
-  const inner = match[1].trim();
-  if (inner.length === 0) {
-    return [];
-  }
-  return inner.split(",").map((token) => token.trim().replace(/^"(.*)"$/u, "$1")).filter((token) => token.length > 0);
-}
-function* iterateRelevanceFrontmatter(projectRoot) {
-  for (const visit of iterateCanonicalFilenames(projectRoot)) {
-    const layerRoot = visit.layer === "team" ? join5(projectRoot, ".fabric", "knowledge") : resolvePersonalKnowledgeRoot();
-    const absPath = join5(layerRoot, visit.type, visit.filename);
-    let source;
-    try {
-      source = readFileSync(absPath, "utf8");
-    } catch {
-      continue;
-    }
-    const scope = extractKnowledgeFrontmatterRelevanceScope(source);
-    const paths = extractKnowledgeFrontmatterRelevancePaths(source);
-    yield { visit, scope, paths, absPath };
-  }
-}
-function inspectNarrowNoPaths(projectRoot) {
-  const candidates = [];
-  for (const { visit, scope, paths } of iterateRelevanceFrontmatter(projectRoot)) {
-    if (scope !== "narrow") {
-      continue;
-    }
-    if (paths.length > 0) {
-      continue;
-    }
-    candidates.push({
-      stable_id: visit.parsed.stable_id,
-      path: visit.displayPath
-    });
-  }
-  candidates.sort((a, b) => a.path.localeCompare(b.path));
-  return { candidates };
-}
-function inspectRelevancePathsDangling(projectRoot) {
-  const entries = [];
-  const workspacePaths = collectWorkspacePathsForGlobMatch(projectRoot);
-  if (workspacePaths.length === 0) {
-    return { entries };
-  }
-  for (const { visit, paths } of iterateRelevanceFrontmatter(projectRoot)) {
-    if (paths.length === 0) {
-      continue;
-    }
-    for (const rawGlob of paths) {
-      const glob = rawGlob.endsWith("/") ? `${rawGlob}**` : rawGlob;
-      let matched = false;
-      for (const target of workspacePaths) {
-        if (minimatch(target, glob, { dot: true, matchBase: false })) {
-          matched = true;
-          break;
-        }
-      }
-      if (matched) {
-        continue;
-      }
-      entries.push({
-        stable_id: visit.parsed.stable_id,
-        path: visit.displayPath,
-        dangling_glob: rawGlob
-      });
-    }
-  }
-  entries.sort((a, b) => {
-    const byPath = a.path.localeCompare(b.path);
-    return byPath !== 0 ? byPath : a.dangling_glob.localeCompare(b.dangling_glob);
-  });
-  return { entries };
-}
-function collectWorkspacePathsForGlobMatch(projectRoot) {
-  if (!existsSync4(projectRoot)) {
-    return [];
-  }
-  let rootStat;
-  try {
-    rootStat = statSync3(projectRoot);
-  } catch {
-    return [];
-  }
-  if (!rootStat.isDirectory()) {
-    return [];
-  }
-  const paths = [];
-  const stack = [projectRoot];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    if (current === void 0) continue;
-    let entries;
-    try {
-      entries = readdirSync(current, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      const abs = join5(current, entry.name);
-      const rel = normalizePath(abs.slice(projectRoot.length + 1));
-      if (rel.length === 0) continue;
-      if (entry.isDirectory()) {
-        if (IGNORED_DIRECTORIES.has(entry.name)) {
-          continue;
-        }
-        paths.push(rel);
-        stack.push(abs);
-      } else if (entry.isFile()) {
-        paths.push(rel);
-      }
-    }
-  }
-  return paths;
-}
-function inspectRelevancePathsDrift(projectRoot) {
-  let recentPaths = null;
-  try {
-    recentPaths = readRecentGitTouchedPaths(projectRoot, RELEVANCE_PATHS_DRIFT_WINDOW_DAYS);
-  } catch {
-    recentPaths = null;
-  }
-  if (recentPaths === null) {
-    return { candidates: [], git_available: false };
-  }
-  const candidates = [];
-  for (const { visit, scope, paths } of iterateRelevanceFrontmatter(projectRoot)) {
-    if (scope !== "narrow") {
-      continue;
-    }
-    if (paths.length === 0) {
-      continue;
-    }
-    let anyMatch = false;
-    for (const rawGlob of paths) {
-      const glob = rawGlob.endsWith("/") ? `${rawGlob}**` : rawGlob;
-      for (const target of recentPaths) {
-        if (minimatch(target, glob, { dot: true, matchBase: false })) {
-          anyMatch = true;
-          break;
-        }
-      }
-      if (anyMatch) break;
-    }
-    if (anyMatch) {
-      continue;
-    }
-    candidates.push({
-      stable_id: visit.parsed.stable_id,
-      path: visit.displayPath,
-      globs: paths.slice()
-    });
-  }
-  candidates.sort((a, b) => a.path.localeCompare(b.path));
-  return { candidates, git_available: true };
-}
-function readRecentGitTouchedPaths(projectRoot, windowDays) {
-  const since = new Date(Date.now() - windowDays * MS_PER_DAY).toISOString();
-  const stdout = execFileSync(
-    "git",
-    ["log", `--since=${since}`, "--name-only", "--pretty=format:"],
-    {
-      cwd: projectRoot,
-      stdio: ["ignore", "pipe", "pipe"],
-      encoding: "utf8"
-    }
-  );
-  const set = /* @__PURE__ */ new Set();
-  for (const line of stdout.split(/\r?\n/u)) {
-    const trimmed = line.trim();
-    if (trimmed.length === 0) continue;
-    set.add(normalizePath(trimmed));
-  }
-  return Array.from(set);
-}
-function createNarrowNoPathsCheck(inspection) {
-  if (inspection.candidates.length === 0) {
-    return okCheck(
-      "Knowledge narrow without paths",
-      "No narrow-scope canonical entries have an empty relevance_paths array."
-    );
-  }
-  const first = inspection.candidates[0];
-  const detail = `${first.stable_id} (${first.path})`;
-  return issueCheck(
-    "Knowledge narrow without paths",
-    "warn",
-    "warning",
-    "knowledge_narrow_no_paths",
-    `${inspection.candidates.length} narrow-scope canonical entr${inspection.candidates.length === 1 ? "y has" : "ies have"} an empty relevance_paths array (silent recall risk \u2014 narrow without anchors can never match a target path). First: ${detail}.`,
-    "Either add path anchors to relevance_paths or widen the entry's relevance_scope to broad."
-  );
-}
-function createRelevancePathsDanglingCheck(inspection) {
-  if (inspection.entries.length === 0) {
-    return okCheck(
-      "Knowledge relevance_paths dangling",
-      "All relevance_paths globs resolve to at least one file under the workspace root."
-    );
-  }
-  const first = inspection.entries[0];
-  const detail = `${first.stable_id} at ${first.path} \u2192 \`${first.dangling_glob}\` (0 matches)`;
-  return issueCheck(
-    "Knowledge relevance_paths dangling",
-    "warn",
-    "warning",
-    "knowledge_relevance_paths_dangling",
-    `${inspection.entries.length} relevance_paths glob${inspection.entries.length === 1 ? " resolves" : "s resolve"} to zero files in the current workspace. First: ${detail}.`,
-    "Update the entry's relevance_paths to remove globs that no longer match any files, or use `fab_review.modify` to rewrite the anchor set."
-  );
-}
-function createRelevancePathsDriftCheck(inspection) {
-  if (!inspection.git_available) {
-    return okCheck(
-      "Knowledge relevance_paths drift",
-      `Skipped (git history unavailable; cannot evaluate ${RELEVANCE_PATHS_DRIFT_WINDOW_DAYS}d drift window).`
-    );
-  }
-  if (inspection.candidates.length === 0) {
-    return okCheck(
-      "Knowledge relevance_paths drift",
-      `All narrow-scope canonical entries have at least one relevance_path touched in the last ${RELEVANCE_PATHS_DRIFT_WINDOW_DAYS}d.`
-    );
-  }
-  const first = inspection.candidates[0];
-  const detail = `${first.stable_id} at ${first.path} (globs: ${first.globs.join(", ")})`;
-  return issueCheck(
-    "Knowledge relevance_paths drift",
-    "ok",
-    "info",
-    "knowledge_relevance_paths_drift",
-    `${inspection.candidates.length} narrow-scope canonical entr${inspection.candidates.length === 1 ? "y has" : "ies have"} relevance_paths whose globs match no file touched in the last ${RELEVANCE_PATHS_DRIFT_WINDOW_DAYS}d of git history. First: ${detail}.`,
-    "Review whether the entry is still relevant \u2014 use `fab_review.modify` to refresh the anchors or `fab_review.reject` to archive."
-  );
-}
-function createNarrowTooFewCheck(inspection) {
-  const { structural_flagged, telemetry_flagged } = inspection;
-  if (!structural_flagged && !telemetry_flagged) {
-    const ratioPct = (inspection.narrow_ratio * 100).toFixed(0);
-    const teleNote = inspection.telemetry_skipped ? "telemetry skipped (no edit-counter fires in window)" : `silence rate ${(inspection.silence_rate * 100).toFixed(0)}% over ${SILENCE_WINDOW_DAYS}d`;
-    return okCheck(
-      "Knowledge narrow too few",
-      `Narrow-with-paths ratio ${ratioPct}% (${inspection.narrow_with_paths_count}/${inspection.total_canonical_entries}); ${teleNote}.`
-    );
-  }
-  const parts = [];
-  if (structural_flagged) {
-    const ratioPct = (inspection.narrow_ratio * 100).toFixed(0);
-    parts.push(
-      `narrow-with-paths share ${ratioPct}% (${inspection.narrow_with_paths_count}/${inspection.total_canonical_entries}) below ${(NARROW_RATIO_THRESHOLD * 100).toFixed(0)}% threshold`
-    );
-  }
-  if (telemetry_flagged) {
-    const silencePct = (inspection.silence_rate * 100).toFixed(0);
-    parts.push(
-      `narrow-hook silence rate ${silencePct}% (${inspection.silence_fires_in_window}/${inspection.total_edit_fires_in_window}) over ${SILENCE_WINDOW_DAYS}d above ${(SILENCE_RATE_THRESHOLD * 100).toFixed(0)}% threshold`
-    );
-  }
-  return issueCheck(
-    "Knowledge narrow too few",
-    "ok",
-    "info",
-    "knowledge_narrow_too_few",
-    `Narrow-scope KB coverage is below the useful floor: ${parts.join("; ")}.`,
-    "Run the fabric-import Skill (`/fabric-import`) to re-seed narrow anchors against the current codebase."
-  );
-}
-function resolvePersonalKnowledgeRoot() {
-  const home = process.env.FABRIC_HOME ?? homedir2();
-  return join5(home, ".fabric", "knowledge");
-}
-function parseStableIdFromCanonicalFilename(filename) {
-  const match = CANONICAL_KNOWLEDGE_FILENAME_PATTERN.exec(filename);
-  if (match === null) {
-    return null;
-  }
-  const stableId = match[1];
-  const inner = /^(K[PT])-(MOD|DEC|GLD|PIT|PRO)-(\d{4,})$/u.exec(stableId);
-  if (inner === null) {
-    return null;
-  }
-  return {
-    prefix: inner[1],
-    typeCode: inner[2],
-    counter: Number.parseInt(inner[3], 10),
-    stable_id: stableId
-  };
-}
-function* iterateCanonicalFilenames(projectRoot) {
-  const teamRoot = join5(projectRoot, ".fabric", "knowledge");
-  const personalRoot = resolvePersonalKnowledgeRoot();
-  for (const [layer, root, displayPrefix] of [
-    ["team", teamRoot, ".fabric/knowledge"],
-    ["personal", personalRoot, "~/.fabric/knowledge"]
-  ]) {
-    if (!existsSync4(root)) {
-      continue;
-    }
-    for (const typeDir of KNOWLEDGE_CANONICAL_TYPE_DIRS) {
-      const dir = join5(root, typeDir);
-      if (!existsSync4(dir)) {
-        continue;
-      }
-      let entries;
-      try {
-        entries = readdirSync(dir, { withFileTypes: true });
-      } catch {
-        continue;
-      }
-      for (const entry of entries) {
-        if (!entry.isFile()) {
-          continue;
-        }
-        const parsed = parseStableIdFromCanonicalFilename(entry.name);
-        if (parsed === null) {
-          continue;
-        }
-        const displayPath = posix.join(displayPrefix, typeDir, entry.name);
-        yield {
-          layer,
-          type: typeDir,
-          filename: entry.name,
-          displayPath,
-          parsed
-        };
-      }
-    }
-  }
-}
-function inspectStableIdDuplicate(projectRoot) {
-  const idToPaths = /* @__PURE__ */ new Map();
-  for (const visit of iterateCanonicalFilenames(projectRoot)) {
-    const existing = idToPaths.get(visit.parsed.stable_id) ?? [];
-    existing.push(visit.displayPath);
-    idToPaths.set(visit.parsed.stable_id, existing);
-  }
-  const duplicates = [];
-  for (const [stable_id, paths] of idToPaths) {
-    if (paths.length > 1) {
-      duplicates.push({ stable_id, paths: paths.slice().sort() });
-    }
-  }
-  duplicates.sort((a, b) => a.stable_id.localeCompare(b.stable_id));
-  return { duplicates };
-}
-function inspectLayerMismatch(projectRoot) {
-  const mismatches = [];
-  for (const visit of iterateCanonicalFilenames(projectRoot)) {
-    const expected_layer = visit.parsed.prefix === "KT" ? "team" : "personal";
-    if (expected_layer === visit.layer) {
-      continue;
-    }
-    mismatches.push({
-      path: visit.displayPath,
-      located_in: visit.layer,
-      expected_layer,
-      stable_id: visit.parsed.stable_id
-    });
-  }
-  mismatches.sort((a, b) => a.path.localeCompare(b.path));
-  return { mismatches };
-}
-function inspectIndexDrift(projectRoot, meta) {
-  if (!meta.valid || meta.meta === null) {
-    return { drifts: [] };
-  }
-  const counters = AgentsMetaCountersSchema.parse(meta.meta.counters ?? void 0);
-  const observed = {
-    KP: { MOD: 0, DEC: 0, GLD: 0, PIT: 0, PRO: 0 },
-    KT: { MOD: 0, DEC: 0, GLD: 0, PIT: 0, PRO: 0 }
-  };
-  for (const visit of iterateCanonicalFilenames(projectRoot)) {
-    const { prefix, typeCode, counter } = visit.parsed;
-    if (counter > observed[prefix][typeCode]) {
-      observed[prefix][typeCode] = counter;
-    }
-  }
-  const drifts = [];
-  for (const layer of ["KP", "KT"]) {
-    for (const code of COUNTER_TYPE_CODES) {
-      const max = observed[layer][code];
-      if (max === 0) {
-        continue;
-      }
-      const current = counters[layer][code];
-      if (current < max) {
-        drifts.push({
-          layer,
-          type: code,
-          counter: current,
-          max_observed: max,
-          proposed_after: max + 1
-        });
-      }
-    }
-  }
-  drifts.sort(
-    (a, b) => a.layer === b.layer ? a.type.localeCompare(b.type) : a.layer.localeCompare(b.layer)
-  );
-  return { drifts };
-}
-function createStableIdDuplicateCheck(inspection) {
-  if (inspection.duplicates.length === 0) {
-    return okCheck(
-      "Knowledge stable_id duplicate",
-      "No canonical knowledge files share a stable_id across team / personal trees."
-    );
-  }
-  const first = inspection.duplicates[0];
-  const detail = `${first.stable_id} appears in ${first.paths.length} files: ${first.paths.join(", ")}`;
-  return issueCheck(
-    "Knowledge stable_id duplicate",
-    "error",
-    "manual_error",
-    "knowledge_stable_id_duplicate",
-    `${inspection.duplicates.length} stable_id${inspection.duplicates.length === 1 ? "" : "s"} duplicated across canonical knowledge files (path-decoupled identity invariant). First: ${detail}.`,
-    "Manually rename one of the colliding files to a fresh `<prefix>-<type>-<counter>--<slug>.md` allocated via the canonical id allocator; do not edit by hand."
-  );
-}
-function createLayerMismatchCheck(inspection) {
-  if (inspection.mismatches.length === 0) {
-    return okCheck(
-      "Knowledge layer mismatch",
-      "All canonical knowledge files are physically located under the layer their stable_id prefix declares."
-    );
-  }
-  const first = inspection.mismatches[0];
-  const detail = `${first.stable_id} at ${first.path} (located in ${first.located_in}, expected ${first.expected_layer})`;
-  return issueCheck(
-    "Knowledge layer mismatch",
-    "error",
-    "manual_error",
-    "knowledge_layer_mismatch",
-    `${inspection.mismatches.length} canonical knowledge file${inspection.mismatches.length === 1 ? "" : "s"} are physically misaligned with their stable_id layer prefix (KT-* must live under team/, KP-* under personal/). First: ${detail}.`,
-    "Move the file to the correct layer root, or use the fabric-review modify flow to flip its layer (which renames the stable_id prefix accordingly)."
-  );
-}
-function createIndexDriftCheck(inspection) {
-  if (inspection.drifts.length === 0) {
-    return okCheck(
-      "Knowledge index drift",
-      "agents.meta.json counters envelope is at or above the highest existing canonical counter for every (layer, type) pair."
-    );
-  }
-  const first = inspection.drifts[0];
-  const detail = `${first.layer}.${first.type} counter=${first.counter} but max_observed=${first.max_observed} (would propose counters.${first.layer}.${first.type}=${first.proposed_after})`;
-  return issueCheck(
-    "Knowledge index drift",
-    "error",
-    "fixable_error",
-    "knowledge_index_drift",
-    `${inspection.drifts.length} (layer, type) counter slot${inspection.drifts.length === 1 ? "" : "s"} have drifted below the observed canonical maximum (next allocate would collide). First: ${detail}.`,
-    "Run `fab doctor --apply-lint` (rc.4 TASK-003) to bump agents.meta.json counters to max_observed + 1."
-  );
-}
-async function fixMcpConfigInWrongFile(projectRoot) {
-  const settingsPath = join5(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 ensureKnowledgeSubdirs(projectRoot) {
-  for (const sub of KNOWLEDGE_SUBDIRS2) {
-    await mkdir3(join5(projectRoot, ".fabric", "knowledge", sub), { recursive: true });
-  }
-}
-async function fixCounterDesync(projectRoot) {
-  const metaPath = join5(projectRoot, ".fabric", "agents.meta.json");
-  if (!existsSync4(metaPath)) {
-    return;
-  }
-  let meta;
-  try {
-    meta = agentsMetaSchema4.parse(JSON.parse(await readFile5(metaPath, "utf8")));
-  } catch {
-    return;
-  }
-  const synthetic = {
-    present: true,
-    valid: true,
-    meta,
-    revision: meta.revision,
-    computedRevision: null,
-    ruleCount: 0,
-    missingContentRefs: [],
-    invalidContentRefs: [],
-    stale: false,
-    changed: false
-  };
-  const desync = inspectCounterDesync(synthetic);
-  if (desync.desyncs.length === 0 || desync.correctedCounters === null) {
-    return;
-  }
-  const updated = { ...meta, counters: desync.correctedCounters };
-  await atomicWriteJson2(metaPath, updated, { indent: 2 });
-}
-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 isValidJsonLine(line) {
-  try {
-    JSON.parse(line);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function normalizeTarget(targetInput) {
-  return isAbsolute2(targetInput) ? targetInput : resolve3(process.cwd(), targetInput);
-}
-function normalizePath(path) {
-  return posix.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 = join5(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 = posix.dirname(relativePath);
-  const fileName = posix.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";
-}
-
-// src/services/get-knowledge.ts
-import { readFile as readFile6 } from "fs/promises";
-import { join as join6 } from "path";
-import { minimatch as minimatch2 } from "minimatch";
-var PRIORITY_ORDER = {
-  high: 0,
-  medium: 1,
-  low: 2
-};
-async function getKnowledge(projectRoot, input) {
-  const context = await loadGetKnowledgeContext(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 resolveKnowledgeForPath(projectRoot, context, input.path);
-  const result = {
-    revision_hash: context.meta.revision,
-    stale,
-    rules
-  };
-  try {
-    await appendEventLedgerEvent(projectRoot, {
-      event_type: "knowledge_context_planned",
-      target_paths: [input.path],
-      required_stable_ids: requiredStableIds,
-      ai_selectable_stable_ids: aiSelectableStableIds,
-      final_stable_ids: [...requiredStableIds, ...aiSelectableStableIds],
-      client_hash: input.client_hash,
-      correlation_id: input.correlation_id,
-      session_id: input.session_id
-    });
-  } catch {
-  }
-  return result;
-}
-async function loadGetKnowledgeContext(projectRoot) {
-  const cached = contextCache.get("context", projectRoot);
-  if (cached !== void 0) {
-    return cached;
-  }
-  const meta = await readAgentsMeta(projectRoot);
-  const l0Content = await readFile6(join6(projectRoot, ".fabric", "bootstrap", "README.md"), "utf8");
-  const context = {
-    meta,
-    l0Content,
-    humanLockedNearby: []
-  };
-  contextCache.set("context", projectRoot, context);
-  return context;
-}
-async function resolveKnowledgeForPath(projectRoot, context, path, options = {}) {
-  const matchedNodes = matchRuleNodes(context.meta, path);
-  const loaded = await loadMatchedRules(projectRoot, matchedNodes);
-  return buildKnowledgePayload(context, loaded, options);
-}
-function normalizeKnowledgePath(value) {
-  return value.replaceAll("\\", "/");
-}
-function matchRuleNodes(meta, path) {
-  const requestedPath = normalizeKnowledgePath(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 ?? "medium"] - PRIORITY_ORDER[rightNode.priority ?? "medium"];
-    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 buildKnowledgePayload(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 ?? null;
-}
-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 minimatch2(requestedPath, normalizeKnowledgePath(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 = readFile6(join6(projectRoot, file), "utf8");
-  fileContentCache.set(file, pending);
-  return await pending;
-}
-
-export {
-  contextCache,
-  resolveProjectRoot,
-  readAgentsMeta,
-  LEDGER_PATH,
-  LEGACY_LEDGER_PATH,
-  EVENT_LEDGER_PATH,
-  getLedgerPath,
-  getLegacyLedgerPath,
-  getEventLedgerPath,
-  ensureParentDirectory,
-  sha256,
-  isNodeError,
-  atomicWriteText,
-  appendEventLedgerEvent,
-  readEventLedger,
-  flushAndSyncEventLedger,
-  buildKnowledgeMeta,
-  writeKnowledgeMeta,
-  computeKnowledgeBasedAgentsMeta,
-  computeKnowledgeTestIndex,
-  deriveKnowledgeMetaLayer,
-  deriveKnowledgeMetaTopologyType,
-  isSameKnowledgeTestIndex,
-  stableStringify,
-  invalidateKnowledgeSyncCooldown,
-  ensureKnowledgeFresh,
-  reconcileKnowledge,
-  getKnowledge,
-  normalizeKnowledgePath,
-  runDoctorReport,
-  runDoctorFix,
-  runDoctorApplyLint
-};