@fenglimg/fabric-shared 1.5.2 → 1.7.0

package/dist/index.js

@@ -6,23 +6,40 @@ import {
   enMessages,
   normalizeLocale,
   zhCNMessages
-} from "./chunk-KNZIX6IL.js";
+} from "./chunk-5H2PVNB2.js";
 import "./chunk-LXNCAKJZ.js";
 
 // src/schemas/agents-meta.ts
 import { z } from "zod";
 var FABRIC_AGENTS_PREFIX = ".fabric/agents/";
 var AGENTS_META_LAYERS = ["L0", "L1", "L2"];
-var AGENTS_META_TOPOLOGY_TYPES = ["mirror", "cross-cutting"];
+var AGENTS_META_TOPOLOGY_TYPES = ["mirror", "cross-cutting", "domain", "local", "global"];
 var AGENTS_META_IDENTITY_SOURCES = ["declared", "derived"];
 var agentsLayerSchema = z.enum(AGENTS_META_LAYERS);
 var agentsTopologyTypeSchema = z.enum(AGENTS_META_TOPOLOGY_TYPES);
 var agentsIdentitySourceSchema = z.enum(AGENTS_META_IDENTITY_SOURCES);
+var ruleDescriptionSchema = z.object({
+  summary: z.string(),
+  intent_clues: z.array(z.string()),
+  tech_stack: z.array(z.string()),
+  impact: z.array(z.string()),
+  must_read_if: z.string(),
+  entities: z.array(z.string()).optional()
+}).strict();
+var ruleDescriptionIndexItemSchema = z.object({
+  stable_id: z.string(),
+  level: agentsLayerSchema,
+  required: z.boolean(),
+  selectable: z.boolean(),
+  description: ruleDescriptionSchema
+}).strict();
 var agentsMetaNodeBaseSchema = z.object({
   file: z.string(),
+  content_ref: z.string().optional(),
   scope_glob: z.string(),
   deps: z.array(z.string()),
   priority: z.enum(["high", "medium", "low"]),
+  level: agentsLayerSchema.optional(),
   layer: agentsLayerSchema,
   topology_type: agentsTopologyTypeSchema,
   hash: z.string(),
@@ -31,7 +48,9 @@ var agentsMetaNodeBaseSchema = z.object({
   activation: z.object({
     tier: z.enum(["always", "path", "description"]),
     description: z.string().optional()
-  }).optional()
+  }).optional(),
+  description: ruleDescriptionSchema.optional(),
+  sections: z.array(z.string()).optional()
 });
 var agentsMetaNodeSchema = z.preprocess((value) => {
   if (!isRecord(value) || typeof value.file !== "string") {
@@ -48,7 +67,8 @@ function withDerivedAgentsMetaNodeDefaults(node) {
   const identitySource = deriveAgentsMetaIdentitySource(node);
   return {
     ...node,
-    layer: node.layer ?? deriveAgentsMetaLayer(node.file),
+    layer: node.layer ?? node.level ?? deriveAgentsMetaLayer(node.file),
+    level: node.level ?? node.layer ?? deriveAgentsMetaLayer(node.file),
     topology_type: node.topology_type ?? deriveAgentsMetaTopologyType(node.file),
     stable_id: stableId,
     identity_source: identitySource
@@ -106,10 +126,40 @@ function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
 
-// src/schemas/api-contracts.ts
+// src/schemas/rule-test-index.ts
 import { z as z2 } from "zod";
-var ledgerSourceSchema = z2.enum(["ai", "human"]);
-var timestampFilterSchema = z2.preprocess((value) => {
+var RULE_TEST_INDEX_SCHEMA_VERSION = 1;
+var hashSchema = z2.string().min(1);
+var ruleTestLinkSchema = z2.object({
+  rule_stable_id: z2.string().min(1),
+  rule_file: z2.string().min(1),
+  rule_hash: hashSchema,
+  previous_rule_hash: hashSchema.optional(),
+  test_file: z2.string().min(1),
+  test_hash: hashSchema,
+  previous_test_hash: hashSchema.optional(),
+  annotation_line: z2.number().int().positive()
+}).strict();
+var ruleTestOrphanAnnotationSchema = z2.object({
+  rule_stable_id: z2.string().min(1),
+  test_file: z2.string().min(1),
+  test_hash: hashSchema,
+  previous_test_hash: hashSchema.optional(),
+  annotation_line: z2.number().int().positive()
+}).strict();
+var ruleTestIndexSchema = z2.object({
+  schema_version: z2.literal(RULE_TEST_INDEX_SCHEMA_VERSION),
+  generated_at: z2.string().datetime({ offset: true }),
+  revision: z2.string().min(1).optional(),
+  previous_revision: z2.string().min(1).optional(),
+  links: z2.array(ruleTestLinkSchema),
+  orphan_annotations: z2.array(ruleTestOrphanAnnotationSchema)
+}).strict();
+
+// src/schemas/api-contracts.ts
+import { z as z3 } from "zod";
+var ledgerSourceSchema = z3.enum(["ai", "human"]);
+var timestampFilterSchema = z3.preprocess((value) => {
   if (value === void 0 || value === null || value === "") {
     return void 0;
   }
@@ -128,61 +178,61 @@ var timestampFilterSchema = z2.preprocess((value) => {
     return Number.isNaN(parsed) ? value : parsed;
   }
   return value;
-}, z2.number().int().nonnegative());
-var ledgerQuerySchema = z2.object({
+}, z3.number().int().nonnegative());
+var ledgerQuerySchema = z3.object({
   source: ledgerSourceSchema.optional(),
   since: timestampFilterSchema.optional()
 });
-var historyStateQuerySchema = z2.object({
-  ledger_id: z2.string().trim().min(1).optional(),
+var historyStateQuerySchema = z3.object({
+  ledger_id: z3.string().trim().min(1).optional(),
   ts: timestampFilterSchema.optional()
 }).superRefine((value, ctx) => {
   const provided = [value.ledger_id, value.ts].filter((entry) => entry !== void 0);
   if (provided.length !== 1) {
     ctx.addIssue({
-      code: z2.ZodIssueCode.custom,
+      code: z3.ZodIssueCode.custom,
       message: "Provide exactly one of ledger_id or ts.",
       path: ["ledger_id"]
     });
   }
 });
-var humanLockApproveRequestSchema = z2.object({
-  file: z2.string().min(1),
-  start_line: z2.number().int().positive(),
-  end_line: z2.number().int().positive(),
-  new_hash: z2.string().min(1)
+var humanLockApproveRequestSchema = z3.object({
+  file: z3.string().min(1),
+  start_line: z3.number().int().positive(),
+  end_line: z3.number().int().positive(),
+  new_hash: z3.string().min(1)
 });
-var humanLockFileParamsSchema = z2.object({
-  file: z2.string().min(1)
+var humanLockFileParamsSchema = z3.object({
+  file: z3.string().min(1)
 });
-var annotateIntentRequestSchema = z2.object({
-  ledger_entry_id: z2.string().min(1),
-  annotation: z2.string().trim().min(1)
+var annotateIntentRequestSchema = z3.object({
+  ledger_entry_id: z3.string().min(1),
+  annotation: z3.string().trim().min(1)
 });
 
 // src/schemas/ledger-entry.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var ledgerEntryBaseSchema = {
-  id: z3.string().optional(),
-  ts: z3.number().int().nonnegative(),
-  intent: z3.string(),
-  affected_paths: z3.array(z3.string())
+  id: z4.string().optional(),
+  ts: z4.number().int().nonnegative(),
+  intent: z4.string(),
+  affected_paths: z4.array(z4.string())
 };
-var aiLedgerEntrySchema = z3.object({
+var aiLedgerEntrySchema = z4.object({
   ...ledgerEntryBaseSchema,
-  source: z3.literal("ai"),
-  commit_sha: z3.string().optional()
+  source: z4.literal("ai"),
+  commit_sha: z4.string().optional()
 });
-var humanLedgerEntrySchema = z3.object({
+var humanLedgerEntrySchema = z4.object({
   ...ledgerEntryBaseSchema,
-  source: z3.literal("human"),
-  parent_sha: z3.string(),
-  parent_ledger_entry_id: z3.string().optional(),
-  diff_stat: z3.string(),
-  annotation: z3.string().optional()
-});
-var ledgerEntryUnionSchema = z3.discriminatedUnion("source", [aiLedgerEntrySchema, humanLedgerEntrySchema]);
-var ledgerEntrySchema = z3.preprocess((value) => {
+  source: z4.literal("human"),
+  parent_sha: z4.string(),
+  parent_ledger_entry_id: z4.string().optional(),
+  diff_stat: z4.string(),
+  annotation: z4.string().optional()
+});
+var ledgerEntryUnionSchema = z4.discriminatedUnion("source", [aiLedgerEntrySchema, humanLedgerEntrySchema]);
+var ledgerEntrySchema = z4.preprocess((value) => {
   if (value && typeof value === "object" && !Array.isArray(value) && (!("source" in value) || value.source === void 0)) {
     return {
       ...value,
@@ -193,198 +243,313 @@ var ledgerEntrySchema = z3.preprocess((value) => {
 }, ledgerEntryUnionSchema);
 
 // src/schemas/human-lock.ts
-import { z as z4 } from "zod";
-var humanLockEntrySchema = z4.object({
-  file: z4.string(),
-  start_line: z4.number().int().nonnegative(),
-  end_line: z4.number().int().nonnegative(),
-  hash: z4.string()
+import { z as z5 } from "zod";
+var humanLockEntrySchema = z5.object({
+  file: z5.string(),
+  start_line: z5.number().int().nonnegative(),
+  end_line: z5.number().int().nonnegative(),
+  hash: z5.string()
 });
-var humanLockFileSchema = z4.object({
-  locked: z4.array(humanLockEntrySchema).optional()
+var humanLockFileSchema = z5.object({
+  locked: z5.array(humanLockEntrySchema).optional()
 });
 
 // src/schemas/fabric-config.ts
-import { z as z5 } from "zod";
-var auditModeSchema = z5.enum(["strict", "warn", "off"]);
-var clientPathsSchema = z5.object({
-  claudeCodeCLI: z5.string().optional(),
-  claudeCodeDesktop: z5.string().optional(),
-  cursor: z5.string().optional(),
-  windsurf: z5.string().optional(),
-  rooCode: z5.string().optional(),
-  geminiCLI: z5.string().optional(),
-  codexCLI: z5.string().optional()
-});
-var fabricConfigSchema = z5.object({
+import { z as z6 } from "zod";
+var auditModeSchema = z6.enum(["strict", "warn", "off"]);
+var clientPathsSchema = z6.object({
+  claudeCodeCLI: z6.string().optional(),
+  claudeCodeDesktop: z6.string().optional(),
+  cursor: z6.string().optional(),
+  windsurf: z6.string().optional(),
+  rooCode: z6.string().optional(),
+  geminiCLI: z6.string().optional(),
+  codexCLI: z6.string().optional()
+});
+var fabricConfigSchema = z6.object({
   clientPaths: clientPathsSchema.optional(),
-  externalFixturePath: z5.string().optional(),
-  scanIgnores: z5.array(z5.string()).optional(),
+  externalFixturePath: z6.string().optional(),
+  scanIgnores: z6.array(z6.string()).optional(),
   auditMode: auditModeSchema.optional(),
   audit_mode: auditModeSchema.optional()
 });
 
 // src/schemas/forensic-report.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),
+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()
-});
-var initContextInvariantConfidenceSnapshotSchema = z7.object({
-  confidence: z7.enum(["HIGH", "MEDIUM", "LOW"]),
-  evidence_refs: z7.array(z7.string())
-});
-var initContextSourceEvidenceSchema = z7.object({
-  file: z7.string(),
-  lines: z7.string()
-});
-var initContextInvariantSchema = z7.object({
-  type: z7.enum(["ban", "require", "protect"]),
-  rule: z7.string(),
-  rationale: z7.string().optional(),
+import { z as z8 } from "zod";
+var initContextFrameworkSchema = z8.object({
+  kind: z8.string(),
+  version: z8.string(),
+  subkind: z8.string()
+});
+var initContextInvariantConfidenceSnapshotSchema = z8.object({
+  confidence: z8.enum(["HIGH", "MEDIUM", "LOW"]),
+  evidence_refs: z8.array(z8.string())
+});
+var initContextSourceEvidenceSchema = z8.object({
+  file: z8.string(),
+  lines: z8.string()
+});
+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,
   ledgerAppendedEventSchema,
   driftDetectedEventSchema
 ]);
+
+// src/schemas/event-ledger.ts
+import { z as z10 } from "zod";
+var eventLedgerEnvelopeSchema = {
+  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 = z10.record(z10.string());
+var ruleContextPlannedEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("rule_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 ruleSelectionEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("rule_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: z10.array(z10.string()),
+  ignored_stable_ids: z10.array(z10.string())
+});
+var ruleSectionsFetchedEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("rule_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(),
+  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 ruleDriftDetectedEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("rule_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 ruleBaselineAcceptedEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("rule_baseline_accepted"),
+  revision: z10.string(),
+  previous_revision: z10.string().optional(),
+  accepted_stable_ids: z10.array(z10.string()),
+  source: z10.enum(["doctor_fix", "sync_meta"]).optional()
+});
+var baselineSyncedEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("baseline_synced"),
+  revision: z10.string(),
+  previous_revision: z10.string().optional(),
+  synced_files: z10.array(z10.string()),
+  accepted_stable_ids: z10.array(z10.string()),
+  source: z10.enum(["doctor_fix", "sync_meta"])
+});
+var mcpEventLedgerEventSchema = z10.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z10.literal("mcp_event"),
+  mcp_event_id: z10.string(),
+  stream_id: z10.string(),
+  message: z10.unknown()
+});
+var eventLedgerEventSchema = z10.discriminatedUnion("event_type", [
+  ruleContextPlannedEventSchema,
+  ruleSelectionEventSchema,
+  ruleSectionsFetchedEventSchema,
+  editIntentCheckedEventSchema,
+  ruleDriftDetectedEventSchema,
+  ruleBaselineAcceptedEventSchema,
+  baselineSyncedEventSchema,
+  mcpEventLedgerEventSchema
+]);
 export {
   AGENTS_META_IDENTITY_SOURCES,
   AGENTS_META_LAYERS,
   AGENTS_META_TOPOLOGY_TYPES,
   PROTECTED_TOKENS,
+  RULE_TEST_INDEX_SCHEMA_VERSION,
   agentsIdentitySourceSchema,
   agentsLayerSchema,
   agentsMetaNodeSchema,
@@ -393,6 +558,7 @@ export {
   aiLedgerEntrySchema,
   annotateIntentRequestSchema,
   auditModeSchema,
+  baselineSyncedEventSchema,
   candidateFileEntrySchema,
   clientPathsSchema,
   createTranslator,
@@ -403,7 +569,9 @@ export {
   deriveAgentsMetaTopologyType,
   detectNodeLocale,
   driftDetectedEventSchema,
+  editIntentCheckedEventSchema,
   enMessages,
+  eventLedgerEventSchema,
   fabricConfigSchema,
   fabricEventSchema,
   forensicAssertionCoverageSchema,
@@ -435,8 +603,19 @@ export {
   ledgerSourceSchema,
   lockApprovedEventSchema,
   lockDriftEventSchema,
+  mcpEventLedgerEventSchema,
   metaUpdatedEventSchema,
   normalizeLocale,
+  ruleBaselineAcceptedEventSchema,
+  ruleContextPlannedEventSchema,
+  ruleDescriptionIndexItemSchema,
+  ruleDescriptionSchema,
+  ruleDriftDetectedEventSchema,
+  ruleSectionsFetchedEventSchema,
+  ruleSelectionEventSchema,
+  ruleTestIndexSchema,
+  ruleTestLinkSchema,
+  ruleTestOrphanAnnotationSchema,
   withDerivedAgentsMetaNodeDefaults,
   zhCNMessages
 };