ushman-ledger 1.2.1 → 1.3.0

package/dist/index.d.ts

@@ -1,11 +1,13 @@
-export { type BuildRecordInput, buildChangeLogRecord, buildCorrectionRecord, buildOperatorDecisionRecord, buildStripDecisionRevertedRecord, buildValidatorResultRecord, } from './builders.ts';
+export { type BuildRecordInput, buildChangeLogRecord, buildCorrectionRecord, buildOperatorDecisionRecord, buildStageWriteRecord, buildStripDecisionRevertedRecord, buildValidatorResultRecord, } from './builders.ts';
 export { runLedgerCli } from './cli.ts';
 export { type CoverageReport, computeCoverage } from './coverage.ts';
+export { DOCTOR_FINDING_CODES, type DoctorFinding, type DoctorFindingCode, type DoctorFindingMetadataValue, type DoctorReport, runLedgerDoctor, } from './doctor.ts';
 export { type LedgerHandle, type LedgerRenderOptions, type LedgerRenderToOptions, openLedger, type RenderTarget, type RenderWriter, } from './handle.ts';
 export type { LedgerFilter } from './list.ts';
 export { appendCleanupWaveNote, appendDecompositionWaveNote, appendNote, appendOpenIssueNote, appendSemanticCleanupSummaryNote, appendVerifiedFlowNote, type NoteBody, } from './note.ts';
 export { deriveFilesChangedFromPatch } from './patch-resolver.ts';
-export { type AgentPatchDiff, AgentPatchDiffSchema, AgentPatchEntrySchema, AgentPatchRecordSchema, type ChangeLogEntry, ChangeLogEntrySchema, type ChangeLogFileChange, ChangeLogFileChangeSchema, type ChangeLogParityStatus, ChangeLogParityStatusSchema, type ChangeLogRecord, ChangeLogRecordSchema, type ChangeLogSmokeResult, ChangeLogSmokeResultSchema, type ChangeLogSubkind, ChangeLogSubkindSchema, CorrectionEntrySchema, CorrectionRecordSchema, EmitterSchema, type LedgerEntry, LedgerEntrySchema, type LedgerKind, type LedgerLinks, LedgerLinksSchema, type LedgerPhase, LedgerPhaseSchema, type LedgerRecord, LedgerRecordSchema, type NoteEntry, NoteEntrySchema, type OperatorDecisionAction, OperatorDecisionActionSchema, OperatorDecisionEntrySchema, type OperatorDecisionPayload, OperatorDecisionPayloadSchema, OperatorDecisionRecordSchema, OperatorPatchEntrySchema, OperatorPatchRecordSchema, parseLedgerEntry, parseLedgerRecord, RuntimeEventEntrySchema, StripDecisionRevertedEntrySchema, type StripDecisionRevertedPayload, StripDecisionRevertedPayloadSchema, StripDecisionRevertedRecordSchema, ToolInvocationEntrySchema, ToolInvocationRecordSchema, ValidatorResultEntrySchema, ValidatorResultRecordSchema, } from './schema/entry.ts';
+export { getLedgerRuntimeConfig, type LedgerRuntimeConfig, validateLedgerRuntimeConfig } from './runtime-config.ts';
+export { type AgentPatchDiff, AgentPatchDiffSchema, AgentPatchEntrySchema, AgentPatchRecordSchema, type ChangeLogEntry, ChangeLogEntrySchema, type ChangeLogFileChange, ChangeLogFileChangeSchema, type ChangeLogParityStatus, ChangeLogParityStatusSchema, type ChangeLogRecord, ChangeLogRecordSchema, type ChangeLogSmokeResult, ChangeLogSmokeResultSchema, type ChangeLogSubkind, ChangeLogSubkindSchema, CorrectionEntrySchema, CorrectionRecordSchema, EmitterSchema, type LedgerEntry, LedgerEntrySchema, type LedgerKind, type LedgerLinks, LedgerLinksSchema, type LedgerPhase, LedgerPhaseSchema, type LedgerRecord, LedgerRecordSchema, type NoteEntry, NoteEntrySchema, type OperatorDecisionAction, OperatorDecisionActionSchema, OperatorDecisionEntrySchema, type OperatorDecisionPayload, OperatorDecisionPayloadSchema, OperatorDecisionRecordSchema, OperatorPatchEntrySchema, OperatorPatchRecordSchema, parseLedgerEntry, parseLedgerRecord, RuntimeEventEntrySchema, STAGE_WRITE_STAGES, type StageWriteStage, StageWriteEntrySchema, StageWriteRecordSchema, StripDecisionRevertedEntrySchema, type StripDecisionRevertedPayload, StripDecisionRevertedPayloadSchema, StripDecisionRevertedRecordSchema, ToolInvocationEntrySchema, ToolInvocationRecordSchema, ValidatorResultEntrySchema, ValidatorResultRecordSchema, } from './schema/entry.ts';
 export { type NoteSubkind, NoteSubkindSchema } from './schema/note.ts';
 export { resolveLedgerPaths } from './storage/filesystem.ts';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,gBAAgB,EACrB,oBAAoB,EACpB,qBAAqB,EACrB,2BAA2B,EAC3B,gCAAgC,EAChC,0BAA0B,GAC7B,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,KAAK,cAAc,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EACH,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,UAAU,EACV,KAAK,YAAY,EACjB,KAAK,YAAY,GACpB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EACH,qBAAqB,EACrB,2BAA2B,EAC3B,UAAU,EACV,mBAAmB,EACnB,gCAAgC,EAChC,sBAAsB,EACtB,KAAK,QAAQ,GAChB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,EACH,KAAK,cAAc,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,sBAAsB,EACtB,KAAK,cAAc,EACnB,oBAAoB,EACpB,KAAK,mBAAmB,EACxB,yBAAyB,EACzB,KAAK,qBAAqB,EAC1B,2BAA2B,EAC3B,KAAK,eAAe,EACpB,qBAAqB,EACrB,KAAK,oBAAoB,EACzB,0BAA0B,EAC1B,KAAK,gBAAgB,EACrB,sBAAsB,EACtB,qBAAqB,EACrB,sBAAsB,EACtB,aAAa,EACb,KAAK,WAAW,EAChB,iBAAiB,EACjB,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,iBAAiB,EACjB,KAAK,WAAW,EAChB,iBAAiB,EACjB,KAAK,YAAY,EACjB,kBAAkB,EAClB,KAAK,SAAS,EACd,eAAe,EACf,KAAK,sBAAsB,EAC3B,4BAA4B,EAC5B,2BAA2B,EAC3B,KAAK,uBAAuB,EAC5B,6BAA6B,EAC7B,4BAA4B,EAC5B,wBAAwB,EACxB,yBAAyB,EACzB,gBAAgB,EAChB,iBAAiB,EACjB,uBAAuB,EACvB,gCAAgC,EAChC,KAAK,4BAA4B,EACjC,kCAAkC,EAClC,iCAAiC,EACjC,yBAAyB,EACzB,0BAA0B,EAC1B,0BAA0B,EAC1B,2BAA2B,GAC9B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,WAAW,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,gBAAgB,EACrB,oBAAoB,EACpB,qBAAqB,EACrB,2BAA2B,EAC3B,qBAAqB,EACrB,gCAAgC,EAChC,0BAA0B,GAC7B,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,KAAK,cAAc,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EACH,oBAAoB,EACpB,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,0BAA0B,EAC/B,KAAK,YAAY,EACjB,eAAe,GAClB,MAAM,aAAa,CAAC;AACrB,OAAO,EACH,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,UAAU,EACV,KAAK,YAAY,EACjB,KAAK,YAAY,GACpB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EACH,qBAAqB,EACrB,2BAA2B,EAC3B,UAAU,EACV,mBAAmB,EACnB,gCAAgC,EAChC,sBAAsB,EACtB,KAAK,QAAQ,GAChB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,EAAE,sBAAsB,EAAE,KAAK,mBAAmB,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AACpH,OAAO,EACH,KAAK,cAAc,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,sBAAsB,EACtB,KAAK,cAAc,EACnB,oBAAoB,EACpB,KAAK,mBAAmB,EACxB,yBAAyB,EACzB,KAAK,qBAAqB,EAC1B,2BAA2B,EAC3B,KAAK,eAAe,EACpB,qBAAqB,EACrB,KAAK,oBAAoB,EACzB,0BAA0B,EAC1B,KAAK,gBAAgB,EACrB,sBAAsB,EACtB,qBAAqB,EACrB,sBAAsB,EACtB,aAAa,EACb,KAAK,WAAW,EAChB,iBAAiB,EACjB,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,iBAAiB,EACjB,KAAK,WAAW,EAChB,iBAAiB,EACjB,KAAK,YAAY,EACjB,kBAAkB,EAClB,KAAK,SAAS,EACd,eAAe,EACf,KAAK,sBAAsB,EAC3B,4BAA4B,EAC5B,2BAA2B,EAC3B,KAAK,uBAAuB,EAC5B,6BAA6B,EAC7B,4BAA4B,EAC5B,wBAAwB,EACxB,yBAAyB,EACzB,gBAAgB,EAChB,iBAAiB,EACjB,uBAAuB,EACvB,kBAAkB,EAClB,KAAK,eAAe,EACpB,qBAAqB,EACrB,sBAAsB,EACtB,gCAAgC,EAChC,KAAK,4BAA4B,EACjC,kCAAkC,EAClC,iCAAiC,EACjC,yBAAyB,EACzB,0BAA0B,EAC1B,0BAA0B,EAC1B,2BAA2B,GAC9B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,WAAW,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/index.js

@@ -1,9 +1,11 @@
-export { buildChangeLogRecord, buildCorrectionRecord, buildOperatorDecisionRecord, buildStripDecisionRevertedRecord, buildValidatorResultRecord, } from "./builders.js";
+export { buildChangeLogRecord, buildCorrectionRecord, buildOperatorDecisionRecord, buildStageWriteRecord, buildStripDecisionRevertedRecord, buildValidatorResultRecord, } from "./builders.js";
 export { runLedgerCli } from "./cli.js";
 export { computeCoverage } from "./coverage.js";
+export { DOCTOR_FINDING_CODES, runLedgerDoctor, } from "./doctor.js";
 export { openLedger, } from "./handle.js";
 export { appendCleanupWaveNote, appendDecompositionWaveNote, appendNote, appendOpenIssueNote, appendSemanticCleanupSummaryNote, appendVerifiedFlowNote, } from "./note.js";
 export { deriveFilesChangedFromPatch } from "./patch-resolver.js";
-export { AgentPatchDiffSchema, AgentPatchEntrySchema, AgentPatchRecordSchema, ChangeLogEntrySchema, ChangeLogFileChangeSchema, ChangeLogParityStatusSchema, ChangeLogRecordSchema, ChangeLogSmokeResultSchema, ChangeLogSubkindSchema, CorrectionEntrySchema, CorrectionRecordSchema, EmitterSchema, LedgerEntrySchema, LedgerLinksSchema, LedgerPhaseSchema, LedgerRecordSchema, NoteEntrySchema, OperatorDecisionActionSchema, OperatorDecisionEntrySchema, OperatorDecisionPayloadSchema, OperatorDecisionRecordSchema, OperatorPatchEntrySchema, OperatorPatchRecordSchema, parseLedgerEntry, parseLedgerRecord, RuntimeEventEntrySchema, StripDecisionRevertedEntrySchema, StripDecisionRevertedPayloadSchema, StripDecisionRevertedRecordSchema, ToolInvocationEntrySchema, ToolInvocationRecordSchema, ValidatorResultEntrySchema, ValidatorResultRecordSchema, } from "./schema/entry.js";
+export { getLedgerRuntimeConfig, validateLedgerRuntimeConfig } from "./runtime-config.js";
+export { AgentPatchDiffSchema, AgentPatchEntrySchema, AgentPatchRecordSchema, ChangeLogEntrySchema, ChangeLogFileChangeSchema, ChangeLogParityStatusSchema, ChangeLogRecordSchema, ChangeLogSmokeResultSchema, ChangeLogSubkindSchema, CorrectionEntrySchema, CorrectionRecordSchema, EmitterSchema, LedgerEntrySchema, LedgerLinksSchema, LedgerPhaseSchema, LedgerRecordSchema, NoteEntrySchema, OperatorDecisionActionSchema, OperatorDecisionEntrySchema, OperatorDecisionPayloadSchema, OperatorDecisionRecordSchema, OperatorPatchEntrySchema, OperatorPatchRecordSchema, parseLedgerEntry, parseLedgerRecord, RuntimeEventEntrySchema, STAGE_WRITE_STAGES, StageWriteEntrySchema, StageWriteRecordSchema, StripDecisionRevertedEntrySchema, StripDecisionRevertedPayloadSchema, StripDecisionRevertedRecordSchema, ToolInvocationEntrySchema, ToolInvocationRecordSchema, ValidatorResultEntrySchema, ValidatorResultRecordSchema, } from "./schema/entry.js";
 export { NoteSubkindSchema } from "./schema/note.js";
 export { resolveLedgerPaths } from "./storage/filesystem.js";

package/dist/list.d.ts

@@ -8,9 +8,10 @@ export type LedgerFilter = {
     readonly since?: string;
 };
 export declare const getOrderedEntryLocations: (manifest: LedgerManifest, readIndex: LedgerReadIndex, filter: LedgerFilter, direction?: "asc" | "desc") => ManifestEntryLocation[];
-export declare const readManifestEntryBatch: ({ allowMissing, entryLocations, workspaceRoot, }: {
+export declare const readManifestEntryBatch: ({ allowMissing, entryLocations, entryReadConcurrency, workspaceRoot, }: {
     readonly allowMissing?: boolean;
     readonly entryLocations: readonly ManifestEntryLocation[];
+    readonly entryReadConcurrency?: number;
     readonly workspaceRoot: string;
 }) => Promise<({
     entry: {
@@ -75,6 +76,38 @@ export declare const readManifestEntryBatch: ({ allowMissing, entryLocations, wo
         schemaVersion: "ushman-ledger-entry/v1";
         summary: string;
         ts: string;
+    } | {
+        filePath: string;
+        kind: "stage-write";
+        rationale: string;
+        stage: "intake" | "seed" | "vendor-extract" | "cleanup" | "candidate-promotion";
+        details?: {
+            [x: string]: unknown;
+        } | undefined;
+        emitter: {
+            tool: string;
+            user?: string | undefined;
+            version: string;
+        };
+        id: string;
+        links: {
+            affectedFiles?: string[] | undefined;
+            blobs?: string[] | undefined;
+            briefId?: string | undefined;
+            correctsLedgerId?: string | undefined;
+            gitRef?: string | undefined;
+            idempotencyKey?: string | undefined;
+            stripDecisionId?: string | undefined;
+            supersedesLedgerId?: string | undefined;
+            validatorVerdictId?: string | undefined;
+        } & {
+            [key: string]: unknown;
+        };
+        phase: "capture" | "intake" | "seed" | "vendor-extract" | "cleanup" | "parity" | "characterize" | "equiv" | "analyze" | "recover" | "ship" | "migration";
+        prevEntryId: string | null;
+        schemaVersion: "ushman-ledger-entry/v1";
+        summary: string;
+        ts: string;
     } | {
         agent: {
             name: string;

package/dist/list.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../src/list.ts"],"names":[],"mappings":"AACA,OAAO,EACH,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAG7B,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAoB,MAAM,mBAAmB,CAAC;AAC1G,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAG3D,MAAM,MAAM,YAAY,GAAG;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAmDF,eAAO,MAAM,wBAAwB,GACjC,UAAU,cAAc,EACxB,WAAW,eAAe,EAC1B,QAAQ,YAAY,EACpB,YAAW,KAAK,GAAG,MAAc,4BAgBpC,CAAC;AAgCF,eAAO,MAAM,sBAAsB,GAAU,kDAI1C;IACC,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,cAAc,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAC1D,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAQI,CAAC;AAiDN,eAAO,MAAM,0BAA0B,GACnC,eAAe,MAAM,EACrB,UAAU,cAAc,EACxB,WAAW,eAAe,EAC1B,SAAQ,YAAiB,EACzB,YAAW,KAAK,GAAG,MAAc,KAClC,aAAa,CAAC,WAAW,CAwB3B,CAAC;AAEF,eAAO,MAAM,WAAW,GACpB,eAAe,MAAM,EACrB,SAAQ,YAAiB,KAC1B,aAAa,CAAC,WAAW,CAG3B,CAAC;AAEF,eAAO,MAAM,cAAc,GAAU,eAAe,MAAM,EAAE,SAAQ,YAAiB,KAAG,OAAO,CAAC,WAAW,EAAE,CAM5G,CAAC"}
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../src/list.ts"],"names":[],"mappings":"AACA,OAAO,EACH,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAG7B,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAoB,MAAM,mBAAmB,CAAC;AAC1G,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAG3D,MAAM,MAAM,YAAY,GAAG;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAgDF,eAAO,MAAM,wBAAwB,GACjC,UAAU,cAAc,EACxB,WAAW,eAAe,EAC1B,QAAQ,YAAY,EACpB,YAAW,KAAK,GAAG,MAAc,4BAgBpC,CAAC;AAiCF,eAAO,MAAM,sBAAsB,GAAU,wEAK1C;IACC,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,cAAc,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAC1D,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IACvC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAQI,CAAC;AAkDN,eAAO,MAAM,0BAA0B,GACnC,eAAe,MAAM,EACrB,UAAU,cAAc,EACxB,WAAW,eAAe,EAC1B,SAAQ,YAAiB,EACzB,YAAW,KAAK,GAAG,MAAc,KAClC,aAAa,CAAC,WAAW,CAkC3B,CAAC;AAEF,eAAO,MAAM,WAAW,GACpB,eAAe,MAAM,EACrB,SAAQ,YAAiB,KAC1B,aAAa,CAAC,WAAW,CAG3B,CAAC;AAEF,eAAO,MAAM,cAAc,GAAU,eAAe,MAAM,EAAE,SAAQ,YAAiB,KAAG,OAAO,CAAC,WAAW,EAAE,CAM5G,CAAC"}

package/dist/list.js

@@ -1,6 +1,7 @@
 import { mapWithConcurrencyLimit } from "./async.js";
 import { matchesReadIndexFilter, } from "./read-index.js";
 import { loadLedgerState } from "./recovery.js";
+import { getLedgerRuntimeConfig } from "./runtime-config.js";
 import { parseLedgerEntry } from "./schema/entry.js";
 import { readPhaseEntryText } from "./storage/filesystem.js";
 const matchesFilter = (entry, filter) => {
@@ -15,8 +16,6 @@ const matchesFilter = (entry, filter) => {
     }
     return true;
 };
-const ENTRY_READ_BATCH_SIZE = 32;
-const ENTRY_READ_CONCURRENCY = 16;
 const getFilteredReadIndexEntries = ({ direction, filter, manifest, readIndex, }) => {
     const sourceEntries = direction === 'asc' ? readIndex.entries : [...readIndex.entries].reverse();
     const filteredEntries = [];
@@ -71,20 +70,21 @@ const readManifestEntry = async ({ allowMissing, entryId, location, workspaceRoo
         throw error;
     }
 };
-export const readManifestEntryBatch = async ({ allowMissing = false, entryLocations, workspaceRoot, }) => mapWithConcurrencyLimit(entryLocations, ENTRY_READ_CONCURRENCY, async ([entryId, location]) => readManifestEntry({
+export const readManifestEntryBatch = async ({ allowMissing = false, entryLocations, entryReadConcurrency = getLedgerRuntimeConfig().scanConcurrency, workspaceRoot, }) => mapWithConcurrencyLimit(entryLocations, entryReadConcurrency, async ([entryId, location]) => readManifestEntry({
     allowMissing,
     entryId,
     location,
     workspaceRoot,
 }));
-const collectLimitedEntries = async ({ direction, filter, manifest, readIndex, workspaceRoot, }) => {
+const collectLimitedEntries = async ({ batchSize, direction, entryReadConcurrency, filter, manifest, readIndex, workspaceRoot, }) => {
     const collectedEntries = [];
     const orderedEntries = getOrderedEntryLocations(manifest, readIndex, filter, 'desc');
     const limit = filter.limit ?? 0;
-    for (let index = 0; index < orderedEntries.length && collectedEntries.length < limit; index += ENTRY_READ_BATCH_SIZE) {
-        const batch = orderedEntries.slice(index, index + ENTRY_READ_BATCH_SIZE);
+    for (let index = 0; index < orderedEntries.length && collectedEntries.length < limit; index += batchSize) {
+        const batch = orderedEntries.slice(index, index + batchSize);
         const resolvedEntries = await readManifestEntryBatch({
             entryLocations: batch,
+            entryReadConcurrency,
             workspaceRoot,
         });
         for (const resolvedEntry of resolvedEntries) {
@@ -105,17 +105,27 @@ const collectLimitedEntries = async ({ direction, filter, manifest, readIndex, w
     return collectedEntries;
 };
 export const iterateEntriesFromManifest = async function* (workspaceRoot, manifest, readIndex, filter = {}, direction = 'asc') {
+    const { scanBatchSize, scanConcurrency } = getLedgerRuntimeConfig();
     if (filter.limit) {
-        for (const entry of await collectLimitedEntries({ direction, filter, manifest, readIndex, workspaceRoot })) {
+        for (const entry of await collectLimitedEntries({
+            batchSize: scanBatchSize,
+            direction,
+            entryReadConcurrency: scanConcurrency,
+            filter,
+            manifest,
+            readIndex,
+            workspaceRoot,
+        })) {
             yield entry;
         }
         return;
     }
     const orderedEntries = getOrderedEntryLocations(manifest, readIndex, filter, direction);
-    for (let index = 0; index < orderedEntries.length; index += ENTRY_READ_BATCH_SIZE) {
-        const batch = orderedEntries.slice(index, index + ENTRY_READ_BATCH_SIZE);
+    for (let index = 0; index < orderedEntries.length; index += scanBatchSize) {
+        const batch = orderedEntries.slice(index, index + scanBatchSize);
         const resolvedEntries = await readManifestEntryBatch({
             entryLocations: batch,
+            entryReadConcurrency: scanConcurrency,
             workspaceRoot,
         });
         for (const resolvedEntry of resolvedEntries) {

package/dist/patch-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"patch-resolver.d.ts","sourceRoot":"","sources":["../src/patch-resolver.ts"],"names":[],"mappings":"AAIA,OAAO,EACH,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,WAAW,EAChB,KAAK,YAAY,EAEpB,MAAM,mBAAmB,CAAC;AAI3B,KAAK,gBAAgB,GAAG,OAAO,CAAC,YAAY,EAAE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC,CAAC;AACvE,KAAK,mBAAmB,GAAG,OAAO,CAAC,YAAY,EAAE;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC,CAAC;AAQ7E,KAAK,wBAAwB,GAAG,IAAI,CAAC,gBAAgB,EAAE,UAAU,GAAG,UAAU,GAAG,OAAO,CAAC,GAAG;IACxF,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;CAC/B,CAAC;AACF,KAAK,2BAA2B,GAAG,IAAI,CAAC,mBAAmB,EAAE,UAAU,GAAG,UAAU,GAAG,OAAO,CAAC,GAAG;IAC9F,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,wBAAwB,GAAG,2BAA2B,CAAC;AAqKzF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,2BAA2B,GAAI,WAAW,MAAM,KAAG,mBAAmB,EAuClF,CAAC;AAmBF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACrC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;AACtC,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACrC,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAC;IACrC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAAC"}
+{"version":3,"file":"patch-resolver.d.ts","sourceRoot":"","sources":["../src/patch-resolver.ts"],"names":[],"mappings":"AAIA,OAAO,EACH,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,WAAW,EAChB,KAAK,YAAY,EAEpB,MAAM,mBAAmB,CAAC;AAK3B,KAAK,gBAAgB,GAAG,OAAO,CAAC,YAAY,EAAE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC,CAAC;AACvE,KAAK,mBAAmB,GAAG,OAAO,CAAC,YAAY,EAAE;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC,CAAC;AAQ7E,KAAK,wBAAwB,GAAG,IAAI,CAAC,gBAAgB,EAAE,UAAU,GAAG,UAAU,GAAG,OAAO,CAAC,GAAG;IACxF,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;CAC/B,CAAC;AACF,KAAK,2BAA2B,GAAG,IAAI,CAAC,mBAAmB,EAAE,UAAU,GAAG,UAAU,GAAG,OAAO,CAAC,GAAG;IAC9F,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,wBAAwB,GAAG,2BAA2B,CAAC;AAsTzF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,2BAA2B,GAAI,WAAW,MAAM,KAAG,mBAAmB,EAuClF,CAAC;AAmBF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACrC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;AACtC,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACrC,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAC;IACrC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAAC"}

package/dist/patch-resolver.js

@@ -1,28 +1,94 @@
-import { readFile } from 'node:fs/promises';
+import { readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
 import * as v from 'valibot';
-import { resolveBlobPath, storePatchBlob } from "./blobs.js";
+import { assertPatchTextWithinLimit, readPatchTextFromFile, resolveBlobPath, storePatchBlob } from "./blobs.js";
 import { WorkspaceRelativePathSchema, } from "./schema/entry.js";
+import { forEachLine } from "./text-lines.js";
 const readBlobText = async (workspaceRoot, blobSha256) => readFile(resolveBlobPath(workspaceRoot, blobSha256), 'utf8');
 const formatRecordContext = (record) => `${record.kind} "${record.summary}" [${record.phase}]`;
 const normalizeWorkspaceRelativePath = (value) => v.parse(WorkspaceRelativePathSchema, value.replaceAll('\\', '/'));
-const stripGitPathPrefix = (value) => {
+const normalizeDiffPathToken = ({ headerPrefixes, side, value, }) => {
     const normalized = value.trim().replace(/^"([^"]*)"$/u, '$1');
     if (normalized === '/dev/null') {
         return null;
     }
-    if (normalized.startsWith('a/') || normalized.startsWith('b/')) {
-        return normalized.slice(2);
+    const expectedPrefix = side === 'old' ? headerPrefixes?.oldPrefix : headerPrefixes?.newPrefix;
+    if (expectedPrefix && normalized.startsWith(expectedPrefix)) {
+        return normalized.slice(expectedPrefix.length);
     }
     return normalized;
 };
-const inferHeaderPath = (line) => {
-    const match = /^diff --git (?:"a\/([^"]+)"|a\/(\S+)) (?:"b\/([^"]+)"|b\/(\S+))$/u.exec(line.trim());
-    if (!match) {
+const splitPrefixCandidate = (value) => {
+    const slashIndex = value.indexOf('/');
+    if (slashIndex <= 0) {
         return null;
     }
-    const rightPath = match[3] ?? match[4];
-    return rightPath ? stripGitPathPrefix(`b/${rightPath}`) : null;
+    return {
+        prefix: value.slice(0, slashIndex + 1),
+        suffix: value.slice(slashIndex + 1),
+    };
+};
+const readDiffHeaderToken = (headerBody, startIndex) => {
+    let index = startIndex;
+    while (headerBody[index] === ' ') {
+        index += 1;
+    }
+    if (index >= headerBody.length) {
+        return null;
+    }
+    if (headerBody[index] === '"') {
+        const endIndex = headerBody.indexOf('"', index + 1);
+        if (endIndex === -1) {
+            return null;
+        }
+        return {
+            nextIndex: endIndex + 1,
+            token: headerBody.slice(index + 1, endIndex),
+        };
+    }
+    let endIndex = index;
+    while (endIndex < headerBody.length && headerBody[endIndex] !== ' ') {
+        endIndex += 1;
+    }
+    return {
+        nextIndex: endIndex + 1,
+        token: headerBody.slice(index, endIndex),
+    };
+};
+const resolveHeaderPrefixes = (oldPath, newPath) => {
+    if (oldPath.startsWith('a/') && newPath.startsWith('b/')) {
+        return {
+            newPrefix: 'b/',
+            oldPrefix: 'a/',
+        };
+    }
+    const oldCandidate = splitPrefixCandidate(oldPath);
+    const newCandidate = splitPrefixCandidate(newPath);
+    if (!oldCandidate ||
+        !newCandidate ||
+        oldCandidate.prefix === newCandidate.prefix ||
+        oldCandidate.suffix !== newCandidate.suffix) {
+        return null;
+    }
+    return {
+        newPrefix: newCandidate.prefix,
+        oldPrefix: oldCandidate.prefix,
+    };
+};
+const parseDiffHeaderPaths = (line) => {
+    const headerBody = line.trim().slice('diff --git '.length);
+    const firstToken = readDiffHeaderToken(headerBody, 0);
+    const secondToken = firstToken ? readDiffHeaderToken(headerBody, firstToken.nextIndex) : null;
+    if (!firstToken?.token || !secondToken?.token) {
+        return null;
+    }
+    const oldPath = firstToken.token;
+    const newPath = secondToken.token;
+    return {
+        headerPrefixes: resolveHeaderPrefixes(oldPath, newPath),
+        newPath,
+        oldPath,
+    };
 };
 const finalizeFileChange = (current, filesChanged) => {
     if (!current) {
@@ -38,19 +104,33 @@ const finalizeFileChange = (current, filesChanged) => {
         removed: current.removed > 0 ? current.removed : undefined,
     });
 };
-const createDiffFileAccumulator = (line) => ({
-    added: 0,
-    headerPath: inferHeaderPath(line),
-    minusPath: null,
-    plusPath: null,
-    removed: 0,
-});
+const createDiffFileAccumulator = (line) => {
+    const headerPaths = parseDiffHeaderPaths(line);
+    return {
+        added: 0,
+        headerPath: headerPaths
+            ? normalizeDiffPathToken({
+                headerPrefixes: headerPaths.headerPrefixes,
+                side: 'new',
+                value: headerPaths.newPath,
+            })
+            : null,
+        headerPrefixes: headerPaths?.headerPrefixes ?? null,
+        minusPath: null,
+        plusPath: null,
+        removed: 0,
+    };
+};
 const applyPatchMetadataLine = (current, line) => {
     if (line.startsWith('+++ ')) {
         return {
             next: {
                 ...current,
-                plusPath: stripGitPathPrefix(line.slice(4)),
+                plusPath: normalizeDiffPathToken({
+                    headerPrefixes: current.headerPrefixes,
+                    side: 'new',
+                    value: line.slice(4),
+                }),
             },
         };
     }
@@ -58,7 +138,35 @@ const applyPatchMetadataLine = (current, line) => {
         return {
             next: {
                 ...current,
-                minusPath: stripGitPathPrefix(line.slice(4)),
+                minusPath: normalizeDiffPathToken({
+                    headerPrefixes: current.headerPrefixes,
+                    side: 'old',
+                    value: line.slice(4),
+                }),
+            },
+        };
+    }
+    if (line.startsWith('rename from ')) {
+        return {
+            next: {
+                ...current,
+                minusPath: normalizeDiffPathToken({
+                    headerPrefixes: null,
+                    side: 'old',
+                    value: line.slice('rename from '.length),
+                }),
+            },
+        };
+    }
+    if (line.startsWith('rename to ')) {
+        return {
+            next: {
+                ...current,
+                plusPath: normalizeDiffPathToken({
+                    headerPrefixes: null,
+                    side: 'new',
+                    value: line.slice('rename to '.length),
+                }),
             },
         };
     }
@@ -74,16 +182,12 @@ const applyPatchMetadataLine = (current, line) => {
 };
 const applyPatchHunkLine = (current, line) => {
     if (line.startsWith('+')) {
-        return {
-            ...current,
-            added: current.added + 1,
-        };
+        current.added += 1;
+        return current;
     }
     if (line.startsWith('-')) {
-        return {
-            ...current,
-            removed: current.removed + 1,
-        };
+        current.removed += 1;
+        return current;
     }
     return current;
 };
@@ -91,36 +195,56 @@ const mergeBlobLink = (links, blobSha256) => ({
     ...links,
     blobs: [...new Set([...(links?.blobs ?? []), blobSha256])],
 });
-const resolvePatchSource = async ({ record, workspaceRoot, }) => {
-    if (record.diffPath) {
-        const resolvedPath = path.resolve(workspaceRoot, record.diffPath);
+const resolvePatchSourceFromFile = async (record, workspaceRoot) => {
+    const resolvedPath = path.resolve(workspaceRoot, record.diffPath);
+    try {
         return {
-            patchText: await readFile(resolvedPath, 'utf8'),
+            patchText: await readPatchTextFromFile(resolvedPath),
             source: 'file',
             sourceLabel: resolvedPath,
         };
     }
-    if (record.diffText) {
+    catch (error) {
+        throw new Error(`Failed to read diff file ${resolvedPath} for ${formatRecordContext(record)}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+const resolvePatchSourceFromInlineText = (record) => {
+    try {
+        assertPatchTextWithinLimit(record.diffText, 'inline diff text');
         return {
             patchText: record.diffText,
             source: 'inline',
             sourceLabel: 'inline diff text',
         };
     }
-    if (record.diff) {
-        try {
-            return {
-                patchText: await readBlobText(workspaceRoot, record.diff.blobSha256),
-                source: 'blob',
-                sourceLabel: `blob ${record.diff.blobSha256}`,
-            };
-        }
-        catch (error) {
-            if (error.code === 'ENOENT') {
-                throw new Error(`Patch blob ${record.diff.blobSha256} was not found for ${formatRecordContext(record)}. Store it first or use diffPath.`);
-            }
-            throw error;
+    catch (error) {
+        throw new Error(`Failed to validate inline diff text for ${formatRecordContext(record)}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+const resolvePatchSourceFromStoredBlob = async (record, workspaceRoot) => {
+    try {
+        return {
+            patchText: await readBlobText(workspaceRoot, record.diff?.blobSha256),
+            source: 'blob',
+            sourceLabel: `blob ${record.diff?.blobSha256}`,
+        };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(`Patch blob ${record.diff?.blobSha256} was not found for ${formatRecordContext(record)}. Store it first or use diffPath.`);
         }
+        throw error;
+    }
+};
+const resolvePatchSource = async ({ record, workspaceRoot, }) => {
+    if (record.diffPath) {
+        return resolvePatchSourceFromFile(record, workspaceRoot);
+    }
+    if (record.diffText) {
+        return resolvePatchSourceFromInlineText(record);
+    }
+    if (record.diff) {
+        return resolvePatchSourceFromStoredBlob(record, workspaceRoot);
     }
     throw new Error(`${record.kind} records require diff, diffPath, or diffText.`);
 };
@@ -140,34 +264,34 @@ export const deriveFilesChangedFromPatch = (patchText) => {
     const filesChanged = [];
     let current;
     let insideHunk = false;
-    for (const line of patchText.split(/\r?\n/u)) {
+    forEachLine(patchText, (line) => {
         if (line.startsWith('diff --git ')) {
             finalizeFileChange(current, filesChanged);
             current = createDiffFileAccumulator(line);
             insideHunk = false;
-            continue;
+            return;
         }
         if (!current) {
-            continue;
+            return;
         }
         if (insideHunk) {
             if (line.startsWith('@@')) {
-                continue;
+                return;
             }
             current = applyPatchHunkLine(current, line);
-            continue;
+            return;
         }
         const metadataUpdate = applyPatchMetadataLine(current, line);
         current = metadataUpdate.next;
         if (metadataUpdate.startHunk) {
             insideHunk = true;
-            continue;
+            return;
         }
         if (!insideHunk) {
-            continue;
+            return;
         }
         current = applyPatchHunkLine(current, line);
-    }
+    });
     finalizeFileChange(current, filesChanged);
     return filesChanged;
 };
@@ -180,6 +304,22 @@ const buildResolvedPatchRecord = ({ links, record, storedDiff, }) => {
     };
 };
 export async function resolvePatchRecord({ record, workspaceRoot, }) {
+    if (record.diff && !record.diffPath && !record.diffText) {
+        try {
+            await stat(resolveBlobPath(workspaceRoot, record.diff.blobSha256));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                throw new Error(`Patch blob ${record.diff.blobSha256} was not found for ${formatRecordContext(record)}. Store it first or use diffPath.`);
+            }
+            throw new Error(`Failed to read patch blob ${record.diff.blobSha256} for ${formatRecordContext(record)}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return buildResolvedPatchRecord({
+            links: mergeBlobLink(record.links, record.diff.blobSha256),
+            record,
+            storedDiff: record.diff,
+        });
+    }
     const { patchText, sourceLabel } = await resolvePatchSource({
         record,
         workspaceRoot,

package/dist/process.d.ts

@@ -0,0 +1,2 @@
+export declare const isProcessAlive: (pid: number) => boolean;
+//# sourceMappingURL=process.d.ts.map

package/dist/process.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process.d.ts","sourceRoot":"","sources":["../src/process.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,GAAI,KAAK,MAAM,YAczC,CAAC"}

package/dist/process.js

@@ -0,0 +1,16 @@
+export const isProcessAlive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'EPERM') {
+            return true;
+        }
+        if (code === 'ESRCH') {
+            return false;
+        }
+        throw error;
+    }
+};

package/dist/read-index.d.ts

@@ -3,14 +3,14 @@ import { type LedgerEntry, type LedgerKind, type LedgerPhase } from './schema/en
 import type { LedgerManifest } from './schema/manifest.ts';
 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", "change-log"], undefined>;
+    readonly kind: v.PicklistSchema<readonly ["tool-invocation", "stage-write", "agent-patch", "operator-patch", "operator-decision", "validator-result", "runtime-event", "note", "correction", "strip-decision-reverted", "change-log"], 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", "change-log"], undefined>;
+        readonly kind: v.PicklistSchema<readonly ["tool-invocation", "stage-write", "agent-patch", "operator-patch", "operator-decision", "validator-result", "runtime-event", "note", "correction", "strip-decision-reverted", "change-log"], 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>]>;
@@ -21,7 +21,7 @@ declare const LedgerReadIndexSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
     coveredFiles: string[];
     entries: {
         id: string;
-        kind: "operator-decision" | "validator-result" | "change-log" | "tool-invocation" | "agent-patch" | "operator-patch" | "runtime-event" | "note" | "correction" | "strip-decision-reverted";
+        kind: "operator-decision" | "validator-result" | "change-log" | "tool-invocation" | "stage-write" | "agent-patch" | "operator-patch" | "runtime-event" | "note" | "correction" | "strip-decision-reverted";
         ts: string;
     }[];
     entryCount: number;
@@ -32,7 +32,7 @@ declare const LedgerReadIndexSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
     coveredFiles: string[];
     entries: {
         id: string;
-        kind: "operator-decision" | "validator-result" | "change-log" | "tool-invocation" | "agent-patch" | "operator-patch" | "runtime-event" | "note" | "correction" | "strip-decision-reverted";
+        kind: "operator-decision" | "validator-result" | "change-log" | "tool-invocation" | "stage-write" | "agent-patch" | "operator-patch" | "runtime-event" | "note" | "correction" | "strip-decision-reverted";
         ts: string;
     }[];
     entryCount: number;
@@ -50,7 +50,7 @@ export declare const buildReadIndexFromManifest: (workspaceRoot: string, manifes
     coveredFiles: string[];
     entries: {
         id: string;
-        kind: "operator-decision" | "validator-result" | "change-log" | "tool-invocation" | "agent-patch" | "operator-patch" | "runtime-event" | "note" | "correction" | "strip-decision-reverted";
+        kind: "operator-decision" | "validator-result" | "change-log" | "tool-invocation" | "stage-write" | "agent-patch" | "operator-patch" | "runtime-event" | "note" | "correction" | "strip-decision-reverted";
         ts: string;
     }[];
     entryCount: number;
@@ -65,7 +65,7 @@ export declare const ensureReadIndexUnderLock: (workspaceRoot: string, manifest:
     coveredFiles: string[];
     entries: {
         id: string;
-        kind: "operator-decision" | "validator-result" | "change-log" | "tool-invocation" | "agent-patch" | "operator-patch" | "runtime-event" | "note" | "correction" | "strip-decision-reverted";
+        kind: "operator-decision" | "validator-result" | "change-log" | "tool-invocation" | "stage-write" | "agent-patch" | "operator-patch" | "runtime-event" | "note" | "correction" | "strip-decision-reverted";
         ts: string;
     }[];
     entryCount: number;
@@ -81,7 +81,7 @@ export declare const appendEntryToReadIndex: ({ entry, readIndex, sequence, }: {
     coveredFiles: string[];
     entries: {
         id: string;
-        kind: "operator-decision" | "validator-result" | "change-log" | "tool-invocation" | "agent-patch" | "operator-patch" | "runtime-event" | "note" | "correction" | "strip-decision-reverted";
+        kind: "operator-decision" | "validator-result" | "change-log" | "tool-invocation" | "stage-write" | "agent-patch" | "operator-patch" | "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,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sDAc1B,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"}
+{"version":3,"file":"read-index.d.ts","sourceRoot":"","sources":["../src/read-index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAI7B,OAAO,EAAgB,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAoB,MAAM,mBAAmB,CAAC;AACxH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAK3D,QAAA,MAAM,oBAAoB;;;;aAIxB,CAAC;AAEH,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sDAc1B,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;AAmIhG,eAAO,MAAM,0BAA0B,GAAU,eAAe,MAAM,EAAE,UAAU,cAAc;;;;;;;;;;;EAyB/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;;;;;;;;;;;CASA,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"}