@fenglimg/fabric-server 2.0.0-rc.8 → 2.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 wangzhichao (fenglimg)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,34 @@
+# @fenglimg/fabric-server
+
+Fabric MCP knowledge server. Runs over stdio transport and serves Claude Code, Cursor, and Codex CLI from a single `.fabric/` directory.
+
+## Tools exposed
+
+- `fab_plan_context` — neutral rule description index + selection token
+- `fab_get_knowledge_sections` — fetch full markdown bodies by stable_id
+- `fab_recall` — combined one-call recall (plan + sections), the rc.37+ default
+- `fab_extract_knowledge` — persist a pending knowledge entry
+- `fab_review` — list / approve / reject / modify / defer pending entries
+
+## Install
+
+Usually installed indirectly via [`@fenglimg/fabric-cli`](https://www.npmjs.com/package/@fenglimg/fabric-cli):
+
+```bash
+npm i -g @fenglimg/fabric-cli
+fabric install
+```
+
+Direct consumption (programmatic):
+
+```bash
+npm i @fenglimg/fabric-server
+```
+
+## Repo
+
+Source + issues + roadmap: <https://github.com/fenglimg/fabric-v2>
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/dist/index.d.ts

@@ -1,8 +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';
 
 interface InFlightTracker {
     enter(requestId: string): void;
@@ -18,9 +16,11 @@ declare function createInFlightTracker(): InFlightTracker;
 declare const LEDGER_PATH = ".fabric/.intent-ledger.jsonl";
 declare const LEGACY_LEDGER_PATH = ".intent-ledger.jsonl";
 declare const EVENT_LEDGER_PATH = ".fabric/events.jsonl";
+declare const METRICS_LEDGER_PATH = ".fabric/metrics.jsonl";
 declare function getLedgerPath(projectRoot: string): string;
 declare function getLegacyLedgerPath(projectRoot: string): string;
 declare function getEventLedgerPath(projectRoot: string): string;
+declare function getMetricsLedgerPath(projectRoot: string): string;
 
 type DoctorStatus = "ok" | "warn" | "error";
 type DoctorIssueKind = "fixable_error" | "manual_error" | "warning" | "info";
@@ -32,12 +32,20 @@ type DoctorCheck = {
     code?: string;
     fixable?: boolean;
     actionHint?: string;
+    audience?: "user" | "maintainer";
 };
 type DoctorIssue = {
     code: string;
     name: string;
     message: string;
     path?: string;
+    actionHint?: string;
+    audience?: "user" | "maintainer";
+};
+type DoctorPayloadLimits = {
+    warn_bytes: number;
+    hard_bytes: number;
+    source: "default" | "config";
 };
 type DoctorSummary = {
     target: string;
@@ -59,6 +67,7 @@ type DoctorSummary = {
     warningCount: number;
     infoCount: number;
     targetFiles: Record<string, boolean>;
+    payload_limits: DoctorPayloadLimits;
 };
 type DoctorReport = {
     status: DoctorStatus;
@@ -77,7 +86,7 @@ type DoctorFixReport = {
     message: string;
     report: DoctorReport;
 };
-type DoctorApplyLintMutationKind = "knowledge_orphan_demote_required" | "knowledge_stale_archive_required" | "knowledge_index_drift" | "knowledge_pending_auto_archive" | "knowledge_session_hints_stale_cleanup";
+type DoctorApplyLintMutationKind = "knowledge_orphan_demote_required" | "knowledge_stale_archive_required" | "knowledge_index_drift" | "knowledge_pending_auto_archive" | "knowledge_session_hints_stale_cleanup" | "knowledge_relevance_fields_missing";
 type DoctorApplyLintMutation = {
     kind: DoctorApplyLintMutationKind;
     path: string;
@@ -97,6 +106,112 @@ 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;
+        recalled_unverified: number;
+        expected_but_missed: number;
+        total_turns: number;
+        cite_compliance_rate?: number | null;
+        compliant_cites?: number;
+        noncompliant_cites?: number;
+        uncorrelatable_edits?: number;
+    };
+    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;
+    rollup_days_merged?: number;
+    rollup_trend?: {
+        date: string;
+        generated_at: string;
+        metrics: CiteCoverageReport["metrics"];
+    }[];
+};
+declare function runDoctorCiteCoverage(projectRoot: string, options: {
+    since: number;
+    client: "cc" | "codex" | "cursor" | "all";
+    layer?: "team" | "personal" | "all";
+    until?: number;
+}): 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 HistoryDayRow = {
+    date: string;
+    doctor_runs_lint: number;
+    doctor_runs_fix: number;
+    doctor_total_issues: number;
+    doctor_total_mutations: number;
+    archive_attempts: number;
+    archive_proposed: number;
+};
+type HistoryAllReport = {
+    rows: HistoryDayRow[];
+    since_ms: number;
+    generated_at: string;
+};
+declare function runDoctorHistoryAll(projectRoot: string, options: {
+    since: number;
+}): Promise<HistoryAllReport>;
+type EnrichDescriptionsMode = "auto" | "preview" | "readonly" | "interactive";
+type EnrichDescriptionsCandidate = {
+    path: string;
+    missing: Array<"intent_clues" | "tech_stack" | "impact" | "must_read_if">;
+    modified: boolean;
+    added_fields: Array<"intent_clues" | "tech_stack" | "impact" | "must_read_if">;
+    error?: string;
+};
+type EnrichDescriptionsReport = {
+    mode: EnrichDescriptionsMode;
+    dryRun: boolean;
+    scanned: number;
+    modified: number;
+    skipped: number;
+    candidates: EnrichDescriptionsCandidate[];
+};
+declare function enrichDescriptions(projectRoot: string, opts?: {
+    auto?: boolean;
+    dryRun?: boolean;
+}): Promise<EnrichDescriptionsReport>;
 
 type KnowledgeMetaBuildSource = "doctor_fix" | "sync_meta";
 type KnowledgeMetaBuildResult = {
@@ -107,6 +222,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.
+ *
+ * **Plural knowledge_type contract (rc.29 BUG-C1 unification):** the returned
+ * map values are the PLURAL `KnowledgeType` enum (`"models" | "decisions" |
+ * "guidelines" | "pitfalls" | "processes"`) — matching disk frontmatter,
+ * filesystem layout, MCP I/O surface, and the canonical `KnowledgeTypeSchema`
+ * exported from `@fenglimg/fabric-shared`. Legacy singular frontmatter is
+ * normalized at parse time (see `SINGULAR_TO_PLURAL` in `parseFrontmatter`);
+ * downstream callers (TASK-08 doctor) match against the plural 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>;
@@ -155,8 +295,11 @@ declare class KnowledgeIdAllocator {
 /**
  * Append-evidence-on-collision service for fab_extract_knowledge.
  *
- * Idempotency_key = sha256({source_session, type, slug}). When the same
- * triple hits an existing pending file (verified by frontmatter
+ * Idempotency_key = sha256({source_session: source_sessions[0], type, slug}).
+ * The `source_session` key inside the hash payload is FROZEN for backward
+ * compatibility with on-disk pending entries written before rc.23 — changing
+ * it would invalidate every existing `x-fabric-idempotency-key`. When the
+ * same triple hits an existing pending file (verified by frontmatter
  * `x-fabric-idempotency-key`), the body is preserved and a fresh
  * `## Evidence (call N)` section is appended — LLM-regenerated summaries
  * stay observable without overwriting prior context.
@@ -209,8 +352,6 @@ type PlanContextInput = {
 };
 type RequirementProfile = {
     target_path: string;
-    path_segments: string[];
-    extension: string;
     known_tech: string[];
     user_intent: string;
     detected_entities: string[];
@@ -218,23 +359,24 @@ type RequirementProfile = {
 type PlanContextEntry = {
     path: string;
     requirement_profile: RequirementProfile;
-    description_index: RuleDescriptionIndexItem[];
+};
+type PreflightDiagnostic = {
+    code: "missing_description" | "empty_shell_suppressed";
+    severity: "warn";
+    message: string;
+    stable_ids?: string[];
+    path?: string;
 };
 type PlanContextResult = {
     revision_hash: string;
     stale: boolean;
     selection_token: string;
     entries: PlanContextEntry[];
-    shared: {
-        description_index: RuleDescriptionIndexItem[];
-        preflight_diagnostics: Array<{
-            code: "missing_description";
-            severity: "warn";
-            message: string;
-            stable_ids?: string[];
-            path?: string;
-        }>;
-    };
+    candidates: RuleDescriptionIndexItem[];
+    preflight_diagnostics: PreflightDiagnostic[];
+    auto_healed?: boolean;
+    previous_revision_hash?: string;
+    redirects?: Record<string, string>;
 };
 type SelectionTokenState = {
     token: string;
@@ -248,31 +390,149 @@ type SelectionTokenState = {
 declare function planContext(projectRoot: string, input: PlanContextInput): Promise<PlanContextResult>;
 declare function readSelectionToken(token: string, now?: number): SelectionTokenState | undefined;
 
-/**
- * Shared constants used across the server package.
- */
-/** MCP resource URI for the project's bootstrap README (L0 rules) file. */
-declare const AGENTS_MD_RESOURCE_URI = "fabric://bootstrap-readme";
+type RecallInput = PlanContextInput & {
+    /**
+     * Optional explicit set of stable_ids to fetch bodies for. When omitted,
+     * fab_recall picks up every stable_id surfaced in the shared description
+     * index (the common case after rc.37 selectable-filter removal). When
+     * provided, filters the fetched body set to this intersection.
+     */
+    ids?: string[];
+};
+type RecallResult = PlanContextResult & {
+    rules: Array<{
+        stable_id: string;
+        level: "L0" | "L1" | "L2";
+        path: string;
+        body: string;
+    }>;
+    selected_stable_ids: string[];
+    diagnostics: Array<{
+        code: "missing_knowledge_metadata";
+        severity: "warn";
+        stable_id: string;
+        message: string;
+    }>;
+};
+declare function recall(projectRoot: string, input: RecallInput): Promise<RecallResult>;
 
 /**
- * knowledge-sync.ts — Rule-sync orchestrator framework (R28, TASK-011)
+ * O(1) in-memory increment for a named counter. Safe to call from any MCP
+ * tool handler; no I/O happens until the next `flushMetrics()` call.
  *
- * Public surface: ensureKnowledgeFresh, reconcileKnowledge + exported types.
- * Internal helpers are co-located in this file.
- * Does NOT wire any consumers (MCP tools, doctor, watchers).
+ * `delta` defaults to 1; callers can pass a positive integer (e.g. fetched
+ * N stable_ids in a single sections call) to fold N bumps into one.
+ */
+declare function bumpCounter(projectRoot: string, name: string, delta?: number): void;
+/**
+ * Snapshot the current counter accumulator and reset it. Returned map is a
+ * frozen copy; the live accumulator starts fresh from zero. Exposed so
+ * flushMetrics + tests + a future fab_metrics manual-flush CLI hook can all
+ * use the same primitive without racing.
+ */
+declare function drainCounters(projectRoot: string): Record<string, number>;
+/**
+ * Drain the current accumulator and append one JSONL row to
+ * `.fabric/metrics.jsonl`. Returns the appended row (or `null` when the
+ * accumulator was empty — no spurious zero rows). fs failures degrade
+ * silently; the next flush will carry the union of the failed-write
+ * interval + the current one.
+ */
+declare function flushMetrics(projectRoot: string, options?: {
+    windowMs?: number;
+    now?: Date;
+}): Promise<MetricsRow | null>;
+/**
+ * Start the background flush timer for a project root. Idempotent — calling
+ * twice on the same root replaces the prior interval. Returns a stop handle
+ * the caller can invoke at shutdown to flush + clear the timer.
  *
- * Distinction between the two public entry points:
+ * The flush is fire-and-forget (no await on the setInterval callback) so
+ * the timer cadence stays accurate even when fs is slow.
+ */
+declare function startMetricsFlush(projectRoot: string, options?: {
+    intervalMs?: number;
+}): () => Promise<void>;
+/**
+ * Cancel the background flush timer for a project root if one is running.
+ * Does NOT drain the accumulator — callers that want a final flush should
+ * await flushMetrics(projectRoot) afterward.
+ */
+declare function stopMetricsFlush(projectRoot: string): void;
+/**
+ * Read accumulated metrics rows from `.fabric/metrics.jsonl`. Missing file
+ * returns []. Malformed rows are dropped silently (the sidecar is best-
+ * effort observability; a corrupt row never blocks a reader).
  *
- * - `ensureKnowledgeFresh`: detects drift, emits ledger events, invalidates cache.
- *   Does NOT rewrite agents.meta.json. Optimised for hot-path consumers (MCP tools).
+ * Exposed for the NEW-34 `fab metrics` CLI dashboard + future doctor lints
+ * (e.g. cite-goodhart pattern replay) that need counter trends without
+ * walking events.jsonl.
+ */
+declare function readMetrics(projectRoot: string): Promise<MetricsRow[]>;
+type MetricsRow = {
+    timestamp: string;
+    window: string;
+    counters: Record<string, number>;
+};
+/**
+ * Canonical metric counter names used by the high-frequency emitters that
+ * left events.jsonl as part of the rc.37 Wave B clean-slate. Centralized
+ * here so the B5 hard-gate (`metric_event_in_jsonl`) can grep for these
+ * exact strings and fail when one accidentally re-appears in the audit
+ * ledger emit path.
+ */
+declare const METRIC_COUNTER_NAMES: {
+    readonly knowledge_consumed: "knowledge_consumed";
+    readonly edit_intent_checked: "edit_intent_checked";
+    readonly knowledge_context_planned: "knowledge_context_planned";
+    readonly knowledge_sections_fetched: "knowledge_sections_fetched";
+};
+type MetricCounterName = (typeof METRIC_COUNTER_NAMES)[keyof typeof METRIC_COUNTER_NAMES];
+
+/**
+ * Start the background rotation timer for a project root. Idempotent —
+ * calling twice on the same root replaces the prior interval. Returns a
+ * stop handle the caller can invoke at shutdown.
  *
- * - `reconcileKnowledge`: full scan + rewrites agents.meta.json (via knowledge-meta-builder)
- *   + emits ledger events. Used by startup (TASK-022) and doctor repair (TASK-023).
+ * The tick fires fire-and-forget (no await on the setInterval callback) so
+ * the cadence stays accurate even when fs is slow. The first tick fires
+ * AFTER one full interval — startup-time rotation should run separately
+ * if desired (most callers don't, because rotation work blocks the
+ * connect path).
  */
+declare function startRotationTick(projectRoot: string, options?: {
+    intervalMs?: number;
+}): () => void;
+/**
+ * Cancel the background rotation timer for a project root if one is
+ * running. Does NOT trigger a final rotation — callers that want a final
+ * rotation should call rotateEventLedgerIfNeeded(projectRoot) directly.
+ */
+declare function stopRotationTick(projectRoot: string): void;
+
+/**
+ * Shared constants used across the server package.
+ */
+/** MCP resource URI for the project's bootstrap README (L0 rules) file. */
+declare const AGENTS_MD_RESOURCE_URI = "fabric://bootstrap-readme";
+
 interface KnowledgeSyncOptions {
     mode?: "incremental" | "full";
     /** When true, invalid frontmatter throws RuleValidationError (default: false — collect as warning). */
     throwOnInvalidFrontmatter?: boolean;
+    /**
+     * v2.0.0-rc.29 TASK-005 (BUG-G1): when true, `ensureKnowledgeFresh`
+     * synchronously follows a drift detection with a `reconcileKnowledge`
+     * call to materialize the auto-heal (rewrite agents.meta.json + emit a
+     * paired `knowledge_meta_auto_healed` event). Default false preserves
+     * the rc.28 hot-path semantics where drift detection never blocks the
+     * MCP read on a meta rebuild. Opt-in is intended for callers that can
+     * tolerate ~tens-of-ms extra latency in exchange for the invariant
+     * "every knowledge_drift_detected has a paired heal event in the same
+     * tail window." Audit (BUG-G1) found 5/72 drifts healed on this repo
+     * (~7%) because the hot path emitted detect-only events.
+     */
+    autoHealOnDrift?: boolean;
 }
 interface StructuredWarning {
     code: string;
@@ -310,8 +570,20 @@ interface KnowledgeSyncReport {
  */
 declare function ensureKnowledgeFresh(projectRoot: string, opts?: KnowledgeSyncOptions): Promise<KnowledgeSyncReport>;
 interface ReconcileKnowledgeOptions {
-    /** Identifies who triggered the reconcile; controls which summary ledger event is written. */
-    trigger?: "startup" | "doctor" | "manual";
+    /**
+     * Identifies who triggered the reconcile; controls which summary ledger event is written.
+     *
+     * v2.0.0-rc.23 TASK-005 (a-B): `auto-heal-description` added so plan_context
+     * can drive a full reconcile when it detects nodes with `description === undefined`
+     * (legacy meta drift the revision-hash gate cannot detect).
+     *
+     * v2.0.0-rc.27 TASK-001 (§2.9 root): `post-approve` / `post-modify` added so
+     * `fab_review` approve/modify-layer-flip can drive an immediate meta rebuild
+     * — without this the new entry's `nodes[id]` stays empty until the next
+     * plan_context call's auto-heal, which leaves the entry undiscoverable in
+     * the description_index window between approve and the next hint call.
+     */
+    trigger?: "startup" | "doctor" | "manual" | "auto-heal-description" | "auto-heal-after-drift" | "post-approve" | "post-modify";
 }
 /**
  * Full scan + rewrites agents.meta.json with ground-truth disk state + emits
@@ -324,23 +596,6 @@ interface ReconcileKnowledgeOptions {
  */
 declare function reconcileKnowledge(projectRoot: string, opts?: ReconcileKnowledgeOptions): Promise<KnowledgeSyncReport>;
 
-declare class ServeLockHeldError extends IOFabricError {
-    readonly code = "SERVE_LOCK_HELD";
-    readonly httpStatus = 423;
-}
-interface LockState {
-    pid: number;
-    acquiredAt: number;
-    host?: string;
-}
-interface AcquireOptions {
-    force?: boolean;
-}
-declare function acquireLock(projectRoot: string, opts?: AcquireOptions): void;
-declare function releaseLock(projectRoot: string): void;
-declare function readLockState(projectRoot: string): LockState | null;
-declare function checkLockOrThrow(projectRoot: string, opts?: AcquireOptions): void;
-
 /**
  * Returns an info-level startup message when CLAUDE.md or AGENTS.md exist at
  * the project root, or null when neither is present.
@@ -375,11 +630,5 @@ interface ShutdownHandlerDeps {
  * `invoked` flag, so per-signal dedup is isolated.
  */
 declare function createShutdownHandler(deps: ShutdownHandlerDeps): () => void;
-declare function startHttpServer(options: {
-    port: number;
-    projectRoot: string;
-    host?: string;
-    authToken?: string;
-}): Promise<Server>;
 
-export { AGENTS_MD_RESOURCE_URI, type AcquireOptions, type DoctorApplyLintMutation, type DoctorApplyLintMutationKind, type DoctorApplyLintReport, type DoctorFixReport, type DoctorIssue, type DoctorReport, EVENT_LEDGER_PATH, 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, ensureKnowledgeFresh, extractKnowledge, flushAndSyncEventLedger, formatPreexistingRootMessage, getEventLedgerPath, getLedgerPath, getLegacyLedgerPath, isSameKnowledgeTestIndex, planContext, readLockState, readSelectionToken, reconcileKnowledge, releaseLock, reviewKnowledge, runDoctorApplyLint, runDoctorFix, runDoctorReport, stableStringify, startHttpServer, startStdioServer, writeKnowledgeMeta };
+export { AGENTS_MD_RESOURCE_URI, 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 HistoryAllReport, type HistoryDayRow, type InFlightTracker, KnowledgeIdAllocator, type KnowledgeMetaBuildResult, type KnowledgeMetaBuildSource, type KnowledgeSyncLedgerEvent, type KnowledgeSyncOptions, type KnowledgeSyncReport, LEDGER_PATH, LEGACY_LEDGER_PATH, type LedgerEvent, METRICS_LEDGER_PATH, METRIC_COUNTER_NAMES, type MetricCounterName, type MetricsRow, type PlanContextInput, type PlanContextResult, type RecallInput, type RecallResult, type ReconcileKnowledgeOptions, type RequirementProfile, type SelectionTokenState, type ShutdownHandlerDeps, type StructuredWarning, type WriteKnowledgeMetaOptions, appendEventLedgerEvent, buildKnowledgeMeta, bumpCounter, computeKnowledgeBasedAgentsMeta, computeKnowledgeTestIndex, createFabricServer, createInFlightTracker, createShutdownHandler, deriveKnowledgeMetaLayer, deriveKnowledgeMetaTopologyType, drainCounters, enrichDescriptions, ensureKnowledgeFresh, extractKnowledge, flushAndSyncEventLedger, flushMetrics, formatPreexistingRootMessage, getEventLedgerPath, getLedgerPath, getLegacyLedgerPath, getMetricsLedgerPath, isSameKnowledgeTestIndex, loadKbIdTypeMap, planContext, readMetrics, readSelectionToken, recall, reconcileKnowledge, reviewKnowledge, runDoctorApplyLint, runDoctorArchiveHistory, runDoctorCiteCoverage, runDoctorFix, runDoctorHistoryAll, runDoctorReport, stableStringify, startMetricsFlush, startRotationTick, startStdioServer, stopMetricsFlush, stopRotationTick, writeKnowledgeMeta };