ushman-ledger 0.3.0 → 1.1.0

package/dist/read-index.d.ts

@@ -1,59 +1,47 @@
-import { z } from 'zod';
+import * as v from 'valibot';
 import { type LedgerEntry, type LedgerKind, type LedgerPhase } from './schema/entry.ts';
 import type { LedgerManifest } from './schema/manifest.ts';
-declare const ReadIndexEntrySchema: z.ZodObject<{
-    id: z.ZodString;
-    kind: z.ZodEnum<{
-        "tool-invocation": "tool-invocation";
-        "agent-patch": "agent-patch";
-        "operator-patch": "operator-patch";
-        "stage-transition": "stage-transition";
-        "operator-decision": "operator-decision";
-        "validator-result": "validator-result";
-        "runtime-event": "runtime-event";
-        note: "note";
-        correction: "correction";
-        "strip-decision-reverted": "strip-decision-reverted";
-        "descope-brief": "descope-brief";
-        "merge-return": "merge-return";
-        "merge-return-rejected": "merge-return-rejected";
-        revert: "revert";
-        rollback: "rollback";
-        "rework.test_retired": "rework.test_retired";
-    }>;
-    ts: z.ZodString;
-}, z.core.$strip>;
-declare const LedgerReadIndexSchema: z.ZodObject<{
-    coveredFiles: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    entries: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        kind: z.ZodEnum<{
-            "tool-invocation": "tool-invocation";
-            "agent-patch": "agent-patch";
-            "operator-patch": "operator-patch";
-            "stage-transition": "stage-transition";
-            "operator-decision": "operator-decision";
-            "validator-result": "validator-result";
-            "runtime-event": "runtime-event";
-            note: "note";
-            correction: "correction";
-            "strip-decision-reverted": "strip-decision-reverted";
-            "descope-brief": "descope-brief";
-            "merge-return": "merge-return";
-            "merge-return-rejected": "merge-return-rejected";
-            revert: "revert";
-            rollback: "rollback";
-            "rework.test_retired": "rework.test_retired";
-        }>;
-        ts: z.ZodString;
-    }, z.core.$strip>>>;
-    entryCount: z.ZodNumber;
-    lastEntryId: z.ZodNullable<z.ZodString>;
-    lastSequence: z.ZodNumber;
-    schemaVersion: z.ZodLiteral<"ushman-ledger-read-index/v1">;
-}, z.core.$strip>;
-export type LedgerReadIndex = z.infer<typeof LedgerReadIndexSchema>;
-export type ReadIndexEntry = z.infer<typeof ReadIndexEntrySchema>;
+declare const ReadIndexEntrySchema: v.ObjectSchema<{
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly kind: v.PicklistSchema<readonly ["tool-invocation", "agent-patch", "operator-patch", "operator-decision", "validator-result", "runtime-event", "note", "correction", "strip-decision-reverted"], undefined>;
+    readonly ts: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+}, undefined>;
+declare const LedgerReadIndexSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly coveredFiles: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, readonly []>;
+    readonly entries: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+        readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly kind: v.PicklistSchema<readonly ["tool-invocation", "agent-patch", "operator-patch", "operator-decision", "validator-result", "runtime-event", "note", "correction", "strip-decision-reverted"], undefined>;
+        readonly ts: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+    }, undefined>, undefined>, readonly []>;
+    readonly entryCount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly lastEntryId: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+    readonly lastSequence: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly schemaVersion: v.LiteralSchema<"ushman-ledger-read-index/v1", undefined>;
+}, undefined>, v.CheckAction<{
+    coveredFiles: string[];
+    entries: {
+        id: string;
+        kind: "tool-invocation" | "agent-patch" | "operator-patch" | "operator-decision" | "validator-result" | "runtime-event" | "note" | "correction" | "strip-decision-reverted";
+        ts: string;
+    }[];
+    entryCount: number;
+    lastEntryId: string | null;
+    lastSequence: number;
+    schemaVersion: "ushman-ledger-read-index/v1";
+}, "entryCount must match entries.length">, v.CheckAction<{
+    coveredFiles: string[];
+    entries: {
+        id: string;
+        kind: "tool-invocation" | "agent-patch" | "operator-patch" | "operator-decision" | "validator-result" | "runtime-event" | "note" | "correction" | "strip-decision-reverted";
+        ts: string;
+    }[];
+    entryCount: number;
+    lastEntryId: string | null;
+    lastSequence: number;
+    schemaVersion: "ushman-ledger-read-index/v1";
+}, "lastEntryId must match the final indexed entry">]>;
+export type LedgerReadIndex = v.InferOutput<typeof LedgerReadIndexSchema>;
+export type ReadIndexEntry = v.InferOutput<typeof ReadIndexEntrySchema>;
 export type ManifestEntryLocation = readonly [string, {
     phase: LedgerPhase;
     sequence: number;
@@ -62,7 +50,7 @@ export declare const buildReadIndexFromManifest: (workspaceRoot: string, manifes
     coveredFiles: string[];
     entries: {
         id: string;
-        kind: "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";
+        kind: "tool-invocation" | "agent-patch" | "operator-patch" | "operator-decision" | "validator-result" | "runtime-event" | "note" | "correction" | "strip-decision-reverted";
         ts: string;
     }[];
     entryCount: number;
@@ -77,7 +65,7 @@ export declare const ensureReadIndexUnderLock: (workspaceRoot: string, manifest:
     coveredFiles: string[];
     entries: {
         id: string;
-        kind: "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";
+        kind: "tool-invocation" | "agent-patch" | "operator-patch" | "operator-decision" | "validator-result" | "runtime-event" | "note" | "correction" | "strip-decision-reverted";
         ts: string;
     }[];
     entryCount: number;
@@ -93,7 +81,7 @@ export declare const appendEntryToReadIndex: ({ entry, readIndex, sequence, }: {
     coveredFiles: string[];
     entries: {
         id: string;
-        kind: "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";
+        kind: "tool-invocation" | "agent-patch" | "operator-patch" | "operator-decision" | "validator-result" | "runtime-event" | "note" | "correction" | "strip-decision-reverted";
         ts: string;
     }[];
     entryCount: number;

package/dist/read-index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"read-index.d.ts","sourceRoot":"","sources":["../src/read-index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAgB,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAoB,MAAM,mBAAmB,CAAC;AACxH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAO3D,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;iBAIxB,CAAC;AAEH,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyBrB,CAAC;AAEP,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,qBAAqB,GAAG,SAAS,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AA0HhG,eAAO,MAAM,0BAA0B,GAAU,eAAe,MAAM,EAAE,UAAU,cAAc;;;;;;;;;;;EAuB/F,CAAC;AAYF,eAAO,MAAM,kBAAkB,GAAI,OAAO,eAAe,EAAE,UAAU,cAAc,YAG1C,CAAC;AAE1C,eAAO,MAAM,aAAa,GAAU,eAAe,MAAM,KAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAWzF,CAAC;AAEF,eAAO,MAAM,aAAa,GAAU,eAAe,MAAM,EAAE,WAAW,eAAe,kBAGpF,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAU,eAAe,MAAM,EAAE,UAAU,cAAc;;;;;;;;;;;EAiB7F,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,iCAIpC;IACC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC7B;;;;;;;;;;;CAYA,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,uCAIpC;IACC,QAAQ,CAAC,MAAM,EAAE;QACb,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC;QAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;QAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;KAC3B,CAAC;IACF,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;CAC3C,YAeA,CAAC"}
+{"version":3,"file":"read-index.d.ts","sourceRoot":"","sources":["../src/read-index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAG7B,OAAO,EAAgB,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAoB,MAAM,mBAAmB,CAAC;AACxH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAO3D,QAAA,MAAM,oBAAoB;;;;aAIxB,CAAC;AAEH,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sDAiB1B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAC1E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACxE,MAAM,MAAM,qBAAqB,GAAG,SAAS,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AA0HhG,eAAO,MAAM,0BAA0B,GAAU,eAAe,MAAM,EAAE,UAAU,cAAc;;;;;;;;;;;EAuB/F,CAAC;AAYF,eAAO,MAAM,kBAAkB,GAAI,OAAO,eAAe,EAAE,UAAU,cAAc,YAG1C,CAAC;AAE1C,eAAO,MAAM,aAAa,GAAU,eAAe,MAAM,KAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAWzF,CAAC;AAEF,eAAO,MAAM,aAAa,GAAU,eAAe,MAAM,EAAE,WAAW,eAAe,kBAGpF,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAU,eAAe,MAAM,EAAE,UAAU,cAAc;;;;;;;;;;;EAiB7F,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,iCAIpC;IACC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC7B;;;;;;;;;;;CAYA,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,uCAIpC;IACC,QAAQ,CAAC,MAAM,EAAE;QACb,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC;QAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;QAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;KAC3B,CAAC;IACF,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;CAC3C,YAeA,CAAC"}

package/dist/read-index.js

@@ -1,5 +1,5 @@
 import { readFile } from 'node:fs/promises';
-import { z } from 'zod';
+import * as v from 'valibot';
 import { mapWithConcurrencyLimit } from "./async.js";
 import { stableStringify } from "./json.js";
 import { LEDGER_KINDS, parseLedgerEntry } from "./schema/entry.js";
@@ -7,40 +7,22 @@ import { readPhaseEntryText, resolveLedgerPaths, writeAtomicTextFile } from "./s
 const READ_INDEX_SCHEMA_VERSION = 'ushman-ledger-read-index/v1';
 const ENTRY_READ_BATCH_SIZE = 32;
 const ENTRY_READ_CONCURRENCY = 16;
-const ReadIndexEntrySchema = z.object({
-    id: z.string().min(1),
-    kind: z.enum(LEDGER_KINDS),
-    ts: z.string().datetime({ offset: true }),
-});
-const LedgerReadIndexSchema = z
-    .object({
-    coveredFiles: z.array(z.string()).default([]),
-    entries: z.array(ReadIndexEntrySchema).default([]),
-    entryCount: z.number().int().nonnegative(),
-    lastEntryId: z.string().min(1).nullable(),
-    lastSequence: z.number().int().nonnegative(),
-    schemaVersion: z.literal(READ_INDEX_SCHEMA_VERSION),
-})
-    .superRefine((value, ctx) => {
-    if (value.entryCount !== value.entries.length) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'entryCount must match entries.length',
-            path: ['entryCount'],
-        });
-    }
-    const expectedLastEntryId = value.entries.at(-1)?.id ?? null;
-    if (value.lastEntryId !== expectedLastEntryId) {
-        ctx.addIssue({
-            code: 'custom',
-            message: 'lastEntryId must match the final indexed entry',
-            path: ['lastEntryId'],
-        });
-    }
+const ReadIndexEntrySchema = v.object({
+    id: v.pipe(v.string(), v.minLength(1)),
+    kind: v.picklist(LEDGER_KINDS),
+    ts: v.pipe(v.string(), v.isoTimestamp()),
 });
+const LedgerReadIndexSchema = v.pipe(v.object({
+    coveredFiles: v.optional(v.array(v.string()), []),
+    entries: v.optional(v.array(ReadIndexEntrySchema), []),
+    entryCount: v.pipe(v.number(), v.integer(), v.minValue(0)),
+    lastEntryId: v.nullable(v.pipe(v.string(), v.minLength(1))),
+    lastSequence: v.pipe(v.number(), v.integer(), v.minValue(0)),
+    schemaVersion: v.literal(READ_INDEX_SCHEMA_VERSION),
+}), v.check((value) => value.entryCount === value.entries.length, 'entryCount must match entries.length'), v.check((value) => value.lastEntryId === (value.entries.at(-1)?.id ?? null), 'lastEntryId must match the final indexed entry'));
 const parseReadIndexText = (filePath, text) => {
     try {
-        return LedgerReadIndexSchema.parse(JSON.parse(text));
+        return v.parse(LedgerReadIndexSchema, JSON.parse(text));
     }
     catch (error) {
         throw new Error(`Invalid ledger read index at ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
@@ -89,7 +71,7 @@ const mergeSortedUniquePaths = (existingPaths, additionalPaths) => {
     }
     return mergedPaths;
 };
-const buildReadIndex = ({ coveredFiles, entries, lastSequence, }) => LedgerReadIndexSchema.parse({
+const buildReadIndex = ({ coveredFiles, entries, lastSequence, }) => v.parse(LedgerReadIndexSchema, {
     coveredFiles,
     entries,
     entryCount: entries.length,
@@ -162,7 +144,7 @@ export const readReadIndex = async (workspaceRoot) => {
 };
 export const saveReadIndex = async (workspaceRoot, readIndex) => {
     const filePath = resolveLedgerPaths(workspaceRoot).readIndexFile;
-    await writeAtomicTextFile(filePath, `${stableStringify(LedgerReadIndexSchema.parse(readIndex), true)}\n`);
+    await writeAtomicTextFile(filePath, `${stableStringify(v.parse(LedgerReadIndexSchema, readIndex), true)}\n`);
 };
 export const ensureReadIndexUnderLock = async (workspaceRoot, manifest) => {
     let currentReadIndex = null;

package/dist/record.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../src/record.ts"],"names":[],"mappings":"AAQA,OAAO,EAEH,KAAK,WAAW,EAQnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAW3D,KAAK,qBAAqB,GAAG;IACzB,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,WAAW,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9E,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,WAAW,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAChF,QAAQ,CAAC,uBAAuB,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,WAAW,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,WAAW,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACpF,CAAC;AAuBF,eAAO,MAAM,wBAAwB,GAAI,eAAe,MAAM,EAAE,OAAO,qBAAqB,GAAG,IAAI,SAOlG,CAAC;AAgNF,eAAO,MAAM,YAAY,GACrB,eAAe,MAAM,EACrB,OAAO,OAAO,KACf,OAAO,CAAC;IAAE,KAAK,EAAE,WAAW,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAqF5C,CAAC;AAEF,eAAO,MAAM,aAAa,GACtB,eAAe,MAAM,EACrB,UAAU,cAAc,EACxB,SAAS,MAAM,KAChB,OAAO,CAAC,WAAW,CAUrB,CAAC"}
+{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../src/record.ts"],"names":[],"mappings":"AAQA,OAAO,EAEH,KAAK,WAAW,EAKnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAU3D,KAAK,qBAAqB,GAAG;IACzB,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,WAAW,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9E,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,WAAW,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAChF,QAAQ,CAAC,uBAAuB,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,WAAW,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,WAAW,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACpF,CAAC;AAUF,eAAO,MAAM,wBAAwB,GAAI,eAAe,MAAM,EAAE,OAAO,qBAAqB,GAAG,IAAI,SAOlG,CAAC;AAoHF,eAAO,MAAM,YAAY,GACrB,eAAe,MAAM,EACrB,OAAO,OAAO,KACf,OAAO,CAAC;IAAE,KAAK,EAAE,WAAW,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAqF5C,CAAC;AAEF,eAAO,MAAM,aAAa,GACtB,eAAe,MAAM,EACrB,UAAU,cAAc,EACxB,SAAS,MAAM,KAChB,OAAO,CAAC,WAAW,CAMrB,CAAC"}

package/dist/record.js

@@ -1,29 +1,17 @@
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
+import * as v from 'valibot';
 import { resolveBlobPath, storePatchBlob } from "./blobs.js";
 import { sha256Hex, stableStringify } from "./json.js";
 import { updateManifestForEntry } from "./manifest-update.js";
-import { derivePatchPayloadFromDiffText } from "./patch-metadata.js";
 import { appendEntryToReadIndex, saveReadIndex } from "./read-index.js";
 import { reconcileLedgerStateUnderLock, removePendingCommit, writePendingCommit } from "./recovery.js";
-import { LedgerEntrySchema, OperatorDecisionPayloadSchema, PatchPayloadWriteSchema, parseLedgerEntry, parseLedgerRecord, ValidatorResultPayloadSchema, } from "./schema/entry.js";
+import { LedgerEntrySchema, parseLedgerEntry, parseLedgerRecord, } from "./schema/entry.js";
 import { ensureLedgerDirectories, readManifest, resolveLedgerPaths, saveManifest, writeEntryFile, } from "./storage/filesystem.js";
 import { acquireLock } from "./storage/lock.js";
-import { createDeterministicUuidV7 } from "./uuid.js";
 const appendRecordTestHooks = new Map();
 const resolveWorkspaceKey = (workspaceRoot) => path.resolve(workspaceRoot);
 const getAppendRecordTestHooks = (workspaceRoot) => appendRecordTestHooks.get(resolveWorkspaceKey(workspaceRoot));
-const warnedDeprecations = new Set();
-const warnOnce = (key, message) => {
-    if (warnedDeprecations.has(key)) {
-        return;
-    }
-    warnedDeprecations.add(key);
-    process.emitWarning(message, {
-        code: key,
-        type: 'DeprecationWarning',
-    });
-};
 export const setAppendRecordTestHooks = (workspaceRoot, hooks) => {
     const key = resolveWorkspaceKey(workspaceRoot);
     if (!hooks) {
@@ -64,118 +52,47 @@ const buildEntryId = (entryWithoutId, sequence) => {
     const bodyHash = sha256Hex(stableStringify(entryWithoutId));
     return `${toEntryIdTimestamp(entryWithoutId.ts)}-${sequence.toString().padStart(8, '0')}-${bodyHash.slice(0, 12)}`;
 };
-const normalizeValidatorResultRecord = (record) => {
-    if (record.kind !== 'validator-result') {
-        return record;
-    }
-    const payloadId = record.payload?.id;
-    if (payloadId) {
-        return {
-            ...record,
-            payload: ValidatorResultPayloadSchema.parse(record.payload),
-        };
-    }
-    warnOnce('USHMAN_LEDGER_VALIDATOR_ID_COMPAT', 'validator-result records should provide payload.id. A compatibility UUIDv7 was synthesized for this append.');
-    return {
-        ...record,
-        payload: {
-            id: createDeterministicUuidV7({
-                seed: stableStringify(record),
-                timestamp: 0,
-            }),
-        },
-    };
-};
-const resolvePatchTextAndBlob = async ({ record, workspaceRoot, }) => {
+const loadPatchText = async ({ record, workspaceRoot, }) => {
     if (record.diffPath) {
-        const patchText = await readFile(path.resolve(record.diffPath), 'utf8');
-        return {
-            patchText,
-            storedDiff: await storePatchBlob(workspaceRoot, patchText),
-        };
+        return readFile(path.resolve(record.diffPath), 'utf8');
     }
-    if (record.payload?.diff) {
-        const storedDiff = await storePatchBlob(workspaceRoot, record.payload.diff);
-        if (record.diff && record.diff.blobSha256 !== storedDiff.blobSha256) {
-            throw new Error(`Provided diff blob ${record.diff.blobSha256} does not match payload.diff hash ${storedDiff.blobSha256}.`);
-        }
-        return {
-            patchText: record.payload.diff,
-            storedDiff,
-        };
+    if (record.diffText) {
+        return record.diffText;
     }
-    if (!record.diff) {
-        throw new Error(`${record.kind} records require payload.diff, diffPath, or diff metadata.`);
-    }
-    try {
-        const patchText = await readBlobText(workspaceRoot, record.diff);
-        return {
-            patchText,
-            storedDiff: record.diff,
-        };
-    }
-    catch (error) {
-        if (error.code === 'ENOENT') {
-            throw new Error(`Patch blob ${record.diff.blobSha256} was not found. Store it first or use diffPath.`);
+    if (record.diff) {
+        try {
+            return await readBlobText(workspaceRoot, record.diff);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                throw new Error(`Patch blob ${record.diff.blobSha256} was not found. Store it first or use diffPath.`);
+            }
+            throw error;
         }
-        throw error;
     }
-};
-const resolvePatchPayload = async ({ patchText, record, workspaceRoot, }) => {
-    const derivedPayload = await derivePatchPayloadFromDiffText({
-        patchText,
-        workspaceRoot,
-    });
-    const mergedPayload = PatchPayloadWriteSchema.parse({
-        ...derivedPayload,
-        ...record.payload,
-        diff: record.payload?.diff ?? patchText,
-        diffSha256: record.payload?.diffSha256 ?? derivedPayload.diffSha256,
-        fileSha256After: record.payload?.fileSha256After ?? derivedPayload.fileSha256After,
-        fileSha256Before: record.payload?.fileSha256Before ?? derivedPayload.fileSha256Before,
-        hunks: record.payload?.hunks ?? derivedPayload.hunks,
-        touchedPaths: record.payload?.touchedPaths ?? derivedPayload.touchedPaths,
-    });
-    return mergedPayload;
+    throw new Error(`${record.kind} records require diff, diffPath, or diffText.`);
 };
 const resolvePatchRecord = async ({ record, workspaceRoot, }) => {
-    const { patchText, storedDiff } = await resolvePatchTextAndBlob({
-        record,
-        workspaceRoot,
-    });
-    const payload = await resolvePatchPayload({
-        patchText,
-        record,
-        workspaceRoot,
-    });
-    if (payload.diffSha256 !== storedDiff.blobSha256) {
-        throw new Error(`Patch payload hash ${payload.diffSha256} does not match stored blob hash ${storedDiff.blobSha256}.`);
+    const patchText = await loadPatchText({ record, workspaceRoot });
+    const storedDiff = await storePatchBlob(workspaceRoot, patchText);
+    if (record.diff && record.diff.blobSha256 !== storedDiff.blobSha256) {
+        throw new Error(`Provided diff blob ${record.diff.blobSha256} does not match patch text hash ${storedDiff.blobSha256}.`);
     }
+    const { diffPath: _diffPath, diffText: _diffText, ...rest } = record;
     return {
-        ...record,
+        ...rest,
         diff: storedDiff,
         links: {
             ...record.links,
-            affectedFiles: [...new Set([...(record.links?.affectedFiles ?? []), ...payload.touchedPaths])],
             blobs: [...new Set([...(record.links?.blobs ?? []), storedDiff.blobSha256])],
         },
-        payload,
     };
 };
 const normalizeRecord = async ({ record, workspaceRoot, }) => {
-    const normalizedRecord = normalizeValidatorResultRecord(record);
-    if (normalizedRecord.kind === 'agent-patch' || normalizedRecord.kind === 'operator-patch') {
-        return resolvePatchRecord({
-            record: normalizedRecord,
-            workspaceRoot,
-        });
+    if (record.kind === 'agent-patch' || record.kind === 'operator-patch') {
+        return resolvePatchRecord({ record, workspaceRoot });
     }
-    return normalizedRecord.kind === 'operator-decision'
-        ? {
-            ...normalizedRecord,
-            payload: OperatorDecisionPayloadSchema.parse(normalizedRecord.payload),
-        }
-        : normalizedRecord;
+    return record;
 };
 export const appendRecord = async (workspaceRoot, input) => {
     const parsed = parseLedgerRecord(input);
@@ -222,7 +139,7 @@ export const appendRecord = async (workspaceRoot, input) => {
             schemaVersion: 'ushman-ledger-entry/v1',
             ts: new Date().toISOString(),
         };
-        const entry = LedgerEntrySchema.parse({
+        const entry = v.parse(LedgerEntrySchema, {
             ...entryWithoutId,
             id: buildEntryId(entryWithoutId, nextSequence),
         });
@@ -259,10 +176,6 @@ export const appendRecord = async (workspaceRoot, input) => {
     }
 };
 export const readEntryById = async (workspaceRoot, manifest, entryId) => {
-    const location = manifest.entryLocations[entryId];
-    if (!location) {
-        throw new Error(`Ledger entry not found: ${entryId}`);
-    }
-    const text = await readFile(path.join(resolveLedgerPaths(workspaceRoot).phaseDir(location.phase), `${entryId}.json`), 'utf8');
+    const text = await readFile(path.join(resolveLedgerPaths(workspaceRoot).phaseDir(manifest.entryLocations[entryId].phase), `${entryId}.json`), 'utf8');
     return parseLedgerEntry(JSON.parse(text));
 };

package/dist/recovery.d.ts

@@ -13,7 +13,6 @@ export declare const writePendingCommit: ({ entry, logicalHash, manifest, worksp
 }) => Promise<string>;
 export declare const removePendingCommit: (filePath: string) => Promise<void>;
 export declare const reconcilePendingCommitsUnderLock: (workspaceRoot: string) => Promise<{
-    [x: string]: unknown;
     archives: {
         createdAt: string;
         integrityHash: string;
@@ -21,17 +20,29 @@ export declare const reconcilePendingCommitsUnderLock: (workspaceRoot: string) =
     }[];
     createdAt: string;
     entryCount: number;
-    entryLocations: Record<string, {
-        phase: "seed" | "capture" | "intake" | "vendor-extract" | "cleanup" | "parity" | "characterize" | "equiv" | "analyze" | "recover" | "ship" | "migration";
-        sequence: number;
-    }>;
-    idempotencyIndex: Record<string, Record<string, string>>;
+    entryLocations: {
+        [x: string]: {
+            phase: "capture" | "intake" | "seed" | "vendor-extract" | "cleanup" | "parity" | "characterize" | "equiv" | "analyze" | "recover" | "ship" | "migration";
+            sequence: number;
+        };
+    };
+    idempotencyIndex: {
+        [x: string]: {
+            [x: string]: string;
+        };
+    };
     lastSequence: number;
-    perPhaseCounts: Record<string, number>;
-    perPhaseLatest: Record<string, string>;
+    perPhaseCounts: {
+        [x: string]: number;
+    };
+    perPhaseLatest: {
+        [x: string]: string;
+    };
     schemaVersion: "ushman-ledger-manifest/v1";
     updatedAt: string;
     workspaceId: string;
+} & {
+    [key: string]: unknown;
 }>;
 export declare const reconcileLedgerStateUnderLock: (workspaceRoot: string) => Promise<PreparedLedgerState>;
 export declare const loadLedgerState: (workspaceRoot: string) => Promise<PreparedLedgerState>;

package/dist/recovery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recovery.d.ts","sourceRoot":"","sources":["../src/recovery.ts"],"names":[],"mappings":"AAKA,OAAO,EAA4B,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACjF,OAAO,EAAE,KAAK,WAAW,EAAqB,MAAM,mBAAmB,CAAC;AACxE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AA0B3D,MAAM,MAAM,mBAAmB,GAAG;IAC9B,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;CACvC,CAAC;AA0JF,eAAO,MAAM,kBAAkB,GAAU,kDAKtC;IACC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC,oBAeA,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAU,UAAU,MAAM,kBAEzD,CAAC;AAEF,eAAO,MAAM,gCAAgC,GAAU,eAAe,MAAM;;;;;;;;;;;;;;;;;;;;EAyB3E,CAAC;AAEF,eAAO,MAAM,6BAA6B,GAAU,eAAe,MAAM,KAAG,OAAO,CAAC,mBAAmB,CAQtG,CAAC;AAEF,eAAO,MAAM,eAAe,GAAU,eAAe,MAAM,KAAG,OAAO,CAAC,mBAAmB,CAQxF,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,eAAe,MAAM,kBAE7D,CAAC"}
+{"version":3,"file":"recovery.d.ts","sourceRoot":"","sources":["../src/recovery.ts"],"names":[],"mappings":"AAKA,OAAO,EAA4B,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACjF,OAAO,EAAE,KAAK,WAAW,EAAqB,MAAM,mBAAmB,CAAC;AACxE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AA0B3D,MAAM,MAAM,mBAAmB,GAAG;IAC9B,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;CACvC,CAAC;AA0JF,eAAO,MAAM,kBAAkB,GAAU,kDAKtC;IACC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC,oBAeA,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAU,UAAU,MAAM,kBAEzD,CAAC;AAEF,eAAO,MAAM,gCAAgC,GAAU,eAAe,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyB3E,CAAC;AAEF,eAAO,MAAM,6BAA6B,GAAU,eAAe,MAAM,KAAG,OAAO,CAAC,mBAAmB,CAQtG,CAAC;AAEF,eAAO,MAAM,eAAe,GAAU,eAAe,MAAM,KAAG,OAAO,CAAC,mBAAmB,CAQxF,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,eAAe,MAAM,kBAE7D,CAAC"}

package/dist/recovery.js

@@ -1,6 +1,6 @@
 import { readdir, readFile, rm, stat } from 'node:fs/promises';
 import path from 'node:path';
-import { z } from 'zod';
+import * as v from 'valibot';
 import { reconcilePendingArchivesUnderLock } from "./archive-journal.js";
 import { getNextManifestSequence, updateManifestForEntry } from "./manifest-update.js";
 import { ensureReadIndexUnderLock } from "./read-index.js";
@@ -10,18 +10,18 @@ import { acquireLock } from "./storage/lock.js";
 const PendingCommitSchemaVersion = 'ushman-ledger-pending-commit/v1';
 // Pending commits capture the intended sequence and logical hash before the
 // entry file and manifest update diverge, so recovery can replay safely.
-const PendingCommitSchema = z.object({
-    baseLastSequence: z.number().int().nonnegative(),
-    createdAt: z.string().datetime({ offset: true }),
+const PendingCommitSchema = v.object({
+    baseLastSequence: v.pipe(v.number(), v.integer(), v.minValue(0)),
+    createdAt: v.pipe(v.string(), v.isoTimestamp()),
     entry: LedgerEntrySchema,
-    logicalHash: z.string().min(1),
-    schemaVersion: z.literal(PendingCommitSchemaVersion),
-    sequence: z.number().int().positive(),
+    logicalHash: v.pipe(v.string(), v.minLength(1)),
+    schemaVersion: v.literal(PendingCommitSchemaVersion),
+    sequence: v.pipe(v.number(), v.integer(), v.minValue(1)),
 });
 const formatSequence = (sequence) => sequence.toString().padStart(8, '0');
-const PendingCommitFileNameSchema = z.object({
-    entryId: z.string().min(1),
-    sequence: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+const PendingCommitFileNameSchema = v.object({
+    entryId: v.pipe(v.string(), v.minLength(1)),
+    sequence: v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(Number.MAX_SAFE_INTEGER)),
 });
 const buildPendingCommitFilePath = (workspaceRoot, sequence, entryId) => path.join(resolveLedgerPaths(workspaceRoot).pendingCommitsDir, `${formatSequence(sequence)}-${entryId}.json`);
 const parsePendingCommitFileName = (name) => {
@@ -29,7 +29,7 @@ const parsePendingCommitFileName = (name) => {
     if (!match) {
         return null;
     }
-    return PendingCommitFileNameSchema.parse({
+    return v.parse(PendingCommitFileNameSchema, {
         entryId: match[2],
         sequence: Number.parseInt(match[1], 10),
     });
@@ -37,7 +37,7 @@ const parsePendingCommitFileName = (name) => {
 const readPendingCommit = async (filePath) => {
     try {
         const text = await readFile(filePath, 'utf8');
-        return PendingCommitSchema.parse(JSON.parse(text));
+        return v.parse(PendingCommitSchema, JSON.parse(text));
     }
     catch (error) {
         throw new Error(`Invalid pending commit at ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
@@ -128,7 +128,7 @@ const applyPendingCommit = async ({ manifest, pending, workspaceRoot, }) => {
 export const writePendingCommit = async ({ entry, logicalHash, manifest, workspaceRoot, }) => {
     const nextSequence = getNextManifestSequence(manifest.lastSequence);
     const filePath = buildPendingCommitFilePath(workspaceRoot, nextSequence, entry.id);
-    await writeAtomicJsonFile(filePath, PendingCommitSchema.parse({
+    await writeAtomicJsonFile(filePath, v.parse(PendingCommitSchema, {
         baseLastSequence: manifest.lastSequence,
         createdAt: new Date().toISOString(),
         entry,

package/dist/render/retro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"retro.d.ts","sourceRoot":"","sources":["../../src/render/retro.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAgHtD,eAAO,MAAM,mBAAmB,GAAU,wBAGvC;IACC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;IAC7C,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC9B,KAAG,OAAO,CAAC,MAAM,CA6CjB,CAAC"}
+{"version":3,"file":"retro.d.ts","sourceRoot":"","sources":["../../src/render/retro.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AA6GtD,eAAO,MAAM,mBAAmB,GAAU,wBAGvC;IACC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;IAC7C,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC9B,KAAG,OAAO,CAAC,MAAM,CA6CjB,CAAC"}

package/dist/render/retro.js

@@ -13,10 +13,7 @@ const createRetroBuckets = () => ({
 });
 const isProblemEntry = (entry) => (entry.kind === 'note' && entry.subkind === 'regression') ||
     (entry.kind === 'runtime-event' && entry.level === 'error');
-const isToolEntry = (entry) => entry.kind === 'tool-invocation' ||
-    entry.kind === 'agent-patch' ||
-    entry.kind === 'operator-patch' ||
-    entry.kind === 'stage-transition';
+const isToolEntry = (entry) => entry.kind === 'tool-invocation' || entry.kind === 'agent-patch' || entry.kind === 'operator-patch';
 const isToolingEntry = (entry) => (entry.kind === 'note' && entry.subkind === 'automation') ||
     (entry.kind === 'note' && entry.subkind === 'tooling-gap');
 const isRetroNote = (entry) => entry.kind === 'note' && entry.subkind === 'retro';