@fenglimg/fabric-server 1.0.0 → 1.2.0

package/dist/{http-3BNWQWPP.js → http-EQBDM4C7.js}

@@ -9,398 +9,19 @@ import {
   readHumanLock,
   readHumanLockDocument,
   readHumanLockEntry,
-  readLedger
-} from "./chunk-KZO24GUQ.js";
+  readLedger,
+  runDoctorReport
+} from "./chunk-U3IQH5H6.js";
 
 // src/http.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { appendFile, readFile as readFile3 } from "fs/promises";
-import { join as join4 } from "path";
+import { appendFile, readFile as readFile2 } from "fs/promises";
+import { join as join3 } from "path";
 import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
 import {
   StreamableHTTPServerTransport
 } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 
-// src/services/doctor.ts
-import { createHash } from "crypto";
-import { existsSync, readFileSync, readdirSync, statSync } from "fs";
-import { readFile } from "fs/promises";
-import { isAbsolute, join, posix, resolve } from "path";
-import { detectFramework, forensicReportSchema } from "@fenglimg/fabric-shared";
-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 LEDGER_WARN_AFTER_MS = 3 * 24 * 60 * 60 * 1e3;
-var LEDGER_ERROR_AFTER_MS = 7 * 24 * 60 * 60 * 1e3;
-async function runDoctorReport(target) {
-  const projectRoot = normalizeTarget(target);
-  const framework = detectFramework(projectRoot);
-  const entryPoints = collectEntryPoints(projectRoot);
-  const [savedForensic, metaSnapshot, humanLockSnapshot, ledgerSnapshot] = await Promise.all([
-    readSavedForensic(projectRoot),
-    inspectMetaRevision(projectRoot),
-    inspectHumanLock(projectRoot),
-    inspectLedger(projectRoot)
-  ]);
-  const checks = [
-    createForensicCheck(savedForensic, framework, entryPoints),
-    createFrameworkCheck(savedForensic, framework, entryPoints),
-    createMetaRevisionCheck(metaSnapshot),
-    createProtectedPathsCheck(humanLockSnapshot),
-    createLedgerCheck(ledgerSnapshot)
-  ];
-  return {
-    status: reduceStatus(checks.map((check) => check.status)),
-    checks,
-    summary: {
-      target: projectRoot,
-      framework: {
-        kind: framework.kind,
-        version: framework.version,
-        subkind: framework.subkind
-      },
-      entryPoints,
-      driftCount: humanLockSnapshot.driftCount,
-      protectedPathCount: humanLockSnapshot.protectedPathCount,
-      protectedPathsIntact: humanLockSnapshot.present && humanLockSnapshot.driftCount === 0,
-      lastLedgerEntryTs: ledgerSnapshot.lastEntryTs,
-      lastLedgerEntryAgeMs: ledgerSnapshot.lastEntryAgeMs,
-      metaRevision: metaSnapshot.revision
-    }
-  };
-}
-function createForensicCheck(forensic, framework, entryPoints) {
-  if (!forensic.present) {
-    return {
-      name: "Forensic snapshot",
-      status: "error",
-      message: `${forensic.reason} Live scan detects ${formatFramework(framework)} with ${entryPoints.length} entry point${entryPoints.length === 1 ? "" : "s"}.`
-    };
-  }
-  return {
-    name: "Forensic snapshot",
-    status: "ok",
-    message: `Loaded .fabric/forensic.json for ${formatFramework(forensic.report.framework)} with ${forensic.report.entry_points.length} recorded entry point${forensic.report.entry_points.length === 1 ? "" : "s"}.`
-  };
-}
-function createFrameworkCheck(forensic, framework, entryPoints) {
-  if (framework.kind === "unknown") {
-    return {
-      name: "Framework fingerprint",
-      status: "warn",
-      message: "Unable to identify the project framework from current files."
-    };
-  }
-  if (!forensic.present) {
-    return {
-      name: "Framework fingerprint",
-      status: "warn",
-      message: `Live detection sees ${formatFramework(framework)} and ${entryPoints.length} entry point${entryPoints.length === 1 ? "" : "s"}, but no forensic baseline exists yet.`
-    };
-  }
-  const matches = forensic.report.framework.kind === framework.kind && forensic.report.framework.version === framework.version && forensic.report.framework.subkind === framework.subkind;
-  if (!matches) {
-    return {
-      name: "Framework fingerprint",
-      status: "warn",
-      message: `Forensic baseline says ${formatFramework(forensic.report.framework)}; live scan says ${formatFramework(framework)}.`
-    };
-  }
-  return {
-    name: "Framework fingerprint",
-    status: "ok",
-    message: `Framework baseline matches live scan: ${formatFramework(framework)} \xB7 ${entryPoints.length} current entry point${entryPoints.length === 1 ? "" : "s"}.`
-  };
-}
-function createMetaRevisionCheck(snapshot) {
-  if (!snapshot.present) {
-    return {
-      name: "Meta revision",
-      status: "error",
-      message: snapshot.unexpectedError ?? "agents.meta.json is missing."
-    };
-  }
-  if (snapshot.driftCount > 0 || snapshot.missingFiles.length > 0) {
-    const parts = [
-      `${snapshot.driftCount} tracked AGENTS file drift`,
-      snapshot.missingFiles.length > 0 ? `${snapshot.missingFiles.length} missing tracked file` : null
-    ].filter((part) => part !== null);
-    return {
-      name: "Meta revision",
-      status: "error",
-      message: `agents.meta.json revision ${snapshot.revision} is stale: ${parts.join(" \xB7 ")}.`
-    };
-  }
-  return {
-    name: "Meta revision",
-    status: "ok",
-    message: `agents.meta.json revision ${snapshot.revision} matches ${snapshot.nodeCount} tracked AGENTS file${snapshot.nodeCount === 1 ? "" : "s"}.`
-  };
-}
-function createProtectedPathsCheck(snapshot) {
-  if (!snapshot.present) {
-    return {
-      name: "Protected paths",
-      status: "warn",
-      message: snapshot.reason
-    };
-  }
-  if (snapshot.driftCount > 0) {
-    return {
-      name: "Protected paths",
-      status: "warn",
-      message: `${snapshot.driftCount} of ${snapshot.protectedPathCount} protected path${snapshot.protectedPathCount === 1 ? "" : "s"} drifted from approved hashes.`
-    };
-  }
-  return {
-    name: "Protected paths",
-    status: "ok",
-    message: `${snapshot.protectedPathCount} protected path${snapshot.protectedPathCount === 1 ? "" : "s"} intact with zero hash drift.`
-  };
-}
-function createLedgerCheck(snapshot) {
-  if (snapshot.lastEntryTs === null || snapshot.lastEntryAgeMs === null) {
-    return {
-      name: "Intent ledger",
-      status: "warn",
-      message: "No ledger entries recorded yet."
-    };
-  }
-  if (snapshot.lastEntryAgeMs >= LEDGER_ERROR_AFTER_MS) {
-    return {
-      name: "Intent ledger",
-      status: "error",
-      message: `Last ledger entry is ${formatAge(snapshot.lastEntryAgeMs)} old (${new Date(snapshot.lastEntryTs).toISOString()}).`
-    };
-  }
-  if (snapshot.lastEntryAgeMs >= LEDGER_WARN_AFTER_MS) {
-    return {
-      name: "Intent ledger",
-      status: "warn",
-      message: `Last ledger entry is ${formatAge(snapshot.lastEntryAgeMs)} old (${new Date(snapshot.lastEntryTs).toISOString()}).`
-    };
-  }
-  return {
-    name: "Intent ledger",
-    status: "ok",
-    message: `Last ledger entry is ${formatAge(snapshot.lastEntryAgeMs)} old (${snapshot.count} total entr${snapshot.count === 1 ? "y" : "ies"}).`
-  };
-}
-async function readSavedForensic(projectRoot) {
-  const forensicPath = join(projectRoot, ".fabric", "forensic.json");
-  try {
-    const raw = await readFile(forensicPath, "utf8");
-    const parsed = forensicReportSchema.safeParse(JSON.parse(raw));
-    if (!parsed.success) {
-      return {
-        present: false,
-        reason: "forensic.json is invalid."
-      };
-    }
-    return {
-      present: true,
-      report: parsed.data
-    };
-  } catch (error) {
-    if (isMissingFileError(error)) {
-      return {
-        present: false,
-        reason: ".fabric/forensic.json is missing."
-      };
-    }
-    return {
-      present: false,
-      reason: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-async function inspectMetaRevision(projectRoot) {
-  try {
-    const meta = readAgentsMeta(projectRoot);
-    const entries = Object.entries(meta.nodes).sort(([left], [right]) => left.localeCompare(right));
-    const missingFiles = [];
-    let driftCount = 0;
-    const revisionSource = entries.map(([, node]) => {
-      const absolutePath = join(projectRoot, node.file);
-      if (!existsSync(absolutePath)) {
-        missingFiles.push(node.file);
-        driftCount += 1;
-        return "missing";
-      }
-      const actualHash = sha256(readFileSync(absolutePath, "utf8"));
-      if (actualHash !== node.hash) {
-        driftCount += 1;
-      }
-      return actualHash;
-    }).join("");
-    const revision = sha256(revisionSource);
-    return {
-      present: true,
-      revision: meta.revision,
-      nodeCount: entries.length,
-      driftCount: revision === meta.revision ? driftCount : Math.max(driftCount, 1),
-      missingFiles
-    };
-  } catch (error) {
-    return {
-      present: false,
-      revision: null,
-      nodeCount: 0,
-      driftCount: 0,
-      missingFiles: [],
-      unexpectedError: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-async function inspectHumanLock(projectRoot) {
-  try {
-    const entries = await readHumanLock(projectRoot);
-    return {
-      present: true,
-      driftCount: entries.filter((entry) => entry.drift).length,
-      protectedPathCount: entries.length
-    };
-  } catch (error) {
-    if (isMissingFileError(error)) {
-      return {
-        present: false,
-        driftCount: 0,
-        protectedPathCount: 0,
-        reason: ".fabric/human-lock.json is missing; no protected paths are being tracked."
-      };
-    }
-    return {
-      present: false,
-      driftCount: 0,
-      protectedPathCount: 0,
-      reason: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-async function inspectLedger(projectRoot) {
-  const entries = await readLedger(projectRoot);
-  const lastEntry = entries.reduce(
-    (latest, entry) => latest === null || entry.ts > latest ? entry.ts : latest,
-    null
-  );
-  return {
-    count: entries.length,
-    lastEntryTs: lastEntry,
-    lastEntryAgeMs: lastEntry === null ? null : Math.max(Date.now() - lastEntry, 0)
-  };
-}
-function normalizeTarget(targetInput) {
-  return isAbsolute(targetInput) ? targetInput : resolve(process.cwd(), targetInput);
-}
-function collectEntryPoints(root) {
-  if (!existsSync(root) || !statSync(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 = join(current, entry.name);
-      const relativePath = posix.normalize(absolutePath.slice(root.length + 1).split("\\").join("/"));
-      if (relativePath.length === 0) {
-        continue;
-      }
-      if (entry.isDirectory()) {
-        if (IGNORED_DIRECTORIES.has(entry.name)) {
-          continue;
-        }
-        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 formatFramework(framework) {
-  const pieces = [framework.kind, framework.version !== "unknown" ? framework.version : null, framework.subkind].filter((piece) => piece !== null && piece !== "unknown");
-  return pieces.length > 0 ? pieces.join(" \xB7 ") : "unknown";
-}
-function formatAge(ageMs) {
-  const seconds = Math.floor(ageMs / 1e3);
-  if (seconds < 60) {
-    return `${seconds}s`;
-  }
-  const minutes = Math.floor(seconds / 60);
-  if (minutes < 60) {
-    return `${minutes}m`;
-  }
-  const hours = Math.floor(minutes / 60);
-  if (hours < 48) {
-    return `${hours}h`;
-  }
-  const days = Math.floor(hours / 24);
-  if (days < 14) {
-    return `${days}d`;
-  }
-  return `${Math.floor(days / 7)}w`;
-}
-function sha256(content) {
-  return `sha256:${createHash("sha256").update(content).digest("hex")}`;
-}
-function isMissingFileError(error) {
-  return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
-
 // src/api/_error.ts
 function sendError(res, status, code, message, details) {
   const payload = {
@@ -490,13 +111,13 @@ function registerDoctorApi(app, projectRoot) {
 }
 
 // src/api/events.ts
-import { createHash as createHash2, randomUUID } from "crypto";
-import { open, readFile as readFile2, stat } from "fs/promises";
-import { join as join2 } from "path";
+import { createHash, randomUUID } from "crypto";
+import { open, readFile, stat } from "fs/promises";
+import { join } from "path";
 import {
   agentsMetaSchema,
   fabricEventSchema,
-  forensicReportSchema as forensicReportSchema2,
+  forensicReportSchema,
   humanLockFileSchema,
   ledgerEntrySchema
 } from "@fenglimg/fabric-shared";
@@ -576,7 +197,7 @@ async function ensureWatcher(state, projectRoot) {
   if (state.watcher !== void 0) {
     return;
   }
-  state.ledgerOffset = await readFileSize(join2(projectRoot, LEDGER_PATH));
+  state.ledgerOffset = await readFileSize(join(projectRoot, LEDGER_PATH));
   state.ledgerRemainder = "";
   state.humanLockSnapshot = await readHumanLockSnapshot(projectRoot);
   const watcher = chokidar.watch([...WATCHED_PATHS], {
@@ -645,7 +266,7 @@ async function readEventsForFile(state, projectRoot, relativePath) {
   return [];
 }
 async function readMetaUpdatedEvent(projectRoot) {
-  const filePath = join2(projectRoot, AGENTS_META_PATH);
+  const filePath = join(projectRoot, AGENTS_META_PATH);
   const raw = await readUtf8File(filePath);
   if (raw === null) {
     return null;
@@ -657,12 +278,12 @@ async function readMetaUpdatedEvent(projectRoot) {
   };
 }
 async function readDriftDetectedEvent(projectRoot) {
-  const filePath = join2(projectRoot, FORENSIC_PATH);
+  const filePath = join(projectRoot, FORENSIC_PATH);
   const raw = await readUtf8File(filePath);
   if (raw === null) {
     return null;
   }
-  const parsed = forensicReportSchema2.parse(JSON.parse(raw));
+  const parsed = forensicReportSchema.parse(JSON.parse(raw));
   return {
     type: "drift:detected",
     payload: parsed
@@ -703,7 +324,7 @@ async function readHumanLockEvents(state, projectRoot) {
   return events;
 }
 async function readLedgerAppendedEvents(state, projectRoot) {
-  const ledgerPath = join2(projectRoot, LEDGER_PATH);
+  const ledgerPath = join(projectRoot, LEDGER_PATH);
   const nextSize = await readFileSize(ledgerPath);
   if (nextSize < state.ledgerOffset) {
     state.ledgerOffset = 0;
@@ -772,7 +393,7 @@ data: ${JSON.stringify(payload)}
   }
 }
 async function readHumanLockSnapshot(projectRoot) {
-  const humanLockPath = join2(projectRoot, HUMAN_LOCK_PATH);
+  const humanLockPath = join(projectRoot, HUMAN_LOCK_PATH);
   const raw = await readUtf8File(humanLockPath);
   if (raw === null) {
     return createEmptyHumanLockSnapshot();
@@ -793,7 +414,7 @@ async function readActualHumanLockHashes(projectRoot, locked) {
   const uniqueFiles = Array.from(new Set(locked.map((entry) => entry.file)));
   const fileContents = await Promise.all(
     uniqueFiles.map(async (file) => {
-      const raw = await readUtf8File(join2(projectRoot, file));
+      const raw = await readUtf8File(join(projectRoot, file));
       return [file, raw];
     })
   );
@@ -808,7 +429,7 @@ async function readActualHumanLockHashes(projectRoot, locked) {
 function hashLockedContent(content, entry) {
   const lines = content.split(/\r?\n/);
   const slice = lines.slice(Math.max(entry.start_line - 1, 0), Math.max(entry.end_line, 0)).join("\n");
-  return `sha256:${createHash2("sha256").update(slice).digest("hex")}`;
+  return `sha256:${createHash("sha256").update(slice).digest("hex")}`;
 }
 function getHumanLockKey(entry) {
   return `${entry.file}:${entry.start_line}:${entry.end_line}`;
@@ -838,7 +459,7 @@ function normalizePath(value) {
 }
 async function readUtf8File(path) {
   try {
-    return await readFile2(path, "utf8");
+    return await readFile(path, "utf8");
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") {
       return null;
@@ -985,6 +606,8 @@ function buildLedgerFallbackMeta(entries) {
         scope_glob: affectedPath,
         deps: [],
         priority: "medium",
+        layer: "L2",
+        topology_type: "mirror",
         hash: `replayed:${hashBase ?? entry.id}`
       };
     }
@@ -1241,9 +864,9 @@ function registerRulesApi(app, projectRoot) {
 }
 
 // src/api/scan.ts
-import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
-import { isAbsolute as isAbsolute2, join as join3, relative, resolve as resolve2, sep } from "path";
-import { detectFramework as detectFramework2 } from "@fenglimg/fabric-shared";
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { isAbsolute, join as join2, relative, resolve, sep } from "path";
+import { detectFramework } from "@fenglimg/fabric-shared/node";
 var DEFAULT_IGNORES = [
   "**/*.meta",
   "library/**",
@@ -1266,11 +889,11 @@ function registerScanApi(app, projectRoot) {
   });
 }
 function createScanReport(targetInput = process.cwd()) {
-  const target = normalizeTarget2(targetInput);
-  const framework = detectFramework2(target);
+  const target = normalizeTarget(targetInput);
+  const framework = detectFramework(target);
   const readmeQuality = getReadmeQuality(target);
-  const hasContributing = existsSync2(join3(target, "CONTRIBUTING.md"));
-  const hasExistingFabric = existsSync2(join3(target, "AGENTS.md")) || existsSync2(join3(target, ".fabric"));
+  const hasContributing = existsSync(join2(target, "CONTRIBUTING.md"));
+  const hasExistingFabric = existsSync(join2(target, "AGENTS.md")) || existsSync(join2(target, ".fabric"));
   const walkResult = walkFiles(target, DEFAULT_IGNORES);
   return {
     target,
@@ -1288,19 +911,19 @@ function createScanReport(targetInput = process.cwd()) {
     })
   };
 }
-function normalizeTarget2(targetInput) {
-  return isAbsolute2(targetInput) ? targetInput : resolve2(process.cwd(), targetInput);
+function normalizeTarget(targetInput) {
+  return isAbsolute(targetInput) ? targetInput : resolve(process.cwd(), targetInput);
 }
 function getReadmeQuality(target) {
-  const readmePath = join3(target, "README.md");
-  if (!existsSync2(readmePath)) {
+  const readmePath = join2(target, "README.md");
+  if (!existsSync(readmePath)) {
     return "stub";
   }
-  const wordCount = readFileSync2(readmePath, "utf8").trim().split(/\s+/).filter(Boolean).length;
+  const wordCount = readFileSync(readmePath, "utf8").trim().split(/\s+/).filter(Boolean).length;
   return wordCount >= 200 ? "ok" : "stub";
 }
 function walkFiles(root, ignorePatterns) {
-  if (!existsSync2(root) || !statSync2(root).isDirectory()) {
+  if (!existsSync(root) || !statSync(root).isDirectory()) {
     throw new Error(`Target must be an existing directory: ${root}`);
   }
   let fileCount = 0;
@@ -1311,8 +934,8 @@ function walkFiles(root, ignorePatterns) {
     if (current === void 0) {
       continue;
     }
-    for (const entry of readdirSync2(current, { withFileTypes: true })) {
-      const absolutePath = join3(current, entry.name);
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      const absolutePath = join2(current, entry.name);
       const relativePath = toPosixPath(relative(root, absolutePath));
       if (shouldIgnore(relativePath, entry.isDirectory(), ignorePatterns)) {
         ignoredCount += 1;
@@ -1364,18 +987,18 @@ function buildRecommendations(input) {
 }
 
 // src/api/static.ts
-import { existsSync as existsSync3 } from "fs";
-import { dirname, resolve as resolve3 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { dirname, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 import express from "express";
-var DEFAULT_STATIC_DIR = resolve3(dirname(fileURLToPath(import.meta.url)), "static");
+var DEFAULT_STATIC_DIR = resolve2(dirname(fileURLToPath(import.meta.url)), "static");
 function registerDashboardStatic(app, options = {}) {
   if (options.dev ?? process.env.NODE_ENV === "development") {
     return;
   }
-  const staticDir = resolve3(options.dashboardDistPath ?? DEFAULT_STATIC_DIR);
-  const indexPath = resolve3(staticDir, "index.html");
-  if (!existsSync3(indexPath)) {
+  const staticDir = resolve2(options.dashboardDistPath ?? DEFAULT_STATIC_DIR);
+  const indexPath = resolve2(staticDir, "index.html");
+  if (!existsSync2(indexPath)) {
     warnMissingDashboard(staticDir);
     app.get("/", (_req, res) => {
       res.status(404).json({
@@ -1400,7 +1023,7 @@ function warnMissingDashboard(staticDir) {
 }
 
 // src/middleware/bearer-auth.ts
-import { createHash as createHash3, timingSafeEqual } from "crypto";
+import { createHash as createHash2, timingSafeEqual } from "crypto";
 function createBearerAuthMiddleware(token) {
   const expectedDigest = hashToken(token);
   return function bearerAuthMiddleware(req, res, next) {
@@ -1433,7 +1056,7 @@ function tokensMatch(token, expectedDigest) {
   return timingSafeEqual(hashToken(token), expectedDigest);
 }
 function hashToken(token) {
-  return createHash3("sha256").update(token, "utf8").digest();
+  return createHash2("sha256").update(token, "utf8").digest();
 }
 
 // src/http.ts
@@ -1481,7 +1104,7 @@ var JsonlEventStore = class {
   async readEvents() {
     let raw;
     try {
-      raw = await readFile3(this.ledgerPath, "utf8");
+      raw = await readFile2(this.ledgerPath, "utf8");
     } catch (error) {
       if (isNodeError2(error) && error.code === "ENOENT") {
         return [];
@@ -1494,7 +1117,7 @@ var JsonlEventStore = class {
 function createFabricHttpApp(options) {
   const { projectRoot, host = DEFAULT_HOST, authToken, dashboardDistPath, dev } = options;
   const app = createMcpExpressApp({ host });
-  const ledgerPath = join4(projectRoot, LEDGER_FILE);
+  const ledgerPath = join3(projectRoot, LEDGER_FILE);
   const eventStore = new JsonlEventStore(ledgerPath);
   const sessions = /* @__PURE__ */ new Map();
   process.env.FABRIC_PROJECT_ROOT = projectRoot;

package/dist/index.d.ts

@@ -1,5 +1,65 @@
 import { Server } from 'node:http';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { AuditMode } from '@fenglimg/fabric-shared';
+
+type DoctorStatus = "ok" | "warn" | "error";
+type DoctorCheck = {
+    name: string;
+    status: DoctorStatus;
+    message: string;
+};
+type DoctorSummary = {
+    target: string;
+    framework: {
+        kind: string;
+        version: string;
+        subkind: string;
+    };
+    entryPoints: Array<{
+        path: string;
+        reason: string;
+    }>;
+    driftCount: number;
+    protectedPathCount: number;
+    protectedPathsIntact: boolean;
+    lastLedgerEntryTs: number | null;
+    lastLedgerEntryAgeMs: number | null;
+    metaRevision: string | null;
+    audit: {
+        enabled: boolean;
+        mode: AuditMode;
+        checkedPathCount: number;
+        violationCount: number;
+        windowMs: number;
+    } | null;
+};
+type DoctorReport = {
+    status: DoctorStatus;
+    checks: DoctorCheck[];
+    summary: DoctorSummary;
+    audit: DoctorAuditReport | null;
+};
+type DoctorAuditViolation = {
+    editTs: number;
+    entryId: string;
+    intent: string;
+    lastGetRulesTs: number | null;
+    path: string;
+};
+type DoctorAuditReport = {
+    mode: AuditMode;
+    skipped: boolean;
+    windowMs: number;
+    checkedPathCount: number;
+    violationCount: number;
+    violations: DoctorAuditViolation[];
+};
+declare function runDoctorReport(target: string): Promise<DoctorReport>;
+declare function runDoctorAuditReport(target: string, options?: {
+    force?: boolean;
+    mode?: AuditMode;
+    windowMs?: number;
+}): Promise<DoctorAuditReport>;
 
 declare function createFabricServer(): McpServer;
 declare function startStdioServer(): Promise<void>;
@@ -12,4 +72,4 @@ declare function startHttpServer(options: {
     dev?: boolean;
 }): Promise<Server>;
 
-export { createFabricServer, startHttpServer, startStdioServer };
+export { type DoctorAuditReport, type DoctorReport, createFabricServer, runDoctorAuditReport, runDoctorReport, startHttpServer, startStdioServer };