ushman-ledger 1.2.0 → 1.2.2

package/dist/helpers.js

@@ -36,3 +36,26 @@ export const waitForFile = async (filePath, timeoutMs = 1_000) => {
     }
     throw new Error(`Timed out waiting for file: ${filePath}`);
 };
+export const withEnvOverrides = async (overrides, action) => {
+    const previousValues = new Map();
+    for (const [key, value] of Object.entries(overrides)) {
+        previousValues.set(key, process.env[key]);
+        if (value === undefined) {
+            delete process.env[key];
+            continue;
+        }
+        process.env[key] = value;
+    }
+    try {
+        return await action();
+    }
+    finally {
+        for (const [key, value] of previousValues.entries()) {
+            if (value === undefined) {
+                delete process.env[key];
+                continue;
+            }
+            process.env[key] = value;
+        }
+    }
+};

package/dist/index.d.ts

@@ -1,10 +1,13 @@
-export { buildChangeLogRecord, buildCorrectionRecord, buildOperatorDecisionRecord, buildStripDecisionRevertedRecord, buildValidatorResultRecord, } from './builders.ts';
+export { type BuildRecordInput, buildChangeLogRecord, buildCorrectionRecord, buildOperatorDecisionRecord, buildStripDecisionRevertedRecord, buildValidatorResultRecord, } from './builders.ts';
 export { runLedgerCli } from './cli.ts';
 export { type CoverageReport, computeCoverage } from './coverage.ts';
-export { type LedgerHandle, type RenderTarget, openLedger } from './handle.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 { type LedgerRuntimeConfig, getLedgerRuntimeConfig, validateLedgerRuntimeConfig } from './runtime-config.ts';
 export { appendCleanupWaveNote, appendDecompositionWaveNote, appendNote, appendOpenIssueNote, appendSemanticCleanupSummaryNote, appendVerifiedFlowNote, type NoteBody, } from './note.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, LedgerLinksSchema, type LedgerLinks, 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 { 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 { 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,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,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC/E,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,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,iBAAiB,EACjB,KAAK,WAAW,EAChB,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,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,EAAE,KAAK,mBAAmB,EAAE,sBAAsB,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AACpH,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"}

package/dist/index.js

@@ -1,8 +1,11 @@
 export { buildChangeLogRecord, buildCorrectionRecord, buildOperatorDecisionRecord, buildStripDecisionRevertedRecord, buildValidatorResultRecord, } from "./builders.js";
 export { runLedgerCli } from "./cli.js";
 export { computeCoverage } from "./coverage.js";
-export { openLedger } from "./handle.js";
+export { DOCTOR_FINDING_CODES, runLedgerDoctor, } from "./doctor.js";
+export { openLedger, } from "./handle.js";
+export { getLedgerRuntimeConfig, validateLedgerRuntimeConfig } from "./runtime-config.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 { 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: {
@@ -377,7 +378,7 @@ export declare const readManifestEntryBatch: ({ allowMissing, entryLocations, wo
         sequence: number;
     };
 })[]>;
-export declare const iterateEntriesFromManifest: (workspaceRoot: string, manifest: LedgerManifest, readIndex: LedgerReadIndex, filter?: LedgerFilter) => AsyncIterable<LedgerEntry>;
+export declare const iterateEntriesFromManifest: (workspaceRoot: string, manifest: LedgerManifest, readIndex: LedgerReadIndex, filter?: LedgerFilter, direction?: "asc" | "desc") => AsyncIterable<LedgerEntry>;
 export declare const listEntries: (workspaceRoot: string, filter?: LedgerFilter) => AsyncIterable<LedgerEntry>;
 export declare const readAllEntries: (workspaceRoot: string, filter?: LedgerFilter) => Promise<LedgerEntry[]>;
 //# sourceMappingURL=list.d.ts.map

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;AA6CN,eAAO,MAAM,0BAA0B,GACnC,eAAe,MAAM,EACrB,UAAU,cAAc,EACxB,WAAW,eAAe,EAC1B,SAAQ,YAAiB,KAC1B,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;AAsDN,eAAO,MAAM,0BAA0B,GACnC,eAAe,MAAM,EACrB,UAAU,cAAc,EACxB,WAAW,eAAe,EAC1B,SAAQ,YAAiB,EACzB,YAAW,KAAK,GAAG,MAAc,KAClC,aAAa,CAAC,WAAW,CAoC3B,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,5 +1,6 @@
 import { mapWithConcurrencyLimit } from "./async.js";
 import { matchesReadIndexFilter, } from "./read-index.js";
+import { getLedgerRuntimeConfig } from "./runtime-config.js";
 import { loadLedgerState } from "./recovery.js";
 import { parseLedgerEntry } from "./schema/entry.js";
 import { readPhaseEntryText } from "./storage/filesystem.js";
@@ -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 ({ 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) {
@@ -99,21 +99,33 @@ const collectLimitedEntries = async ({ filter, manifest, readIndex, workspaceRoo
             }
         }
     }
-    collectedEntries.reverse();
+    if (direction === 'asc') {
+        collectedEntries.reverse();
+    }
     return collectedEntries;
 };
-export const iterateEntriesFromManifest = async function* (workspaceRoot, manifest, readIndex, filter = {}) {
+export const iterateEntriesFromManifest = async function* (workspaceRoot, manifest, readIndex, filter = {}, direction = 'asc') {
+    const { scanBatchSize, scanConcurrency } = getLedgerRuntimeConfig();
     if (filter.limit) {
-        for (const entry of await collectLimitedEntries({ 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);
-    for (let index = 0; index < orderedEntries.length; index += ENTRY_READ_BATCH_SIZE) {
-        const batch = orderedEntries.slice(index, index + ENTRY_READ_BATCH_SIZE);
+    const orderedEntries = getOrderedEntryLocations(manifest, readIndex, filter, direction);
+    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/note.d.ts

@@ -1,31 +1,38 @@
 import { appendRecord } from './record.ts';
 import type { LedgerPhase } from './schema/entry.ts';
 import type { NoteSubkind } from './schema/note.ts';
+/** Input shared by the narrative and note helper wrappers. */
 export type NoteBody = {
     readonly body: string;
     readonly phase: LedgerPhase;
     readonly summary: string;
 };
+/** Append a typed note entry using the library emitter metadata. */
 export declare const appendNote: (workspaceRoot: string, subkind: NoteSubkind, noteBody: NoteBody) => Promise<{
     entry: Awaited<ReturnType<typeof appendRecord>>["entry"];
     id: string;
 }>;
+/** Append a `cleanup-wave` narrative note. */
 export declare const appendCleanupWaveNote: (workspaceRoot: string, noteBody: NoteBody) => Promise<{
     entry: Awaited<ReturnType<typeof appendRecord>>["entry"];
     id: string;
 }>;
+/** Append a `verified-flow` narrative note. */
 export declare const appendVerifiedFlowNote: (workspaceRoot: string, noteBody: NoteBody) => Promise<{
     entry: Awaited<ReturnType<typeof appendRecord>>["entry"];
     id: string;
 }>;
+/** Append an `open-issue` narrative note. */
 export declare const appendOpenIssueNote: (workspaceRoot: string, noteBody: NoteBody) => Promise<{
     entry: Awaited<ReturnType<typeof appendRecord>>["entry"];
     id: string;
 }>;
+/** Append a `decomposition-wave` narrative note. */
 export declare const appendDecompositionWaveNote: (workspaceRoot: string, noteBody: NoteBody) => Promise<{
     entry: Awaited<ReturnType<typeof appendRecord>>["entry"];
     id: string;
 }>;
+/** Append the current `semantic-cleanup-summary` note for workspace narrative rendering. */
 export declare const appendSemanticCleanupSummaryNote: (workspaceRoot: string, noteBody: NoteBody) => Promise<{
     entry: Awaited<ReturnType<typeof appendRecord>>["entry"];
     id: string;

package/dist/note.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"note.d.ts","sourceRoot":"","sources":["../src/note.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAGpD,MAAM,MAAM,QAAQ,GAAG;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,eAAO,MAAM,UAAU,GACnB,eAAe,MAAM,EACrB,SAAS,WAAW,EACpB,UAAU,QAAQ,KACnB,OAAO,CAAC;IAAE,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAYlF,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,eAAe,MAAM,EAAE,UAAU,QAAQ;WAd3D,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC;QAAM,MAAM;EAe1B,CAAC;AAExD,eAAO,MAAM,sBAAsB,GAAI,eAAe,MAAM,EAAE,UAAU,QAAQ;WAjB5D,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC;QAAM,MAAM;EAkBzB,CAAC;AAEzD,eAAO,MAAM,mBAAmB,GAAI,eAAe,MAAM,EAAE,UAAU,QAAQ;WApBzD,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC;QAAM,MAAM;EAqB5B,CAAC;AAEtD,eAAO,MAAM,2BAA2B,GAAI,eAAe,MAAM,EAAE,UAAU,QAAQ;WAvBjE,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC;QAAM,MAAM;EAwBpB,CAAC;AAE9D,eAAO,MAAM,gCAAgC,GAAI,eAAe,MAAM,EAAE,UAAU,QAAQ;WA1BtE,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC;QAAM,MAAM;EA2Bd,CAAC"}
+{"version":3,"file":"note.d.ts","sourceRoot":"","sources":["../src/note.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAGpD,8DAA8D;AAC9D,MAAM,MAAM,QAAQ,GAAG;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,oEAAoE;AACpE,eAAO,MAAM,UAAU,GACnB,eAAe,MAAM,EACrB,SAAS,WAAW,EACpB,UAAU,QAAQ,KACnB,OAAO,CAAC;IAAE,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAYlF,CAAC;AAEF,8CAA8C;AAC9C,eAAO,MAAM,qBAAqB,GAAI,eAAe,MAAM,EAAE,UAAU,QAAQ;WAf3D,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC;QAAM,MAAM;EAgB1B,CAAC;AAExD,+CAA+C;AAC/C,eAAO,MAAM,sBAAsB,GAAI,eAAe,MAAM,EAAE,UAAU,QAAQ;WAnB5D,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC;QAAM,MAAM;EAoBzB,CAAC;AAEzD,6CAA6C;AAC7C,eAAO,MAAM,mBAAmB,GAAI,eAAe,MAAM,EAAE,UAAU,QAAQ;WAvBzD,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC;QAAM,MAAM;EAwB5B,CAAC;AAEtD,oDAAoD;AACpD,eAAO,MAAM,2BAA2B,GAAI,eAAe,MAAM,EAAE,UAAU,QAAQ;WA3BjE,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC;QAAM,MAAM;EA4BpB,CAAC;AAE9D,4FAA4F;AAC5F,eAAO,MAAM,gCAAgC,GAAI,eAAe,MAAM,EAAE,UAAU,QAAQ;WA/BtE,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC;QAAM,MAAM;EAgCd,CAAC"}

package/dist/note.js

@@ -1,5 +1,6 @@
 import { appendRecord } from "./record.js";
 import { LEDGER_LIBRARY_VERSION } from "./version.js";
+/** Append a typed note entry using the library emitter metadata. */
 export const appendNote = async (workspaceRoot, subkind, noteBody) => {
     return appendRecord(workspaceRoot, {
         body: noteBody.body,
@@ -13,8 +14,13 @@ export const appendNote = async (workspaceRoot, subkind, noteBody) => {
         summary: noteBody.summary,
     });
 };
+/** Append a `cleanup-wave` narrative note. */
 export const appendCleanupWaveNote = (workspaceRoot, noteBody) => appendNote(workspaceRoot, 'cleanup-wave', noteBody);
+/** Append a `verified-flow` narrative note. */
 export const appendVerifiedFlowNote = (workspaceRoot, noteBody) => appendNote(workspaceRoot, 'verified-flow', noteBody);
+/** Append an `open-issue` narrative note. */
 export const appendOpenIssueNote = (workspaceRoot, noteBody) => appendNote(workspaceRoot, 'open-issue', noteBody);
+/** Append a `decomposition-wave` narrative note. */
 export const appendDecompositionWaveNote = (workspaceRoot, noteBody) => appendNote(workspaceRoot, 'decomposition-wave', noteBody);
+/** Append the current `semantic-cleanup-summary` note for workspace narrative rendering. */
 export const appendSemanticCleanupSummaryNote = (workspaceRoot, noteBody) => appendNote(workspaceRoot, 'semantic-cleanup-summary', noteBody);

package/dist/patch-resolver.d.ts

@@ -14,6 +14,18 @@ type ResolvedOperatorPatchRecord = Omit<OperatorPatchRecord, 'diffPath' | 'diffT
     readonly links: LedgerLinks;
 };
 export type ResolvedPatchRecord = ResolvedAgentPatchRecord | ResolvedOperatorPatchRecord;
+/**
+ * Derive `change-log.filesChanged` metadata from a git-style unified diff.
+ *
+ * Example:
+ * `deriveFilesChangedFromPatch(await readFile('/tmp/change.patch', 'utf8'))`
+ *
+ * Known limits:
+ * - Requires `diff --git` headers to identify file boundaries.
+ * - Counts only textual hunk `+` and `-` lines, so binary or mode-only diffs can yield zero line counts.
+ * - Uses the post-image path when available and rejects diff blocks that cannot be mapped to a normalized
+ *   workspace-relative path.
+ */
 export declare const deriveFilesChangedFromPatch: (patchText: string) => ChangeLogFileChange[];
 export declare function resolvePatchRecord(args: {
     readonly record: AgentPatchRecord;

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,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":"AASA,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,71 +195,103 @@ 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.`);
 };
+/**
+ * Derive `change-log.filesChanged` metadata from a git-style unified diff.
+ *
+ * Example:
+ * `deriveFilesChangedFromPatch(await readFile('/tmp/change.patch', 'utf8'))`
+ *
+ * Known limits:
+ * - Requires `diff --git` headers to identify file boundaries.
+ * - Counts only textual hunk `+` and `-` lines, so binary or mode-only diffs can yield zero line counts.
+ * - Uses the post-image path when available and rejects diff blocks that cannot be mapped to a normalized
+ *   workspace-relative path.
+ */
 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;
 };
@@ -168,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,