@fenglimg/fabric-server 2.0.0-rc.36 → 2.0.0-rc.38

package/dist/http-ZRVOXE6C.js

@@ -1,1286 +0,0 @@
-import {
-  EVENT_LEDGER_PATH,
-  LEDGER_PATH,
-  LEGACY_LEDGER_PATH,
-  appendEventLedgerEvent,
-  contextCache,
-  getEventLedgerPath,
-  getKnowledge,
-  getLedgerPath,
-  getLegacyLedgerPath,
-  invalidateKnowledgeSyncCooldown,
-  isNodeError,
-  readAgentsMeta,
-  readEventLedger,
-  runDoctorReport,
-  sha256
-} from "./chunk-5XXH2VZZ.js";
-
-// src/http.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { readFile as readFile3 } from "fs/promises";
-import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
-import {
-  StreamableHTTPServerTransport
-} from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import chokidar2 from "chokidar";
-
-// src/api/_error.ts
-import { FabricError } from "@fenglimg/fabric-shared/errors";
-function sendError(res, status, code, message, details) {
-  const payload = {
-    error: {
-      code,
-      message
-    }
-  };
-  if (details !== void 0) {
-    payload.error.details = details;
-  }
-  res.status(status).json(payload);
-}
-function sendValidationError(res, message, details) {
-  sendError(res, 400, "BAD_REQUEST", message, details);
-}
-function sendUnknownError(res, error) {
-  const normalized = normalizeApiError(error);
-  sendError(res, normalized.status, normalized.code, normalized.message, normalized.details);
-}
-function normalizeApiError(error) {
-  if (error instanceof FabricError) {
-    return {
-      status: error.httpStatus,
-      code: error.code,
-      message: error.message,
-      details: error.details
-    };
-  }
-  if (error instanceof Error) {
-    return {
-      status: 500,
-      code: "INTERNAL_ERROR",
-      message: error.message
-    };
-  }
-  return {
-    status: 500,
-    code: "INTERNAL_ERROR",
-    message: `Unexpected error: ${String(error)}`
-  };
-}
-
-// src/api/doctor.ts
-function registerDoctorApi(app, projectRoot) {
-  app.get("/api/doctor", async (_req, res) => {
-    try {
-      res.json(await runDoctorReport(projectRoot));
-    } catch (error) {
-      sendUnknownError(res, error);
-    }
-  });
-}
-
-// src/api/events.ts
-import { open, readFile as readFile2, stat } from "fs/promises";
-import { join } from "path";
-import {
-  agentsMetaSchema,
-  fabricEventSchema,
-  ledgerEntrySchema as ledgerEntrySchema2
-} from "@fenglimg/fabric-shared";
-import { eventLedgerEventSchema } from "@fenglimg/fabric-shared";
-import chokidar from "chokidar";
-
-// src/services/read-ledger.ts
-import { randomUUID } from "crypto";
-import { access, copyFile, readFile, 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 [legacyEntries, eventEntries] = await Promise.all([
-    readLegacyLedger(projectRoot),
-    readLedgerFromEventLedger(projectRoot)
-  ]);
-  const entries = mergeLedgerEntries(legacyEntries, eventEntries);
-  return entries.filter((entry) => options.source === void 0 || entry.source === options.source).filter((entry) => options.since === void 0 || entry.ts >= options.since);
-}
-async function readLegacyLedger(projectRoot) {
-  const { readPath } = await resolveLedgerPaths(projectRoot);
-  let raw;
-  try {
-    raw = await readFile(readPath, "utf8");
-  } catch (error) {
-    if (isNodeError(error) && error.code === "ENOENT") {
-      return [];
-    }
-    throw error;
-  }
-  return raw.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0).map((line, index) => parseLedgerLine(line, index)).filter((entry) => entry !== null);
-}
-function parseLedgerLine(line, index) {
-  try {
-    const parsed = JSON.parse(line);
-    if (parsed.kind === "mcp-event") {
-      return null;
-    }
-    const result = ledgerEntrySchema.safeParse(parsed);
-    if (!result.success) {
-      return null;
-    }
-    return {
-      ...result.data,
-      id: result.data.id ?? createDerivedId(index, line)
-    };
-  } catch {
-    return null;
-  }
-}
-async function readLedgerFromEventLedger(projectRoot) {
-  const { events } = await readEventLedger(projectRoot);
-  const grouped = /* @__PURE__ */ new Map();
-  for (const event of events) {
-    const entry = projectLedgerEvent(event);
-    if (entry === null) {
-      continue;
-    }
-    const existing = grouped.get(entry.id);
-    if (existing === void 0) {
-      grouped.set(entry.id, entry);
-      continue;
-    }
-    grouped.set(entry.id, {
-      ...existing,
-      ts: Math.min(existing.ts, entry.ts),
-      affected_paths: dedupeStrings([...existing.affected_paths, ...entry.affected_paths])
-    });
-  }
-  return Array.from(grouped.values());
-}
-function projectLedgerEvent(event) {
-  if (event.event_type !== "edit_intent_checked") {
-    return null;
-  }
-  const base = {
-    id: event.ledger_entry_id,
-    ts: event.ts,
-    intent: event.intent,
-    affected_paths: [event.path]
-  };
-  if (event.ledger_source === "human") {
-    return {
-      ...base,
-      source: "human",
-      parent_sha: event.parent_sha ?? event.ledger_entry_id,
-      parent_ledger_entry_id: event.parent_ledger_entry_id,
-      diff_stat: event.diff_stat ?? "event-ledger",
-      annotation: event.annotation
-    };
-  }
-  return {
-    ...base,
-    source: "ai",
-    commit_sha: event.commit_sha
-  };
-}
-function mergeLedgerEntries(legacyEntries, eventEntries) {
-  const byId = /* @__PURE__ */ new Map();
-  for (const entry of [...legacyEntries, ...eventEntries]) {
-    if (!byId.has(entry.id)) {
-      byId.set(entry.id, entry);
-    }
-  }
-  return Array.from(byId.values()).sort((left, right) => left.ts - right.ts);
-}
-function dedupeStrings(values) {
-  return Array.from(new Set(values));
-}
-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/api/events.ts
-var AGENTS_META_PATH = ".fabric/agents.meta.json";
-var WATCHED_PATHS = [
-  AGENTS_META_PATH,
-  EVENT_LEDGER_PATH,
-  LEDGER_PATH,
-  LEGACY_LEDGER_PATH
-];
-var CONNECTION_LIMIT = 10;
-var HEARTBEAT_INTERVAL_MS = 3e4;
-var WATCH_DEBOUNCE_MS = 75;
-var RING_BUFFER_CAPACITY = 50;
-var RingBuffer = class {
-  constructor(capacity) {
-    this.capacity = capacity;
-    this.buf = new Array(capacity).fill(void 0);
-  }
-  capacity;
-  buf;
-  head = 0;
-  count = 0;
-  push(event) {
-    this.buf[this.head] = event;
-    this.head = (this.head + 1) % this.capacity;
-    if (this.count < this.capacity) {
-      this.count++;
-    }
-  }
-  replayFrom(afterId) {
-    const result = [];
-    const total = this.count;
-    const start = this.count < this.capacity ? 0 : this.head;
-    for (let i = 0; i < total; i++) {
-      const entry = this.buf[(start + i) % this.capacity];
-      if (entry !== void 0 && entry.id > afterId) {
-        result.push(entry);
-      }
-    }
-    return result;
-  }
-};
-function createEventsHandler(options) {
-  const { projectRoot } = options;
-  const state = {
-    clients: /* @__PURE__ */ new Set(),
-    pendingTimers: /* @__PURE__ */ new Map(),
-    activeLedgerPath: getLedgerPath(projectRoot),
-    ledgerOffset: 0,
-    ledgerRemainder: "",
-    eventLedgerOffset: 0,
-    eventLedgerRemainder: "",
-    nextEventId: 1,
-    ringBuffer: new RingBuffer(RING_BUFFER_CAPACITY)
-  };
-  return async function handleEvents(req, res) {
-    if (state.clients.size >= CONNECTION_LIMIT) {
-      res.statusCode = 503;
-      res.setHeader("Content-Type", "application/json; charset=utf-8");
-      res.end(
-        JSON.stringify({
-          error: {
-            code: "SSE_CONNECTION_LIMIT",
-            message: `Too many SSE clients connected. Limit: ${CONNECTION_LIMIT}.`
-          }
-        })
-      );
-      return;
-    }
-    await ensureWatcher(state, projectRoot);
-    res.statusCode = 200;
-    res.setHeader("Content-Type", "text/event-stream; charset=utf-8");
-    res.setHeader("Cache-Control", "no-cache, no-transform");
-    res.setHeader("Connection", "keep-alive");
-    res.setHeader("X-Accel-Buffering", "no");
-    res.flushHeaders?.();
-    res.write(": connected\n\n");
-    const lastEventId = readLastEventId(req);
-    if (lastEventId !== void 0) {
-      const missed = state.ringBuffer.replayFrom(lastEventId);
-      for (const entry of missed) {
-        if (!res.writableEnded) {
-          res.write(`id: ${entry.id}
-event: ${entry.type}
-data: ${entry.data}
-
-`);
-        }
-      }
-    }
-    state.clients.add(res);
-    const heartbeat = setInterval(() => {
-      if (!res.writableEnded) {
-        res.write(": ping\n\n");
-      }
-    }, HEARTBEAT_INTERVAL_MS);
-    let cleanedUp = false;
-    const cleanup = async () => {
-      if (cleanedUp) {
-        return;
-      }
-      cleanedUp = true;
-      clearInterval(heartbeat);
-      state.clients.delete(res);
-      if (state.clients.size === 0) {
-        await stopWatcher(state);
-      }
-    };
-    req.on("aborted", () => {
-      void cleanup();
-    });
-    req.on("close", () => {
-      void cleanup();
-    });
-    res.on("close", () => {
-      void cleanup();
-    });
-    res.on("error", () => {
-      void cleanup();
-    });
-  };
-}
-async function ensureWatcher(state, projectRoot) {
-  if (state.watcher !== void 0) {
-    return;
-  }
-  const ledgerState = await resolveLedgerWatchState(projectRoot);
-  state.activeLedgerPath = ledgerState.path;
-  state.ledgerOffset = ledgerState.size;
-  state.ledgerRemainder = "";
-  state.eventLedgerOffset = await readFileSize(getEventLedgerPath(projectRoot));
-  state.eventLedgerRemainder = "";
-  const watcher = chokidar.watch([...WATCHED_PATHS], {
-    cwd: projectRoot,
-    ignoreInitial: true,
-    awaitWriteFinish: {
-      stabilityThreshold: 120,
-      pollInterval: 20
-    }
-  });
-  watcher.on("add", (relativePath) => {
-    scheduleFileChange(state, projectRoot, normalizePath(relativePath));
-  });
-  watcher.on("change", (relativePath) => {
-    scheduleFileChange(state, projectRoot, normalizePath(relativePath));
-  });
-  state.watcher = watcher;
-}
-async function stopWatcher(state) {
-  const watcher = state.watcher;
-  if (watcher === void 0) {
-    return;
-  }
-  state.watcher = void 0;
-  for (const timer of state.pendingTimers.values()) {
-    clearTimeout(timer);
-  }
-  state.pendingTimers.clear();
-  await watcher.close();
-}
-function scheduleFileChange(state, projectRoot, relativePath) {
-  if (!WATCHED_PATHS.includes(relativePath)) {
-    return;
-  }
-  const existingTimer = state.pendingTimers.get(relativePath);
-  if (existingTimer !== void 0) {
-    clearTimeout(existingTimer);
-  }
-  const timer = setTimeout(() => {
-    state.pendingTimers.delete(relativePath);
-    void publishFileChange(state, projectRoot, relativePath);
-  }, WATCH_DEBOUNCE_MS);
-  state.pendingTimers.set(relativePath, timer);
-}
-async function publishFileChange(state, projectRoot, relativePath) {
-  const events = await readEventsForFile(state, projectRoot, relativePath);
-  for (const event of events) {
-    broadcastEvent(state, event);
-  }
-}
-async function readEventsForFile(state, projectRoot, relativePath) {
-  if (relativePath === AGENTS_META_PATH) {
-    const event = await readMetaUpdatedEvent(projectRoot);
-    return event === null ? [] : [event];
-  }
-  if (relativePath === EVENT_LEDGER_PATH) {
-    return await readEventLedgerAppendedEvents(state, projectRoot);
-  }
-  if (relativePath === LEDGER_PATH || relativePath === LEGACY_LEDGER_PATH) {
-    return await readLedgerAppendedEvents(state, projectRoot);
-  }
-  return [];
-}
-async function readMetaUpdatedEvent(projectRoot) {
-  const filePath = join(projectRoot, AGENTS_META_PATH);
-  const raw = await readUtf8File(filePath);
-  if (raw === null) {
-    return null;
-  }
-  const parsed = agentsMetaSchema.parse(JSON.parse(raw));
-  return {
-    type: "meta:updated",
-    payload: parsed
-  };
-}
-async function readLedgerAppendedEvents(state, projectRoot) {
-  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 = "";
-  }
-  if (nextSize === state.ledgerOffset) {
-    return [];
-  }
-  const startOffset = state.ledgerOffset;
-  state.ledgerOffset = nextSize;
-  const handle = await open(ledgerPath, "r");
-  try {
-    const length = nextSize - startOffset;
-    const buffer = Buffer.alloc(length);
-    await handle.read(buffer, 0, length, startOffset);
-    const chunk = `${state.ledgerRemainder}${buffer.toString("utf8")}`;
-    const lines = chunk.split(/\r?\n/);
-    state.ledgerRemainder = chunk.endsWith("\n") ? "" : lines.pop() ?? "";
-    return lines.map((line) => line.trim()).filter((line) => line.length > 0).map(parseLedgerAppendedEvent).filter((event) => event !== null);
-  } finally {
-    await handle.close();
-  }
-}
-async function readEventLedgerAppendedEvents(state, projectRoot) {
-  const eventLedgerPath = getEventLedgerPath(projectRoot);
-  const nextSize = await readFileSize(eventLedgerPath);
-  if (nextSize < state.eventLedgerOffset) {
-    state.eventLedgerOffset = 0;
-    state.eventLedgerRemainder = "";
-  }
-  if (nextSize === state.eventLedgerOffset) {
-    return [];
-  }
-  const startOffset = state.eventLedgerOffset;
-  state.eventLedgerOffset = nextSize;
-  const handle = await open(eventLedgerPath, "r");
-  try {
-    const length = nextSize - startOffset;
-    const buffer = Buffer.alloc(length);
-    await handle.read(buffer, 0, length, startOffset);
-    const chunk = `${state.eventLedgerRemainder}${buffer.toString("utf8")}`;
-    const lines = chunk.split(/\r?\n/);
-    state.eventLedgerRemainder = chunk.endsWith("\n") ? "" : lines.pop() ?? "";
-    return lines.map((line) => line.trim()).filter((line) => line.length > 0).map(parseEventLedgerAppendedEvent).filter((event) => event !== null);
-  } finally {
-    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);
-    if (parsed.kind === "mcp-event") {
-      return null;
-    }
-    const validation = ledgerEntrySchema2.safeParse(parsed);
-    if (!validation.success) {
-      return null;
-    }
-    return {
-      type: "ledger:appended",
-      payload: validation.data
-    };
-  } catch {
-    return null;
-  }
-}
-function parseEventLedgerAppendedEvent(line) {
-  try {
-    const parsed = eventLedgerEventSchema.safeParse(JSON.parse(line));
-    if (!parsed.success || parsed.data.event_type !== "edit_intent_checked") {
-      return null;
-    }
-    return {
-      type: "ledger:appended",
-      payload: {
-        id: parsed.data.ledger_entry_id,
-        ts: parsed.data.ts,
-        source: "ai",
-        intent: parsed.data.intent,
-        affected_paths: [parsed.data.path]
-      }
-    };
-  } catch {
-    return null;
-  }
-}
-function broadcastEvent(state, event) {
-  const payload = fabricEventSchema.parse(event);
-  const eventId = state.nextEventId++;
-  const data = JSON.stringify(payload);
-  const frame = `id: ${eventId}
-event: ${payload.type}
-data: ${data}
-
-`;
-  state.ringBuffer.push({ id: eventId, type: payload.type, data });
-  const disconnectedClients = [];
-  for (const client of state.clients) {
-    try {
-      if (client.writableEnded) {
-        disconnectedClients.push(client);
-        continue;
-      }
-      client.write(frame);
-    } catch {
-      disconnectedClients.push(client);
-    }
-  }
-  for (const client of disconnectedClients) {
-    state.clients.delete(client);
-    if (!client.writableEnded) {
-      client.end();
-    }
-  }
-}
-function readLastEventId(req) {
-  const header = req.headers["last-event-id"];
-  const headerValue = Array.isArray(header) ? header[0] : header;
-  const rawUrl = req.url ?? "";
-  const queryStart = rawUrl.indexOf("?");
-  const queryString = queryStart >= 0 ? rawUrl.slice(queryStart + 1) : "";
-  const params = new URLSearchParams(queryString);
-  const queryValue = params.get("lastEventId") ?? void 0;
-  const raw = headerValue ?? queryValue;
-  if (raw === void 0 || raw.length === 0) {
-    return void 0;
-  }
-  const parsed = Number.parseInt(raw, 10);
-  return Number.isFinite(parsed) && parsed >= 0 ? parsed : void 0;
-}
-function normalizePath(value) {
-  return value.replaceAll("\\", "/");
-}
-async function readUtf8File(path) {
-  try {
-    return await readFile2(path, "utf8");
-  } catch (error) {
-    if (isNodeError2(error) && error.code === "ENOENT") {
-      return null;
-    }
-    throw error;
-  }
-}
-async function readFileSize(path) {
-  try {
-    const fileStat = await stat(path);
-    return fileStat.size;
-  } catch (error) {
-    if (isNodeError2(error) && error.code === "ENOENT") {
-      return 0;
-    }
-    throw error;
-  }
-}
-function isNodeError2(error) {
-  return error instanceof Error;
-}
-
-// src/api/history.ts
-import { historyStateQuerySchema } from "@fenglimg/fabric-shared";
-
-// src/services/rehydrate-state.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-import { agentsMetaSchema as agentsMetaSchema2 } from "@fenglimg/fabric-shared";
-import { IOFabricError, RuleError } from "@fenglimg/fabric-shared/errors";
-var execFileAsync = promisify(execFile);
-var AGENTS_META_GIT_PATH = ".fabric/agents.meta.json";
-var HistoryStateNotFoundError = class extends IOFabricError {
-  code = "HISTORY_STATE_NOT_FOUND";
-  httpStatus = 404;
-  constructor(message, opts) {
-    super(message, {
-      actionHint: opts?.actionHint ?? "Ensure the ledger exists and the requested timestamp or entry ID is within its range"
-    });
-  }
-};
-var LedgerEntryNotFoundError = class extends RuleError {
-  code = "LEDGER_ENTRY_NOT_FOUND";
-  httpStatus = 404;
-  constructor(message, opts) {
-    super(message, {
-      actionHint: opts?.actionHint ?? "Verify the ledger entry ID exists in the current ledger"
-    });
-  }
-};
-async function rehydrateAgentsMetaAt(projectRoot, target) {
-  const ledger = await readLedger(projectRoot);
-  const selectedIndex = resolveTargetIndex(ledger, target);
-  const replayedEntries = ledger.slice(0, selectedIndex + 1);
-  const selectedEntry = replayedEntries.at(-1);
-  if (selectedEntry === void 0) {
-    throw new HistoryStateNotFoundError(
-      "Cannot rehydrate history state because the ledger is empty."
-    );
-  }
-  const commitCandidates = collectCommitCandidates(replayedEntries);
-  for (const commit of commitCandidates) {
-    const meta = await tryReadAgentsMetaFromGit(projectRoot, commit);
-    if (meta !== null) {
-      return {
-        meta,
-        metadata: {
-          at_ledger_id: selectedEntry.id,
-          at_commit: commit,
-          replayed_count: replayedEntries.length,
-          mode: "git-show"
-        },
-        entries: replayedEntries
-      };
-    }
-  }
-  const fallbackMeta = buildLedgerFallbackMeta(replayedEntries);
-  return {
-    meta: fallbackMeta,
-    metadata: {
-      at_ledger_id: selectedEntry.id,
-      at_commit: commitCandidates[0] ?? null,
-      replayed_count: replayedEntries.length,
-      mode: "ledger-fallback"
-    },
-    entries: replayedEntries
-  };
-}
-function resolveTargetIndex(ledger, target) {
-  if ("ledgerEntryId" in target) {
-    const index = ledger.findIndex((entry) => entry.id === target.ledgerEntryId);
-    if (index === -1) {
-      throw new LedgerEntryNotFoundError(
-        `Cannot find ledger entry: ${target.ledgerEntryId}`
-      );
-    }
-    return index;
-  }
-  for (let index = ledger.length - 1; index >= 0; index -= 1) {
-    if (ledger[index]?.ts <= target.timestamp) {
-      return index;
-    }
-  }
-  throw new HistoryStateNotFoundError(
-    `Cannot find ledger entry at or before timestamp: ${new Date(target.timestamp).toISOString()}`
-  );
-}
-function collectCommitCandidates(entries) {
-  const commits = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (let index = entries.length - 1; index >= 0; index -= 1) {
-    const entry = entries[index];
-    const commit = entry.source === "ai" ? entry.commit_sha : entry.parent_sha;
-    if (typeof commit !== "string" || commit.length === 0 || commit === "root" || seen.has(commit)) {
-      continue;
-    }
-    seen.add(commit);
-    commits.push(commit);
-  }
-  return commits;
-}
-async function tryReadAgentsMetaFromGit(projectRoot, commit) {
-  try {
-    const { stdout } = await execFileAsync(
-      "git",
-      ["show", `${commit}:${AGENTS_META_GIT_PATH}`],
-      {
-        cwd: projectRoot,
-        encoding: "utf8",
-        maxBuffer: 1024 * 1024
-      }
-    );
-    return agentsMetaSchema2.parse(JSON.parse(stdout));
-  } catch (error) {
-    if (isRecoverableGitError(error)) {
-      return null;
-    }
-    throw error;
-  }
-}
-function buildLedgerFallbackMeta(entries) {
-  const nodes = entries.reduce((current, entry) => {
-    const hashBase = entry.source === "ai" ? entry.commit_sha ?? entry.id : entry.parent_sha;
-    for (const affectedPath of entry.affected_paths) {
-      current[affectedPath] = {
-        file: affectedPath,
-        scope_glob: affectedPath,
-        deps: [],
-        priority: "medium",
-        // v2.0.0-rc.30 TASK-004: dropped `layer: "L2"` — use `level` only;
-        // AgentsMetaNode no longer carries `layer`.
-        level: "L2",
-        topology_type: "mirror",
-        hash: `replayed:${hashBase ?? entry.id}`
-      };
-    }
-    return current;
-  }, {});
-  const lastEntry = entries.at(-1);
-  return {
-    revision: lastEntry?.source === "ai" ? lastEntry.commit_sha ?? `replayed:${lastEntry.id ?? entries.length}` : `replayed:${lastEntry?.id ?? entries.length}`,
-    nodes
-  };
-}
-function isRecoverableGitError(error) {
-  if (!(error instanceof Error)) {
-    return false;
-  }
-  const nodeError = error;
-  return nodeError.code === "ENOENT" || typeof nodeError.stderr === "string";
-}
-
-// src/api/history.ts
-function registerHistoryApi(app, projectRoot) {
-  app.get("/api/history/state", async (req, res) => {
-    const validation = historyStateQuerySchema.safeParse({
-      ledger_id: req.query.ledger_id,
-      ts: req.query.at ?? req.query.ts
-    });
-    if (!validation.success) {
-      sendValidationError(res, "Invalid history replay query parameters", validation.error.flatten());
-      return;
-    }
-    try {
-      const result = "ledger_id" in validation.data && validation.data.ledger_id !== void 0 ? await rehydrateAgentsMetaAt(projectRoot, { ledgerEntryId: validation.data.ledger_id }) : await rehydrateAgentsMetaAt(projectRoot, { timestamp: validation.data.ts });
-      res.json(result);
-    } catch (error) {
-      sendUnknownError(res, error);
-    }
-  });
-  app.get("/api/replay", async (req, res) => {
-    const validation = historyStateQuerySchema.safeParse({
-      ledger_id: req.query.ledger_id,
-      ts: req.query.at ?? req.query.ts
-    });
-    if (!validation.success) {
-      sendValidationError(res, "Invalid history replay query parameters", validation.error.flatten());
-      return;
-    }
-    try {
-      const result = "ledger_id" in validation.data && validation.data.ledger_id !== void 0 ? await rehydrateAgentsMetaAt(projectRoot, { ledgerEntryId: validation.data.ledger_id }) : await rehydrateAgentsMetaAt(projectRoot, { timestamp: validation.data.ts });
-      res.json(result);
-    } catch (error) {
-      sendUnknownError(res, error);
-    }
-  });
-}
-
-// src/api/ledger.ts
-import { ledgerQuerySchema } from "@fenglimg/fabric-shared";
-function registerLedgerApi(app, projectRoot) {
-  app.get("/api/ledger", async (req, res) => {
-    const validation = ledgerQuerySchema.safeParse({
-      source: req.query.source,
-      since: req.query.since
-    });
-    if (!validation.success) {
-      sendValidationError(res, "Invalid ledger query parameters", validation.error.flatten());
-      return;
-    }
-    try {
-      await readAgentsMeta(projectRoot);
-      res.json(await readLedger(projectRoot, validation.data));
-    } catch (error) {
-      sendUnknownError(res, error);
-    }
-  });
-}
-
-// src/api/knowledge.ts
-function registerKnowledgeApi(app, projectRoot) {
-  app.get("/api/rules", async (_req, res) => {
-    try {
-      res.json(await readAgentsMeta(projectRoot));
-    } catch (error) {
-      sendUnknownError(res, error);
-    }
-  });
-}
-
-// src/api/knowledge-context.ts
-function registerKnowledgeContextApi(app, projectRoot) {
-  app.get("/api/rules/context", async (req, res) => {
-    const path = typeof req.query.path === "string" ? req.query.path.trim() : "";
-    if (path.length === 0) {
-      sendValidationError(res, "Missing required query parameter: path", {
-        fieldErrors: {
-          path: ["Expected a non-empty path query parameter."]
-        }
-      });
-      return;
-    }
-    try {
-      const result = await getKnowledge(projectRoot, { path });
-      res.json(result.rules);
-    } catch (error) {
-      sendUnknownError(res, error);
-    }
-  });
-}
-
-// src/api/scan.ts
-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/**",
-  "temp/**",
-  "build/**",
-  "settings/**",
-  "profiles/**",
-  "node_modules/**",
-  "dist/**",
-  ".git/**",
-  ".fabric/**"
-];
-function registerScanApi(app, projectRoot) {
-  app.get("/api/scan", async (_req, res) => {
-    try {
-      res.json(await createScanReport(projectRoot));
-    } catch (error) {
-      sendUnknownError(res, error);
-    }
-  });
-}
-async function createScanReport(targetInput = process.cwd()) {
-  const target = normalizeTarget(targetInput);
-  const framework = detectFramework(target);
-  const readmeQuality = getReadmeQuality(target);
-  const hasContributing = existsSync(join2(target, "CONTRIBUTING.md"));
-  const hasExistingFabric = existsSync(join2(target, ".fabric"));
-  const walkResult = walkFiles(target, DEFAULT_IGNORES);
-  return {
-    target,
-    framework,
-    readmeQuality,
-    hasContributing,
-    fileCount: walkResult.fileCount,
-    ignoredCount: walkResult.ignoredCount,
-    hasExistingFabric,
-    recommendations: buildRecommendations({
-      framework,
-      readmeQuality,
-      hasContributing,
-      hasExistingFabric
-    })
-  };
-}
-function normalizeTarget(targetInput) {
-  return isAbsolute(targetInput) ? targetInput : resolve(process.cwd(), targetInput);
-}
-function getReadmeQuality(target) {
-  const readmePath = join2(target, "README.md");
-  if (!existsSync(readmePath)) {
-    return "stub";
-  }
-  const wordCount = readFileSync(readmePath, "utf8").trim().split(/\s+/).filter(Boolean).length;
-  return wordCount >= 200 ? "ok" : "stub";
-}
-function walkFiles(root, ignorePatterns) {
-  if (!existsSync(root) || !statSync(root).isDirectory()) {
-    throw new Error(`Target must be an existing directory: ${root}`);
-  }
-  let fileCount = 0;
-  let ignoredCount = 0;
-  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 = join2(current, entry.name);
-      const relativePath = toPosixPath(relative(root, absolutePath));
-      if (shouldIgnore(relativePath, entry.isDirectory(), ignorePatterns)) {
-        ignoredCount += 1;
-        continue;
-      }
-      if (entry.isDirectory()) {
-        stack.push(absolutePath);
-      } else if (entry.isFile()) {
-        fileCount += 1;
-      }
-    }
-  }
-  return { fileCount, ignoredCount };
-}
-function shouldIgnore(relativePath, isDirectory, ignorePatterns) {
-  return ignorePatterns.some((pattern) => matchesIgnorePattern(relativePath, isDirectory, pattern));
-}
-function matchesIgnorePattern(relativePath, isDirectory, pattern) {
-  const normalizedPattern = toPosixPath(pattern);
-  if (normalizedPattern === "**/*.meta") {
-    return relativePath.endsWith(".meta");
-  }
-  if (normalizedPattern.endsWith("/**")) {
-    const directoryPrefix = normalizedPattern.slice(0, -3);
-    return relativePath === directoryPrefix || relativePath.startsWith(`${directoryPrefix}/`) || isDirectory && `${relativePath}/` === directoryPrefix;
-  }
-  return relativePath === normalizedPattern;
-}
-function toPosixPath(path) {
-  return path.split(sep).join("/");
-}
-function buildRecommendations(input) {
-  const recommendations = [];
-  if (!input.hasExistingFabric) {
-    recommendations.push("L0: Run `fabric install` to scaffold the .fabric/ knowledge layout (decisions, pitfalls, guidelines, models, processes).");
-  }
-  if (input.readmeQuality === "stub") {
-    recommendations.push("L0: Expand README.md before promoting project facts into Fabric knowledge entries.");
-  }
-  if (!input.hasContributing) {
-    recommendations.push("L0: Add CONTRIBUTING.md or capture contribution-flow guidance under .fabric/knowledge/processes/.");
-  }
-  if (input.framework.kind === "unknown") {
-    recommendations.push("L1: Add tech-stack TODOs manually because no framework marker was detected.");
-  } else {
-    recommendations.push(`L1: Review ${input.framework.kind} directories for future scoped Fabric rule files.`);
-  }
-  return recommendations;
-}
-
-// src/middleware/bearer-auth.ts
-import { createHash, timingSafeEqual } from "crypto";
-function createBearerAuthMiddleware(token) {
-  const expectedDigest = hashToken(token);
-  return function bearerAuthMiddleware(req, res, next) {
-    const header = readAuthorizationHeader(req.headers.authorization);
-    const providedToken = parseBearerToken(header);
-    if (providedToken === void 0 || !tokensMatch(providedToken, expectedDigest)) {
-      sendError(res, 401, "UNAUTHORIZED", "Bearer token required");
-      return;
-    }
-    next();
-  };
-}
-function createLoopbackDenyMiddleware() {
-  return function loopbackDenyMiddleware(_req, res, _next) {
-    sendError(
-      res,
-      401,
-      "UNAUTHORIZED",
-      "FABRIC_AUTH_TOKEN is not set. Either export FABRIC_AUTH_TOKEN=<secret> before running `fabric serve`, or pass `--allow-loopback-no-auth` to explicitly opt in to unauthenticated loopback access (security risk)."
-    );
-  };
-}
-function readAuthorizationHeader(value) {
-  if (typeof value === "string" && value.length > 0) {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.find((entry) => entry.length > 0);
-  }
-  return void 0;
-}
-function parseBearerToken(header) {
-  if (header === void 0) {
-    return void 0;
-  }
-  const match = /^Bearer\s+(.+)$/i.exec(header);
-  return match?.[1];
-}
-function tokensMatch(token, expectedDigest) {
-  return timingSafeEqual(hashToken(token), expectedDigest);
-}
-function hashToken(token) {
-  return createHash("sha256").update(token, "utf8").digest();
-}
-
-// src/http.ts
-var DEFAULT_HOST = "127.0.0.1";
-var NOTIFY_DEBOUNCE_MS = 200;
-var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "::1"]);
-function isLoopbackHost(host) {
-  return LOOPBACK_HOSTS.has(host);
-}
-var JsonlEventStore = class {
-  constructor(projectRoot) {
-    this.projectRoot = projectRoot;
-  }
-  projectRoot;
-  async storeEvent(streamId, message) {
-    const eventId = randomUUID2();
-    await appendEventLedgerEvent(this.projectRoot, {
-      event_type: "mcp_event",
-      mcp_event_id: eventId,
-      stream_id: streamId,
-      message
-    });
-    return eventId;
-  }
-  async getStreamIdForEventId(eventId) {
-    const events = await this.readEvents();
-    return events.find((event) => event.eventId === eventId)?.streamId;
-  }
-  async replayEventsAfter(lastEventId, { send }) {
-    const events = await this.readEvents();
-    const startIndex = events.findIndex((event) => event.eventId === lastEventId);
-    if (startIndex === -1) {
-      throw new Error(`Unknown event ID: ${lastEventId}`);
-    }
-    const streamId = events[startIndex]?.streamId;
-    if (streamId === void 0) {
-      throw new Error(`Missing stream for event ID: ${lastEventId}`);
-    }
-    for (const event of events.slice(startIndex + 1)) {
-      if (event.streamId !== streamId) {
-        continue;
-      }
-      await send(event.eventId, event.message);
-    }
-    return streamId;
-  }
-  async readEvents() {
-    const { events: eventLedgerEvents } = await readEventLedger(this.projectRoot);
-    const projectedEvents = eventLedgerEvents.flatMap((event) => {
-      if (event.event_type !== "mcp_event") {
-        return [];
-      }
-      return [{
-        kind: "mcp-event",
-        eventId: event.mcp_event_id,
-        streamId: event.stream_id,
-        message: event.message
-      }];
-    });
-    if (projectedEvents.length > 0) {
-      return projectedEvents;
-    }
-    let raw;
-    try {
-      raw = await readFile3(getLedgerPath(this.projectRoot), "utf8");
-    } catch (error) {
-      if (isNodeError3(error) && error.code === "ENOENT") {
-        try {
-          raw = await readFile3(getLegacyLedgerPath(this.projectRoot), "utf8");
-        } catch (legacyError) {
-          if (isNodeError3(legacyError) && legacyError.code === "ENOENT") {
-            return [];
-          }
-          throw legacyError;
-        }
-      } else {
-        throw error;
-      }
-    }
-    return raw.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => parseStoredMcpEvent(line)).filter((event) => event !== null);
-  }
-};
-function handleCacheWatcherEvent(relativePath, projectRoot, sessions, timers) {
-  const normalized = relativePath.replaceAll("\\", "/");
-  if (normalized === ".fabric/agents.meta.json") {
-    contextCache.invalidate("file_watch", projectRoot);
-    clearTimeout(timers.getToolListTimer());
-    timers.setToolListTimer(
-      setTimeout(() => {
-        notifyAllSessions(sessions, "tools/list_changed");
-      }, NOTIFY_DEBOUNCE_MS)
-    );
-    return;
-  }
-  if (normalized.startsWith(".fabric/knowledge/") && normalized.endsWith(".md")) {
-    contextCache.invalidate("file_watch", projectRoot);
-    invalidateKnowledgeSyncCooldown(projectRoot);
-  }
-}
-function createFabricHttpApp(options) {
-  const { projectRoot, host = DEFAULT_HOST, authToken, allowLoopbackNoAuth = false } = options;
-  if (allowLoopbackNoAuth && authToken === void 0 && !isLoopbackHost(host)) {
-    throw new Error(
-      `createFabricHttpApp: allowLoopbackNoAuth=true requires a loopback host (127.0.0.1 / localhost / ::1); got ${JSON.stringify(host)}. Either bind to loopback or set FABRIC_AUTH_TOKEN.`
-    );
-  }
-  const app = createMcpExpressApp({ host });
-  const eventStore = new JsonlEventStore(projectRoot);
-  const sessions = /* @__PURE__ */ new Map();
-  process.env.FABRIC_PROJECT_ROOT = projectRoot;
-  const cacheWatcher = chokidar2.watch(
-    [
-      ".fabric/agents.meta.json",
-      ".fabric/knowledge/**/*.md",
-      ".fabric/knowledge/pending/**/*.md"
-    ],
-    {
-      cwd: projectRoot,
-      ignoreInitial: true,
-      awaitWriteFinish: {
-        stabilityThreshold: 120,
-        pollInterval: 20
-      }
-    }
-  );
-  let agentsMdNotifyTimer;
-  let toolListNotifyTimer;
-  const onCacheWatcherEvent = (relativePath) => {
-    handleCacheWatcherEvent(relativePath, projectRoot, sessions, {
-      getAgentsMdTimer: () => agentsMdNotifyTimer,
-      getToolListTimer: () => toolListNotifyTimer,
-      setAgentsMdTimer: (t) => {
-        agentsMdNotifyTimer = t;
-      },
-      setToolListTimer: (t) => {
-        toolListNotifyTimer = t;
-      }
-    });
-  };
-  cacheWatcher.on("change", onCacheWatcherEvent);
-  cacheWatcher.on("add", onCacheWatcherEvent);
-  cacheWatcher.on("unlink", onCacheWatcherEvent);
-  let disposed = false;
-  app.dispose = async () => {
-    if (disposed) {
-      return;
-    }
-    disposed = true;
-    clearTimeout(agentsMdNotifyTimer);
-    clearTimeout(toolListNotifyTimer);
-    await cacheWatcher.close();
-  };
-  app.disable("x-powered-by");
-  if (authToken !== void 0) {
-    const bearerAuth = createBearerAuthMiddleware(authToken);
-    app.use("/api", bearerAuth);
-    app.use("/events", bearerAuth);
-    app.use("/mcp", bearerAuth);
-  } else if (!allowLoopbackNoAuth) {
-    const denyAll = createLoopbackDenyMiddleware();
-    app.use("/api", denyAll);
-    app.use("/events", denyAll);
-    app.use("/mcp", denyAll);
-  }
-  registerKnowledgeApi(app, projectRoot);
-  registerKnowledgeContextApi(app, projectRoot);
-  registerLedgerApi(app, projectRoot);
-  registerHistoryApi(app, projectRoot);
-  registerScanApi(app, projectRoot);
-  registerDoctorApi(app, projectRoot);
-  app.get("/events", createEventsHandler({ projectRoot }));
-  app.all("/mcp", async (req, res) => {
-    const sessionId = readHeader(req.headers["mcp-session-id"]);
-    if (sessionId !== void 0) {
-      const session2 = sessions.get(sessionId);
-      if (session2 === void 0) {
-        writeJsonRpcError(res, 404, -32001, "Session not found");
-        return;
-      }
-      await session2.transport.handleRequest(req, res, req.body);
-      return;
-    }
-    if (!isInitializeRequest(req.body)) {
-      writeJsonRpcError(res, 400, -32e3, "Bad Request: Mcp-Session-Id header is required");
-      return;
-    }
-    const session = await createSession(eventStore, sessions);
-    await session.transport.handleRequest(req, res, req.body);
-  });
-  return app;
-}
-function notifyAllSessions(sessions, kind, uri) {
-  for (const { server } of sessions.values()) {
-    try {
-      if (kind === "tools/list_changed") {
-        server.sendToolListChanged();
-      } else if (kind === "resources/list_changed") {
-        server.sendResourceListChanged();
-      } else if (kind === "resource_updated" && uri !== void 0) {
-        void server.server.sendResourceUpdated({ uri });
-      }
-    } catch {
-    }
-  }
-}
-async function createSession(eventStore, sessions) {
-  const { createFabricServer } = await import("./index.js");
-  const server = createFabricServer();
-  const transport = new StreamableHTTPServerTransport({
-    sessionIdGenerator: randomUUID2,
-    enableJsonResponse: true,
-    eventStore,
-    onsessioninitialized: async (sessionId) => {
-      sessions.set(sessionId, { server, transport });
-    },
-    onsessionclosed: async (sessionId) => {
-      sessions.delete(sessionId);
-    }
-  });
-  transport.onclose = () => {
-    const sessionId = transport.sessionId;
-    if (sessionId !== void 0) {
-      sessions.delete(sessionId);
-    }
-  };
-  await server.connect(transport);
-  return { server, transport };
-}
-function isInitializeRequest(body) {
-  if (Array.isArray(body)) {
-    return body.some((entry) => isInitializeMessage(entry));
-  }
-  return isInitializeMessage(body);
-}
-function isInitializeMessage(value) {
-  return value !== null && typeof value === "object" && "jsonrpc" in value && "method" in value && value.jsonrpc === "2.0" && value.method === "initialize";
-}
-function parseStoredMcpEvent(line) {
-  try {
-    const parsed = JSON.parse(line);
-    if (parsed.kind !== "mcp-event" || typeof parsed.eventId !== "string" || typeof parsed.streamId !== "string" || parsed.message === void 0) {
-      return null;
-    }
-    return {
-      kind: "mcp-event",
-      eventId: parsed.eventId,
-      streamId: parsed.streamId,
-      message: parsed.message
-    };
-  } catch {
-    return null;
-  }
-}
-function readHeader(value) {
-  if (typeof value === "string" && value.length > 0) {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.find((entry) => entry.length > 0);
-  }
-  return void 0;
-}
-function writeJsonRpcError(res, status, code, message) {
-  res.status(status).json({
-    jsonrpc: "2.0",
-    error: {
-      code,
-      message
-    },
-    id: null
-  });
-}
-function isNodeError3(error) {
-  return error instanceof Error;
-}
-export {
-  createFabricHttpApp,
-  handleCacheWatcherEvent
-};