ushman-ledger 0.3.0 → 1.1.0

package/dist/schema/entry.js

@@ -1,6 +1,5 @@
 import path from 'node:path';
-import { z } from 'zod';
-import { createDeterministicUuidV7, isUuidV7 } from "../uuid.js";
+import * as v from 'valibot';
 import { NoteSubkindSchema } from "./note.js";
 export const LedgerSchemaVersion = 'ushman-ledger-entry/v1';
 export const LEDGER_PHASES = [
@@ -21,27 +20,12 @@ export const LEDGER_KINDS = [
     'tool-invocation',
     'agent-patch',
     'operator-patch',
-    'stage-transition',
     'operator-decision',
     'validator-result',
     'runtime-event',
     'note',
     'correction',
     'strip-decision-reverted',
-    'descope-brief',
-    'merge-return',
-    'merge-return-rejected',
-    'revert',
-    'rollback',
-    'rework.test_retired',
-];
-export const STAGE_TRANSITION_STAGES = [
-    'intake',
-    'seed',
-    'vendor-extract',
-    'cleanup',
-    'parity',
-    'characterize',
 ];
 export const OPERATOR_DECISION_ACTIONS = [
     'bypass-doctor',
@@ -52,16 +36,18 @@ export const OPERATOR_DECISION_ACTIONS = [
     'ledger-hand-edit',
     'escalation',
 ];
+const STRIP_DECISION_INVALIDATED_STAGES = [
+    'intake',
+    'seed',
+    'vendor-extract',
+    'cleanup',
+    'parity',
+    'characterize',
+];
 const SHA256_HEX_PATTERN = /^[a-f0-9]{64}$/u;
 const WINDOWS_ABSOLUTE_PATH_PATTERN = /^[a-z]:[\\/]/iu;
 const normalizeWorkspaceRelativePath = (value) => value.replaceAll('\\', '/');
-const mergeAffectedFiles = (left, right) => [
-    ...new Set([...(left ?? []), ...right]),
-];
-const WorkspaceRelativePathSchema = z
-    .string()
-    .min(1)
-    .refine((value) => {
+const isNormalizedWorkspaceRelativePath = (value) => {
     const normalized = normalizeWorkspaceRelativePath(value);
     if (normalized.startsWith('/') || WINDOWS_ABSOLUTE_PATH_PATTERN.test(value)) {
         return false;
@@ -77,543 +63,225 @@ const WorkspaceRelativePathSchema = z
         return false;
     }
     return !normalized.split('/').includes('..');
-}, 'Expected a normalized workspace-relative path.');
-const SHA256HexSchema = z.string().regex(SHA256_HEX_PATTERN, 'Expected a lowercase SHA-256 hex digest.');
-const UuidV7Schema = z.string().refine(isUuidV7, 'Expected a UUIDv7 value.');
-const LegacyOperatorDecisionTypeSchema = z.enum([
-    'strip-decision',
-    'strip-decision-revised',
-    'vendor-boundary',
-    'intent-exclusion',
-    'other',
-]);
-export const mapLegacyDecisionTypeToAction = (decisionType) => {
-    switch (decisionType) {
-        case 'strip-decision':
-        case 'strip-decision-revised':
-            return 'override-strip-decision';
-        default:
-            return 'escalation';
-    }
-};
-const makeDigestRecordSchema = () => z.record(z.string().min(1), SHA256HexSchema);
-const validatePatchPayload = ({ ctx, payload, }) => {
-    const touchedPaths = payload.touchedPaths ?? [];
-    const beforeMap = payload.fileSha256Before ?? {};
-    const afterMap = payload.fileSha256After ?? {};
-    if (touchedPaths.length === 0) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'payload.touchedPaths must contain at least one path',
-            path: ['payload', 'touchedPaths'],
-        });
-    }
-    for (const touchedPath of touchedPaths) {
-        if (!(touchedPath in beforeMap)) {
-            ctx.addIssue({
-                code: 'custom',
-                message: `payload.fileSha256Before is missing ${touchedPath}`,
-                path: ['payload', 'fileSha256Before', touchedPath],
-            });
-        }
-        if (!(touchedPath in afterMap)) {
-            ctx.addIssue({
-                code: 'custom',
-                message: `payload.fileSha256After is missing ${touchedPath}`,
-                path: ['payload', 'fileSha256After', touchedPath],
-            });
-        }
-    }
-    for (const hunk of payload.hunks ?? []) {
-        if (!touchedPaths.includes(hunk.path)) {
-            ctx.addIssue({
-                code: 'custom',
-                message: `payload.hunks path ${hunk.path} must appear in payload.touchedPaths`,
-                path: ['payload', 'hunks'],
-            });
-        }
-    }
 };
-export const LedgerPhaseSchema = z.enum(LEDGER_PHASES);
-export const StageTransitionStageSchema = z.enum(STAGE_TRANSITION_STAGES);
-export const OperatorDecisionActionSchema = z.enum(OPERATOR_DECISION_ACTIONS);
-export const EmitterSchema = z.object({
-    tool: z.string().min(1),
-    user: z.string().min(1).optional(),
-    version: z.string().min(1),
-});
-export const LedgerLinksSchema = z
-    .object({
-    affectedFiles: z.array(WorkspaceRelativePathSchema).optional(),
-    blobs: z.array(z.string()).optional(),
-    briefId: z.string().optional(),
-    correctsLedgerId: z.string().optional(),
-    gitRef: z.string().optional(),
-    idempotencyKey: z.string().optional(),
-    stripDecisionId: z.string().optional(),
-    supersedesLedgerId: z.string().optional(),
-    validatorVerdictId: z.string().optional(),
-})
-    .catchall(z.unknown());
-const LedgerEntryBaseSchema = z.object({
-    _legacy: z.literal(true).optional(),
-    details: z.record(z.string(), z.unknown()).optional(),
+const WorkspaceRelativePathSchema = v.pipe(v.string(), v.minLength(1), v.check(isNormalizedWorkspaceRelativePath, 'Expected a normalized workspace-relative path.'));
+const SHA256HexSchema = v.pipe(v.string(), v.regex(SHA256_HEX_PATTERN, 'Expected a lowercase SHA-256 hex digest.'));
+export const LedgerPhaseSchema = v.picklist(LEDGER_PHASES);
+export const OperatorDecisionActionSchema = v.picklist(OPERATOR_DECISION_ACTIONS);
+const StripDecisionInvalidatedStageSchema = v.picklist(STRIP_DECISION_INVALIDATED_STAGES);
+export const EmitterSchema = v.object({
+    tool: v.pipe(v.string(), v.minLength(1)),
+    user: v.optional(v.pipe(v.string(), v.minLength(1))),
+    version: v.pipe(v.string(), v.minLength(1)),
+});
+export const LedgerLinksSchema = v.objectWithRest({
+    affectedFiles: v.optional(v.array(WorkspaceRelativePathSchema)),
+    blobs: v.optional(v.array(v.string())),
+    briefId: v.optional(v.string()),
+    correctsLedgerId: v.optional(v.string()),
+    gitRef: v.optional(v.string()),
+    idempotencyKey: v.optional(v.string()),
+    stripDecisionId: v.optional(v.string()),
+    supersedesLedgerId: v.optional(v.string()),
+    validatorVerdictId: v.optional(v.string()),
+}, v.unknown());
+const ledgerEntryBaseEntries = {
+    details: v.optional(v.record(v.string(), v.unknown())),
     emitter: EmitterSchema,
-    id: z.string().min(1),
-    kind: z.string().min(1),
-    links: LedgerLinksSchema.default({}),
+    id: v.pipe(v.string(), v.minLength(1)),
+    links: v.optional(LedgerLinksSchema, {}),
     phase: LedgerPhaseSchema,
-    prevEntryId: z.string().min(1).nullable(),
-    schemaVersion: z.literal(LedgerSchemaVersion),
-    summary: z.string().min(1),
-    ts: z.string().datetime({ offset: true }),
-});
-export const PatchHunkSchema = z
-    .object({
-    endLine: z.number().int().positive(),
-    path: WorkspaceRelativePathSchema,
-    startLine: z.number().int().positive(),
-})
-    .refine((value) => value.endLine >= value.startLine, {
-    message: 'payload.hunks endLine must be greater than or equal to startLine',
-    path: ['endLine'],
-});
-export const PatchPayloadSchema = z.object({
-    diff: z.string().min(1).optional(),
-    diffSha256: SHA256HexSchema,
-    fileSha256After: makeDigestRecordSchema().default({}),
-    fileSha256Before: makeDigestRecordSchema().default({}),
-    hunks: z.array(PatchHunkSchema).default([]),
-    touchedPaths: z.array(WorkspaceRelativePathSchema).default([]),
-});
-export const PatchPayloadWriteSchema = PatchPayloadSchema.superRefine((value, ctx) => {
-    validatePatchPayload({
-        ctx,
-        payload: value,
-    });
-    if (!value.diff) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'payload.diff is required for new patch records',
-            path: ['diff'],
-        });
-    }
-});
-export const OperatorDecisionPayloadSchema = z.object({
-    action: OperatorDecisionActionSchema,
-    checkId: z.string().min(1).optional(),
-    rationale: z.string().trim().min(1, 'payload.rationale must not be empty'),
-});
-export const ValidatorResultPayloadSchema = z.object({
-    id: UuidV7Schema,
-});
-export const CorrectionPayloadSchema = z.object({
-    correctsValidatorResultId: UuidV7Schema.optional(),
-});
-export const StageTransitionPayloadSchema = z.object({
-    doctorBaselineId: z.string().min(1).optional(),
-    endedAt: z.string().datetime({ offset: true }),
-    exitCode: z.number().int(),
-    stage: StageTransitionStageSchema,
-    startedAt: z.string().datetime({ offset: true }),
-});
-export const StripDecisionRevertedPayloadSchema = z.object({
-    invalidatedStages: z.array(StageTransitionStageSchema).optional(),
-    rationale: z.string().trim().min(1),
-    stripDecisionId: z.string().min(1),
-});
-export const DescopeBriefPayloadSchema = z.object({
-    briefId: z.string().min(1),
-    reason: z.string().trim().min(1).optional(),
-    round: z.number().int().positive().optional(),
-    stripDecisionIds: z.array(z.string().min(1)).optional(),
-});
-export const MergeReturnPayloadSchema = z.object({
-    briefId: z.string().min(1).optional(),
-    returnId: z.string().min(1),
-    source: z.string().min(1).optional(),
-});
-export const MergeReturnRejectedPayloadSchema = MergeReturnPayloadSchema.extend({
-    reason: z.string().trim().min(1),
-});
-export const RevertPayloadSchema = z.object({
-    reason: z.string().trim().min(1),
-    targetEntryId: z.string().min(1).optional(),
-});
-export const RollbackPayloadSchema = RevertPayloadSchema.extend({
-    targetStage: StageTransitionStageSchema.optional(),
-});
-export const ReworkTestRetiredPayloadSchema = z.object({
-    briefId: z.string().min(1).optional(),
-    removedBy: z.enum(['descope', 'decompose', 'operator']),
-    removedTestPath: WorkspaceRelativePathSchema,
-    removedTestSymbols: z.array(z.string().min(1)),
-    sourceSymbolDeletedFrom: WorkspaceRelativePathSchema,
-});
-export const ToolInvocationEntrySchema = LedgerEntryBaseSchema.extend({
-    args: z.array(z.string()).optional(),
-    cwd: z.string().optional(),
-    exitCode: z.number().int().optional(),
-    kind: z.literal('tool-invocation'),
-});
-export const AgentPatchDiffSchema = z.object({
-    addedLines: z.number().int().nonnegative(),
+    prevEntryId: v.nullable(v.pipe(v.string(), v.minLength(1))),
+    schemaVersion: v.literal(LedgerSchemaVersion),
+    summary: v.pipe(v.string(), v.minLength(1)),
+    ts: v.pipe(v.string(), v.isoTimestamp()),
+};
+export const AgentPatchDiffSchema = v.object({
+    addedLines: v.pipe(v.number(), v.integer(), v.minValue(0)),
     blobSha256: SHA256HexSchema,
-    bytes: z.number().int().nonnegative(),
-    removedLines: z.number().int().nonnegative(),
+    bytes: v.pipe(v.number(), v.integer(), v.minValue(0)),
+    removedLines: v.pipe(v.number(), v.integer(), v.minValue(0)),
 });
-const PatchEntryBaseSchema = LedgerEntryBaseSchema.extend({
+export const OperatorDecisionPayloadSchema = v.object({
+    action: OperatorDecisionActionSchema,
+    checkId: v.optional(v.pipe(v.string(), v.minLength(1))),
+    rationale: v.pipe(v.string(), v.trim(), v.minLength(1, 'payload.rationale must not be empty')),
+});
+export const StripDecisionRevertedPayloadSchema = v.object({
+    invalidatedStages: v.optional(v.array(StripDecisionInvalidatedStageSchema)),
+    rationale: v.pipe(v.string(), v.trim(), v.minLength(1)),
+    stripDecisionId: v.pipe(v.string(), v.minLength(1)),
+});
+export const ToolInvocationEntrySchema = v.object({
+    ...ledgerEntryBaseEntries,
+    args: v.optional(v.array(v.string())),
+    cwd: v.optional(v.string()),
+    exitCode: v.optional(v.pipe(v.number(), v.integer())),
+    kind: v.literal('tool-invocation'),
+});
+const patchEntryEntries = {
+    ...ledgerEntryBaseEntries,
     diff: AgentPatchDiffSchema,
-    payload: PatchPayloadSchema,
-    rationale: z.string().min(1),
-}).superRefine((value, ctx) => {
-    if (value.payload.diffSha256 !== value.diff.blobSha256) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'payload.diffSha256 must match diff.blobSha256',
-            path: ['payload', 'diffSha256'],
-        });
-    }
-    validatePatchPayload({
-        ctx,
-        payload: value.payload,
-    });
-});
-export const AgentPatchEntrySchema = PatchEntryBaseSchema.safeExtend({
-    agent: z.object({
-        name: z.string().min(1),
-        sessionId: z.string().min(1).optional(),
+    rationale: v.pipe(v.string(), v.minLength(1)),
+};
+export const AgentPatchEntrySchema = v.object({
+    ...patchEntryEntries,
+    agent: v.object({
+        name: v.pipe(v.string(), v.minLength(1)),
+        sessionId: v.optional(v.pipe(v.string(), v.minLength(1))),
     }),
-    kind: z.literal('agent-patch'),
+    kind: v.literal('agent-patch'),
 });
-export const OperatorPatchEntrySchema = PatchEntryBaseSchema.safeExtend({
-    kind: z.literal('operator-patch'),
-    operator: z.object({
-        name: z.string().min(1),
+export const OperatorPatchEntrySchema = v.object({
+    ...patchEntryEntries,
+    kind: v.literal('operator-patch'),
+    operator: v.object({
+        name: v.pipe(v.string(), v.minLength(1)),
     }),
 });
-export const StageTransitionEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('stage-transition'),
-    payload: StageTransitionPayloadSchema,
-});
-export const OperatorDecisionEntrySchema = LedgerEntryBaseSchema.extend({
-    body: z.record(z.string(), z.unknown()).optional(),
-    decisionType: LegacyOperatorDecisionTypeSchema.optional(),
-    kind: z.literal('operator-decision'),
+export const OperatorDecisionEntrySchema = v.object({
+    ...ledgerEntryBaseEntries,
+    kind: v.literal('operator-decision'),
     payload: OperatorDecisionPayloadSchema,
 });
-export const ValidatorResultEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('validator-result'),
-    metrics: z.record(z.string(), z.unknown()).optional(),
-    payload: ValidatorResultPayloadSchema,
-    resultPath: z.string().optional(),
-    validator: z.enum(['parity', 'equiv', 'characterize', 'verify', 'doctor']),
-    verdict: z.enum(['green', 'yellow', 'red']),
-});
-export const RuntimeEventEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('runtime-event'),
-    level: z.enum(['info', 'warn', 'error']),
-    message: z.string().min(1),
-    source: z.string().min(1),
-    stripDecisionId: z.string().optional(),
-});
-export const NoteEntrySchema = LedgerEntryBaseSchema.extend({
-    body: z.string(),
-    kind: z.literal('note'),
+export const ValidatorResultEntrySchema = v.object({
+    ...ledgerEntryBaseEntries,
+    kind: v.literal('validator-result'),
+    metrics: v.optional(v.record(v.string(), v.unknown())),
+    resultPath: v.optional(v.string()),
+    validator: v.picklist(['parity', 'equiv', 'characterize', 'verify', 'doctor']),
+    verdict: v.picklist(['green', 'yellow', 'red']),
+});
+export const RuntimeEventEntrySchema = v.object({
+    ...ledgerEntryBaseEntries,
+    kind: v.literal('runtime-event'),
+    level: v.picklist(['info', 'warn', 'error']),
+    message: v.pipe(v.string(), v.minLength(1)),
+    source: v.pipe(v.string(), v.minLength(1)),
+    stripDecisionId: v.optional(v.string()),
+});
+export const NoteEntrySchema = v.object({
+    ...ledgerEntryBaseEntries,
+    body: v.string(),
+    kind: v.literal('note'),
     subkind: NoteSubkindSchema,
 });
-export const CorrectionEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('correction'),
-    payload: CorrectionPayloadSchema.default({}),
-    rationale: z.string().min(1),
-}).superRefine((value, ctx) => {
-    if (!value.links?.correctsLedgerId) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'correction entries require links.correctsLedgerId',
-            path: ['links', 'correctsLedgerId'],
-        });
-    }
-});
-export const StripDecisionRevertedEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('strip-decision-reverted'),
+export const CorrectionEntrySchema = v.pipe(v.object({
+    ...ledgerEntryBaseEntries,
+    kind: v.literal('correction'),
+    rationale: v.pipe(v.string(), v.minLength(1)),
+}), v.check((value) => Boolean(value.links?.correctsLedgerId), 'correction entries require links.correctsLedgerId'));
+export const StripDecisionRevertedEntrySchema = v.object({
+    ...ledgerEntryBaseEntries,
+    kind: v.literal('strip-decision-reverted'),
     payload: StripDecisionRevertedPayloadSchema,
 });
-export const DescopeBriefEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('descope-brief'),
-    payload: DescopeBriefPayloadSchema,
-});
-export const MergeReturnEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('merge-return'),
-    payload: MergeReturnPayloadSchema,
-});
-export const MergeReturnRejectedEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('merge-return-rejected'),
-    payload: MergeReturnRejectedPayloadSchema,
-});
-export const RevertEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('revert'),
-    payload: RevertPayloadSchema,
-});
-export const RollbackEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('rollback'),
-    payload: RollbackPayloadSchema,
-});
-export const ReworkTestRetiredEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('rework.test_retired'),
-    payload: ReworkTestRetiredPayloadSchema,
-});
-export const LedgerEntrySchema = z.discriminatedUnion('kind', [
+export const LedgerEntrySchema = v.variant('kind', [
     ToolInvocationEntrySchema,
     AgentPatchEntrySchema,
     OperatorPatchEntrySchema,
-    StageTransitionEntrySchema,
     OperatorDecisionEntrySchema,
     ValidatorResultEntrySchema,
     RuntimeEventEntrySchema,
     NoteEntrySchema,
     CorrectionEntrySchema,
     StripDecisionRevertedEntrySchema,
-    DescopeBriefEntrySchema,
-    MergeReturnEntrySchema,
-    MergeReturnRejectedEntrySchema,
-    RevertEntrySchema,
-    RollbackEntrySchema,
-    ReworkTestRetiredEntrySchema,
 ]);
-const LegacyAgentPatchEntrySchema = LedgerEntryBaseSchema.extend({
-    agent: z.object({
-        name: z.string().min(1),
-        sessionId: z.string().min(1).optional(),
-    }),
-    diff: AgentPatchDiffSchema,
-    kind: z.literal('agent-patch'),
-    rationale: z.string().min(1),
-});
-const LegacyOperatorDecisionEntrySchema = LedgerEntryBaseSchema.extend({
-    body: z.record(z.string(), z.unknown()),
-    decisionType: LegacyOperatorDecisionTypeSchema,
-    kind: z.literal('operator-decision'),
-});
-const LegacyValidatorResultEntrySchema = LedgerEntryBaseSchema.extend({
-    kind: z.literal('validator-result'),
-    metrics: z.record(z.string(), z.unknown()).optional(),
-    resultPath: z.string().optional(),
-    validator: z.enum(['parity', 'equiv', 'characterize', 'verify', 'doctor']),
-    verdict: z.enum(['green', 'yellow', 'red']),
-});
-const RecordEntryBaseSchema = z.object({
-    details: z.record(z.string(), z.unknown()).optional(),
+const recordEntryBaseEntries = {
+    details: v.optional(v.record(v.string(), v.unknown())),
     emitter: EmitterSchema,
-    idempotencyKey: z.string().min(1).optional(),
-    links: LedgerLinksSchema.optional(),
+    idempotencyKey: v.optional(v.pipe(v.string(), v.minLength(1))),
+    links: v.optional(LedgerLinksSchema),
     phase: LedgerPhaseSchema,
-    summary: z.string().min(1),
-});
-export const ToolInvocationRecordSchema = RecordEntryBaseSchema.extend({
-    args: z.array(z.string()).optional(),
-    cwd: z.string().optional(),
-    exitCode: z.number().int().optional(),
-    kind: z.literal('tool-invocation'),
-});
-const PatchRecordPayloadInputSchema = z.object({
-    diff: z.string().min(1).optional(),
-    diffSha256: SHA256HexSchema.optional(),
-    fileSha256After: makeDigestRecordSchema().optional(),
-    fileSha256Before: makeDigestRecordSchema().optional(),
-    hunks: z.array(PatchHunkSchema).optional(),
-    touchedPaths: z.array(WorkspaceRelativePathSchema).min(1).optional(),
-});
-const PatchRecordBaseSchema = RecordEntryBaseSchema.extend({
-    diff: AgentPatchDiffSchema.optional(),
-    diffPath: z.string().min(1).optional(),
-    payload: PatchRecordPayloadInputSchema.optional(),
-    rationale: z.string().min(1),
-}).superRefine((value, ctx) => {
-    if (!value.payload && !value.diff && !value.diffPath) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'patch records require payload, diff, or diffPath',
-            path: ['payload'],
-        });
+    summary: v.pipe(v.string(), v.minLength(1)),
+};
+export const ToolInvocationRecordSchema = v.object({
+    ...recordEntryBaseEntries,
+    args: v.optional(v.array(v.string())),
+    cwd: v.optional(v.string()),
+    exitCode: v.optional(v.pipe(v.number(), v.integer())),
+    kind: v.literal('tool-invocation'),
+});
+const patchRecordEntries = {
+    ...recordEntryBaseEntries,
+    diff: v.optional(AgentPatchDiffSchema),
+    diffPath: v.optional(v.pipe(v.string(), v.minLength(1))),
+    diffText: v.optional(v.pipe(v.string(), v.minLength(1))),
+    rationale: v.pipe(v.string(), v.minLength(1)),
+};
+const validatePatchRecord = (value) => {
+    const provided = [value.diff, value.diffPath, value.diffText].filter((entry) => Boolean(entry));
+    if (provided.length === 0) {
+        return false;
     }
-    if (value.diff && value.diffPath) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'patch records must provide either diff or diffPath, not both',
-            path: ['diffPath'],
-        });
+    if (value.diffPath && value.diffText) {
+        return false;
     }
-});
-export const AgentPatchRecordSchema = PatchRecordBaseSchema.safeExtend({
-    agent: z.object({
-        name: z.string().min(1),
-        sessionId: z.string().min(1).optional(),
+    return true;
+};
+const PATCH_RECORD_REFINEMENT_MESSAGE = 'patch records require exactly one source: diff, diffPath, or diffText (diffPath and diffText cannot be combined).';
+export const AgentPatchRecordSchema = v.pipe(v.object({
+    ...patchRecordEntries,
+    agent: v.object({
+        name: v.pipe(v.string(), v.minLength(1)),
+        sessionId: v.optional(v.pipe(v.string(), v.minLength(1))),
     }),
-    kind: z.literal('agent-patch'),
-});
-export const OperatorPatchRecordSchema = PatchRecordBaseSchema.safeExtend({
-    kind: z.literal('operator-patch'),
-    operator: z.object({
-        name: z.string().min(1),
+    kind: v.literal('agent-patch'),
+}), v.check(validatePatchRecord, PATCH_RECORD_REFINEMENT_MESSAGE));
+export const OperatorPatchRecordSchema = v.pipe(v.object({
+    ...patchRecordEntries,
+    kind: v.literal('operator-patch'),
+    operator: v.object({
+        name: v.pipe(v.string(), v.minLength(1)),
     }),
-});
-export const StageTransitionRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('stage-transition'),
-    payload: StageTransitionPayloadSchema,
-});
-export const OperatorDecisionRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('operator-decision'),
+}), v.check(validatePatchRecord, PATCH_RECORD_REFINEMENT_MESSAGE));
+export const OperatorDecisionRecordSchema = v.object({
+    ...recordEntryBaseEntries,
+    kind: v.literal('operator-decision'),
     payload: OperatorDecisionPayloadSchema,
 });
-export const ValidatorResultRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('validator-result'),
-    metrics: z.record(z.string(), z.unknown()).optional(),
-    payload: z
-        .object({
-        id: UuidV7Schema.optional(),
-    })
-        .optional(),
-    resultPath: z.string().optional(),
-    validator: z.enum(['parity', 'equiv', 'characterize', 'verify', 'doctor']),
-    verdict: z.enum(['green', 'yellow', 'red']),
-});
-export const RuntimeEventRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('runtime-event'),
-    level: z.enum(['info', 'warn', 'error']),
-    message: z.string().min(1),
-    source: z.string().min(1),
-    stripDecisionId: z.string().optional(),
-});
-export const NoteRecordSchema = RecordEntryBaseSchema.extend({
-    body: z.string(),
-    kind: z.literal('note'),
+export const ValidatorResultRecordSchema = v.object({
+    ...recordEntryBaseEntries,
+    kind: v.literal('validator-result'),
+    metrics: v.optional(v.record(v.string(), v.unknown())),
+    resultPath: v.optional(v.string()),
+    validator: v.picklist(['parity', 'equiv', 'characterize', 'verify', 'doctor']),
+    verdict: v.picklist(['green', 'yellow', 'red']),
+});
+export const RuntimeEventRecordSchema = v.object({
+    ...recordEntryBaseEntries,
+    kind: v.literal('runtime-event'),
+    level: v.picklist(['info', 'warn', 'error']),
+    message: v.pipe(v.string(), v.minLength(1)),
+    source: v.pipe(v.string(), v.minLength(1)),
+    stripDecisionId: v.optional(v.string()),
+});
+export const NoteRecordSchema = v.object({
+    ...recordEntryBaseEntries,
+    body: v.string(),
+    kind: v.literal('note'),
     subkind: NoteSubkindSchema,
 });
-export const CorrectionRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('correction'),
-    payload: CorrectionPayloadSchema.optional(),
-    rationale: z.string().min(1),
-}).superRefine((value, ctx) => {
-    if (!value.links?.correctsLedgerId) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'correction records require links.correctsLedgerId',
-            path: ['links', 'correctsLedgerId'],
-        });
-    }
-});
-export const StripDecisionRevertedRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('strip-decision-reverted'),
+export const CorrectionRecordSchema = v.pipe(v.object({
+    ...recordEntryBaseEntries,
+    kind: v.literal('correction'),
+    rationale: v.pipe(v.string(), v.minLength(1)),
+}), v.check((value) => Boolean(value.links?.correctsLedgerId), 'correction records require links.correctsLedgerId'));
+export const StripDecisionRevertedRecordSchema = v.object({
+    ...recordEntryBaseEntries,
+    kind: v.literal('strip-decision-reverted'),
     payload: StripDecisionRevertedPayloadSchema,
 });
-export const DescopeBriefRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('descope-brief'),
-    payload: DescopeBriefPayloadSchema,
-});
-export const MergeReturnRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('merge-return'),
-    payload: MergeReturnPayloadSchema,
-});
-export const MergeReturnRejectedRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('merge-return-rejected'),
-    payload: MergeReturnRejectedPayloadSchema,
-});
-export const RevertRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('revert'),
-    payload: RevertPayloadSchema,
-});
-export const RollbackRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('rollback'),
-    payload: RollbackPayloadSchema,
-});
-export const ReworkTestRetiredRecordSchema = RecordEntryBaseSchema.extend({
-    kind: z.literal('rework.test_retired'),
-    payload: ReworkTestRetiredPayloadSchema,
-});
-export const LedgerRecordSchema = z.discriminatedUnion('kind', [
+export const LedgerRecordSchema = v.variant('kind', [
     ToolInvocationRecordSchema,
     AgentPatchRecordSchema,
     OperatorPatchRecordSchema,
-    StageTransitionRecordSchema,
     OperatorDecisionRecordSchema,
     ValidatorResultRecordSchema,
     RuntimeEventRecordSchema,
     NoteRecordSchema,
     CorrectionRecordSchema,
     StripDecisionRevertedRecordSchema,
-    DescopeBriefRecordSchema,
-    MergeReturnRecordSchema,
-    MergeReturnRejectedRecordSchema,
-    RevertRecordSchema,
-    RollbackRecordSchema,
-    ReworkTestRetiredRecordSchema,
 ]);
-const normalizePatchEntry = (entry) => ({
-    ...entry,
-    links: {
-        ...entry.links,
-        affectedFiles: mergeAffectedFiles(entry.links.affectedFiles, entry.payload.touchedPaths),
-    },
-});
-const normalizeLegacyAgentPatchEntry = (entry) => normalizePatchEntry({
-    ...entry,
-    _legacy: true,
-    payload: {
-        diffSha256: entry.diff.blobSha256,
-        fileSha256After: {},
-        fileSha256Before: {},
-        hunks: [],
-        touchedPaths: entry.links.affectedFiles ?? [],
-    },
-});
-const normalizeLegacyOperatorDecisionEntry = (entry) => ({
-    ...entry,
-    _legacy: true,
-    payload: {
-        action: mapLegacyDecisionTypeToAction(entry.decisionType),
-        checkId: typeof entry.links.stripDecisionId === 'string' ? entry.links.stripDecisionId : undefined,
-        rationale: typeof entry.body.rationale === 'string' && entry.body.rationale.trim().length > 0
-            ? entry.body.rationale
-            : entry.summary,
-    },
-});
-const normalizeLegacyValidatorResultEntry = (entry) => ({
-    ...entry,
-    _legacy: true,
-    payload: {
-        id: createDeterministicUuidV7({
-            seed: `${entry.id}:${entry.summary}:${entry.validator}:${entry.verdict}`,
-            timestamp: entry.ts,
-        }),
-    },
-});
-const normalizeCurrentEntry = (entry) => {
-    switch (entry.kind) {
-        case 'agent-patch':
-        case 'operator-patch':
-            return normalizePatchEntry(entry);
-        default:
-            return entry;
-    }
-};
-export const parseLedgerEntry = (input) => {
-    const current = LedgerEntrySchema.safeParse(input);
-    if (current.success) {
-        return normalizeCurrentEntry(current.data);
-    }
-    const legacyAgentPatch = LegacyAgentPatchEntrySchema.safeParse(input);
-    if (legacyAgentPatch.success) {
-        return normalizeLegacyAgentPatchEntry(legacyAgentPatch.data);
-    }
-    const legacyOperatorDecision = LegacyOperatorDecisionEntrySchema.safeParse(input);
-    if (legacyOperatorDecision.success) {
-        return normalizeLegacyOperatorDecisionEntry(legacyOperatorDecision.data);
-    }
-    const legacyValidatorResult = LegacyValidatorResultEntrySchema.safeParse(input);
-    if (legacyValidatorResult.success) {
-        return normalizeLegacyValidatorResultEntry(legacyValidatorResult.data);
-    }
-    return LedgerEntrySchema.parse(input);
-};
-export const parseLedgerRecord = (input) => LedgerRecordSchema.parse(input);
+export const parseLedgerEntry = (input) => v.parse(LedgerEntrySchema, input);
+export const parseLedgerRecord = (input) => v.parse(LedgerRecordSchema, input);