@fenglimg/fabric-server 1.5.1 → 1.5.2

package/dist/{chunk-E3RZ276F.js → chunk-4G6VFG5N.js}

@@ -82,23 +82,29 @@ var ContextCache = class {
 };
 var contextCache = new ContextCache(5e3);
 
-// src/services/read-human-lock.ts
-import { readFile } from "fs/promises";
-import { join } from "path";
-import { humanLockEntrySchema } from "@fenglimg/fabric-shared";
-
 // src/services/_shared.ts
-import { resolve, sep } from "path";
+import { dirname, join, resolve, sep } from "path";
 import { createHash } from "crypto";
-import { rename, writeFile } from "fs/promises";
+import { mkdir, rename, writeFile } from "fs/promises";
 var FABRIC_DIR = ".fabric";
 var HUMAN_LOCK_FILE = "human-lock.json";
 var LEDGER_FILE = ".intent-ledger.jsonl";
+var LEDGER_PATH = `${FABRIC_DIR}/${LEDGER_FILE}`;
+var LEGACY_LEDGER_PATH = LEDGER_FILE;
 async function atomicWriteText(path, content) {
   const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
   await writeFile(tempPath, content, "utf8");
   await rename(tempPath, path);
 }
+function getLedgerPath(projectRoot) {
+  return join(projectRoot, LEDGER_PATH);
+}
+function getLegacyLedgerPath(projectRoot) {
+  return join(projectRoot, LEGACY_LEDGER_PATH);
+}
+async function ensureParentDirectory(path) {
+  await mkdir(dirname(path), { recursive: true });
+}
 function sha256(content) {
   return `sha256:${createHash("sha256").update(content).digest("hex")}`;
 }
@@ -116,6 +122,9 @@ function assertPathWithinProjectRoot(projectRoot, file) {
 }
 
 // src/services/read-human-lock.ts
+import { readFile } from "fs/promises";
+import { join as join2 } from "path";
+import { humanLockEntrySchema } from "@fenglimg/fabric-shared";
 async function readHumanLock(projectRoot) {
   const document = await readHumanLockDocument(projectRoot);
   return await Promise.all(
@@ -134,7 +143,7 @@ async function readHumanLockEntry(projectRoot, file) {
   return entries.find((entry) => entry.file === file) ?? null;
 }
 async function readHumanLockDocument(projectRoot) {
-  const humanLockPath = join(projectRoot, FABRIC_DIR, HUMAN_LOCK_FILE);
+  const humanLockPath = join2(projectRoot, FABRIC_DIR, HUMAN_LOCK_FILE);
   const raw = await readFile(humanLockPath, "utf8");
   const parsed = JSON.parse(raw);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
@@ -177,7 +186,7 @@ import { detectFramework } from "@fenglimg/fabric-shared/node";
 
 // src/meta-reader.ts
 import { readFile as readFile2 } from "fs/promises";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { agentsMetaSchema } from "@fenglimg/fabric-shared";
 import { agentsMetaNodeSchema, agentsMetaSchema as agentsMetaSchema2 } from "@fenglimg/fabric-shared";
 var AgentsMetaFileMissingError = class extends Error {
@@ -200,7 +209,7 @@ var AgentsMetaInvalidError = class extends Error {
   code = "FABRIC_META_INVALID";
 };
 function getAgentsMetaPath(projectRoot) {
-  return join2(projectRoot, ".fabric", "agents.meta.json");
+  return join3(projectRoot, ".fabric", "agents.meta.json");
 }
 function resolveProjectRoot() {
   return process.env.FABRIC_PROJECT_ROOT ?? process.cwd();
@@ -231,8 +240,8 @@ async function readAgentsMeta(projectRoot) {
 }
 
 // src/services/audit-log.ts
-import { appendFile, mkdir, open, stat } from "fs/promises";
-import { isAbsolute, join as join3, posix, relative, resolve as resolve2 } from "path";
+import { appendFile, mkdir as mkdir2, open, stat } from "fs/promises";
+import { isAbsolute, join as join4, posix, relative, resolve as resolve2 } from "path";
 var AUDIT_LOG_FILE = `${FABRIC_DIR}/audit.jsonl`;
 var DEFAULT_AUDIT_WINDOW_MS = 5 * 60 * 1e3;
 async function appendGetRulesAuditEvent(projectRoot, input) {
@@ -285,7 +294,7 @@ async function readAuditLog(projectRoot, opts) {
   return readAuditLogWindowed(projectRoot, opts.ts, opts.windowMs);
 }
 async function readAuditLogFull(projectRoot) {
-  const auditPath = join3(projectRoot, AUDIT_LOG_FILE);
+  const auditPath = join4(projectRoot, AUDIT_LOG_FILE);
   let raw;
   try {
     const fileStat = await stat(auditPath);
@@ -306,7 +315,7 @@ async function readAuditLogFull(projectRoot) {
   return parseAuditLogText(raw);
 }
 async function readAuditLogWindowed(projectRoot, ts, windowMs) {
-  const auditPath = join3(projectRoot, AUDIT_LOG_FILE);
+  const auditPath = join4(projectRoot, AUDIT_LOG_FILE);
   let fileSize;
   try {
     const fileStat = await stat(auditPath);
@@ -394,9 +403,9 @@ function isGetRulesAuditEntry(entry) {
   return entry.event === "get_rules";
 }
 async function appendAuditLogEntries(projectRoot, entries) {
-  const auditPath = join3(projectRoot, AUDIT_LOG_FILE);
-  const auditDir = join3(projectRoot, FABRIC_DIR);
-  await mkdir(auditDir, { recursive: true });
+  const auditPath = join4(projectRoot, AUDIT_LOG_FILE);
+  const auditDir = join4(projectRoot, FABRIC_DIR);
+  await mkdir2(auditDir, { recursive: true });
   await appendFile(auditPath, `${entries.map((entry) => JSON.stringify(entry)).join("\n")}
 `, "utf8");
 }
@@ -436,14 +445,27 @@ function parseAuditLogLine(line) {
 
 // src/services/read-ledger.ts
 import { randomUUID } from "crypto";
-import { appendFile as appendFile2, readFile as readFile3 } from "fs/promises";
-import { join as join4 } from "path";
+import { access, appendFile as appendFile2, copyFile, readFile as readFile3, rm } from "fs/promises";
 import { ledgerEntrySchema } from "@fenglimg/fabric-shared";
+async function resolveLedgerPaths(projectRoot) {
+  const primaryPath = getLedgerPath(projectRoot);
+  const legacyPath = getLegacyLedgerPath(projectRoot);
+  const [primaryExists, legacyExists] = await Promise.all([
+    pathExists(primaryPath),
+    pathExists(legacyPath)
+  ]);
+  return {
+    primaryPath,
+    legacyPath,
+    readPath: primaryExists ? primaryPath : legacyPath,
+    usingLegacy: !primaryExists && legacyExists
+  };
+}
 async function readLedger(projectRoot, options = {}) {
-  const ledgerPath = join4(projectRoot, LEDGER_FILE);
+  const { readPath } = await resolveLedgerPaths(projectRoot);
   let raw;
   try {
-    raw = await readFile3(ledgerPath, "utf8");
+    raw = await readFile3(readPath, "utf8");
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") {
       return [];
@@ -453,15 +475,40 @@ async function readLedger(projectRoot, options = {}) {
   return raw.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0).map((line, index) => parseLedgerLine(line, index)).filter((entry) => entry !== null).filter((entry) => options.source === void 0 || entry.source === options.source).filter((entry) => options.since === void 0 || entry.ts >= options.since);
 }
 async function appendLedgerEntry(projectRoot, entry) {
-  const ledgerPath = join4(projectRoot, LEDGER_FILE);
+  const ledgerPath = getLedgerPath(projectRoot);
   const nextEntry = ledgerEntrySchema.parse({
     ...entry,
     id: entry.id ?? `ledger:${randomUUID()}`
   });
+  await ensureParentDirectory(ledgerPath);
   await appendFile2(ledgerPath, `${JSON.stringify(nextEntry)}
 `, "utf8");
   return nextEntry;
 }
+async function migrateLegacyLedger(projectRoot) {
+  const { primaryPath, legacyPath } = await resolveLedgerPaths(projectRoot);
+  const [primaryExists, legacyExists] = await Promise.all([
+    pathExists(primaryPath),
+    pathExists(legacyPath)
+  ]);
+  if (!legacyExists) {
+    return {
+      migrated: false,
+      from: null,
+      to: primaryPath
+    };
+  }
+  if (!primaryExists) {
+    await ensureParentDirectory(primaryPath);
+    await copyFile(legacyPath, primaryPath);
+  }
+  await rm(legacyPath, { force: true });
+  return {
+    migrated: true,
+    from: legacyPath,
+    to: primaryPath
+  };
+}
 function parseLedgerLine(line, index) {
   try {
     const parsed = JSON.parse(line);
@@ -483,6 +530,17 @@ function parseLedgerLine(line, index) {
 function createDerivedId(index, line) {
   return `ledger:${index + 1}:${sha256(line).slice("sha256:".length)}`;
 }
+async function pathExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
 
 // src/services/doctor.ts
 var SCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".ts", ".tsx"]);
@@ -538,6 +596,9 @@ async function runDoctorReport(target) {
       lastLedgerEntryTs: ledgerSnapshot.lastEntryTs,
       lastLedgerEntryAgeMs: ledgerSnapshot.lastEntryAgeMs,
       metaRevision: metaSnapshot.revision,
+      ledgerPath: ledgerSnapshot.primaryPath,
+      legacyLedgerPath: ledgerSnapshot.legacyPath,
+      legacyLedgerDetected: ledgerSnapshot.usingLegacy,
       audit: auditReport.skipped ? null : {
         enabled: true,
         mode: auditReport.mode,
@@ -549,6 +610,17 @@ async function runDoctorReport(target) {
     audit: auditReport.skipped ? null : auditReport
   };
 }
+async function runDoctorFix(target) {
+  const projectRoot = normalizeTarget(target);
+  const migration = await migrateLegacyLedger(projectRoot);
+  const report = await runDoctorReport(projectRoot);
+  return {
+    changed: migration.migrated,
+    migratedLedger: migration.migrated,
+    message: migration.migrated ? `Migrated legacy ledger from ${migration.from} to ${migration.to}.` : `No legacy ledger migration needed. Canonical ledger path: ${migration.to}.`,
+    report
+  };
+}
 async function runDoctorAuditReport(target, options = {}) {
   const projectRoot = normalizeTarget(target);
   const mode = options.mode ?? readDoctorAuditMode(projectRoot);
@@ -647,6 +719,15 @@ function createMetaRevisionCheck(snapshot) {
       message: `agents.meta.json revision ${snapshot.revision} is stale: ${parts.join(" \xB7 ")}.`
     };
   }
+  if (snapshot.derivedIdentityFiles.length > 0) {
+    const [firstFile] = snapshot.derivedIdentityFiles;
+    const suffix = snapshot.derivedIdentityFiles.length > 1 ? ` (+${snapshot.derivedIdentityFiles.length - 1} more)` : "";
+    return {
+      name: "Meta revision",
+      status: "warn",
+      message: `agents.meta.json revision ${snapshot.revision} matches ${snapshot.nodeCount} tracked AGENTS files, but ${snapshot.derivedIdentityFiles.length} rule node${snapshot.derivedIdentityFiles.length === 1 ? "" : "s"} still use derived identities. Add \`<!-- fab:rule-id ... -->\` to the rule file header instead of editing meta directly (${firstFile}${suffix}).`
+    };
+  }
   return {
     name: "Meta revision",
     status: "ok",
@@ -675,6 +756,13 @@ function createProtectedPathsCheck(snapshot) {
   };
 }
 function createLedgerCheck(snapshot) {
+  if (snapshot.usingLegacy) {
+    return {
+      name: "Intent ledger",
+      status: "warn",
+      message: `Legacy ledger path detected at ${snapshot.legacyPath}. Fabric now reads ${snapshot.primaryPath} by default; run fab doctor --fix to migrate.`
+    };
+  }
   if (snapshot.lastEntryTs === null || snapshot.lastEntryAgeMs === null) {
     return {
       name: "Intent ledger",
@@ -756,8 +844,9 @@ async function inspectMetaRevision(projectRoot) {
     const meta = await readAgentsMeta(projectRoot);
     const entries = Object.entries(meta.nodes).sort(([left], [right]) => left.localeCompare(right));
     const missingFiles = [];
+    const derivedIdentityFiles = [];
     let driftCount = 0;
-    const revisionSource = entries.map(([, node]) => {
+    const revisionSource = entries.map(([id, node]) => {
       const absolutePath = join5(projectRoot, node.file);
       if (!existsSync(absolutePath)) {
         missingFiles.push(node.file);
@@ -768,15 +857,19 @@ async function inspectMetaRevision(projectRoot) {
       if (actualHash !== node.hash) {
         driftCount += 1;
       }
-      return actualHash;
-    }).join("");
+      if (node.file !== ".fabric/bootstrap/README.md" && node.identity_source !== "declared") {
+        derivedIdentityFiles.push(node.file);
+      }
+      return [id, actualHash, node.stable_id ?? "", node.identity_source ?? ""].join("|");
+    }).join("\n");
     const revision = sha2562(revisionSource);
     return {
       present: true,
       revision: meta.revision,
       nodeCount: entries.length,
       driftCount: revision === meta.revision ? driftCount : Math.max(driftCount, 1),
-      missingFiles
+      missingFiles,
+      derivedIdentityFiles
     };
   } catch (error) {
     return {
@@ -785,6 +878,7 @@ async function inspectMetaRevision(projectRoot) {
       nodeCount: 0,
       driftCount: 0,
       missingFiles: [],
+      derivedIdentityFiles: [],
       unexpectedError: error instanceof Error ? error.message : String(error)
     };
   }
@@ -815,6 +909,7 @@ async function inspectHumanLock(projectRoot) {
   }
 }
 async function inspectLedger(projectRoot) {
+  const paths = await resolveLedgerPaths(projectRoot);
   const entries = await readLedger(projectRoot);
   const lastEntry = entries.reduce(
     (latest, entry) => latest === null || entry.ts > latest ? entry.ts : latest,
@@ -823,7 +918,10 @@ async function inspectLedger(projectRoot) {
   return {
     count: entries.length,
     lastEntryTs: lastEntry,
-    lastEntryAgeMs: lastEntry === null ? null : Math.max(Date.now() - lastEntry, 0)
+    lastEntryAgeMs: lastEntry === null ? null : Math.max(Date.now() - lastEntry, 0),
+    primaryPath: paths.primaryPath,
+    legacyPath: paths.legacyPath,
+    usingLegacy: paths.usingLegacy
   };
 }
 function collectAuditViolations(projectRoot, ledgerEntries, getRulesEntries, windowMs) {
@@ -1106,56 +1204,76 @@ async function loadGetRulesContext(projectRoot) {
   return context;
 }
 async function resolveRulesForPath(projectRoot, context, path, options = {}) {
-  const { rules: loadedRules, stubs } = await loadRulesForPath(projectRoot, context.meta, path);
-  const { L1, L2 } = partitionRulesByLevel(loadedRules, options.dedupeByPath ?? false);
-  return {
-    L0: context.l0Content,
-    L1,
-    L2,
-    human_locked_nearby: context.humanLockedNearby,
-    description_stubs: stubs.length > 0 ? dedupeDescriptionStubsByPath(stubs) : void 0
-  };
+  const matchedNodes = matchRuleNodes(context.meta, path);
+  const loaded = await loadMatchedRules(projectRoot, matchedNodes);
+  return buildRulesPayload(context, loaded, options);
 }
 function normalizeRulesPath(value) {
   return value.replaceAll("\\", "/");
 }
-function classifyNode(nodeId) {
-  if (nodeId.startsWith("L1/")) {
-    return "L1";
-  }
-  if (nodeId.startsWith("L2/")) {
-    return "L2";
-  }
-  return null;
-}
-async function loadRulesForPath(projectRoot, meta, path) {
+function matchRuleNodes(meta, path) {
   const requestedPath = normalizeRulesPath(path);
-  const matchedNodes = Object.entries(meta.nodes).filter(([, node]) => shouldLoadNodeForPath(requestedPath, node)).sort((left, right) => {
+  return Object.entries(meta.nodes).filter(([, node]) => shouldLoadNodeForPath(requestedPath, node)).sort((left, right) => {
     const [leftId, leftNode] = left;
     const [rightId, rightNode] = right;
     const priorityDelta = PRIORITY_ORDER[leftNode.priority] - PRIORITY_ORDER[rightNode.priority];
     return priorityDelta !== 0 ? priorityDelta : leftId.localeCompare(rightId);
-  });
+  }).map(([nodeId, node]) => ({
+    node_id: nodeId,
+    level: classifyNode(nodeId, node),
+    stable_id: node.stable_id ?? nodeId,
+    identity_source: node.identity_source ?? "derived",
+    node
+  }));
+}
+async function loadMatchedRules(projectRoot, matchedNodes, fileContentCache = /* @__PURE__ */ new Map()) {
   const rules = [];
   const stubs = [];
-  for (const [nodeId, node] of matchedNodes) {
-    if (node.activation?.tier === "description") {
+  for (const matchedNode of matchedNodes) {
+    if (matchedNode.level === null) {
+      continue;
+    }
+    if (matchedNode.node.activation?.tier === "description") {
       stubs.push({
-        path: node.file,
-        description: node.activation.description ?? ""
+        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: classifyNode(nodeId),
+      level: matchedNode.level,
+      stable_id: matchedNode.stable_id,
+      identity_source: matchedNode.identity_source,
       entry: {
-        path: node.file,
-        content: await readFile5(join6(projectRoot, node.file), "utf8")
+        path: matchedNode.node.file,
+        content: await readRuleContent(projectRoot, matchedNode.node.file, fileContentCache)
       }
     });
   }
   return { rules, stubs };
 }
+function buildRulesPayload(context, loaded, options = {}) {
+  const { L1, L2 } = partitionRulesByLevel(loaded.rules, options.dedupeByPath ?? false);
+  return {
+    L0: context.l0Content,
+    L1,
+    L2,
+    human_locked_nearby: context.humanLockedNearby,
+    description_stubs: loaded.stubs.length > 0 ? dedupeDescriptionStubsByPath(loaded.stubs).map(toDescriptionStub) : void 0
+  };
+}
+function classifyNode(nodeId, node) {
+  if (nodeId.startsWith("L1/")) {
+    return "L1";
+  }
+  if (nodeId.startsWith("L2/")) {
+    return "L2";
+  }
+  return node.layer === "L0" ? null : node.layer;
+}
 function partitionRulesByLevel(loadedRules, dedupeByPath) {
   const l1 = [];
   const l2 = [];
@@ -1204,6 +1322,21 @@ function dedupeDescriptionStubsByPath(stubs) {
     return true;
   });
 }
+function toDescriptionStub(stub) {
+  return {
+    path: stub.path,
+    description: stub.description
+  };
+}
+async function readRuleContent(projectRoot, file, fileContentCache) {
+  const cached = fileContentCache.get(file);
+  if (cached !== void 0) {
+    return await cached;
+  }
+  const pending = readFile5(join6(projectRoot, file), "utf8");
+  fileContentCache.set(file, pending);
+  return await pending;
+}
 
 export {
   AGENTS_MD_RESOURCE_URI,
@@ -1213,18 +1346,27 @@ export {
   resolveProjectRoot,
   readAgentsMeta,
   FABRIC_DIR,
+  LEDGER_PATH,
+  LEGACY_LEDGER_PATH,
   atomicWriteText,
+  getLedgerPath,
+  getLegacyLedgerPath,
+  ensureParentDirectory,
   sha256,
   appendEditIntentAuditEvents,
+  resolveLedgerPaths,
   readLedger,
   appendLedgerEntry,
   readHumanLock,
   readHumanLockEntry,
   getRules,
   loadGetRulesContext,
-  resolveRulesForPath,
   normalizeRulesPath,
+  matchRuleNodes,
+  loadMatchedRules,
+  buildRulesPayload,
   runDoctorReport,
+  runDoctorFix,
   runDoctorAuditReport,
   approveHumanLock
 };

package/dist/{http-BVF4GWIM.js → http-U4S7BUP4.js}

@@ -2,21 +2,26 @@ import {
   AGENTS_MD_RESOURCE_URI,
   AgentsMetaFileMissingError,
   AgentsMetaInvalidError,
+  LEDGER_PATH,
+  LEGACY_LEDGER_PATH,
   appendLedgerEntry,
   approveHumanLock,
   contextCache,
+  ensureParentDirectory,
+  getLedgerPath,
+  getLegacyLedgerPath,
   getRules,
   readAgentsMeta,
   readHumanLock,
   readHumanLockEntry,
   readLedger,
+  resolveLedgerPaths,
   runDoctorReport
-} from "./chunk-E3RZ276F.js";
+} from "./chunk-4G6VFG5N.js";
 
 // src/http.ts
 import { randomUUID } from "crypto";
 import { appendFile, readFile as readFile2 } from "fs/promises";
-import { join as join3 } from "path";
 import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
 import {
   StreamableHTTPServerTransport
@@ -126,8 +131,7 @@ import chokidar from "chokidar";
 var AGENTS_META_PATH = ".fabric/agents.meta.json";
 var HUMAN_LOCK_PATH = ".fabric/human-lock.json";
 var FORENSIC_PATH = ".fabric/forensic.json";
-var LEDGER_PATH = ".intent-ledger.jsonl";
-var WATCHED_PATHS = [AGENTS_META_PATH, HUMAN_LOCK_PATH, FORENSIC_PATH, LEDGER_PATH];
+var WATCHED_PATHS = [AGENTS_META_PATH, HUMAN_LOCK_PATH, FORENSIC_PATH, LEDGER_PATH, LEGACY_LEDGER_PATH];
 var CONNECTION_LIMIT = 10;
 var HEARTBEAT_INTERVAL_MS = 3e4;
 var WATCH_DEBOUNCE_MS = 75;
@@ -166,6 +170,7 @@ function createEventsHandler(options) {
   const state = {
     clients: /* @__PURE__ */ new Set(),
     pendingTimers: /* @__PURE__ */ new Map(),
+    activeLedgerPath: getLedgerPath(projectRoot),
     ledgerOffset: 0,
     ledgerRemainder: "",
     humanLockSnapshot: createEmptyHumanLockSnapshot(),
@@ -243,10 +248,12 @@ async function ensureWatcher(state, projectRoot) {
   if (state.watcher !== void 0) {
     return;
   }
-  state.ledgerOffset = await readFileSize(join(projectRoot, LEDGER_PATH));
+  const ledgerState = await resolveLedgerWatchState(projectRoot);
+  state.activeLedgerPath = ledgerState.path;
+  state.ledgerOffset = ledgerState.size;
   state.ledgerRemainder = "";
   state.humanLockSnapshot = await readHumanLockSnapshot(projectRoot);
-  const watcher = chokidar.watch([...WATCHED_PATHS], {
+  const watcher = chokidar.watch(WATCHED_PATHS, {
     cwd: projectRoot,
     ignoreInitial: true,
     awaitWriteFinish: {
@@ -306,7 +313,7 @@ async function readEventsForFile(state, projectRoot, relativePath) {
     const event = await readDriftDetectedEvent(projectRoot);
     return event === null ? [] : [event];
   }
-  if (relativePath === LEDGER_PATH) {
+  if (relativePath === LEDGER_PATH || relativePath === LEGACY_LEDGER_PATH) {
     return await readLedgerAppendedEvents(state, projectRoot);
   }
   return [];
@@ -370,8 +377,14 @@ async function readHumanLockEvents(state, projectRoot) {
   return events;
 }
 async function readLedgerAppendedEvents(state, projectRoot) {
-  const ledgerPath = join(projectRoot, LEDGER_PATH);
-  const nextSize = await readFileSize(ledgerPath);
+  const ledgerState = await resolveLedgerWatchState(projectRoot);
+  const ledgerPath = ledgerState.path;
+  const nextSize = ledgerState.size;
+  if (ledgerPath !== state.activeLedgerPath) {
+    state.activeLedgerPath = ledgerPath;
+    state.ledgerOffset = 0;
+    state.ledgerRemainder = "";
+  }
   if (nextSize < state.ledgerOffset) {
     state.ledgerOffset = 0;
     state.ledgerRemainder = "";
@@ -394,6 +407,12 @@ async function readLedgerAppendedEvents(state, projectRoot) {
     await handle.close();
   }
 }
+async function resolveLedgerWatchState(projectRoot) {
+  const paths = await resolveLedgerPaths(projectRoot);
+  const path = paths.usingLegacy ? paths.legacyPath : paths.primaryPath;
+  const size = await readFileSize(path);
+  return { path, size };
+}
 function parseLedgerAppendedEvent(line) {
   try {
     const parsed = JSON.parse(line);
@@ -1084,12 +1103,13 @@ function hashToken(token) {
 
 // src/http.ts
 var DEFAULT_HOST = "127.0.0.1";
-var LEDGER_FILE = ".intent-ledger.jsonl";
 var NOTIFY_DEBOUNCE_MS = 200;
 var JsonlEventStore = class {
-  constructor(ledgerPath) {
+  constructor(projectRoot, ledgerPath) {
+    this.projectRoot = projectRoot;
     this.ledgerPath = ledgerPath;
   }
+  projectRoot;
   ledgerPath;
   async storeEvent(streamId, message) {
     const eventId = randomUUID();
@@ -1099,6 +1119,7 @@ var JsonlEventStore = class {
       streamId,
       message
     };
+    await ensureParentDirectory(this.ledgerPath);
     await appendFile(this.ledgerPath, `${JSON.stringify(entry)}
 `, "utf8");
     return eventId;
@@ -1131,9 +1152,17 @@ var JsonlEventStore = class {
       raw = await readFile2(this.ledgerPath, "utf8");
     } catch (error) {
       if (isNodeError2(error) && error.code === "ENOENT") {
-        return [];
+        try {
+          raw = await readFile2(getLegacyLedgerPath(this.projectRoot), "utf8");
+        } catch (legacyError) {
+          if (isNodeError2(legacyError) && legacyError.code === "ENOENT") {
+            return [];
+          }
+          throw legacyError;
+        }
+      } else {
+        throw error;
       }
-      throw error;
     }
     return raw.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => parseStoredMcpEvent(line)).filter((event) => event !== null);
   }
@@ -1141,8 +1170,8 @@ var JsonlEventStore = class {
 function createFabricHttpApp(options) {
   const { projectRoot, host = DEFAULT_HOST, authToken, dashboardDistPath, dev } = options;
   const app = createMcpExpressApp({ host });
-  const ledgerPath = join3(projectRoot, LEDGER_FILE);
-  const eventStore = new JsonlEventStore(ledgerPath);
+  const ledgerPath = getLedgerPath(projectRoot);
+  const eventStore = new JsonlEventStore(projectRoot, ledgerPath);
   const sessions = /* @__PURE__ */ new Map();
   process.env.FABRIC_PROJECT_ROOT = projectRoot;
   const cacheWatcher = chokidar2.watch(

package/dist/index.d.ts

@@ -2,6 +2,11 @@ import { Server } from 'node:http';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { AuditMode, LedgerEntry, HumanLockEntry } from '@fenglimg/fabric-shared';
 
+declare const LEDGER_PATH = ".fabric/.intent-ledger.jsonl";
+declare const LEGACY_LEDGER_PATH = ".intent-ledger.jsonl";
+declare function getLedgerPath(projectRoot: string): string;
+declare function getLegacyLedgerPath(projectRoot: string): string;
+
 type DoctorStatus = "ok" | "warn" | "error";
 type DoctorCheck = {
     name: string;
@@ -25,6 +30,9 @@ type DoctorSummary = {
     lastLedgerEntryTs: number | null;
     lastLedgerEntryAgeMs: number | null;
     metaRevision: string | null;
+    ledgerPath: string;
+    legacyLedgerPath: string;
+    legacyLedgerDetected: boolean;
     audit: {
         enabled: boolean;
         mode: AuditMode;
@@ -39,6 +47,12 @@ type DoctorReport = {
     summary: DoctorSummary;
     audit: DoctorAuditReport | null;
 };
+type DoctorFixReport = {
+    changed: boolean;
+    migratedLedger: boolean;
+    message: string;
+    report: DoctorReport;
+};
 type DoctorAuditViolation = {
     editTs: number;
     entryId: string;
@@ -55,6 +69,7 @@ type DoctorAuditReport = {
     violations: DoctorAuditViolation[];
 };
 declare function runDoctorReport(target: string): Promise<DoctorReport>;
+declare function runDoctorFix(target: string): Promise<DoctorFixReport>;
 declare function runDoctorAuditReport(target: string, options?: {
     force?: boolean;
     mode?: AuditMode;
@@ -102,4 +117,4 @@ declare function startHttpServer(options: {
     dev?: boolean;
 }): Promise<Server>;
 
-export { AGENTS_MD_RESOURCE_URI, type ApproveHumanLockInput, type ApproveHumanLockResult, type DoctorAuditReport, type DoctorReport, type HumanLockStatus, approveHumanLock, createFabricServer, readHumanLock, readHumanLockEntry, runDoctorAuditReport, runDoctorReport, startHttpServer, startStdioServer };
+export { AGENTS_MD_RESOURCE_URI, type ApproveHumanLockInput, type ApproveHumanLockResult, type DoctorAuditReport, type DoctorFixReport, type DoctorReport, type HumanLockStatus, LEDGER_PATH, LEGACY_LEDGER_PATH, approveHumanLock, createFabricServer, getLedgerPath, getLegacyLedgerPath, readHumanLock, readHumanLockEntry, runDoctorAuditReport, runDoctorFix, runDoctorReport, startHttpServer, startStdioServer };