@fenglimg/fabric-server 2.0.0-rc.23 → 2.0.0-rc.25

package/dist/{chunk-IRB77C6E.js → chunk-HAXROPQM.js}

@@ -428,6 +428,27 @@ import {
   parseKnowledgeId
 } from "@fenglimg/fabric-shared";
 import { atomicWriteText as atomicWriteText3 } from "@fenglimg/fabric-shared/node/atomic-write";
+async function loadKbIdTypeMap(projectRootInput) {
+  const projectRoot = normalizeProjectRoot(projectRootInput);
+  const metaPath = join4(projectRoot, ".fabric", "agents.meta.json");
+  const meta = await readExistingMeta(metaPath);
+  const map = /* @__PURE__ */ new Map();
+  if (meta === void 0) {
+    return map;
+  }
+  for (const node of Object.values(meta.nodes)) {
+    const stableId = node.stable_id;
+    if (stableId === void 0 || !isKnowledgeStableId(stableId)) {
+      continue;
+    }
+    const knowledgeType = node.description?.knowledge_type;
+    if (knowledgeType === void 0) {
+      continue;
+    }
+    map.set(stableId, knowledgeType);
+  }
+  return map;
+}
 async function buildKnowledgeMeta(projectRootInput) {
   const projectRoot = normalizeProjectRoot(projectRootInput);
   assertExistingDirectory(projectRoot);
@@ -4963,6 +4984,40 @@ async function ensureCitePolicyActivatedMarker(projectRoot) {
     return { marker_ts: 0, emitted_now: false };
   }
 }
+async function ensureCiteContractPolicyActivatedMarker(projectRoot) {
+  let driftStatus;
+  try {
+    const inspection = await inspectL1BootstrapSnapshotDrift(projectRoot);
+    driftStatus = inspection.status;
+  } catch {
+    driftStatus = "drift";
+  }
+  if (driftStatus !== "ok") {
+    return { marker_ts: 0, emitted_now: false, blocked_by: "bootstrap_drift" };
+  }
+  let existing;
+  try {
+    const { events } = await readEventLedger(projectRoot, {
+      event_type: "cite_contract_policy_activated"
+    });
+    if (events.length > 0) {
+      existing = events[0];
+    }
+  } catch {
+    return { marker_ts: 0, emitted_now: false, blocked_by: null };
+  }
+  if (existing !== void 0) {
+    return { marker_ts: existing.ts, emitted_now: false, blocked_by: null };
+  }
+  try {
+    const stored = await appendEventLedgerEvent(projectRoot, {
+      event_type: "cite_contract_policy_activated"
+    });
+    return { marker_ts: stored.ts, emitted_now: true, blocked_by: null };
+  } catch {
+    return { marker_ts: 0, emitted_now: false, blocked_by: null };
+  }
+}
 function parseNoneSentinel(kbLineRaw) {
   if (typeof kbLineRaw !== "string" || kbLineRaw.length === 0) return "unspecified";
   const m = kbLineRaw.match(/^KB:\s*none\b\s*(?:\[([^\]]*)\])?\s*$/i);
@@ -5000,7 +5055,10 @@ function matchesRelevancePath(editPath, relevancePaths) {
   return false;
 }
 async function runDoctorCiteCoverage(projectRoot, options) {
+  const layerFilter = options.layer ?? "all";
   const marker = await ensureCitePolicyActivatedMarker(projectRoot);
+  const contractMarker = await ensureCiteContractPolicyActivatedMarker(projectRoot);
+  const idTypeMap = await loadKbIdTypeMap(projectRoot);
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const zeroMetrics = {
     edits_touched: 0,
@@ -5009,6 +5067,20 @@ async function runDoctorCiteCoverage(projectRoot, options) {
     expected_but_missed: 0,
     total_turns: 0
   };
+  const contractStatus = contractMarker.blocked_by === "bootstrap_drift" ? "skipped:bootstrap_drift" : contractMarker.marker_ts === 0 ? "awaiting_marker" : "ok";
+  const zeroContractMetrics = {
+    decisions_cited: 0,
+    pitfalls_cited: 0,
+    contract_with: 0,
+    contract_missing: 0,
+    hard_violated: 0,
+    cite_id_unresolved: 0,
+    skip_count: {}
+  };
+  const zeroLayerType = {
+    team: {},
+    personal: {}
+  };
   if (marker.marker_ts === 0) {
     return {
       status: "skipped",
@@ -5016,11 +5088,17 @@ async function runDoctorCiteCoverage(projectRoot, options) {
       marker_emitted_now: false,
       since_ts: options.since,
       client_filter: options.client,
+      layer_filter: layerFilter,
       metrics: zeroMetrics,
+      contract_metrics_status: contractStatus,
+      contract_metrics: zeroContractMetrics,
+      per_layer_type: zeroLayerType,
+      contract_marker_ts: contractMarker.marker_ts,
       generated_at: generatedAt
     };
   }
   const effectiveSince = Math.max(marker.marker_ts, options.since);
+  const contractEffectiveSince = contractStatus === "ok" ? Math.max(contractMarker.marker_ts, options.since) : Number.POSITIVE_INFINITY;
   let ledgerEvents = [];
   try {
     const result = await readEventLedger(projectRoot, { since: effectiveSince });
@@ -5032,7 +5110,12 @@ async function runDoctorCiteCoverage(projectRoot, options) {
       marker_emitted_now: marker.emitted_now,
       since_ts: effectiveSince,
       client_filter: options.client,
+      layer_filter: layerFilter,
       metrics: zeroMetrics,
+      contract_metrics_status: contractStatus,
+      contract_metrics: zeroContractMetrics,
+      per_layer_type: zeroLayerType,
+      contract_marker_ts: contractMarker.marker_ts,
       generated_at: generatedAt
     };
   }
@@ -5125,6 +5208,80 @@ async function runDoctorCiteCoverage(projectRoot, options) {
     perClientAccum.set(client, existing);
   };
   const sessionCitedKbs = /* @__PURE__ */ new Map();
+  const sessionEditPaths = /* @__PURE__ */ new Map();
+  for (const edit of editEvents) {
+    const sid = edit.session_id;
+    if (typeof sid !== "string" || sid.length === 0) continue;
+    const list = sessionEditPaths.get(sid) ?? [];
+    list.push(normalizePath(edit.path));
+    sessionEditPaths.set(sid, list);
+  }
+  let decisionsCited = 0;
+  let pitfallsCited = 0;
+  let contractWith = 0;
+  let contractMissing = 0;
+  let hardViolated = 0;
+  let citeIdUnresolved = 0;
+  const skipCount = {};
+  const layerTypeAccum = { team: {}, personal: {} };
+  const bumpLayerType = (citeId, type) => {
+    const layer = citeId.startsWith("KP-") ? "personal" : citeId.startsWith("KT-") ? "team" : null;
+    if (layer === null) return;
+    layerTypeAccum[layer][type] = (layerTypeAccum[layer][type] ?? 0) + 1;
+  };
+  const passesLayerFilter = (citeId) => {
+    if (layerFilter === "all") return true;
+    if (layerFilter === "team") return citeId.startsWith("KT-");
+    return citeId.startsWith("KP-");
+  };
+  const evaluateOperatorViolation = (sessionId, operators) => {
+    const editPaths = typeof sessionId === "string" && sessionId.length > 0 ? sessionEditPaths.get(sessionId) ?? [] : [];
+    for (const op of operators) {
+      switch (op.kind) {
+        case "edit": {
+          let matched = false;
+          for (const p of editPaths) {
+            if (minimatch(p, op.target, { dot: true, matchBase: false })) {
+              matched = true;
+              break;
+            }
+          }
+          if (!matched) return true;
+          break;
+        }
+        case "not_edit": {
+          for (const p of editPaths) {
+            if (minimatch(p, op.target, { dot: true, matchBase: false })) {
+              return true;
+            }
+          }
+          break;
+        }
+        case "require": {
+          let found = false;
+          for (const p of editPaths) {
+            if (p.includes(op.target)) {
+              found = true;
+              break;
+            }
+          }
+          if (!found) return true;
+          break;
+        }
+        case "forbid": {
+          for (const p of editPaths) {
+            if (p.includes(op.target)) {
+              return true;
+            }
+          }
+          break;
+        }
+        default:
+          break;
+      }
+    }
+    return false;
+  };
   let totalTurns = 0;
   let qualifyingCites = 0;
   let recalledUnverified = 0;
@@ -5174,6 +5331,40 @@ async function runDoctorCiteCoverage(projectRoot, options) {
         m.recalled_unverified += 1;
       });
     }
+    if (contractStatus === "ok" && turn.ts >= contractEffectiveSince) {
+      const commitments = turn.cite_commitments ?? [];
+      for (let i = 0; i < turn.cite_ids.length; i += 1) {
+        const citeId = turn.cite_ids[i];
+        if (typeof citeId !== "string" || citeId.length === 0) continue;
+        if (!passesLayerFilter(citeId)) continue;
+        const kbType = idTypeMap.get(citeId);
+        if (kbType === void 0) {
+          citeIdUnresolved += 1;
+          bumpLayerType(citeId, "unresolved");
+          continue;
+        }
+        bumpLayerType(citeId, kbType);
+        if (kbType === "decision" || kbType === "pitfall") {
+          if (kbType === "decision") decisionsCited += 1;
+          else pitfallsCited += 1;
+          const commitment = commitments[i];
+          const operators = commitment?.operators ?? [];
+          const skipReason = commitment?.skip_reason ?? null;
+          if (skipReason !== null) {
+            skipCount[skipReason] = (skipCount[skipReason] ?? 0) + 1;
+            continue;
+          }
+          if (operators.length === 0) {
+            contractMissing += 1;
+            continue;
+          }
+          contractWith += 1;
+          if (evaluateOperatorViolation(sid, operators)) {
+            hardViolated += 1;
+          }
+        }
+      }
+    }
   }
   let editsTouched = 0;
   let expectedButMissed = 0;
@@ -5208,19 +5399,96 @@ async function runDoctorCiteCoverage(projectRoot, options) {
       perClient[client] = m;
     }
   }
+  const contractMetrics = {
+    decisions_cited: decisionsCited,
+    pitfalls_cited: pitfallsCited,
+    contract_with: contractWith,
+    contract_missing: contractMissing,
+    hard_violated: hardViolated,
+    cite_id_unresolved: citeIdUnresolved,
+    skip_count: skipCount
+  };
   return {
     status: "ok",
     marker_ts: marker.marker_ts,
     marker_emitted_now: marker.emitted_now,
     since_ts: effectiveSince,
     client_filter: options.client,
+    layer_filter: layerFilter,
     metrics,
     ...perClient !== void 0 ? { per_client: perClient } : {},
     ...Object.keys(dismissedHistogram).length > 0 ? { dismissed_reason_histogram: dismissedHistogram } : {},
     ...Object.keys(noneHistogram).length > 0 ? { none_reason_histogram: noneHistogram } : {},
+    contract_metrics_status: contractStatus,
+    contract_metrics: contractMetrics,
+    per_layer_type: layerTypeAccum,
+    contract_marker_ts: contractMarker.marker_ts,
     generated_at: generatedAt
   };
 }
+async function runDoctorArchiveHistory(projectRoot, options) {
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const nowMs = Date.now();
+  let events = [];
+  try {
+    const result = await readEventLedger(projectRoot, {
+      event_type: "session_archive_attempted",
+      since: options.since
+    });
+    events = result.events;
+  } catch {
+    return {
+      entries: [],
+      total: 0,
+      since_ms: options.since,
+      generated_at: generatedAt
+    };
+  }
+  const mostRecentBySession = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.event_type !== "session_archive_attempted") {
+      continue;
+    }
+    const sessionId = event.session_id;
+    if (typeof sessionId !== "string" || sessionId.length === 0) {
+      continue;
+    }
+    const prior = mostRecentBySession.get(sessionId);
+    if (prior === void 0 || event.ts > prior.ts) {
+      mostRecentBySession.set(sessionId, event);
+    }
+  }
+  const entries = [];
+  for (const [sessionId, event] of mostRecentBySession.entries()) {
+    const ageHours = Math.max(
+      0,
+      Math.floor((nowMs - event.covered_through_ts) / 36e5)
+    );
+    entries.push({
+      session_id_short: truncateSessionId(sessionId),
+      last_attempted_at: new Date(event.ts).toISOString(),
+      outcome: event.outcome,
+      candidates_proposed: event.candidates_proposed,
+      covered_through_ts: event.covered_through_ts,
+      age_since_covered_hours: ageHours
+    });
+  }
+  entries.sort(
+    (a, b) => a.last_attempted_at < b.last_attempted_at ? 1 : a.last_attempted_at > b.last_attempted_at ? -1 : 0
+  );
+  return {
+    entries,
+    total: entries.length,
+    since_ms: options.since,
+    generated_at: generatedAt
+  };
+}
+function truncateSessionId(sessionId) {
+  if (sessionId.length <= 8) {
+    return sessionId;
+  }
+  return `${sessionId.slice(0, 8)}...`;
+}
 function createFixMessage(fixed, report) {
   const fixedText = fixed.length === 0 ? "No deterministic doctor fixes were needed." : `Applied ${fixed.length} deterministic doctor fix${fixed.length === 1 ? "" : "es"}.`;
   const manualText = report.manual_errors.length === 0 ? "No manual errors remain." : `${report.manual_errors.length} manual error${report.manual_errors.length === 1 ? "" : "s"} remain.`;
@@ -5734,6 +6002,7 @@ export {
   appendEventLedgerEvent,
   readEventLedger,
   flushAndSyncEventLedger,
+  loadKbIdTypeMap,
   buildKnowledgeMeta,
   writeKnowledgeMeta,
   computeKnowledgeBasedAgentsMeta,
@@ -5758,5 +6027,6 @@ export {
   runDoctorFix,
   runDoctorApplyLint,
   runDoctorCiteCoverage,
+  runDoctorArchiveHistory,
   enrichDescriptions
 };

package/dist/{http-ZBV6YUHD.js → http-QBGLHCHA.js}

@@ -14,7 +14,7 @@ import {
   readEventLedger,
   runDoctorReport,
   sha256
-} from "./chunk-IRB77C6E.js";
+} from "./chunk-HAXROPQM.js";
 
 // src/http.ts
 import { randomUUID as randomUUID2 } from "crypto";

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Server } from 'node:http';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { AgentsMeta, KnowledgeTestIndex, AgentsLayer, AgentsTopologyType, Layer, KnowledgeType, StableId, AgentsMetaCounters, EventLedgerEventInput, EventLedgerEvent, RuleDescriptionIndexItem } from '@fenglimg/fabric-shared';
+import { AgentsMeta, KnowledgeTestIndex, AgentsLayer, AgentsTopologyType, KnowledgeType, Layer, StableId, AgentsMetaCounters, EventLedgerEventInput, EventLedgerEvent, RuleDescriptionIndexItem } from '@fenglimg/fabric-shared';
 import { FabExtractKnowledgeInput, FabExtractKnowledgeOutput, FabReviewInput, FabReviewOutput } from '@fenglimg/fabric-shared/schemas/api-contracts';
 import { IOFabricError } from '@fenglimg/fabric-shared/errors';
 
@@ -97,12 +97,26 @@ type DoctorApplyLintReport = {
 declare function runDoctorReport(target: string): Promise<DoctorReport>;
 declare function runDoctorFix(target: string): Promise<DoctorFixReport>;
 declare function runDoctorApplyLint(target: string): Promise<DoctorApplyLintReport>;
+type CiteContractMetrics = {
+    decisions_cited: number;
+    pitfalls_cited: number;
+    contract_with: number;
+    contract_missing: number;
+    hard_violated: number;
+    cite_id_unresolved: number;
+    skip_count: Record<string, number>;
+};
+type CiteLayerTypeBreakdown = {
+    team: Record<string, number>;
+    personal: Record<string, number>;
+};
 type CiteCoverageReport = {
     status: "ok" | "skipped";
     marker_ts: number;
     marker_emitted_now: boolean;
     since_ts: number;
     client_filter: "cc" | "codex" | "cursor" | "all";
+    layer_filter?: "team" | "personal" | "all";
     metrics: {
         edits_touched: number;
         qualifying_cites: number;
@@ -113,12 +127,34 @@ type CiteCoverageReport = {
     per_client?: Record<string, Partial<CiteCoverageReport["metrics"]>>;
     dismissed_reason_histogram?: Record<string, number>;
     none_reason_histogram?: Record<string, number>;
+    contract_metrics_status?: "ok" | "skipped:bootstrap_drift" | "awaiting_marker";
+    contract_metrics?: CiteContractMetrics;
+    per_layer_type?: CiteLayerTypeBreakdown;
+    contract_marker_ts?: number;
     generated_at: string;
 };
 declare function runDoctorCiteCoverage(projectRoot: string, options: {
     since: number;
     client: "cc" | "codex" | "cursor" | "all";
+    layer?: "team" | "personal" | "all";
 }): Promise<CiteCoverageReport>;
+type ArchiveHistoryEntry = {
+    session_id_short: string;
+    last_attempted_at: string;
+    outcome: "proposed" | "viability_failed" | "user_dismissed" | "skipped_no_signal";
+    candidates_proposed: number;
+    covered_through_ts: number;
+    age_since_covered_hours: number;
+};
+type ArchiveHistoryReport = {
+    entries: ArchiveHistoryEntry[];
+    total: number;
+    since_ms: number;
+    generated_at: string;
+};
+declare function runDoctorArchiveHistory(projectRoot: string, options: {
+    since: number;
+}): Promise<ArchiveHistoryReport>;
 type EnrichDescriptionsMode = "auto" | "interactive";
 type EnrichDescriptionsCandidate = {
     path: string;
@@ -149,6 +185,31 @@ type KnowledgeMetaBuildResult = {
 type WriteKnowledgeMetaOptions = {
     source: KnowledgeMetaBuildSource;
 };
+/**
+ * v2.0-rc.24 TASK-07: Load a Map<stable_id, knowledge_type> from the
+ * project's `.fabric/agents.meta.json`. Consumed by the doctor cite-coverage
+ * routing (TASK-08) to dispatch cites to the correct policy bucket
+ * (decision/pitfall = strict contract / model = reference-only /
+ * guideline+process = deferred to rc.25 LLM-judge). Cited ids absent from
+ * this map fall into the `cite_id_unresolved` bucket.
+ *
+ * **Singular knowledge_type contract (rc.24 lock):** the returned map values
+ * are the SINGULAR `KnowledgeType` enum (`"model" | "decision" | "guideline"
+ * | "pitfall" | "process"`) — matching both the on-disk `agents.meta.json`
+ * storage AND the canonical `KnowledgeTypeSchema` exported from
+ * `@fenglimg/fabric-shared`. No normalization happens at this boundary; the
+ * loader is a thin extract over engine-maintained meta. Downstream callers
+ * (TASK-08 doctor) must match against the singular enum.
+ *
+ * Both team (KT-*) and personal (KP-*) entries are included — they live in
+ * the same `meta.nodes` map.
+ *
+ * Graceful on failure: a missing meta file, malformed JSON, or schema
+ * validation failure all yield an empty Map (no throw). The doctor will then
+ * surface every cite as `cite_id_unresolved`, which is the safe degraded
+ * mode.
+ */
+declare function loadKbIdTypeMap(projectRootInput: string): Promise<Map<string, KnowledgeType>>;
 declare function buildKnowledgeMeta(projectRootInput: string): Promise<KnowledgeMetaBuildResult>;
 declare function writeKnowledgeMeta(projectRootInput: string, options: WriteKnowledgeMetaOptions): Promise<KnowledgeMetaBuildResult>;
 declare function computeKnowledgeBasedAgentsMeta(projectRootInput: string, existingMeta?: AgentsMeta): Promise<AgentsMeta>;
@@ -435,4 +496,4 @@ declare function startHttpServer(options: {
     authToken?: string;
 }): Promise<Server>;
 
-export { AGENTS_MD_RESOURCE_URI, type AcquireOptions, type CiteCoverageReport, type DoctorApplyLintMutation, type DoctorApplyLintMutationKind, type DoctorApplyLintReport, type DoctorFixReport, type DoctorIssue, type DoctorReport, EVENT_LEDGER_PATH, type EnrichDescriptionsCandidate, type EnrichDescriptionsMode, type EnrichDescriptionsReport, type InFlightTracker, KnowledgeIdAllocator, type KnowledgeMetaBuildResult, type KnowledgeMetaBuildSource, type KnowledgeSyncLedgerEvent, type KnowledgeSyncOptions, type KnowledgeSyncReport, LEDGER_PATH, LEGACY_LEDGER_PATH, type LedgerEvent, type LockState, type PlanContextInput, type PlanContextResult, type ReconcileKnowledgeOptions, type RequirementProfile, type SelectionTokenState, ServeLockHeldError, type ShutdownHandlerDeps, type StructuredWarning, type WriteKnowledgeMetaOptions, acquireLock, appendEventLedgerEvent, buildKnowledgeMeta, checkLockOrThrow, computeKnowledgeBasedAgentsMeta, computeKnowledgeTestIndex, createFabricServer, createInFlightTracker, createShutdownHandler, deriveKnowledgeMetaLayer, deriveKnowledgeMetaTopologyType, enrichDescriptions, ensureKnowledgeFresh, extractKnowledge, flushAndSyncEventLedger, formatPreexistingRootMessage, getEventLedgerPath, getLedgerPath, getLegacyLedgerPath, isSameKnowledgeTestIndex, planContext, readLockState, readSelectionToken, reconcileKnowledge, releaseLock, reviewKnowledge, runDoctorApplyLint, runDoctorCiteCoverage, runDoctorFix, runDoctorReport, stableStringify, startHttpServer, startStdioServer, writeKnowledgeMeta };
+export { AGENTS_MD_RESOURCE_URI, type AcquireOptions, type ArchiveHistoryEntry, type ArchiveHistoryReport, type CiteCoverageReport, type DoctorApplyLintMutation, type DoctorApplyLintMutationKind, type DoctorApplyLintReport, type DoctorFixReport, type DoctorIssue, type DoctorReport, EVENT_LEDGER_PATH, type EnrichDescriptionsCandidate, type EnrichDescriptionsMode, type EnrichDescriptionsReport, type InFlightTracker, KnowledgeIdAllocator, type KnowledgeMetaBuildResult, type KnowledgeMetaBuildSource, type KnowledgeSyncLedgerEvent, type KnowledgeSyncOptions, type KnowledgeSyncReport, LEDGER_PATH, LEGACY_LEDGER_PATH, type LedgerEvent, type LockState, type PlanContextInput, type PlanContextResult, type ReconcileKnowledgeOptions, type RequirementProfile, type SelectionTokenState, ServeLockHeldError, type ShutdownHandlerDeps, type StructuredWarning, type WriteKnowledgeMetaOptions, acquireLock, appendEventLedgerEvent, buildKnowledgeMeta, checkLockOrThrow, computeKnowledgeBasedAgentsMeta, computeKnowledgeTestIndex, createFabricServer, createInFlightTracker, createShutdownHandler, deriveKnowledgeMetaLayer, deriveKnowledgeMetaTopologyType, enrichDescriptions, ensureKnowledgeFresh, extractKnowledge, flushAndSyncEventLedger, formatPreexistingRootMessage, getEventLedgerPath, getLedgerPath, getLegacyLedgerPath, isSameKnowledgeTestIndex, loadKbIdTypeMap, planContext, readLockState, readSelectionToken, reconcileKnowledge, releaseLock, reviewKnowledge, runDoctorApplyLint, runDoctorArchiveHistory, runDoctorCiteCoverage, runDoctorFix, runDoctorReport, stableStringify, startHttpServer, startStdioServer, writeKnowledgeMeta };

package/dist/index.js

@@ -23,19 +23,21 @@ import {
   isSameKnowledgeTestIndex,
   loadActiveMeta,
   loadActiveMetaOrStale,
+  loadKbIdTypeMap,
   normalizeKnowledgePath,
   readLockState,
   reconcileKnowledge,
   releaseLock,
   resolveProjectRoot,
   runDoctorApplyLint,
+  runDoctorArchiveHistory,
   runDoctorCiteCoverage,
   runDoctorFix,
   runDoctorReport,
   sha256,
   stableStringify,
   writeKnowledgeMeta
-} from "./chunk-IRB77C6E.js";
+} from "./chunk-HAXROPQM.js";
 
 // src/index.ts
 import { existsSync as existsSync4 } from "fs";
@@ -1892,7 +1894,7 @@ function formatPreexistingRootMessage(projectRoot) {
 function createFabricServer(tracker) {
   const server = new McpServer({
     name: "fabric-knowledge-server",
-    version: "2.0.0-rc.23"
+    version: "2.0.0-rc.25"
   });
   registerPlanContext(server, tracker);
   registerKnowledgeSections(server, tracker);
@@ -2000,7 +2002,7 @@ function createShutdownHandler(deps) {
   };
 }
 async function startHttpServer(options) {
-  const { createFabricHttpApp } = await import("./http-ZBV6YUHD.js");
+  const { createFabricHttpApp } = await import("./http-QBGLHCHA.js");
   const { port, projectRoot, host = "127.0.0.1", authToken } = options;
   const app = createFabricHttpApp({ projectRoot, host, authToken });
   return await new Promise((resolveServer, rejectServer) => {
@@ -2052,6 +2054,7 @@ export {
   getLedgerPath,
   getLegacyLedgerPath,
   isSameKnowledgeTestIndex,
+  loadKbIdTypeMap,
   planContext,
   readLockState,
   readSelectionToken,
@@ -2059,6 +2062,7 @@ export {
   releaseLock,
   reviewKnowledge,
   runDoctorApplyLint,
+  runDoctorArchiveHistory,
   runDoctorCiteCoverage,
   runDoctorFix,
   runDoctorReport,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fenglimg/fabric-server",
-  "version": "2.0.0-rc.23",
+  "version": "2.0.0-rc.25",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -13,7 +13,7 @@
     "express": "^5.2.1",
     "minimatch": "^10.0.1",
     "zod": "^3.25.0",
-    "@fenglimg/fabric-shared": "2.0.0-rc.23"
+    "@fenglimg/fabric-shared": "2.0.0-rc.25"
   },
   "devDependencies": {
     "@types/express": "^5.0.6",