@fenglimg/fabric-shared 2.0.0-rc.15 → 2.0.0-rc.21

package/dist/index.js

@@ -1,3 +1,4 @@
+import "./chunk-LXNCAKJZ.js";
 import {
   PROTECTED_TOKENS,
   createTranslator,
@@ -6,7 +7,7 @@ import {
   enMessages,
   normalizeLocale,
   zhCNMessages
-} from "./chunk-BKTCBFXZ.js";
+} from "./chunk-VKCXD6CI.js";
 import {
   FabExtractKnowledgeInputSchema,
   FabExtractKnowledgeInputShape,
@@ -46,7 +47,15 @@ import {
   planContextOutputSchema,
   structuredWarningSchema
 } from "./chunk-NNDFOOBO.js";
-import "./chunk-LXNCAKJZ.js";
+import {
+  BOOTSTRAP_CANONICAL,
+  BOOTSTRAP_MARKER_BEGIN,
+  BOOTSTRAP_MARKER_END,
+  BOOTSTRAP_REGEX,
+  LEGACY_KB_MARKER_BEGIN,
+  LEGACY_KB_MARKER_END,
+  LEGACY_KB_REGEX
+} from "./chunk-QZNUUIL3.js";
 
 // src/schemas/agents-meta.ts
 import { z } from "zod";
@@ -166,7 +175,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, "");
@@ -183,7 +192,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)) {
@@ -315,7 +324,13 @@ var fabricLanguageSchema = z5.enum([
 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(),
   audit_mode: auditModeSchema.optional(),
   mcpPayloadLimits: mcpPayloadLimitsSchema,
@@ -438,156 +453,294 @@ var fabricConfigSchema = z5.object({
   review_stale_pending_days: z5.number().int().positive().optional().default(14)
 });
 
-// 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,
@@ -596,278 +749,304 @@ 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({
+var stringRecordSchema = z10.record(z10.string());
+var knowledgeContextPlannedEventSchema = z10.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({
+  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: 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()),
+  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())
+  rejected_stable_ids: z10.array(z10.string()),
+  ignored_stable_ids: z10.array(z10.string())
 });
-var knowledgeSectionsFetchedEventSchema = z9.object({
+var knowledgeSectionsFetchedEventSchema = z10.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({
+  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: 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({
+  event_type: z10.literal("edit_intent_checked"),
+  path: z10.string(),
+  compliant: z10.boolean(),
+  intent: z10.string(),
+  ledger_entry_id: z10.string(),
+  ledger_source: z10.enum(["ai", "human"]).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: 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()
+  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: z9.literal("mcp_event"),
-  mcp_event_id: z9.string(),
-  stream_id: z9.string(),
-  message: z9.unknown()
+  event_type: z10.literal("mcp_event"),
+  mcp_event_id: z10.string(),
+  stream_id: z10.string(),
+  message: z10.unknown()
 });
-var reapplyCompletedEventSchema = z9.object({
+var reapplyCompletedEventSchema = 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("reapply_completed"),
+  preserved_ledger: z10.boolean(),
+  preserved_meta: z10.boolean(),
+  rules_count: z10.number().int().nonnegative()
 });
-var eventLedgerTruncatedEventSchema = z9.object({
+var eventLedgerTruncatedEventSchema = 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("event_ledger_truncated"),
+  byte_offset: z10.number().int().nonnegative(),
+  byte_length: z10.number().int().nonnegative(),
+  corrupted_path: z10.string()
 });
-var mcpConfigMigratedEventSchema = z9.object({
+var mcpConfigMigratedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("mcp_config_migrated"),
-  source: z9.literal("doctor_fix"),
-  removed_from: z9.string()
+  event_type: z10.literal("mcp_config_migrated"),
+  source: z10.literal("doctor_fix"),
+  removed_from: z10.string()
 });
-var metaReconciledOnStartupEventSchema = z9.object({
+var bootstrapMarkerMigratedEventSchema = 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("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 metaReconciledEventSchema = z9.object({
+var metaReconciledOnStartupEventSchema = 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("meta_reconciled_on_startup"),
+  reconciled_files: z10.array(z10.string()),
+  duration_ms: z10.number().int().nonnegative(),
+  source: z10.literal("reconcileKnowledge")
 });
-var claudeSkillPathMigratedEventSchema = z9.object({
+var metaReconciledEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("claude_skill_path_migrated"),
-  from: z9.string(),
-  to: z9.string()
+  event_type: z10.literal("meta_reconciled"),
+  reconciled_files: z10.array(z10.string()),
+  duration_ms: z10.number().int().nonnegative(),
+  trigger: z10.enum(["doctor", "manual"]),
+  source: z10.literal("reconcileKnowledge")
 });
-var claudeHookPathMigratedEventSchema = z9.object({
+var claudeSkillPathMigratedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("claude_hook_path_migrated"),
-  from: z9.string(),
-  to: z9.string()
+  event_type: z10.literal("claude_skill_path_migrated"),
+  from: z10.string(),
+  to: z10.string()
 });
-var codexSkillPathMigratedEventSchema = z9.object({
+var claudeHookPathMigratedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("codex_skill_path_migrated"),
-  from: z9.string(),
-  to: z9.string()
+  event_type: z10.literal("claude_hook_path_migrated"),
+  from: z10.string(),
+  to: z10.string()
 });
-var initScanCompletedEventSchema = z9.object({
+var codexSkillPathMigratedEventSchema = 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", "doctor-rescan"]).optional()
+  event_type: z10.literal("codex_skill_path_migrated"),
+  from: z10.string(),
+  to: z10.string()
 });
-var knowledgeProposedEventSchema = z9.object({
+var initScanCompletedEventSchema = 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("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 knowledgePromoteStartedEventSchema = z9.object({
+var knowledgeProposedEventSchema = 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_proposed"),
+  stable_id: z10.string().optional(),
+  timestamp: z10.string().datetime(),
+  reason: z10.string().optional()
 });
-var knowledgePromotedEventSchema = z9.object({
+var knowledgePromoteStartedEventSchema = 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_promote_started"),
+  stable_id: z10.string().optional(),
+  timestamp: z10.string().datetime(),
+  reason: z10.string().optional()
 });
-var knowledgePromoteFailedEventSchema = z9.object({
+var knowledgePromotedEventSchema = 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_promoted"),
+  stable_id: z10.string().optional(),
+  timestamp: z10.string().datetime(),
+  reason: z10.string().optional()
 });
-var knowledgeLayerChangedEventSchema = z9.object({
+var knowledgePromoteFailedEventSchema = 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"])
-});
-var knowledgeSlugRenamedEventSchema = z9.object({
+  event_type: z10.literal("knowledge_promote_failed"),
+  stable_id: z10.string().optional(),
+  timestamp: z10.string().datetime(),
+  reason: z10.string()
+});
+var knowledgeLayerChangedEventSchema = 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()
-});
-var knowledgeDemotedEventSchema = z9.object({
+  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"])
+});
+var knowledgeSlugRenamedEventSchema = 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_slug_renamed"),
+  stable_id: z10.string().optional(),
+  timestamp: z10.string().datetime(),
+  reason: z10.string().optional(),
+  from_slug: z10.string(),
+  to_slug: z10.string()
 });
-var knowledgeArchivedEventSchema = z9.object({
+var knowledgeDemotedEventSchema = 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("knowledge_demoted"),
+  stable_id: z10.string().optional(),
+  timestamp: z10.string().datetime(),
+  reason: z10.string().optional()
 });
-var knowledgeArchiveAttemptedEventSchema = z9.object({
+var knowledgeArchivedEventSchema = 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("knowledge_archived"),
+  stable_id: z10.string().optional(),
+  timestamp: z10.string().datetime(),
+  reason: z10.string().optional()
 });
-var knowledgeDeferredEventSchema = z9.object({
+var knowledgeArchiveAttemptedEventSchema = 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("knowledge_archive_attempted"),
+  stable_id: z10.string().optional(),
+  timestamp: z10.string().datetime(),
+  reason: z10.string().optional()
 });
-var knowledgeRejectedEventSchema = z9.object({
+var knowledgeDeferredEventSchema = 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("knowledge_deferred"),
+  stable_id: z10.string().optional(),
+  timestamp: z10.string().datetime(),
+  reason: z10.string().optional(),
+  until: z10.string().datetime().optional()
 });
-var knowledgeConsumedEventSchema = z9.object({
+var knowledgeRejectedEventSchema = 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("knowledge_rejected"),
+  stable_id: z10.string().optional(),
+  timestamp: z10.string().datetime(),
+  reason: z10.string()
 });
-var knowledgeScopeDegradedEventSchema = z9.object({
+var knowledgeConsumedEventSchema = 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()
-});
-var doctorRunEventSchema = z9.object({
+  event_type: z10.literal("knowledge_consumed"),
+  stable_id: z10.string(),
+  consumed_at: z10.string().datetime(),
+  client_hash: z10.string()
+});
+var knowledgeScopeDegradedEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("doctor_run"),
-  mode: z9.enum(["lint", "fix-knowledge"]),
-  issues: z9.number().int().nonnegative(),
-  mutations: z9.number().int().nonnegative().optional(),
-  timestamp: z9.string().datetime()
+  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 knowledgePathDangledEventSchema = z9.object({
+var doctorRunEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("knowledge_path_dangled"),
-  stable_id: z9.string(),
-  removed_glob: 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 relevanceMigrationRunEventSchema = z9.object({
+var knowledgePathDangledEventSchema = z10.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z9.literal("relevance_migration_run"),
-  timestamp: z9.string().datetime(),
-  scanned_count: z9.number().int().nonnegative(),
-  touched_count: z9.number().int().nonnegative()
+  event_type: z10.literal("knowledge_path_dangled"),
+  stable_id: z10.string(),
+  removed_glob: z10.string()
 });
-var pendingAutoArchivedEventSchema = z9.object({
+var relevanceMigrationRunEventSchema = 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("relevance_migration_run"),
+  timestamp: z10.string().datetime(),
+  scanned_count: z10.number().int().nonnegative(),
+  touched_count: z10.number().int().nonnegative()
 });
-var eventLedgerEventSchema = z9.discriminatedUnion("event_type", [
+var pendingAutoArchivedEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("pending_auto_archived"),
+  pending_path: z10.string(),
+  archived_to: z10.string(),
+  reason: z10.string()
+});
+var assistantTurnObservedEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  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([]),
+  client: z10.enum(["cc", "codex", "cursor"]).optional(),
+  turn_id: z10.string(),
+  envelope_index: z10.number().int().nonnegative().optional(),
+  timestamp: z10.string().datetime()
+});
+var citePolicyActivatedEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("cite_policy_activated"),
+  policy_version: z10.string(),
+  timestamp: z10.string().datetime()
+});
+var eventLedgerEventSchema = z10.discriminatedUnion("event_type", [
   knowledgeContextPlannedEventSchema,
   knowledgeSelectionEventSchema,
   knowledgeSectionsFetchedEventSchema,
@@ -877,6 +1056,9 @@ var eventLedgerEventSchema = z9.discriminatedUnion("event_type", [
   reapplyCompletedEventSchema,
   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 `fab doctor --fix`.
+  bootstrapMarkerMigratedEventSchema,
   metaReconciledOnStartupEventSchema,
   metaReconciledEventSchema,
   claudeSkillPathMigratedEventSchema,
@@ -909,13 +1091,23 @@ var eventLedgerEventSchema = z9.discriminatedUnion("event_type", [
   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
+  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
 ]);
 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,
@@ -927,6 +1119,9 @@ export {
   KNOWLEDGE_TYPE_CODES,
   KnowledgeEntryFrontmatterSchema,
   KnowledgeTypeSchema,
+  LEGACY_KB_MARKER_BEGIN,
+  LEGACY_KB_MARKER_END,
+  LEGACY_KB_REGEX,
   LayerSchema,
   MaturitySchema,
   PROPOSED_REASON_DESCRIPTIONS,
@@ -941,8 +1136,11 @@ export {
   aiLedgerEntrySchema,
   allocateKnowledgeId,
   annotateIntentRequestSchema,
+  assistantTurnObservedEventSchema,
   auditModeSchema,
+  bootstrapMarkerMigratedEventSchema,
   candidateFileEntrySchema,
+  citePolicyActivatedEventSchema,
   claudeHookPathMigratedEventSchema,
   claudeSkillPathMigratedEventSchema,
   clientPathsSchema,
@@ -981,6 +1179,8 @@ export {
   getKnowledgeAnnotations,
   getKnowledgeInputSchema,
   getKnowledgeOutputSchema,
+  getPanelFieldByKey,
+  getPanelFields,
   historyStateQuerySchema,
   humanLedgerEntrySchema,
   humanLockApproveRequestSchema,