@fenglimg/fabric-shared 2.0.0 → 2.0.1

package/dist/index.js

@@ -1,3 +1,12 @@
+import {
+  BOOTSTRAP_CANONICAL,
+  BOOTSTRAP_MARKER_BEGIN,
+  BOOTSTRAP_MARKER_END,
+  BOOTSTRAP_REGEX,
+  LEGACY_KB_MARKER_BEGIN,
+  LEGACY_KB_MARKER_END,
+  LEGACY_KB_REGEX
+} from "./chunk-LTDB2UDN.js";
 import {
   PROTECTED_TOKENS,
   createTranslator,
@@ -5,29 +14,37 @@ import {
   detectNodeLocale,
   enMessages,
   normalizeLocale,
+  resolveFabricLocale,
   zhCNMessages
-} from "./chunk-U2SR2M4L.js";
+} from "./chunk-7CX32MYL.js";
 import {
   FabExtractKnowledgeInputSchema,
   FabExtractKnowledgeInputShape,
   FabExtractKnowledgeOutputSchema,
   FabReviewInputSchema,
+  FabReviewInputShape,
   FabReviewOutputSchema,
+  FabReviewOutputShape,
   KNOWLEDGE_TYPE_CODES,
   KnowledgeEntryFrontmatterSchema,
   KnowledgeTypeSchema,
   LayerSchema,
   MaturitySchema,
+  ONBOARD_SLOT_NAMES,
+  ONBOARD_SLOT_TOTAL,
   PROPOSED_REASON_DESCRIPTIONS,
   ProposedReasonSchema,
   StableIdSchema,
   annotateIntentRequestSchema,
+  archiveScanAnnotations,
+  archiveScanInputSchema,
+  archiveScanOutputSchema,
+  citeContractMetricsSchema,
+  citeCoverageReportSchema,
+  citeLayerTypeBreakdownSchema,
   fabExtractKnowledgeAnnotations,
   fabReviewAnnotations,
   formatKnowledgeId,
-  getKnowledgeAnnotations,
-  getKnowledgeInputSchema,
-  getKnowledgeOutputSchema,
   historyStateQuerySchema,
   humanLockApproveRequestSchema,
   humanLockFileParamsSchema,
@@ -36,19 +53,30 @@ import {
   knowledgeSectionsOutputSchema,
   ledgerQuerySchema,
   ledgerSourceSchema,
+  onboardSlotSchema,
   parseKnowledgeId,
   planContextAnnotations,
   planContextHintNarrowEntrySchema,
   planContextHintOutputSchema,
   planContextInputSchema,
   planContextOutputSchema,
+  recallAnnotations,
+  recallInputSchema,
+  recallOutputSchema,
   structuredWarningSchema
-} from "./chunk-VQDCDCJA.js";
+} from "./chunk-WVPDH4BF.js";
 import "./chunk-LXNCAKJZ.js";
 
 // src/schemas/agents-meta.ts
 import { z } from "zod";
 var FABRIC_AGENTS_PREFIX = ".fabric/agents/";
+var KNOWLEDGE_TYPE_SINGULAR_TO_PLURAL = {
+  model: "models",
+  decision: "decisions",
+  guideline: "guidelines",
+  pitfall: "pitfalls",
+  process: "processes"
+};
 var AGENTS_META_LAYERS = ["L0", "L1", "L2"];
 var AGENTS_META_TOPOLOGY_TYPES = ["mirror", "cross-cutting", "domain", "local", "global"];
 var AGENTS_META_IDENTITY_SOURCES = ["declared", "derived"];
@@ -64,7 +92,15 @@ var ruleDescriptionSchema = z.object({
   entities: z.array(z.string()).optional(),
   // v2.0 knowledge entry fields (TASK-002 schemas). All optional for backward compat.
   id: z.string().optional(),
-  knowledge_type: z.enum(["model", "decision", "guideline", "pitfall", "process"]).optional(),
+  // rc.31 NEW-1: forward-compat for legacy on-disk agents.meta.json carrying
+  // singular knowledge_type values (model/decision/guideline/pitfall/process).
+  // Normalize to canonical plural form before enum validation so doctor and
+  // plan-context-hint can load pre-rc.28 meta files without aborting. Disk
+  // gets rewritten to plural on next reconcile (via knowledge-meta-builder).
+  knowledge_type: z.preprocess(
+    (value) => typeof value === "string" && value in KNOWLEDGE_TYPE_SINGULAR_TO_PLURAL ? KNOWLEDGE_TYPE_SINGULAR_TO_PLURAL[value] : value,
+    z.enum(["models", "decisions", "guidelines", "pitfalls", "processes"])
+  ).optional(),
   maturity: z.enum(["draft", "verified", "proven"]).optional(),
   knowledge_layer: z.enum(["personal", "team"]).optional(),
   layer_reason: z.string().optional(),
@@ -134,8 +170,7 @@ function withDerivedAgentsMetaNodeDefaults(node) {
   const identitySource = isKnowledgeEntry ? "declared" : deriveAgentsMetaIdentitySource(node);
   return {
     ...node,
-    layer: node.layer ?? node.level ?? deriveAgentsMetaLayer(node.file),
-    level: node.level ?? node.layer ?? deriveAgentsMetaLayer(node.file),
+    level: node.level ?? deriveAgentsMetaLayer(node.file),
     topology_type: node.topology_type ?? deriveAgentsMetaTopologyType(node.file),
     stable_id: stableId,
     identity_source: identitySource
@@ -164,7 +199,7 @@ function defaultAgentsMetaCounters() {
 }
 function deriveAgentsMetaStableId(file) {
   const normalized = normalizePath(file);
-  if (normalized === "AGENTS.md" || normalized === ".fabric/bootstrap/README.md") {
+  if (normalized === "AGENTS.md") {
     return "bootstrap";
   }
   return getDepthSource(normalized).replace(/\.md$/u, "");
@@ -181,7 +216,7 @@ function deriveAgentsMetaIdentitySource(node) {
 }
 function deriveAgentsMetaLayer(file) {
   const normalized = normalizePath(file);
-  if (normalized === "AGENTS.md" || normalized === ".fabric/bootstrap/README.md") {
+  if (normalized === "AGENTS.md") {
     return "L0";
   }
   if (hasCrossCuttingSegment(normalized)) {
@@ -304,19 +339,30 @@ var mcpPayloadLimitsSchema = z5.object({
   warnBytes: z5.number().int().positive().optional(),
   hardBytes: z5.number().int().positive().optional()
 }).optional();
-var knowledgeLanguageSchema = z5.enum(["match-existing", "zh-CN", "en"]);
+var selectionTokenTtlMsSchema = z5.number().int().min(3e4).max(36e5);
+var fabricLanguageSchema = z5.enum([
+  "match-existing",
+  "zh-CN",
+  "en",
+  "zh-CN-hybrid"
+]);
 var defaultLayerFilterSchema = z5.enum(["team", "personal", "both"]);
 var fabricConfigSchema = z5.object({
   clientPaths: clientPathsSchema.optional(),
-  externalFixturePath: z5.string().optional(),
+  // rc.17 (R-cut): the dev/test fixture-path config field was removed
+  // end-to-end. The `EXTERNAL_FIXTURE_PATH` env var is now the sole source
+  // consumed by `resolveDevMode()`. No z.preprocess alias — pre-rc.17
+  // fabric-config.json files carrying the field will be silently dropped by
+  // the lenient root parser (no .strict() at root). Pre-user clean-slate per
+  // memory/feedback_clean_slate.md; mirrors the rc.12 hard-rename precedent
+  // documented above.
   scanIgnores: z5.array(z5.string()).optional(),
-  auditMode: auditModeSchema.optional(),
   audit_mode: auditModeSchema.optional(),
   mcpPayloadLimits: mcpPayloadLimitsSchema,
   // Backward-compat: both fields are optional with defaults so existing
   // fabric-config.json files (pre-grill-followup) parse unchanged. The default
   // values themselves are load-bearing — see docs/data-schema.md.
-  knowledge_language: knowledgeLanguageSchema.optional().default("match-existing"),
+  fabric_language: fabricLanguageSchema.optional().default("match-existing"),
   default_layer_filter: defaultLayerFilterSchema.optional().default("both"),
   // Cooldown for the fabric-hint Stop hook (formerly archive-hint, renamed in
   // rc.5 TASK-010). After ANY of the three signals (archive / review / import)
@@ -371,159 +417,496 @@ var fabricConfigSchema = z5.object({
   // the user doesn't run doctor. Default 7 keeps the reminder weekly at
   // worst — pairing 14d trigger + 7d cooldown means at most ~2 reminders
   // per month for a workspace that ignores them.
-  maintenance_hint_cooldown_days: z5.number().int().positive().optional().default(7)
+  maintenance_hint_cooldown_days: z5.number().int().positive().optional().default(7),
+  // rc.9+ (skill-contract-fix B1): first-run import window in months. The
+  // `fabric-import` skill scans this many months of git history on the very
+  // first invocation (when no prior `import_run_completed` event exists).
+  // Default 60 (~5 years) captures the bulk of a mature repo's signal in
+  // one pass; small / fresh repos can lower to 12-24 with no loss.
+  import_window_first_run_months: z5.number().int().min(1).optional().default(60),
+  // rc.9+ (skill-contract-fix B1): rerun import window in months. After
+  // the first successful import, subsequent runs only scan this many
+  // recent months — assumed everything older has already been crystallized
+  // into pending or canonical knowledge. Default 2 keeps incremental cost
+  // low; raise to 6 if the workspace pauses fabric-import for long stretches.
+  import_window_rerun_months: z5.number().int().min(1).optional().default(2),
+  // rc.9+ (skill-contract-fix B1): hard cap on pending entries produced
+  // per fabric-import invocation. Prevents one run from dumping hundreds
+  // of proposals when a backfill window is wide open. Default 10 matches
+  // the rule-of-thumb "human can triage ~10 pending entries in one
+  // review pass." Range 1-50.
+  import_max_pending_per_run: z5.number().int().min(1).max(50).optional().default(10),
+  // rc.9+ (skill-contract-fix B1): hard cap on commits scanned per
+  // fabric-import invocation. Bounds runtime on monorepos with high
+  // commit velocity. Default 500 covers ~2 months of typical churn;
+  // range 50-2000. Hitting the cap mid-window is logged but non-fatal.
+  import_max_commits_scan: z5.number().int().min(50).max(2e3).optional().default(500),
+  // rc.9+ (skill-contract-fix B1): canonical-node count above which
+  // fabric-import's pre-flight should warn / suggest review instead of
+  // proceeding. A workspace with 50+ canonical entries usually benefits
+  // more from `fabric-review` to consolidate than from importing more.
+  // Default 50; raise to 100+ for large polyglot repos.
+  import_skip_canonical_threshold: z5.number().int().positive().optional().default(50),
+  // rc.9+ (skill-contract-fix B1): max candidate entries surfaced per
+  // fabric-archive batch (one invocation of the skill). Pagination knob
+  // for the archive UI flow. Default 8 keeps each batch reviewable in
+  // one sitting; raise for large repos with high archive throughput.
+  archive_max_candidates_per_batch: z5.number().int().positive().optional().default(8),
+  // rc.9+ (skill-contract-fix B1): max recently-touched paths included
+  // in fabric-archive's "relevant context" lookup. Limits the size of
+  // the path-relevance digest the skill emits when ranking candidates.
+  // Default 20; large repos with deep directory fan-out can raise to
+  // 50+ if archive candidates feel under-contextualized.
+  archive_max_recent_paths: z5.number().int().positive().optional().default(20),
+  // rc.9+ (skill-contract-fix B1): max prior fabric-archive sessions
+  // summarised in the digest the skill loads on start. Prevents the
+  // digest from ballooning past the model context budget on workspaces
+  // that have archived repeatedly. Default 10; lower if context pressure
+  // bites, raise if you want longer-range archive trend visibility.
+  archive_digest_max_sessions: z5.number().int().positive().optional().default(10),
+  // rc.9+ (skill-contract-fix B1): max review results returned per
+  // topic when `fabric-review` clusters pending entries. Pagination
+  // knob analogous to archive_max_candidates_per_batch but scoped to
+  // each topic cluster. Default 8; raise to 15-20 for large repos
+  // where each topic legitimately groups many pending entries.
+  review_topic_result_cap: z5.number().int().positive().optional().default(8),
+  // rc.9+ (skill-contract-fix B1): age threshold (in days) above which
+  // a pending entry is considered "stale" by fabric-review and surfaced
+  // for explicit resolve-or-drop decision. Default 14; tighter than the
+  // 7d Signal-B trigger because review specifically targets the long
+  // tail. Large repos with slower cadence can raise to 30.
+  review_stale_pending_days: z5.number().int().positive().optional().default(14),
+  // v2.0.0-rc.34 TASK-05: reverse-unarchive opt-in. When true, callers of the
+  // `unarchiveKnowledge` primitive (and any future doctor auto-detect lint built
+  // on top) will execute the file move + ledger emit. When false (default),
+  // the same callers MUST short-circuit before any mutation — the primitive is
+  // shipped but inert until explicitly enabled. Opt-in posture mirrors the
+  // archive-flow precedent: destructive-ish file moves stay behind a flag.
+  reverse_unarchive_enabled: z5.boolean().optional().default(false),
+  // v2.0.0-rc.34 TASK-05: forces `unarchiveKnowledge` into dry-run mode even
+  // when called with `options.dryRun=false`. Lets operators preview a
+  // restoration pass before flipping `reverse_unarchive_enabled` to true.
+  reverse_unarchive_dry_run: z5.boolean().optional().default(false),
+  // v2.0.0-rc.34 TASK-06: long-session cite-policy evict window in user-prompt
+  // turns. UserPromptSubmit hook (Claude Code only) maintains a per-session
+  // counter and re-injects the cite contract reminder via
+  // hookSpecificOutput.additionalContext when `turn_count % interval === 0`.
+  // Default 0 = OFF (opt-in). Recommend 10-20 for active sessions; 5 for
+  // high-contract-criticality projects. Other strategies (time-based,
+  // token-budget) deferred to rc.35 per plan locked-decisions 2026-05-26.
+  cite_evict_interval: z5.number().int().min(0).optional().default(0),
+  // v2.0.0-rc.22 Scope A T3: sliding-window retention (in days) for the
+  // event ledger rotation primitive (`rotateEventLedgerIfNeeded`). Lines
+  // whose `ts` is older than `now - fabric_event_retention_days * 86_400_000`
+  // are partitioned into `.fabric/events.archive/events-rotated-YYYY-MM-DD.jsonl`.
+  // Locked to 7/30/90 — three operator-friendly preset windows. Default 30
+  // is applied at the consumer site (rotateEventLedgerIfNeeded), so this
+  // field stays `.optional()` without a `.default()` to keep the schema
+  // surface honest: absence means "use the library default", not "schema
+  // default of 30 was injected." 7 = ~tight, 30 = balanced, 90 = forensic.
+  // Mirrors cite-policy precedent of locking enum-style numeric tunables
+  // to a small literal set (vs free `.positive()`) to prevent fat-finger
+  // misconfig.
+  fabric_event_retention_days: z5.union([z5.literal(7), z5.literal(30), z5.literal(90)]).optional(),
+  // v2.0.0-rc.23 TASK-014 (F8c): onboard slot opt-out list. Tracks slot
+  // names the user explicitly dismissed during fabric-archive's first-run
+  // onboard phase (or via `fabric config dismiss-slot <slot>`). Dismissed
+  // slots are excluded from `fabric onboard-coverage`'s `missing` set and the
+  // doctor `Onboard coverage` advisory's recompute, so the user is never
+  // re-prompted for slots they consciously declined.
+  //
+  // Re-opening a dismissed slot requires `fabric config onboard-reset <slot>`
+  // — a deliberate two-command UX to keep the dismiss intent reversible
+  // but never silently undone. Schema is intentionally `z.array(z.string())`
+  // rather than `z.array(onboardSlotSchema)` so historical configs survive
+  // a slot rename without a Zod parse error; downstream consumers
+  // intersect against ONBOARD_SLOT_NAMES at read time.
+  //
+  // Default `[]` keeps the field optional on existing configs — fresh
+  // installs land with no opt-outs.
+  onboard_slots_opted_out: z5.array(z5.string()).optional().default([]),
+  // v2.0.0-rc.33 W2-1 (P0-9): TopK upper bound for the broad SessionStart hint
+  // banner emitted by knowledge-hint-broad.cjs. After plan-context-hint returns
+  // its full broad-scoped index, the hook slices the entries to this many
+  // before grouping/truncation rendering — keeps the banner from scrolling off
+  // screen on well-seeded repos (Werewolf-class projects routinely surface 40+
+  // broad entries which buried the actually-relevant top hits). Default 8 is
+  // calibrated against the rc.32 eval baseline (cite-coverage 3.1%): the
+  // banner needs to fit in ~1 screenful so the agent actually reads it.
+  // Range 1..50; values above 20 effectively disable the cap because the
+  // TRUNCATION_THRESHOLD=12 grouped-render kicks in. Mirrors the rc.7 T7 +
+  // archive_max_* pattern of externalizing previously-hardcoded thresholds.
+  hint_broad_top_k: z5.number().int().min(1).max(50).optional().default(8),
+  // v2.0.0-rc.37 NEW-16: durable per-signal dismiss for the fabric-hint Stop
+  // hook nudges. Any signal type listed here is suppressed at emit time across
+  // all sessions (the session-scoped sibling lives in a .fabric/.cache sidecar
+  // written on request). Mirrors the cite_evict_interval=0 opt-out convention —
+  // a knob for an existing surface, not a new feature. Unknown types ignored.
+  hint_dismiss_signals: z5.array(z5.enum(["archive", "review", "import", "maintenance"])).optional(),
+  // v2.0.0-rc.33 W2-1 (P0-9): TopK upper bound for the narrow PreToolUse hint
+  // emitted by knowledge-hint-narrow.cjs. After filtering to entries whose
+  // `relevance_scope === "narrow"` (rc.27 TASK-005 audit §2.5 fix), the hook
+  // slices to this many before the E3 emit-gate / renderSummary pipeline.
+  // Default 5 keeps each per-Edit hint terse — five lines max so the agent's
+  // working memory is not displaced by an unwieldy banner. Range 1..20.
+  hint_narrow_top_k: z5.number().int().min(1).max(20).optional().default(5),
+  // v2.0.0-rc.33 W2-1 (P0-9): per-file dedup window (in PreToolUse turns) for
+  // the narrow hint. Same (file_path, stable_id) tuple stays silent for this
+  // many turns even when the E3 cross-session cache would otherwise re-emit.
+  // Closes the rc.32 eval finding that a single hot file (e.g. werewolf
+  // GameRoom.tsx edited 30 times in a row) re-fired the same narrow hint
+  // each time, training the agent to ignore it. Default 5; range 1..50.
+  // Storage: .fabric/.cache/narrow-dedup-window.json — distinct from session-
+  // hints cache so a window-only suppression does not poison cross-session
+  // dedupe semantics.
+  hint_narrow_dedup_window_turns: z5.number().int().min(1).max(50).optional().default(5),
+  // v2.0.0-rc.33 W2-5 (P1-8): cooldown between broad SessionStart hint emits,
+  // in hours. Distinct from the archive_hint_cooldown_hours that gates the
+  // fabric-hint Stop hook — knowledge-hint-broad re-fires on every
+  // SessionStart by default (compact / clear / new-window), which on long
+  // sessions becomes redundant noise. Setting to 1 means "emit the broad
+  // menu at most once per hour"; 0 means "no cooldown, current behavior."
+  // Range 0..168 (one week). Stored alongside fabric-hint's cooldown cache
+  // under a distinct knowledge-hint-broad key.
+  hint_broad_cooldown_hours: z5.number().int().min(0).max(168).optional().default(0),
+  // v2.0.0-rc.33 W2-5 (P1-8): cooldown for the narrow PreToolUse hint.
+  // Same shape as hint_broad_cooldown_hours but applies to per-Edit hint
+  // re-emission across the cooldown window — independent of E3 session-
+  // hints dedupe. Default 0 preserves rc.32 behavior; set to e.g. 1 to
+  // throttle hint frequency during rapid-fire editing sprints. Range
+  // 0..168 (one week).
+  hint_narrow_cooldown_hours: z5.number().int().min(0).max(168).optional().default(0),
+  // v2.0.0-rc.33 W4-B3 (T5 P2): per-maturity inactivity thresholds (days)
+  // driving orphan_demote. Hardcoded at stable=90/endorsed=30/draft=14 in
+  // rc.32; chatty workspaces want them tighter, slow ones want them looser.
+  // Each field optional; absent → defaults inside doctor.ts apply. Ranges
+  // chosen so a typo can't accidentally disable the lint (min 1).
+  orphan_demote_stable_days: z5.number().int().min(1).max(3650).optional(),
+  orphan_demote_endorsed_days: z5.number().int().min(1).max(3650).optional(),
+  orphan_demote_draft_days: z5.number().int().min(1).max(3650).optional(),
+  // v2.0.0-rc.33 W4-A3 (T4 P2): per-entry summary truncation length used by
+  // knowledge-hint-{broad,narrow}.cjs. Hard-coded at 80 chars in rc.32 — too
+  // short for entries with parameterized summaries (e.g. "Use bcrypt with
+  // cost=12 for password hashing"), too long for terse pitfalls. Range 40..240;
+  // default 80 preserves rc.32 behavior. Both hooks read the same key so the
+  // banner styling stays consistent across SessionStart + PreToolUse.
+  hint_summary_max_len: z5.number().int().min(40).max(240).optional().default(80),
+  // v2.0.0-rc.33 W2-6 (P0-7 + P0-8): when true, knowledge-hint hooks emit
+  // their banners as `hookSpecificOutput.additionalContext` JSON on stdout
+  // (per Claude Code PreToolUse hook contract — see
+  // https://docs.claude.com/en/docs/claude-code/hooks#preToolUse), so the
+  // agent receives them in-context instead of as stderr breadcrumbs the
+  // user may not surface to the model. Default true reflects the rc.33 cite-
+  // coverage focus (rc.32 baseline 3.1% → primary cause: reminders never
+  // entered model context). Set false to revert to legacy stderr-only mode
+  // for hosts that don't honor the JSON contract.
+  hint_reminder_to_context: z5.boolean().optional().default(true),
+  // v2.0.0-rc.29 TASK-008 (BUG-F3): selection-token TTL override. The
+  // `fab_plan_context` MCP tool hands clients a `selection_token` whose default
+  // 5-minute lifetime (`SELECTION_TOKEN_TTL_MS` at
+  // packages/server/src/services/plan-context.ts:91) was hard-coded and could
+  // not be tuned for slow review cycles. Operators on long-running sessions
+  // (manual paste-and-review flows, debugger pauses, etc.) reported tokens
+  // expiring mid-review. Override here; absence means "use the library default
+  // of 5*60*1000 ms." Range 30s..1h keeps the value useful — below 30s the
+  // token expires before MCP round-trips finish; above 1h it stops being a
+  // meaningful liveness signal for the plan-context cache.
+  //
+  // The single-field schema is exported separately (`selectionTokenTtlMsSchema`)
+  // so the server-side per-field reader can validate without re-running the
+  // whole fabricConfigSchema on every plan_context call — that lets a corrupt
+  // unrelated field stay isolated from the hot read path.
+  selection_token_ttl_ms: selectionTokenTtlMsSchema.optional()
 });
 
-// src/schemas/forensic-report.ts
+// src/schemas/fabric-config-introspect.ts
 import { z as z6 } from "zod";
-var forensicCodeSampleSchema = z6.object({
-  path: z6.string(),
-  lines: z6.string(),
-  snippet: z6.string(),
-  pattern_hint: z6.string()
-});
-var forensicEvidenceAnchorSchema = z6.object({
-  file: z6.string(),
-  line: z6.string(),
-  snippet: z6.string()
-});
-var forensicAssertionCoverageSchema = z6.object({
-  ratio: z6.number().min(0).max(1),
-  total: z6.number().int().nonnegative(),
-  matched: z6.number().int().nonnegative(),
-  co_occurring_patterns: z6.array(z6.string())
-});
-var forensicAssertionSchema = z6.object({
-  type: z6.enum(["framework", "pattern", "invariant", "domain"]),
-  statement: z6.string(),
-  confidence: z6.enum(["HIGH", "MEDIUM", "LOW"]),
-  evidence: z6.array(forensicEvidenceAnchorSchema),
+var positiveIntSchema = z6.coerce.number().int().positive();
+function makePositiveIntField(key, defaultValue) {
+  return {
+    key,
+    group: "B_hint_threshold",
+    widget: "text",
+    label_i18n_key: `cli.config.fields.${key}.label`,
+    description_i18n_key: `cli.config.fields.${key}.description`,
+    default: defaultValue,
+    validate(raw) {
+      const trimmed = raw.trim();
+      if (trimmed === "") {
+        return { ok: false, error: "Value is required (positive integer)." };
+      }
+      const parsed = positiveIntSchema.safeParse(trimmed);
+      if (!parsed.success) {
+        return {
+          ok: false,
+          error: "Must be a positive integer (e.g. 1, 12, 24)."
+        };
+      }
+      return { ok: true, value: parsed.data };
+    },
+    format_for_display(value) {
+      if (typeof value === "number") return String(value);
+      if (value === void 0 || value === null) return String(defaultValue);
+      return String(value);
+    }
+  };
+}
+function makeEnumField(key, group, enumValues, defaultValue) {
+  return {
+    key,
+    group,
+    widget: "select",
+    label_i18n_key: `cli.config.fields.${key}.label`,
+    description_i18n_key: `cli.config.fields.${key}.description`,
+    default: defaultValue,
+    enum_values: enumValues,
+    validate(raw) {
+      const trimmed = raw.trim();
+      if (!enumValues.includes(trimmed)) {
+        return {
+          ok: false,
+          error: `Must be one of: ${enumValues.join(", ")}.`
+        };
+      }
+      return { ok: true, value: trimmed };
+    },
+    format_for_display(value) {
+      if (typeof value === "string" && enumValues.includes(value)) return value;
+      if (value === void 0 || value === null) return defaultValue;
+      return String(value);
+    }
+  };
+}
+var SCHEMA_DEFAULTS = fabricConfigSchema.parse({});
+function pickNumberDefault(key) {
+  const v = SCHEMA_DEFAULTS[key];
+  if (typeof v !== "number") {
+    throw new Error(
+      `fabric-config-introspect: expected numeric default for ${String(key)}, got ${typeof v}`
+    );
+  }
+  return v;
+}
+function pickStringDefault(key) {
+  const v = SCHEMA_DEFAULTS[key];
+  if (typeof v !== "string") {
+    throw new Error(
+      `fabric-config-introspect: expected string default for ${String(key)}, got ${typeof v}`
+    );
+  }
+  return v;
+}
+var AUDIT_MODE_PANEL_DEFAULT = "warn";
+function getPanelFields() {
+  return PANEL_FIELDS;
+}
+function getPanelFieldByKey(key) {
+  return PANEL_FIELDS.find((f) => f.key === key);
+}
+var PANEL_FIELDS = [
+  // --- Group A: Locale (2) ---
+  makeEnumField(
+    "fabric_language",
+    "A_locale",
+    fabricLanguageSchema.options,
+    pickStringDefault("fabric_language")
+  ),
+  makeEnumField(
+    "default_layer_filter",
+    "A_locale",
+    defaultLayerFilterSchema.options,
+    pickStringDefault("default_layer_filter")
+  ),
+  // --- Group B: Hint thresholds (8 — see leading docstring for the
+  //     7-vs-8 reconciliation; archive_edit_threshold is the 8th key) ---
+  makePositiveIntField("archive_hint_hours", pickNumberDefault("archive_hint_hours")),
+  makePositiveIntField(
+    "archive_hint_cooldown_hours",
+    pickNumberDefault("archive_hint_cooldown_hours")
+  ),
+  makePositiveIntField(
+    "archive_edit_threshold",
+    pickNumberDefault("archive_edit_threshold")
+  ),
+  makePositiveIntField(
+    "underseed_node_threshold",
+    pickNumberDefault("underseed_node_threshold")
+  ),
+  makePositiveIntField(
+    "review_hint_pending_count",
+    pickNumberDefault("review_hint_pending_count")
+  ),
+  makePositiveIntField(
+    "review_hint_pending_age_days",
+    pickNumberDefault("review_hint_pending_age_days")
+  ),
+  makePositiveIntField(
+    "maintenance_hint_days",
+    pickNumberDefault("maintenance_hint_days")
+  ),
+  makePositiveIntField(
+    "maintenance_hint_cooldown_days",
+    pickNumberDefault("maintenance_hint_cooldown_days")
+  ),
+  // --- Group C: Audit (1) ---
+  makeEnumField(
+    "audit_mode",
+    "C_audit",
+    auditModeSchema.options,
+    AUDIT_MODE_PANEL_DEFAULT
+  )
+];
+
+// src/schemas/forensic-report.ts
+import { z as z7 } from "zod";
+var forensicCodeSampleSchema = z7.object({
+  path: z7.string(),
+  lines: z7.string(),
+  snippet: z7.string(),
+  pattern_hint: z7.string()
+});
+var forensicEvidenceAnchorSchema = z7.object({
+  file: z7.string(),
+  line: z7.string(),
+  snippet: z7.string()
+});
+var forensicAssertionCoverageSchema = z7.object({
+  ratio: z7.number().min(0).max(1),
+  total: z7.number().int().nonnegative(),
+  matched: z7.number().int().nonnegative(),
+  co_occurring_patterns: z7.array(z7.string())
+});
+var forensicAssertionSchema = z7.object({
+  type: z7.enum(["framework", "pattern", "invariant", "domain"]),
+  statement: z7.string(),
+  confidence: z7.enum(["HIGH", "MEDIUM", "LOW"]),
+  evidence: z7.array(forensicEvidenceAnchorSchema),
   coverage: forensicAssertionCoverageSchema,
-  proposed_rule: z6.string().optional(),
-  alternatives: z6.array(z6.string()).optional()
-});
-var forensicTopologySchema = z6.object({
-  total_files: z6.number().int().nonnegative(),
-  by_ext: z6.record(z6.number().int().nonnegative()),
-  key_dirs: z6.array(z6.string()),
-  max_depth: z6.number().int().nonnegative()
-});
-var forensicEntryPointSchema = z6.object({
-  path: z6.string(),
-  reason: z6.string(),
-  size_bytes: z6.number().int().nonnegative().optional()
-});
-var forensicFrameworkSchema = z6.object({
-  kind: z6.string(),
-  version: z6.string(),
-  subkind: z6.string(),
-  evidence: z6.array(z6.string())
-});
-var forensicReadmeSchema = z6.object({
-  quality: z6.enum(["missing", "stub", "ok"]),
-  line_count: z6.number().int().nonnegative(),
-  has_contributing: z6.boolean()
-});
-var candidateFileEntrySchema = z6.object({
-  path: z6.string(),
-  family: z6.enum(["entry", "component", "config", "test", "domain"]),
-  rationale: z6.string()
-});
-var forensicSamplingBudgetSchema = z6.object({
-  max_files: z6.literal(15),
-  max_lines_per_file: z6.literal(100)
-});
-var forensicReportSchema = z6.object({
-  version: z6.string(),
-  generated_at: z6.string(),
-  generated_by: z6.string(),
-  target: z6.string(),
-  project_name: z6.string(),
+  proposed_rule: z7.string().optional(),
+  alternatives: z7.array(z7.string()).optional()
+});
+var forensicTopologySchema = z7.object({
+  total_files: z7.number().int().nonnegative(),
+  by_ext: z7.record(z7.number().int().nonnegative()),
+  key_dirs: z7.array(z7.string()),
+  max_depth: z7.number().int().nonnegative()
+});
+var forensicEntryPointSchema = z7.object({
+  path: z7.string(),
+  reason: z7.string(),
+  size_bytes: z7.number().int().nonnegative().optional()
+});
+var forensicFrameworkSchema = z7.object({
+  kind: z7.string(),
+  version: z7.string(),
+  subkind: z7.string(),
+  evidence: z7.array(z7.string())
+});
+var forensicReadmeSchema = z7.object({
+  quality: z7.enum(["missing", "stub", "ok"]),
+  line_count: z7.number().int().nonnegative(),
+  has_contributing: z7.boolean()
+});
+var candidateFileEntrySchema = z7.object({
+  path: z7.string(),
+  family: z7.enum(["entry", "component", "config", "test", "domain"]),
+  rationale: z7.string()
+});
+var forensicSamplingBudgetSchema = z7.object({
+  max_files: z7.literal(15),
+  max_lines_per_file: z7.literal(100)
+});
+var forensicReportSchema = z7.object({
+  version: z7.string(),
+  generated_at: z7.string(),
+  generated_by: z7.string(),
+  target: z7.string(),
+  project_name: z7.string(),
   framework: forensicFrameworkSchema,
   topology: forensicTopologySchema,
-  entry_points: z6.array(forensicEntryPointSchema),
-  code_samples: z6.array(forensicCodeSampleSchema),
-  assertions: z6.array(forensicAssertionSchema),
-  candidate_files: z6.array(candidateFileEntrySchema),
+  entry_points: z7.array(forensicEntryPointSchema),
+  code_samples: z7.array(forensicCodeSampleSchema),
+  assertions: z7.array(forensicAssertionSchema),
+  candidate_files: z7.array(candidateFileEntrySchema),
   sampling_budget: forensicSamplingBudgetSchema,
   readme: forensicReadmeSchema,
-  recommendations_for_skill: z6.array(z6.string()).optional()
+  recommendations_for_skill: z7.array(z7.string()).optional()
 });
 
 // src/schemas/init-context.ts
-import { z as z7 } from "zod";
-var initContextFrameworkSchema = z7.object({
-  kind: z7.string(),
-  version: z7.string(),
-  subkind: z7.string()
+import { z as z8 } from "zod";
+var initContextFrameworkSchema = z8.object({
+  kind: z8.string(),
+  version: z8.string(),
+  subkind: z8.string()
 });
-var initContextInvariantConfidenceSnapshotSchema = z7.object({
-  confidence: z7.enum(["HIGH", "MEDIUM", "LOW"]),
-  evidence_refs: z7.array(z7.string())
+var initContextInvariantConfidenceSnapshotSchema = z8.object({
+  confidence: z8.enum(["HIGH", "MEDIUM", "LOW"]),
+  evidence_refs: z8.array(z8.string())
 });
-var initContextSourceEvidenceSchema = z7.object({
-  file: z7.string(),
-  lines: z7.string()
+var initContextSourceEvidenceSchema = z8.object({
+  file: z8.string(),
+  lines: z8.string()
 });
-var initContextInvariantSchema = z7.object({
-  type: z7.enum(["ban", "require", "protect"]),
-  rule: z7.string(),
-  rationale: z7.string().optional(),
+var initContextInvariantSchema = z8.object({
+  type: z8.enum(["ban", "require", "protect"]),
+  rule: z8.string(),
+  rationale: z8.string().optional(),
   confidence_snapshot: initContextInvariantConfidenceSnapshotSchema.optional(),
-  source_evidence: z7.array(initContextSourceEvidenceSchema).optional()
-});
-var initContextDomainGroupSchema = z7.object({
-  name: z7.string(),
-  paths: z7.array(z7.string()),
-  summary: z7.string().optional(),
-  topology_type: z7.enum(["mirror", "cross-cutting"]).optional(),
-  target_path: z7.string().optional()
-});
-var initContextInterviewTrailEntrySchema = z7.object({
-  phase: z7.string(),
-  question: z7.string(),
-  answer: z7.string(),
-  presentation: z7.string().optional(),
-  user_corrections: z7.array(z7.string()).optional()
-});
-var initContextSchema = z7.object({
+  source_evidence: z8.array(initContextSourceEvidenceSchema).optional()
+});
+var initContextDomainGroupSchema = z8.object({
+  name: z8.string(),
+  paths: z8.array(z8.string()),
+  summary: z8.string().optional(),
+  topology_type: z8.enum(["mirror", "cross-cutting"]).optional(),
+  target_path: z8.string().optional()
+});
+var initContextInterviewTrailEntrySchema = z8.object({
+  phase: z8.string(),
+  question: z8.string(),
+  answer: z8.string(),
+  presentation: z8.string().optional(),
+  user_corrections: z8.array(z8.string()).optional()
+});
+var initContextSchema = z8.object({
   framework: initContextFrameworkSchema,
-  architecture_patterns: z7.array(z7.string()),
-  invariants: z7.array(initContextInvariantSchema),
-  domain_groups: z7.array(initContextDomainGroupSchema),
-  interview_trail: z7.array(initContextInterviewTrailEntrySchema),
-  forensic_ref: z7.string()
+  architecture_patterns: z8.array(z8.string()),
+  invariants: z8.array(initContextInvariantSchema),
+  domain_groups: z8.array(initContextDomainGroupSchema),
+  interview_trail: z8.array(initContextInterviewTrailEntrySchema),
+  forensic_ref: z8.string()
 });
 
 // src/schemas/events.ts
-import { z as z8 } from "zod";
-var metaUpdatedEventSchema = z8.object({
-  type: z8.literal("meta:updated"),
+import { z as z9 } from "zod";
+var metaUpdatedEventSchema = z9.object({
+  type: z9.literal("meta:updated"),
   payload: agentsMetaSchema
 });
-var lockDriftEventSchema = z8.object({
-  type: z8.literal("lock:drift"),
-  payload: z8.object({
-    locked: z8.array(humanLockEntrySchema),
-    drifted: z8.array(humanLockEntrySchema)
+var lockDriftEventSchema = z9.object({
+  type: z9.literal("lock:drift"),
+  payload: z9.object({
+    locked: z9.array(humanLockEntrySchema),
+    drifted: z9.array(humanLockEntrySchema)
   })
 });
-var lockApprovedEventSchema = z8.object({
-  type: z8.literal("lock:approved"),
-  payload: z8.object({
-    locked: z8.array(humanLockEntrySchema),
-    approved: z8.array(humanLockEntrySchema)
+var lockApprovedEventSchema = z9.object({
+  type: z9.literal("lock:approved"),
+  payload: z9.object({
+    locked: z9.array(humanLockEntrySchema),
+    approved: z9.array(humanLockEntrySchema)
   })
 });
-var ledgerAppendedEventSchema = z8.object({
-  type: z8.literal("ledger:appended"),
+var ledgerAppendedEventSchema = z9.object({
+  type: z9.literal("ledger:appended"),
   payload: ledgerEntrySchema
 });
-var driftDetectedEventSchema = z8.object({
-  type: z8.literal("drift:detected"),
+var driftDetectedEventSchema = z9.object({
+  type: z9.literal("drift:detected"),
   payload: forensicReportSchema
 });
-var fabricEventSchema = z8.discriminatedUnion("type", [
+var fabricEventSchema = z9.discriminatedUnion("type", [
   metaUpdatedEventSchema,
   lockDriftEventSchema,
   lockApprovedEventSchema,
@@ -532,271 +915,426 @@ var fabricEventSchema = z8.discriminatedUnion("type", [
 ]);
 
 // src/schemas/event-ledger.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var eventLedgerEnvelopeSchema = {
-  kind: z9.literal("fabric-event"),
-  id: z9.string(),
-  ts: z9.number().int().nonnegative(),
-  schema_version: z9.literal(1),
-  correlation_id: z9.string().optional(),
-  session_id: z9.string().optional()
+  kind: z10.literal("fabric-event"),
+  id: z10.string(),
+  ts: z10.number().int().nonnegative(),
+  schema_version: z10.literal(1),
+  correlation_id: z10.string().optional(),
+  session_id: z10.string().optional()
 };
-var stringRecordSchema = z9.record(z9.string());
-var knowledgeContextPlannedEventSchema = z9.object({
-  ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_context_planned"),
-  target_paths: z9.array(z9.string()),
-  required_stable_ids: z9.array(z9.string()),
-  ai_selectable_stable_ids: z9.array(z9.string()),
-  final_stable_ids: z9.array(z9.string()),
-  selection_token: z9.string().optional(),
-  client_hash: z9.string().optional(),
-  intent: z9.string().optional(),
-  known_tech: z9.array(z9.string()).optional(),
-  diagnostics: z9.array(z9.unknown()).optional()
-});
-var knowledgeSelectionEventSchema = z9.object({
-  ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_selection"),
-  selection_token: z9.string(),
-  target_paths: z9.array(z9.string()),
-  required_stable_ids: z9.array(z9.string()),
-  ai_selectable_stable_ids: z9.array(z9.string()),
-  ai_selected_stable_ids: z9.array(z9.string()),
-  final_stable_ids: z9.array(z9.string()),
+var stringRecordSchema = z10.record(z10.string());
+var knowledgeContextPlannedEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("knowledge_context_planned"),
+  target_paths: z10.array(z10.string()),
+  required_stable_ids: z10.array(z10.string()),
+  ai_selectable_stable_ids: z10.array(z10.string()),
+  final_stable_ids: z10.array(z10.string()),
+  selection_token: z10.string().optional(),
+  client_hash: z10.string().optional(),
+  intent: z10.string().optional(),
+  known_tech: z10.array(z10.string()).optional(),
+  diagnostics: z10.array(z10.unknown()).optional()
+});
+var knowledgeSelectionEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("knowledge_selection"),
+  selection_token: z10.string(),
+  target_paths: z10.array(z10.string()),
+  required_stable_ids: z10.array(z10.string()),
+  ai_selectable_stable_ids: z10.array(z10.string()),
+  ai_selected_stable_ids: z10.array(z10.string()),
+  final_stable_ids: z10.array(z10.string()),
   ai_selection_reasons: stringRecordSchema,
-  rejected_stable_ids: z9.array(z9.string()),
-  ignored_stable_ids: z9.array(z9.string())
-});
-var knowledgeSectionsFetchedEventSchema = z9.object({
-  ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_sections_fetched"),
-  selection_token: z9.string(),
-  target_paths: z9.array(z9.string()).optional(),
-  requested_sections: z9.array(z9.string()),
-  final_stable_ids: z9.array(z9.string()),
-  ai_selected_stable_ids: z9.array(z9.string()),
-  diagnostics: z9.array(z9.unknown()).optional()
-});
-var editIntentCheckedEventSchema = z9.object({
-  ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("edit_intent_checked"),
-  path: z9.string(),
-  compliant: z9.boolean(),
-  intent: z9.string(),
-  ledger_entry_id: z9.string(),
-  ledger_source: z9.enum(["ai", "human"]).optional(),
-  commit_sha: z9.string().optional(),
-  parent_sha: z9.string().optional(),
-  parent_ledger_entry_id: z9.string().optional(),
-  diff_stat: z9.string().optional(),
-  annotation: z9.string().optional(),
-  matched_rule_context_ts: z9.number().int().nonnegative().nullable(),
-  window_ms: z9.number().int().nonnegative()
-});
-var knowledgeDriftDetectedEventSchema = z9.object({
-  ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_drift_detected"),
-  revision: z9.string().optional(),
-  drifted_stable_ids: z9.array(z9.string()),
-  missing_files: z9.array(z9.string()),
-  stale_files: z9.array(z9.string()),
-  details: z9.array(
-    z9.object({
-      file: z9.string(),
-      stable_id: z9.string(),
-      expected_hash: z9.string(),
-      actual_hash: z9.string().nullable()
+  rejected_stable_ids: z10.array(z10.string()),
+  ignored_stable_ids: z10.array(z10.string())
+});
+var knowledgeSectionsFetchedEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("knowledge_sections_fetched"),
+  selection_token: z10.string(),
+  target_paths: z10.array(z10.string()).optional(),
+  requested_sections: z10.array(z10.string()),
+  final_stable_ids: z10.array(z10.string()),
+  ai_selected_stable_ids: z10.array(z10.string()),
+  diagnostics: z10.array(z10.unknown()).optional()
+});
+var editIntentCheckedEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("edit_intent_checked"),
+  path: z10.string(),
+  compliant: z10.boolean(),
+  intent: z10.string(),
+  ledger_entry_id: z10.string(),
+  // rc.35 TASK-07 (P0-2): add "hook" — emitted by the PreToolUse narrow hook
+  // for every Edit/Write/MultiEdit fire so cite-coverage doctor metrics see
+  // actual edit signals (previously editsTouched was permanently 0 because
+  // no production caller of appendLedgerEntry existed).
+  ledger_source: z10.enum(["ai", "human", "hook"]).optional(),
+  commit_sha: z10.string().optional(),
+  parent_sha: z10.string().optional(),
+  parent_ledger_entry_id: z10.string().optional(),
+  diff_stat: z10.string().optional(),
+  annotation: z10.string().optional(),
+  matched_rule_context_ts: z10.number().int().nonnegative().nullable(),
+  window_ms: z10.number().int().nonnegative()
+});
+var knowledgeDriftDetectedEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("knowledge_drift_detected"),
+  revision: z10.string().optional(),
+  drifted_stable_ids: z10.array(z10.string()),
+  missing_files: z10.array(z10.string()),
+  stale_files: z10.array(z10.string()),
+  details: z10.array(
+    z10.object({
+      file: z10.string(),
+      stable_id: z10.string(),
+      expected_hash: z10.string(),
+      actual_hash: z10.string().nullable()
     })
   ).optional()
 });
-var mcpEventLedgerEventSchema = z9.object({
+var mcpEventLedgerEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("mcp_event"),
+  mcp_event_id: z10.string(),
+  stream_id: z10.string(),
+  message: z10.unknown()
+});
+var reapplyCompletedEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("reapply_completed"),
+  preserved_ledger: z10.boolean(),
+  preserved_meta: z10.boolean(),
+  rules_count: z10.number().int().nonnegative()
+});
+var installDiffAppliedEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("install_diff_applied"),
+  applied: z10.array(z10.string()),
+  canonical: z10.array(z10.string()),
+  drifted: z10.array(z10.string())
+});
+var eventLedgerTruncatedEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("event_ledger_truncated"),
+  byte_offset: z10.number().int().nonnegative(),
+  byte_length: z10.number().int().nonnegative(),
+  corrupted_path: z10.string()
+});
+var mcpConfigMigratedEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("mcp_config_migrated"),
+  source: z10.literal("doctor_fix"),
+  removed_from: z10.string()
+});
+var bootstrapMarkerMigratedEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("bootstrap_marker_migrated"),
+  path: z10.string(),
+  migrated_count: z10.number().int().nonnegative(),
+  legacy_marker: z10.literal("fabric:knowledge-base"),
+  new_marker: z10.literal("fabric:bootstrap"),
+  timestamp: z10.string()
+});
+var metaReconciledOnStartupEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("meta_reconciled_on_startup"),
+  reconciled_files: z10.array(z10.string()),
+  duration_ms: z10.number().int().nonnegative(),
+  source: z10.literal("reconcileKnowledge")
+});
+var metaReconciledEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("meta_reconciled"),
+  reconciled_files: z10.array(z10.string()),
+  duration_ms: z10.number().int().nonnegative(),
+  // v2.0.0-rc.23 TASK-005 (a-B): added `auto-heal-description` trigger so the
+  // read-path plan_context handler can drive a full reconcile when it detects
+  // any node carrying `description === undefined` (legacy meta drift that the
+  // revision-hash gate cannot catch — a missing description doesn't move the
+  // revision). Symmetric to rc.22 D2 read-side auto-heal but covers the
+  // description-undefined case which the revision drift gate misses.
+  // v2.0.0-rc.27 TASK-001 (§2.9): `post-approve` / `post-modify` added so
+  // `fab_review` write-actions can flush newly-promoted entries into
+  // `agents.meta.json.nodes[id]` synchronously — without this the new entry
+  // remains description-less until the next plan_context auto-heal.
+  // v2.0.0-rc.29 TASK-005 (BUG-G1): `auto-heal-after-drift` added so
+  // `ensureKnowledgeFresh` hot-path can chain a paired reconcile (closing the
+  // drift→heal gap) when the caller opts in via `autoHealOnDrift: true`.
+  trigger: z10.enum([
+    "doctor",
+    "manual",
+    "auto-heal-description",
+    "auto-heal-after-drift",
+    "post-approve",
+    "post-modify"
+  ]),
+  source: z10.literal("reconcileKnowledge"),
+  // v2.0.0-rc.22 TASK-014 (Scope E): set when reconcileKnowledge forced a
+  // writeKnowledgeMeta on revision drift alone (no per-file content drift).
+  // Distinguishes top-level schema/revision repair from the standard per-file
+  // drift path. Optional so existing emitters stay unchanged.
+  force_write_reason: z10.enum(["revision_drift"]).optional()
+});
+var claudeSkillPathMigratedEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("claude_skill_path_migrated"),
+  from: z10.string(),
+  to: z10.string()
+});
+var claudeHookPathMigratedEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("claude_hook_path_migrated"),
+  from: z10.string(),
+  to: z10.string()
+});
+var codexSkillPathMigratedEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("codex_skill_path_migrated"),
+  from: z10.string(),
+  to: z10.string()
+});
+var initScanCompletedEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("init_scan_completed"),
+  written_stable_ids: z10.array(z10.string()),
+  duration_ms: z10.number().int().nonnegative(),
+  source: z10.enum(["init", "scan", "doctor_fix", "doctor-rescan"]).optional()
+});
+var knowledgeProposedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("mcp_event"),
-  mcp_event_id: z9.string(),
-  stream_id: z9.string(),
-  message: z9.unknown()
+  event_type: z10.literal("knowledge_proposed"),
+  stable_id: z10.string().optional(),
+  timestamp: z10.string().datetime(),
+  reason: z10.string().optional()
 });
-var reapplyCompletedEventSchema = z9.object({
+var knowledgePromoteStartedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("reapply_completed"),
-  preserved_ledger: z9.boolean(),
-  preserved_meta: z9.boolean(),
-  rules_count: z9.number().int().nonnegative()
+  event_type: z10.literal("knowledge_promote_started"),
+  stable_id: z10.string().optional(),
+  timestamp: z10.string().datetime(),
+  reason: z10.string().optional()
 });
-var eventLedgerTruncatedEventSchema = z9.object({
+var knowledgePromotedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("event_ledger_truncated"),
-  byte_offset: z9.number().int().nonnegative(),
-  byte_length: z9.number().int().nonnegative(),
-  corrupted_path: z9.string()
+  event_type: z10.literal("knowledge_promoted"),
+  stable_id: z10.string().optional(),
+  timestamp: z10.string().datetime(),
+  reason: z10.string().optional()
 });
-var mcpConfigMigratedEventSchema = z9.object({
+var knowledgePromoteFailedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("mcp_config_migrated"),
-  source: z9.literal("doctor_fix"),
-  removed_from: z9.string()
+  event_type: z10.literal("knowledge_promote_failed"),
+  stable_id: z10.string().optional(),
+  timestamp: z10.string().datetime(),
+  reason: z10.string()
 });
-var metaReconciledOnStartupEventSchema = z9.object({
+var knowledgeLayerChangedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("meta_reconciled_on_startup"),
-  reconciled_files: z9.array(z9.string()),
-  duration_ms: z9.number().int().nonnegative(),
-  source: z9.literal("reconcileKnowledge")
+  event_type: z10.literal("knowledge_layer_changed"),
+  stable_id: z10.string().optional(),
+  timestamp: z10.string().datetime(),
+  reason: z10.string().optional(),
+  from_layer: z10.enum(["team", "personal"]),
+  to_layer: z10.enum(["team", "personal"]),
+  // v2.0.0-rc.37 NEW-24: record the pre-flip stable_id so downstream consumers
+  // (fab_plan_context redirect surface, fab_get_knowledge_sections.redirect_to)
+  // can map a stale caller-held id back to the post-flip canonical id without
+  // requiring the caller to re-issue plan-context. Optional for forward-
+  // compatibility with rc ≤36 events that never carried this field.
+  previous_stable_id: z10.string().optional()
 });
-var metaReconciledEventSchema = z9.object({
+var knowledgeIdRedirectEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("meta_reconciled"),
-  reconciled_files: z9.array(z9.string()),
-  duration_ms: z9.number().int().nonnegative(),
-  trigger: z9.enum(["doctor", "manual"]),
-  source: z9.literal("reconcileKnowledge")
+  event_type: z10.literal("knowledge_id_redirect"),
+  timestamp: z10.string().datetime(),
+  previous_stable_id: z10.string(),
+  new_stable_id: z10.string(),
+  reason: z10.string().optional()
 });
-var claudeSkillPathMigratedEventSchema = z9.object({
+var knowledgeSlugRenamedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("claude_skill_path_migrated"),
-  from: z9.string(),
-  to: z9.string()
+  event_type: z10.literal("knowledge_slug_renamed"),
+  stable_id: z10.string().optional(),
+  timestamp: z10.string().datetime(),
+  reason: z10.string().optional(),
+  from_slug: z10.string(),
+  to_slug: z10.string()
 });
-var claudeHookPathMigratedEventSchema = z9.object({
+var knowledgeDemotedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("claude_hook_path_migrated"),
-  from: z9.string(),
-  to: z9.string()
+  event_type: z10.literal("knowledge_demoted"),
+  stable_id: z10.string().optional(),
+  timestamp: z10.string().datetime(),
+  reason: z10.string().optional()
 });
-var codexSkillPathMigratedEventSchema = z9.object({
+var knowledgeArchivedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("codex_skill_path_migrated"),
-  from: z9.string(),
-  to: z9.string()
+  event_type: z10.literal("knowledge_archived"),
+  stable_id: z10.string().optional(),
+  timestamp: z10.string().datetime(),
+  reason: z10.string().optional()
 });
-var initScanCompletedEventSchema = z9.object({
+var knowledgeArchiveAttemptedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("init_scan_completed"),
-  written_stable_ids: z9.array(z9.string()),
-  duration_ms: z9.number().int().nonnegative(),
-  source: z9.enum(["init", "scan", "doctor_fix"]).optional()
+  event_type: z10.literal("knowledge_archive_attempted"),
+  stable_id: z10.string().optional(),
+  timestamp: z10.string().datetime(),
+  reason: z10.string().optional()
 });
-var knowledgeProposedEventSchema = z9.object({
+var knowledgeUnarchivedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_proposed"),
-  stable_id: z9.string().optional(),
-  timestamp: z9.string().datetime(),
-  reason: z9.string().optional()
+  event_type: z10.literal("knowledge_unarchived"),
+  stable_id: z10.string().optional(),
+  timestamp: z10.string().datetime(),
+  reason: z10.string().optional(),
+  // Pre-move archive path (e.g. ".fabric/.archive/decisions/KT-D-0007--single-cjs-hook.md").
+  archive_path: z10.string().optional(),
+  // Post-move canonical path (e.g. ".fabric/knowledge/team/decisions/KT-D-0007--single-cjs-hook.md").
+  restored_to: z10.string().optional()
 });
-var knowledgePromoteStartedEventSchema = z9.object({
+var knowledgeDeferredEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_promote_started"),
-  stable_id: z9.string().optional(),
-  timestamp: z9.string().datetime(),
-  reason: z9.string().optional()
+  event_type: z10.literal("knowledge_deferred"),
+  stable_id: z10.string().optional(),
+  timestamp: z10.string().datetime(),
+  reason: z10.string().optional(),
+  until: z10.string().datetime().optional()
 });
-var knowledgePromotedEventSchema = z9.object({
+var knowledgeRejectedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_promoted"),
-  stable_id: z9.string().optional(),
-  timestamp: z9.string().datetime(),
-  reason: z9.string().optional()
+  event_type: z10.literal("knowledge_rejected"),
+  stable_id: z10.string().optional(),
+  timestamp: z10.string().datetime(),
+  reason: z10.string()
 });
-var knowledgePromoteFailedEventSchema = z9.object({
+var knowledgeConsumedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_promote_failed"),
-  stable_id: z9.string().optional(),
-  timestamp: z9.string().datetime(),
-  reason: z9.string()
+  event_type: z10.literal("knowledge_consumed"),
+  stable_id: z10.string(),
+  consumed_at: z10.string().datetime(),
+  client_hash: z10.string()
 });
-var knowledgeLayerChangedEventSchema = z9.object({
+var knowledgeScopeDegradedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_layer_changed"),
-  stable_id: z9.string().optional(),
-  timestamp: z9.string().datetime(),
-  reason: z9.string().optional(),
-  from_layer: z9.enum(["team", "personal"]),
-  to_layer: z9.enum(["team", "personal"])
+  event_type: z10.literal("knowledge_scope_degraded"),
+  stable_id: z10.string(),
+  timestamp: z10.string().datetime(),
+  from_scope: z10.enum(["narrow", "broad"]),
+  to_scope: z10.enum(["narrow", "broad"]),
+  reason: z10.string()
 });
-var knowledgeSlugRenamedEventSchema = z9.object({
+var doctorRunEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_slug_renamed"),
-  stable_id: z9.string().optional(),
-  timestamp: z9.string().datetime(),
-  reason: z9.string().optional(),
-  from_slug: z9.string(),
-  to_slug: z9.string()
+  event_type: z10.literal("doctor_run"),
+  mode: z10.enum(["lint", "fix-knowledge"]),
+  issues: z10.number().int().nonnegative(),
+  mutations: z10.number().int().nonnegative().optional(),
+  timestamp: z10.string().datetime()
 });
-var knowledgeDemotedEventSchema = z9.object({
+var knowledgePathDangledEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_demoted"),
-  stable_id: z9.string().optional(),
-  timestamp: z9.string().datetime(),
-  reason: z9.string().optional()
+  event_type: z10.literal("knowledge_path_dangled"),
+  stable_id: z10.string(),
+  removed_glob: z10.string()
 });
-var knowledgeArchivedEventSchema = z9.object({
+var relevanceMigrationRunEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_archived"),
-  stable_id: z9.string().optional(),
-  timestamp: z9.string().datetime(),
-  reason: z9.string().optional()
+  event_type: z10.literal("relevance_migration_run"),
+  timestamp: z10.string().datetime(),
+  scanned_count: z10.number().int().nonnegative(),
+  touched_count: z10.number().int().nonnegative()
 });
-var knowledgeArchiveAttemptedEventSchema = z9.object({
+var pendingAutoArchivedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_archive_attempted"),
-  stable_id: z9.string().optional(),
-  timestamp: z9.string().datetime(),
-  reason: z9.string().optional()
+  event_type: z10.literal("pending_auto_archived"),
+  pending_path: z10.string(),
+  archived_to: z10.string(),
+  reason: z10.string()
 });
-var knowledgeDeferredEventSchema = z9.object({
+var assistantTurnObservedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_deferred"),
-  stable_id: z9.string().optional(),
-  timestamp: z9.string().datetime(),
-  reason: z9.string().optional(),
-  until: z9.string().datetime().optional()
+  event_type: z10.literal("assistant_turn_observed"),
+  kb_line_raw: z10.string().nullable(),
+  cite_ids: z10.array(z10.string()).default([]),
+  cite_tags: z10.array(z10.enum(["planned", "recalled", "chained-from", "dismissed", "none"])).default([]),
+  // v2.0.0-rc.24 TASK-01: per-cite contract commitments. Index-aligned with
+  // cite_ids/cite_tags (commitments[i] belongs to cite_ids[i]). Each slot
+  // carries `operators[]` (kind + glob target) or `skip_reason` when the cite
+  // cannot be operator-ized. Old rc.20-rc.23 events naturally parse with an
+  // empty array via `.default([])` and are excluded from contract-policy
+  // audits by the marker-gate (see cite_contract_policy_activated below).
+  // Mirrors the rc.20 cite_tags parallel-array evolution exactly.
+  cite_commitments: z10.array(
+    z10.object({
+      operators: z10.array(
+        z10.object({
+          kind: z10.enum(["edit", "not_edit", "require", "forbid"]),
+          target: z10.string()
+        })
+      ),
+      skip_reason: z10.string().nullable()
+    })
+  ).default([]),
+  client: z10.enum(["cc", "codex", "cursor"]).optional(),
+  turn_id: z10.string(),
+  envelope_index: z10.number().int().nonnegative().optional(),
+  timestamp: z10.string().datetime()
 });
-var knowledgeRejectedEventSchema = z9.object({
+var citePolicyActivatedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_rejected"),
-  stable_id: z9.string().optional(),
-  timestamp: z9.string().datetime(),
-  reason: z9.string()
+  event_type: z10.literal("cite_policy_activated"),
+  policy_version: z10.string(),
+  timestamp: z10.string().datetime()
 });
-var knowledgeConsumedEventSchema = z9.object({
+var citeContractPolicyActivatedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_consumed"),
-  stable_id: z9.string(),
-  consumed_at: z9.string().datetime(),
-  client_hash: z9.string()
+  event_type: z10.literal("cite_contract_policy_activated")
 });
-var knowledgeScopeDegradedEventSchema = z9.object({
+var eventsRotatedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_scope_degraded"),
-  stable_id: z9.string(),
-  timestamp: z9.string().datetime(),
-  from_scope: z9.enum(["narrow", "broad"]),
-  to_scope: z9.enum(["narrow", "broad"]),
-  reason: z9.string()
+  event_type: z10.literal("events_rotated"),
+  cutoff_ts: z10.string().datetime(),
+  archived_count: z10.number().int().nonnegative(),
+  kept_count: z10.number().int().nonnegative(),
+  archive_path: z10.string()
 });
-var doctorRunEventSchema = z9.object({
+var knowledgeMetaAutoHealedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("doctor_run"),
-  mode: z9.enum(["lint", "apply-lint"]),
-  issues: z9.number().int().nonnegative(),
-  mutations: z9.number().int().nonnegative().optional(),
-  timestamp: z9.string().datetime()
+  event_type: z10.literal("knowledge_meta_auto_healed"),
+  previous_revision_hash: z10.string(),
+  revision_hash: z10.string(),
+  trigger: z10.literal("read"),
+  caller: z10.enum(["planContext", "getKnowledgeSections", "getKnowledge", "extractKnowledge"]).optional()
 });
-var knowledgePathDangledEventSchema = z9.object({
+var serveLockClearedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_path_dangled"),
-  stable_id: z9.string(),
-  removed_glob: z9.string()
+  event_type: z10.literal("serve_lock_cleared"),
+  pid: z10.number().int().nonnegative(),
+  age_ms: z10.number().int().nonnegative(),
+  timestamp: z10.string().datetime()
 });
-var pendingAutoArchivedEventSchema = z9.object({
+var knowledgeEnrichedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("pending_auto_archived"),
-  pending_path: z9.string(),
-  archived_to: z9.string(),
-  reason: z9.string()
+  event_type: z10.literal("knowledge_enriched"),
+  path: z10.string(),
+  added_fields: z10.array(z10.enum(["intent_clues", "tech_stack", "impact", "must_read_if"])),
+  mode: z10.enum(["auto", "preview", "readonly", "interactive"]),
+  timestamp: z10.string().datetime()
 });
-var eventLedgerEventSchema = z9.discriminatedUnion("event_type", [
+var sessionArchiveAttemptedEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("session_archive_attempted"),
+  outcome: z10.enum(["proposed", "viability_failed", "user_dismissed", "skipped_no_signal"]),
+  covered_through_ts: z10.number().int().nonnegative(),
+  candidates_proposed: z10.number().int().nonnegative().default(0),
+  knowledge_proposed_ids: z10.array(z10.string()).default([])
+});
+var eventLedgerEventSchema = z10.discriminatedUnion("event_type", [
   knowledgeContextPlannedEventSchema,
   knowledgeSelectionEventSchema,
   knowledgeSectionsFetchedEventSchema,
@@ -804,8 +1342,12 @@ var eventLedgerEventSchema = z9.discriminatedUnion("event_type", [
   knowledgeDriftDetectedEventSchema,
   mcpEventLedgerEventSchema,
   reapplyCompletedEventSchema,
+  installDiffAppliedEventSchema,
   eventLedgerTruncatedEventSchema,
   mcpConfigMigratedEventSchema,
+  // v2.0.0-rc.19 TASK-004: bootstrap_marker_migrated — one-time fabric:knowledge-base
+  // → fabric:bootstrap marker rewrite emitted per file by `fabric doctor --fix`.
+  bootstrapMarkerMigratedEventSchema,
   metaReconciledOnStartupEventSchema,
   metaReconciledEventSchema,
   claudeSkillPathMigratedEventSchema,
@@ -818,10 +1360,14 @@ var eventLedgerEventSchema = z9.discriminatedUnion("event_type", [
   knowledgePromotedEventSchema,
   knowledgePromoteFailedEventSchema,
   knowledgeLayerChangedEventSchema,
+  // v2.0.0-rc.37 NEW-24: dedicated old→new stable_id mapping event
+  knowledgeIdRedirectEventSchema,
   knowledgeSlugRenamedEventSchema,
   knowledgeDemotedEventSchema,
   knowledgeArchivedEventSchema,
   knowledgeArchiveAttemptedEventSchema,
+  // v2.0.0-rc.34 TASK-05: reverse of knowledge_archived
+  knowledgeUnarchivedEventSchema,
   knowledgeDeferredEventSchema,
   knowledgeRejectedEventSchema,
   // v2.0 rc.5 TASK-014: knowledge_consumed (consumption tracking)
@@ -835,24 +1381,161 @@ var eventLedgerEventSchema = z9.discriminatedUnion("event_type", [
   // #24 when a glob in relevance_paths resolves to zero filesystem matches.
   knowledgePathDangledEventSchema,
   // v2.0.0-rc.7 T10: doctor_run — emitted by `fabric doctor` to drive Signal D.
-  doctorRunEventSchema
+  doctorRunEventSchema,
+  // v2.0.0-rc.9 TASK-003 (A3): relevance_migration_run — emitted by
+  // `doctor --apply-lint` after the lint #26 frontmatter back-fill pass.
+  relevanceMigrationRunEventSchema,
+  // v2.0.0-rc.20 TASK-02: assistant_turn_observed — per-turn cite-policy
+  // observation (raw KB: line text + parsed cite_ids/cite_tags + client).
+  assistantTurnObservedEventSchema,
+  // v2.0.0-rc.20 TASK-02: cite_policy_activated — session/policy-bump
+  // marker recording when a given policy_version became active.
+  citePolicyActivatedEventSchema,
+  // v2.0.0-rc.24 TASK-01: cite_contract_policy_activated — drift-gated
+  // idempotent marker opening the contract-policy audit window. Distinct
+  // from cite_policy_activated so contract metrics get their own window.
+  citeContractPolicyActivatedEventSchema,
+  // v2.0.0-rc.22 Scope D T-D1: knowledge_meta_auto_healed — emitted by
+  // loadActiveMeta when read-path drift triggers an in-place meta rebuild.
+  knowledgeMetaAutoHealedEventSchema,
+  // v2.0.0-rc.22 Scope A T3: events_rotated — emitted as the first line of
+  // the post-rotation events.jsonl when sliding-window-by-age rotation moves
+  // stale entries to events.archive/events-rotated-YYYY-MM-DD.jsonl.
+  eventsRotatedEventSchema,
+  // v2.0.0-rc.23 TASK-010 (e): serve_lock_cleared — emitted by
+  // `fabric doctor --fix` when a stale `.fabric/.serve.lock` with a dead PID is
+  // unlinked.
+  serveLockClearedEventSchema,
+  // v2.0.0-rc.23 TASK-007 (a-C2): knowledge_enriched — emitted by
+  // `fabric doctor --enrich-descriptions` once per modified canonical knowledge
+  // file when one or more of the four rc.23 description-grade frontmatter
+  // fields is back-filled.
+  knowledgeEnrichedEventSchema,
+  // v2.0.0-rc.25 TASK-01: session_archive_attempted — emitted by the
+  // fabric-archive skill at the end of every invocation. Drives Phase 0.0
+  // cross-session digest, outcome-based rescan filter (skips user_dismissed),
+  // covered_through_ts watermark, and `fabric doctor --archive-history`.
+  sessionArchiveAttemptedEventSchema
 ]);
+
+// src/cite-line-parser.ts
+var ID_RE = /^K[TP]-[A-Z]+-\d+$/;
+var SENTINEL_RE = /^KB:\s*none\b\s*(?:\[[^\]]*\])?\s*$/i;
+var FULL_RE = /^KB:\s+(K[TP]-[A-Z]+-\d+(?:\s*,\s*K[TP]-[A-Z]+-\d+)*)(?:\s+\(([^)]*)\))?(?:\s+\[([^\]]+)\])?(?:\s+→\s*(.+))?\s*$/;
+var CHAINED_FROM_ID_RE = /chained-from\s+(K[TP]-[A-Z]+-\d+)/i;
+var ALLOWED_TAGS = /* @__PURE__ */ new Set([
+  "planned",
+  "recalled",
+  "chained-from",
+  "dismissed",
+  "none"
+]);
+function parseTag(rawTag) {
+  if (!rawTag) return "none";
+  const head = rawTag.trim().split(/[\s:]+/)[0].toLowerCase();
+  return ALLOWED_TAGS.has(head) ? head : "none";
+}
+function parseContractTail(tail) {
+  const result = { operators: [], skip_reason: null };
+  if (!tail) return result;
+  const tokens = tail.trim().split(/\s+/).filter((t) => t.length > 0);
+  for (const token of tokens) {
+    const skipMatch = token.match(/^skip:(.+)$/i);
+    if (skipMatch) {
+      if (result.skip_reason === null) result.skip_reason = skipMatch[1];
+      continue;
+    }
+    const notEditMatch = token.match(/^!edit:(.+)$/i);
+    if (notEditMatch) {
+      result.operators.push({ kind: "not_edit", target: notEditMatch[1] });
+      continue;
+    }
+    const opMatch = token.match(/^(edit|require|forbid):(.+)$/i);
+    if (opMatch) {
+      result.operators.push({
+        kind: opMatch[1].toLowerCase(),
+        target: opMatch[2]
+      });
+    }
+  }
+  return result;
+}
+function parseLine(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) return null;
+  if (SENTINEL_RE.test(trimmed)) {
+    return { ids: [], tag: "none", commitment: null };
+  }
+  const fullMatch = trimmed.match(FULL_RE);
+  if (fullMatch) {
+    const primaryIds = fullMatch[1].split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+    if (primaryIds.some((id) => !ID_RE.test(id))) return null;
+    const rawTag = fullMatch[3];
+    const tag = parseTag(rawTag);
+    const chainedIds = [];
+    if (rawTag !== void 0) {
+      const chained = CHAINED_FROM_ID_RE.exec(rawTag);
+      if (chained !== null && ID_RE.test(chained[1])) {
+        chainedIds.push(chained[1]);
+      }
+    }
+    return {
+      ids: [...primaryIds, ...chainedIds],
+      tag,
+      commitment: parseContractTail(fullMatch[4])
+    };
+  }
+  return null;
+}
+function parseCiteLine(raw) {
+  const result = {
+    cite_ids: [],
+    cite_tags: [],
+    cite_commitments: []
+  };
+  if (typeof raw !== "string") return result;
+  for (const line of raw.split(/\r?\n/)) {
+    const parsed = parseLine(line);
+    if (!parsed) continue;
+    result.cite_tags.push(parsed.tag);
+    for (const id of parsed.ids) {
+      result.cite_ids.push(id);
+    }
+    if (parsed.commitment !== null) {
+      for (let i = 0; i < parsed.ids.length; i += 1) {
+        result.cite_commitments.push(parsed.commitment);
+      }
+    }
+  }
+  return result;
+}
 export {
   AGENTS_META_IDENTITY_SOURCES,
   AGENTS_META_LAYERS,
   AGENTS_META_TOPOLOGY_TYPES,
   AgentsMetaCountersSchema,
+  BOOTSTRAP_CANONICAL,
+  BOOTSTRAP_MARKER_BEGIN,
+  BOOTSTRAP_MARKER_END,
+  BOOTSTRAP_REGEX,
   FabExtractKnowledgeInputSchema,
   FabExtractKnowledgeInputShape,
   FabExtractKnowledgeOutputSchema,
   FabReviewInputSchema,
+  FabReviewInputShape,
   FabReviewOutputSchema,
+  FabReviewOutputShape,
   KNOWLEDGE_TEST_INDEX_SCHEMA_VERSION,
   KNOWLEDGE_TYPE_CODES,
   KnowledgeEntryFrontmatterSchema,
   KnowledgeTypeSchema,
+  LEGACY_KB_MARKER_BEGIN,
+  LEGACY_KB_MARKER_END,
+  LEGACY_KB_REGEX,
   LayerSchema,
   MaturitySchema,
+  ONBOARD_SLOT_NAMES,
+  ONBOARD_SLOT_TOTAL,
   PROPOSED_REASON_DESCRIPTIONS,
   PROTECTED_TOKENS,
   ProposedReasonSchema,
@@ -865,8 +1548,18 @@ export {
   aiLedgerEntrySchema,
   allocateKnowledgeId,
   annotateIntentRequestSchema,
+  archiveScanAnnotations,
+  archiveScanInputSchema,
+  archiveScanOutputSchema,
+  assistantTurnObservedEventSchema,
   auditModeSchema,
+  bootstrapMarkerMigratedEventSchema,
   candidateFileEntrySchema,
+  citeContractMetricsSchema,
+  citeContractPolicyActivatedEventSchema,
+  citeCoverageReportSchema,
+  citeLayerTypeBreakdownSchema,
+  citePolicyActivatedEventSchema,
   claudeHookPathMigratedEventSchema,
   claudeSkillPathMigratedEventSchema,
   clientPathsSchema,
@@ -886,10 +1579,12 @@ export {
   enMessages,
   eventLedgerEventSchema,
   eventLedgerTruncatedEventSchema,
+  eventsRotatedEventSchema,
   fabExtractKnowledgeAnnotations,
   fabReviewAnnotations,
   fabricConfigSchema,
   fabricEventSchema,
+  fabricLanguageSchema,
   forensicAssertionCoverageSchema,
   forensicAssertionSchema,
   forensicCodeSampleSchema,
@@ -901,9 +1596,8 @@ export {
   forensicSamplingBudgetSchema,
   forensicTopologySchema,
   formatKnowledgeId,
-  getKnowledgeAnnotations,
-  getKnowledgeInputSchema,
-  getKnowledgeOutputSchema,
+  getPanelFieldByKey,
+  getPanelFields,
   historyStateQuerySchema,
   humanLedgerEntrySchema,
   humanLockApproveRequestSchema,
@@ -918,6 +1612,7 @@ export {
   initContextSchema,
   initContextSourceEvidenceSchema,
   initScanCompletedEventSchema,
+  installDiffAppliedEventSchema,
   isKnowledgeStableId,
   knowledgeArchiveAttemptedEventSchema,
   knowledgeArchivedEventSchema,
@@ -926,8 +1621,10 @@ export {
   knowledgeDeferredEventSchema,
   knowledgeDemotedEventSchema,
   knowledgeDriftDetectedEventSchema,
-  knowledgeLanguageSchema,
+  knowledgeEnrichedEventSchema,
+  knowledgeIdRedirectEventSchema,
   knowledgeLayerChangedEventSchema,
+  knowledgeMetaAutoHealedEventSchema,
   knowledgePathDangledEventSchema,
   knowledgePromoteFailedEventSchema,
   knowledgePromoteStartedEventSchema,
@@ -944,6 +1641,7 @@ export {
   knowledgeTestIndexSchema,
   knowledgeTestLinkSchema,
   knowledgeTestOrphanAnnotationSchema,
+  knowledgeUnarchivedEventSchema,
   ledgerAppendedEventSchema,
   ledgerEntrySchema,
   ledgerQuerySchema,
@@ -957,6 +1655,8 @@ export {
   metaReconciledOnStartupEventSchema,
   metaUpdatedEventSchema,
   normalizeLocale,
+  onboardSlotSchema,
+  parseCiteLine,
   parseKnowledgeId,
   pendingAutoArchivedEventSchema,
   planContextAnnotations,
@@ -965,8 +1665,16 @@ export {
   planContextInputSchema,
   planContextOutputSchema,
   reapplyCompletedEventSchema,
+  recallAnnotations,
+  recallInputSchema,
+  recallOutputSchema,
+  relevanceMigrationRunEventSchema,
+  resolveFabricLocale,
   ruleDescriptionIndexItemSchema,
   ruleDescriptionSchema,
+  selectionTokenTtlMsSchema,
+  serveLockClearedEventSchema,
+  sessionArchiveAttemptedEventSchema,
   structuredWarningSchema,
   withDerivedAgentsMetaNodeDefaults,
   zhCNMessages