@fenglimg/fabric-shared 1.7.0 → 1.8.0-rc.2

package/dist/index.js

@@ -1,3 +1,4 @@
+import "./chunk-LXNCAKJZ.js";
 import {
   PROTECTED_TOKENS,
   createTranslator,
@@ -6,8 +7,25 @@ import {
   enMessages,
   normalizeLocale,
   zhCNMessages
-} from "./chunk-5H2PVNB2.js";
-import "./chunk-LXNCAKJZ.js";
+} from "./chunk-BLXHC5HA.js";
+import {
+  annotateIntentRequestSchema,
+  getRulesAnnotations,
+  getRulesInputSchema,
+  getRulesOutputSchema,
+  historyStateQuerySchema,
+  humanLockApproveRequestSchema,
+  humanLockFileParamsSchema,
+  ledgerQuerySchema,
+  ledgerSourceSchema,
+  planContextAnnotations,
+  planContextInputSchema,
+  planContextOutputSchema,
+  ruleSectionsAnnotations,
+  ruleSectionsInputSchema,
+  ruleSectionsOutputSchema,
+  structuredWarningSchema
+} from "./chunk-KV27CZH3.js";
 
 // src/schemas/agents-meta.ts
 import { z } from "zod";
@@ -156,83 +174,29 @@ var ruleTestIndexSchema = z2.object({
   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;
-  }
-  if (typeof value === "number") {
-    return value;
-  }
-  if (typeof value === "string") {
-    const trimmed = value.trim();
-    if (trimmed.length === 0) {
-      return void 0;
-    }
-    if (/^\d+$/.test(trimmed)) {
-      return Number.parseInt(trimmed, 10);
-    }
-    const parsed = Date.parse(trimmed);
-    return Number.isNaN(parsed) ? value : parsed;
-  }
-  return value;
-}, z3.number().int().nonnegative());
-var ledgerQuerySchema = z3.object({
-  source: ledgerSourceSchema.optional(),
-  since: timestampFilterSchema.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: z3.ZodIssueCode.custom,
-      message: "Provide exactly one of ledger_id or ts.",
-      path: ["ledger_id"]
-    });
-  }
-});
-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 = z3.object({
-  file: z3.string().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 z4 } from "zod";
+import { z as z3 } from "zod";
 var ledgerEntryBaseSchema = {
-  id: z4.string().optional(),
-  ts: z4.number().int().nonnegative(),
-  intent: z4.string(),
-  affected_paths: z4.array(z4.string())
+  id: z3.string().optional(),
+  ts: z3.number().int().nonnegative(),
+  intent: z3.string(),
+  affected_paths: z3.array(z3.string())
 };
-var aiLedgerEntrySchema = z4.object({
+var aiLedgerEntrySchema = z3.object({
   ...ledgerEntryBaseSchema,
-  source: z4.literal("ai"),
-  commit_sha: z4.string().optional()
+  source: z3.literal("ai"),
+  commit_sha: z3.string().optional()
 });
-var humanLedgerEntrySchema = z4.object({
+var humanLedgerEntrySchema = z3.object({
   ...ledgerEntryBaseSchema,
-  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) => {
+  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) => {
   if (value && typeof value === "object" && !Array.isArray(value) && (!("source" in value) || value.source === void 0)) {
     return {
       ...value,
@@ -243,187 +207,189 @@ var ledgerEntrySchema = z4.preprocess((value) => {
 }, ledgerEntryUnionSchema);
 
 // src/schemas/human-lock.ts
-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()
+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()
 });
-var humanLockFileSchema = z5.object({
-  locked: z5.array(humanLockEntrySchema).optional()
+var humanLockFileSchema = z4.object({
+  locked: z4.array(humanLockEntrySchema).optional()
 });
 
 // src/schemas/fabric-config.ts
-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({
+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(),
+  codexCLI: z5.string().optional()
+}).passthrough();
+var mcpPayloadLimitsSchema = z5.object({
+  warnBytes: z5.number().int().positive().optional(),
+  hardBytes: z5.number().int().positive().optional()
+}).optional();
+var fabricConfigSchema = z5.object({
   clientPaths: clientPathsSchema.optional(),
-  externalFixturePath: z6.string().optional(),
-  scanIgnores: z6.array(z6.string()).optional(),
+  externalFixturePath: z5.string().optional(),
+  scanIgnores: z5.array(z5.string()).optional(),
   auditMode: auditModeSchema.optional(),
-  audit_mode: auditModeSchema.optional()
+  audit_mode: auditModeSchema.optional(),
+  mcpPayloadLimits: mcpPayloadLimitsSchema
 });
 
 // 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),
+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),
   coverage: forensicAssertionCoverageSchema,
-  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(),
+  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(),
   framework: forensicFrameworkSchema,
   topology: forensicTopologySchema,
-  entry_points: z7.array(forensicEntryPointSchema),
-  code_samples: z7.array(forensicCodeSampleSchema),
-  assertions: z7.array(forensicAssertionSchema),
-  candidate_files: z7.array(candidateFileEntrySchema),
+  entry_points: z6.array(forensicEntryPointSchema),
+  code_samples: z6.array(forensicCodeSampleSchema),
+  assertions: z6.array(forensicAssertionSchema),
+  candidate_files: z6.array(candidateFileEntrySchema),
   sampling_budget: forensicSamplingBudgetSchema,
   readme: forensicReadmeSchema,
-  recommendations_for_skill: z7.array(z7.string()).optional()
+  recommendations_for_skill: z6.array(z6.string()).optional()
 });
 
 // src/schemas/init-context.ts
-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(),
+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(),
   confidence_snapshot: initContextInvariantConfidenceSnapshotSchema.optional(),
-  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({
+  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({
   framework: initContextFrameworkSchema,
-  architecture_patterns: z8.array(z8.string()),
-  invariants: z8.array(initContextInvariantSchema),
-  domain_groups: z8.array(initContextDomainGroupSchema),
-  interview_trail: z8.array(initContextInterviewTrailEntrySchema),
-  forensic_ref: z8.string()
+  architecture_patterns: z7.array(z7.string()),
+  invariants: z7.array(initContextInvariantSchema),
+  domain_groups: z7.array(initContextDomainGroupSchema),
+  interview_trail: z7.array(initContextInterviewTrailEntrySchema),
+  forensic_ref: z7.string()
 });
 
 // src/schemas/events.ts
-import { z as z9 } from "zod";
-var metaUpdatedEventSchema = z9.object({
-  type: z9.literal("meta:updated"),
+import { z as z8 } from "zod";
+var metaUpdatedEventSchema = z8.object({
+  type: z8.literal("meta:updated"),
   payload: agentsMetaSchema
 });
-var lockDriftEventSchema = z9.object({
-  type: z9.literal("lock:drift"),
-  payload: z9.object({
-    locked: z9.array(humanLockEntrySchema),
-    drifted: z9.array(humanLockEntrySchema)
+var lockDriftEventSchema = z8.object({
+  type: z8.literal("lock:drift"),
+  payload: z8.object({
+    locked: z8.array(humanLockEntrySchema),
+    drifted: z8.array(humanLockEntrySchema)
   })
 });
-var lockApprovedEventSchema = z9.object({
-  type: z9.literal("lock:approved"),
-  payload: z9.object({
-    locked: z9.array(humanLockEntrySchema),
-    approved: z9.array(humanLockEntrySchema)
+var lockApprovedEventSchema = z8.object({
+  type: z8.literal("lock:approved"),
+  payload: z8.object({
+    locked: z8.array(humanLockEntrySchema),
+    approved: z8.array(humanLockEntrySchema)
   })
 });
-var ledgerAppendedEventSchema = z9.object({
-  type: z9.literal("ledger:appended"),
+var ledgerAppendedEventSchema = z8.object({
+  type: z8.literal("ledger:appended"),
   payload: ledgerEntrySchema
 });
-var driftDetectedEventSchema = z9.object({
-  type: z9.literal("drift:detected"),
+var driftDetectedEventSchema = z8.object({
+  type: z8.literal("drift:detected"),
   payload: forensicReportSchema
 });
-var fabricEventSchema = z9.discriminatedUnion("type", [
+var fabricEventSchema = z8.discriminatedUnion("type", [
   metaUpdatedEventSchema,
   lockDriftEventSchema,
   lockApprovedEventSchema,
@@ -432,109 +398,161 @@ var fabricEventSchema = z9.discriminatedUnion("type", [
 ]);
 
 // src/schemas/event-ledger.ts
-import { z as z10 } from "zod";
+import { z as z9 } 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()
+  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()
 };
-var stringRecordSchema = z10.record(z10.string());
-var ruleContextPlannedEventSchema = z10.object({
+var stringRecordSchema = z9.record(z9.string());
+var ruleContextPlannedEventSchema = z9.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({
+  event_type: z9.literal("rule_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 ruleSelectionEventSchema = z9.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()),
+  event_type: z9.literal("rule_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()),
   ai_selection_reasons: stringRecordSchema,
-  rejected_stable_ids: z10.array(z10.string()),
-  ignored_stable_ids: z10.array(z10.string())
+  rejected_stable_ids: z9.array(z9.string()),
+  ignored_stable_ids: z9.array(z9.string())
 });
-var ruleSectionsFetchedEventSchema = z10.object({
+var ruleSectionsFetchedEventSchema = z9.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({
+  event_type: z9.literal("rule_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: 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({
+  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 ruleDriftDetectedEventSchema = z9.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()
+  event_type: z9.literal("rule_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()
     })
   ).optional()
 });
-var ruleBaselineAcceptedEventSchema = z10.object({
+var ruleBaselineAcceptedEventSchema = z9.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()
+  event_type: z9.literal("rule_baseline_accepted"),
+  revision: z9.string(),
+  previous_revision: z9.string().optional(),
+  accepted_stable_ids: z9.array(z9.string()),
+  source: z9.enum(["doctor_fix", "sync_meta"]).optional()
 });
-var baselineSyncedEventSchema = z10.object({
+var baselineSyncedEventSchema = z9.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({
+  event_type: z9.literal("baseline_synced"),
+  revision: z9.string(),
+  previous_revision: z9.string().optional(),
+  synced_files: z9.array(z9.string()),
+  accepted_stable_ids: z9.array(z9.string()),
+  source: z9.enum(["doctor_fix", "sync_meta"])
+});
+var mcpEventLedgerEventSchema = z9.object({
   ...eventLedgerEnvelopeSchema,
-  event_type: z10.literal("mcp_event"),
-  mcp_event_id: z10.string(),
-  stream_id: z10.string(),
-  message: z10.unknown()
+  event_type: z9.literal("mcp_event"),
+  mcp_event_id: z9.string(),
+  stream_id: z9.string(),
+  message: z9.unknown()
 });
-var eventLedgerEventSchema = z10.discriminatedUnion("event_type", [
+var reapplyCompletedEventSchema = z9.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z9.literal("reapply_completed"),
+  preserved_ledger: z9.boolean(),
+  preserved_meta: z9.boolean(),
+  rules_count: z9.number().int().nonnegative()
+});
+var eventLedgerTruncatedEventSchema = z9.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()
+});
+var mcpConfigMigratedEventSchema = z9.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z9.literal("mcp_config_migrated"),
+  source: z9.literal("doctor_fix"),
+  removed_from: z9.string()
+});
+var metaReconciledOnStartupEventSchema = z9.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("reconcileRules")
+});
+var metaReconciledEventSchema = z9.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("reconcileRules")
+});
+var claudeSkillPathMigratedEventSchema = z9.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z9.literal("claude_skill_path_migrated"),
+  from: z9.string(),
+  to: z9.string()
+});
+var claudeHookPathMigratedEventSchema = z9.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z9.literal("claude_hook_path_migrated"),
+  from: z9.string(),
+  to: z9.string()
+});
+var legacyClientPathPresentEventSchema = z9.object({
+  ...eventLedgerEnvelopeSchema,
+  event_type: z9.literal("legacy_client_path_present"),
+  removed: z9.array(z9.string())
+});
+var eventLedgerEventSchema = z9.discriminatedUnion("event_type", [
   ruleContextPlannedEventSchema,
   ruleSelectionEventSchema,
   ruleSectionsFetchedEventSchema,
@@ -542,7 +560,15 @@ var eventLedgerEventSchema = z10.discriminatedUnion("event_type", [
   ruleDriftDetectedEventSchema,
   ruleBaselineAcceptedEventSchema,
   baselineSyncedEventSchema,
-  mcpEventLedgerEventSchema
+  mcpEventLedgerEventSchema,
+  reapplyCompletedEventSchema,
+  eventLedgerTruncatedEventSchema,
+  mcpConfigMigratedEventSchema,
+  metaReconciledOnStartupEventSchema,
+  metaReconciledEventSchema,
+  claudeSkillPathMigratedEventSchema,
+  claudeHookPathMigratedEventSchema,
+  legacyClientPathPresentEventSchema
 ]);
 export {
   AGENTS_META_IDENTITY_SOURCES,
@@ -560,6 +586,8 @@ export {
   auditModeSchema,
   baselineSyncedEventSchema,
   candidateFileEntrySchema,
+  claudeHookPathMigratedEventSchema,
+  claudeSkillPathMigratedEventSchema,
   clientPathsSchema,
   createTranslator,
   defaultMessages,
@@ -572,6 +600,7 @@ export {
   editIntentCheckedEventSchema,
   enMessages,
   eventLedgerEventSchema,
+  eventLedgerTruncatedEventSchema,
   fabricConfigSchema,
   fabricEventSchema,
   forensicAssertionCoverageSchema,
@@ -584,6 +613,9 @@ export {
   forensicReportSchema,
   forensicSamplingBudgetSchema,
   forensicTopologySchema,
+  getRulesAnnotations,
+  getRulesInputSchema,
+  getRulesOutputSchema,
   historyStateQuerySchema,
   humanLedgerEntrySchema,
   humanLockApproveRequestSchema,
@@ -601,21 +633,34 @@ export {
   ledgerEntrySchema,
   ledgerQuerySchema,
   ledgerSourceSchema,
+  legacyClientPathPresentEventSchema,
   lockApprovedEventSchema,
   lockDriftEventSchema,
+  mcpConfigMigratedEventSchema,
   mcpEventLedgerEventSchema,
+  mcpPayloadLimitsSchema,
+  metaReconciledEventSchema,
+  metaReconciledOnStartupEventSchema,
   metaUpdatedEventSchema,
   normalizeLocale,
+  planContextAnnotations,
+  planContextInputSchema,
+  planContextOutputSchema,
+  reapplyCompletedEventSchema,
   ruleBaselineAcceptedEventSchema,
   ruleContextPlannedEventSchema,
   ruleDescriptionIndexItemSchema,
   ruleDescriptionSchema,
   ruleDriftDetectedEventSchema,
+  ruleSectionsAnnotations,
   ruleSectionsFetchedEventSchema,
+  ruleSectionsInputSchema,
+  ruleSectionsOutputSchema,
   ruleSelectionEventSchema,
   ruleTestIndexSchema,
   ruleTestLinkSchema,
   ruleTestOrphanAnnotationSchema,
+  structuredWarningSchema,
   withDerivedAgentsMetaNodeDefaults,
   zhCNMessages
 };