ushman-ledger 1.2.0 → 1.2.2

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"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;AA4HhG,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;;;;;;;;;;;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

@@ -2,11 +2,10 @@ import { readFile } from 'node:fs/promises';
 import * as v from 'valibot';
 import { mapWithConcurrencyLimit } from "./async.js";
 import { stableStringify } from "./json.js";
+import { getLedgerRuntimeConfig } from "./runtime-config.js";
 import { LEDGER_KINDS, parseLedgerEntry } from "./schema/entry.js";
 import { readPhaseEntryText, resolveLedgerPaths, writeAtomicTextFile } from "./storage/filesystem.js";
 const READ_INDEX_SCHEMA_VERSION = 'ushman-ledger-read-index/v1';
-const ENTRY_READ_BATCH_SIZE = 32;
-const ENTRY_READ_CONCURRENCY = 16;
 const ReadIndexEntrySchema = v.object({
     id: v.pipe(v.string(), v.minLength(1)),
     kind: v.picklist(LEDGER_KINDS),
@@ -83,7 +82,7 @@ const readIndexedEntry = async ({ entryId, phase, workspaceRoot, }) => {
     const text = await readPhaseEntryText(workspaceRoot, phase, `${entryId}.json`);
     return parseLedgerEntry(JSON.parse(text));
 };
-const readIndexedEntryBatch = async ({ entryLocations, workspaceRoot, }) => mapWithConcurrencyLimit(entryLocations, ENTRY_READ_CONCURRENCY, async ([entryId, location]) => readIndexedEntry({
+const readIndexedEntryBatch = async ({ entryReadConcurrency, entryLocations, workspaceRoot, }) => mapWithConcurrencyLimit(entryLocations, entryReadConcurrency, async ([entryId, location]) => readIndexedEntry({
     entryId,
     phase: location.phase,
     workspaceRoot,
@@ -97,12 +96,14 @@ const collectCoveredFiles = (entry, coveredFiles) => {
     }
 };
 export const buildReadIndexFromManifest = async (workspaceRoot, manifest) => {
+    const { readIndexRebuildBatchSize, readIndexRebuildConcurrency } = getLedgerRuntimeConfig();
     const orderedEntryLocations = getManifestSequenceLocations(manifest);
     const entries = [];
     const coveredFiles = new Set();
-    for (let index = 0; index < orderedEntryLocations.length; index += ENTRY_READ_BATCH_SIZE) {
-        const batch = orderedEntryLocations.slice(index, index + ENTRY_READ_BATCH_SIZE);
+    for (let index = 0; index < orderedEntryLocations.length; index += readIndexRebuildBatchSize) {
+        const batch = orderedEntryLocations.slice(index, index + readIndexRebuildBatchSize);
         const resolvedEntries = await readIndexedEntryBatch({
+            entryReadConcurrency: readIndexRebuildConcurrency,
             entryLocations: batch,
             workspaceRoot,
         });

package/dist/record.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../src/record.ts"],"names":[],"mappings":"AASA,OAAO,EACH,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;AAOF,eAAO,MAAM,wBAAwB,GAAI,eAAe,MAAM,EAAE,OAAO,qBAAqB,GAAG,IAAI,SAOlG,CAAC;AA0EF,eAAO,MAAM,YAAY,GACrB,eAAe,MAAM,EACrB,OAAO,OAAO,KACf,OAAO,CAAC;IAAE,KAAK,EAAE,WAAW,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAsF5C,CAAC;AAEF,eAAO,MAAM,aAAa,GACtB,eAAe,MAAM,EACrB,UAAU,cAAc,EACxB,SAAS,MAAM,KAChB,OAAO,CAAC,WAAW,CAMrB,CAAC"}
+{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../src/record.ts"],"names":[],"mappings":"AASA,OAAO,EACH,KAAK,WAAW,EAMnB,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;AAOF,eAAO,MAAM,wBAAwB,GAAI,eAAe,MAAM,EAAE,OAAO,qBAAqB,GAAG,IAAI,SAOlG,CAAC;AA0EF,eAAO,MAAM,YAAY,GACrB,eAAe,MAAM,EACrB,OAAO,OAAO,KACf,OAAO,CAAC;IAAE,KAAK,EAAE,WAAW,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAsF5C,CAAC;AAEF,eAAO,MAAM,aAAa,GACtB,eAAe,MAAM,EACrB,UAAU,cAAc,EACxB,SAAS,MAAM,KAChB,OAAO,CAAC,WAAW,CASrB,CAAC"}

package/dist/record.js

@@ -2,12 +2,12 @@ import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import * as v from 'valibot';
 import { sha256Hex, stableStringify } from "./json.js";
+import { getNextManifestSequence } from "./manifest-update.js";
 import { updateManifestForEntry } from "./manifest-update.js";
-import { LedgerSchemaVersion } from "./schema/entry.js";
 import { resolvePatchRecord } from "./patch-resolver.js";
 import { appendEntryToReadIndex, saveReadIndex } from "./read-index.js";
 import { reconcileLedgerStateUnderLock, removePendingCommit, writePendingCommit } from "./recovery.js";
-import { LedgerEntrySchema, parseLedgerEntry, parseLedgerRecord, } from "./schema/entry.js";
+import { LedgerEntrySchema, LedgerSchemaVersion, parseLedgerEntry, parseLedgerRecord, } from "./schema/entry.js";
 import { ensureLedgerDirectories, readManifest, resolveLedgerPaths, saveManifest, writeEntryFile, } from "./storage/filesystem.js";
 import { acquireLock } from "./storage/lock.js";
 const appendRecordTestHooks = new Map();
@@ -106,7 +106,7 @@ export const appendRecord = async (workspaceRoot, input) => {
                 id: existingId,
             };
         }
-        const nextSequence = manifest.lastSequence + 1;
+        const nextSequence = getNextManifestSequence(manifest.lastSequence);
         const { idempotencyKey: _idempotencyKey, ...recordWithoutIdempotencyKey } = normalizedRecord;
         const entryWithoutId = {
             ...recordWithoutIdempotencyKey,

package/dist/render/migration-log.d.ts

@@ -1,3 +1,10 @@
 import type { LedgerEntry } from '../schema/entry.ts';
-export declare const renderMigrationLogMarkdown: (entries: AsyncIterable<LedgerEntry>) => Promise<string>;
+export declare const writeMigrationLogMarkdown: ({ entries, write, }: {
+    readonly entries: AsyncIterable<LedgerEntry>;
+    readonly write: (chunk: string) => Promise<void> | void;
+}) => Promise<void>;
+export declare const renderMigrationLogMarkdown: ({ entries, write, }: {
+    readonly entries: AsyncIterable<LedgerEntry>;
+    readonly write?: (chunk: string) => Promise<void> | void;
+}) => Promise<string>;
 //# sourceMappingURL=migration-log.d.ts.map

package/dist/render/migration-log.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"migration-log.d.ts","sourceRoot":"","sources":["../../src/render/migration-log.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAuC,WAAW,EAAE,MAAM,oBAAoB,CAAC;AA2C3F,eAAO,MAAM,0BAA0B,GAAU,SAAS,aAAa,CAAC,WAAW,CAAC,KAAG,OAAO,CAAC,MAAM,CAwCpG,CAAC"}
+{"version":3,"file":"migration-log.d.ts","sourceRoot":"","sources":["../../src/render/migration-log.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAuC,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAmE3F,eAAO,MAAM,yBAAyB,GAAU,qBAG7C;IACC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;IAC7C,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAC3D,kBAaA,CAAC;AAEF,eAAO,MAAM,0BAA0B,GAAU,qBAG9C;IACC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;IAC7C,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAC5D,KAAG,OAAO,CAAC,MAAM,CASjB,CAAC"}

package/dist/render/migration-log.js

@@ -32,41 +32,48 @@ const renderSmokeLine = (entry) => {
     return '**Smoke result**: Not recorded.';
 };
 const isChangeLogEntry = (entry) => entry.kind === 'change-log';
-export const renderMigrationLogMarkdown = async (entries) => {
-    const changeLogEntries = [];
+const renderChangeLogSection = (entry) => [
+    `## ${entry.ts} - ${entry.summary}`,
+    '',
+    `**Type**: ${entry.subkind}`,
+    '',
+    '**Files changed**:',
+    renderFilesChanged(entry.filesChanged),
+    '',
+    renderOptionalLine('Hypothesis', entry.hypothesis),
+    '',
+    '**Commands run**:',
+    toCodeBlock(entry.commandsRun),
+    '',
+    renderSmokeLine(entry),
+    '',
+    renderOptionalLine('Parity status', entry.parityStatus),
+    '',
+    renderOptionalLine('Rollback plan', entry.rollbackPlan),
+    '',
+    '---',
+    '',
+].join('\n');
+export const writeMigrationLogMarkdown = async ({ entries, write, }) => {
+    await write('# Ushman Ledger Migration Log\n\n');
+    let hasEntries = false;
     for await (const entry of entries) {
-        if (isChangeLogEntry(entry)) {
-            changeLogEntries.push(entry);
+        if (!isChangeLogEntry(entry)) {
+            continue;
         }
+        hasEntries = true;
+        await write(renderChangeLogSection(entry));
     }
-    changeLogEntries.reverse();
-    if (changeLogEntries.length === 0) {
-        return ['# Ushman Ledger Migration Log', '', 'No change-log entries recorded.'].join('\n');
+    if (!hasEntries) {
+        await write('No change-log entries recorded.');
     }
-    return [
-        '# Ushman Ledger Migration Log',
-        '',
-        ...changeLogEntries.flatMap((entry) => [
-            `## ${entry.ts} - ${entry.summary}`,
-            '',
-            `**Type**: ${entry.subkind}`,
-            '',
-            '**Files changed**:',
-            renderFilesChanged(entry.filesChanged),
-            '',
-            renderOptionalLine('Hypothesis', entry.hypothesis),
-            '',
-            '**Commands run**:',
-            toCodeBlock(entry.commandsRun),
-            '',
-            renderSmokeLine(entry),
-            '',
-            renderOptionalLine('Parity status', entry.parityStatus),
-            '',
-            renderOptionalLine('Rollback plan', entry.rollbackPlan),
-            '',
-            '---',
-            '',
-        ]),
-    ].join('\n');
+};
+export const renderMigrationLogMarkdown = async ({ entries, write, }) => {
+    const chunks = [];
+    const resolvedWriter = write ??
+        ((chunk) => {
+            chunks.push(chunk);
+        });
+    await writeMigrationLogMarkdown({ entries, write: resolvedWriter });
+    return chunks.join('');
 };

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;AAgItD,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,CAgDjB,CAAC"}
+{"version":3,"file":"retro.d.ts","sourceRoot":"","sources":["../../src/render/retro.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AA4HtD,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,CAgDjB,CAAC"}

package/dist/render/retro.js

@@ -21,13 +21,7 @@ const isRetroNote = (entry) => entry.kind === 'note' && entry.subkind === 'retro
 const isOperatorNote = (entry) => entry.kind === 'note' && entry.subkind === 'operator';
 const isDedicatedNarrativeEntry = (entry) => entry.kind === 'change-log' ||
     (entry.kind === 'note' &&
-        [
-            'cleanup-wave',
-            'verified-flow',
-            'open-issue',
-            'decomposition-wave',
-            'semantic-cleanup-summary',
-        ].includes(entry.subkind));
+        ['cleanup-wave', 'verified-flow', 'open-issue', 'decomposition-wave', 'semantic-cleanup-summary'].includes(entry.subkind));
 const resolveRenderedAt = (entryCount, lastEntryTimestamp, manifest) => {
     if (entryCount > 0) {
         return lastEntryTimestamp ?? 'n/a';

package/dist/render/workspace-narrative.d.ts

@@ -1,6 +1,12 @@
 import type { LedgerEntry } from '../schema/entry.ts';
-export declare const renderWorkspaceNarrativeMarkdown: ({ entries, workspaceName, }: {
+export declare const writeWorkspaceNarrativeMarkdown: ({ entries, workspaceName, write, }: {
     readonly entries: AsyncIterable<LedgerEntry>;
     readonly workspaceName: string;
+    readonly write: (chunk: string) => Promise<void> | void;
+}) => Promise<void>;
+export declare const renderWorkspaceNarrativeMarkdown: ({ entries, workspaceName, write, }: {
+    readonly entries: AsyncIterable<LedgerEntry>;
+    readonly workspaceName: string;
+    readonly write?: (chunk: string) => Promise<void> | void;
 }) => Promise<string>;
 //# sourceMappingURL=workspace-narrative.d.ts.map

package/dist/render/workspace-narrative.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workspace-narrative.d.ts","sourceRoot":"","sources":["../../src/render/workspace-narrative.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAa,MAAM,oBAAoB,CAAC;AAsCjE,eAAO,MAAM,gCAAgC,GAAU,6BAGpD;IACC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;IAC7C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC,KAAG,OAAO,CAAC,MAAM,CA+CjB,CAAC"}
+{"version":3,"file":"workspace-narrative.d.ts","sourceRoot":"","sources":["../../src/render/workspace-narrative.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAa,MAAM,oBAAoB,CAAC;AAuIjE,eAAO,MAAM,+BAA+B,GAAU,oCAInD;IACC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;IAC7C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAC3D,kBA+BA,CAAC;AAEF,eAAO,MAAM,gCAAgC,GAAU,oCAIpD;IACC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;IAC7C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAC5D,KAAG,OAAO,CAAC,MAAM,CAajB,CAAC"}

package/dist/render/workspace-narrative.js

@@ -14,56 +14,124 @@ const NARRATIVE_SUBKINDS = [
     'semantic-cleanup-summary',
 ];
 const isNarrativeNote = (entry) => entry.kind === 'note' && NARRATIVE_SUBKINDS.some((subkind) => subkind === entry.subkind);
-const byNewestFirst = (left, right) => right.ts.localeCompare(left.ts);
-const renderBulletSection = (entries) => entries.length === 0
-    ? '- None recorded.'
-    : entries.map((entry) => `- ${entry.ts} — ${entry.summary}`).join('\n');
-const renderLatestSummary = (entries) => {
-    const [latest] = entries;
-    if (!latest) {
-        return 'No entries recorded.';
-    }
-    return [`### ${latest.ts} — ${latest.summary}`, '', latest.body || 'No narrative body recorded.'].join('\n');
-};
-export const renderWorkspaceNarrativeMarkdown = async ({ entries, workspaceName, }) => {
-    const entriesBySubkind = new Map(NARRATIVE_SUBKINDS.map((subkind) => [subkind, []]));
+const renderSummaryBullet = (entry) => `- ${entry.ts} — ${entry.summary}`;
+const collectNarrativeSections = async (entries) => {
+    let latestSummary = null;
+    const cleanupWaveEntries = [];
+    const decompositionWaveEntries = [];
+    const openIssueEntries = [];
+    const summaryArchiveEntries = [];
+    const verifiedFlowEntries = [];
     for await (const entry of entries) {
         if (!isNarrativeNote(entry)) {
             continue;
         }
-        entriesBySubkind.get(entry.subkind)?.push(entry);
+        switch (entry.subkind) {
+            case 'cleanup-wave':
+                cleanupWaveEntries.push(entry);
+                break;
+            case 'decomposition-wave':
+                decompositionWaveEntries.push(entry);
+                break;
+            case 'open-issue':
+                openIssueEntries.push(entry);
+                break;
+            case 'semantic-cleanup-summary':
+                if (!latestSummary) {
+                    latestSummary = entry;
+                    break;
+                }
+                summaryArchiveEntries.push(entry);
+                break;
+            case 'verified-flow':
+                verifiedFlowEntries.push(entry);
+                break;
+        }
+    }
+    return {
+        cleanupWaveEntries,
+        decompositionWaveEntries,
+        latestSummary,
+        openIssueEntries,
+        summaryArchiveEntries,
+        verifiedFlowEntries,
+    };
+};
+const writeBulletSection = async ({ entries, title, write, }) => {
+    await write(`${title}\n\n`);
+    if (entries.length === 0) {
+        await write('- None recorded.\n');
+        await write('\n');
+        return;
+    }
+    for (const entry of entries) {
+        await write(`${renderSummaryBullet(entry)}\n`);
     }
-    for (const noteEntries of entriesBySubkind.values()) {
-        noteEntries.sort(byNewestFirst);
+    await write('\n');
+};
+const writeLatestSummarySection = async ({ latestSummary, write, }) => {
+    await write(`${SECTION_TITLES.semanticCleanupSummary}\n\n`);
+    if (latestSummary) {
+        await write(`### ${latestSummary.ts} — ${latestSummary.summary}\n\n`);
+        await write(`${latestSummary.body || 'No narrative body recorded.'}\n\n`);
+        return;
+    }
+    await write('No entries recorded.\n\n');
+};
+const writeSummaryArchiveSection = async ({ entries, write, }) => {
+    await write(`${SECTION_TITLES.semanticCleanupSummaryArchive}\n\n`);
+    if (entries.length === 0) {
+        await write('- None recorded.\n');
+        await write('\n');
+        return;
     }
-    const semanticCleanupSummaries = entriesBySubkind.get('semantic-cleanup-summary') ?? [];
-    const [, ...archivedSummaries] = semanticCleanupSummaries;
-    return [
-        `# Workspace narrative — ${workspaceName}`,
-        '',
-        SECTION_TITLES.semanticCleanupSummary,
-        '',
-        renderLatestSummary(semanticCleanupSummaries),
-        '',
-        SECTION_TITLES.cleanupWave,
-        '',
-        renderBulletSection(entriesBySubkind.get('cleanup-wave') ?? []),
-        '',
-        SECTION_TITLES.verifiedFlow,
-        '',
-        renderBulletSection(entriesBySubkind.get('verified-flow') ?? []),
-        '',
-        SECTION_TITLES.openIssue,
-        '',
-        renderBulletSection(entriesBySubkind.get('open-issue') ?? []),
-        '',
-        SECTION_TITLES.decompositionWave,
-        '',
-        renderBulletSection(entriesBySubkind.get('decomposition-wave') ?? []),
-        '',
-        SECTION_TITLES.semanticCleanupSummaryArchive,
-        '',
-        renderBulletSection(archivedSummaries),
-        '',
-    ].join('\n');
+    for (const entry of entries) {
+        await write(`${renderSummaryBullet(entry)}\n`);
+    }
+    await write('\n');
+};
+export const writeWorkspaceNarrativeMarkdown = async ({ entries, workspaceName, write, }) => {
+    const sections = await collectNarrativeSections(entries);
+    await write(`# Workspace narrative — ${workspaceName}\n\n`);
+    await writeLatestSummarySection({
+        latestSummary: sections.latestSummary,
+        write,
+    });
+    await writeBulletSection({
+        entries: sections.cleanupWaveEntries,
+        title: SECTION_TITLES.cleanupWave,
+        write,
+    });
+    await writeBulletSection({
+        entries: sections.verifiedFlowEntries,
+        title: SECTION_TITLES.verifiedFlow,
+        write,
+    });
+    await writeBulletSection({
+        entries: sections.openIssueEntries,
+        title: SECTION_TITLES.openIssue,
+        write,
+    });
+    await writeBulletSection({
+        entries: sections.decompositionWaveEntries,
+        title: SECTION_TITLES.decompositionWave,
+        write,
+    });
+    await writeSummaryArchiveSection({
+        entries: sections.summaryArchiveEntries,
+        write,
+    });
+};
+export const renderWorkspaceNarrativeMarkdown = async ({ entries, workspaceName, write, }) => {
+    const chunks = [];
+    const resolvedWriter = write ??
+        ((chunk) => {
+            chunks.push(chunk);
+        });
+    await writeWorkspaceNarrativeMarkdown({
+        entries,
+        workspaceName,
+        write: resolvedWriter,
+    });
+    return chunks.join('');
 };

package/dist/runtime-config.d.ts

@@ -0,0 +1,12 @@
+export type LedgerRuntimeConfig = {
+    readonly blobHashConcurrency: number;
+    readonly coverageFileStatConcurrency: number;
+    readonly maxPatchBytes: number;
+    readonly readIndexRebuildBatchSize: number;
+    readonly readIndexRebuildConcurrency: number;
+    readonly scanBatchSize: number;
+    readonly scanConcurrency: number;
+};
+export declare const validateLedgerRuntimeConfig: (env?: NodeJS.ProcessEnv) => void;
+export declare const getLedgerRuntimeConfig: (env?: NodeJS.ProcessEnv) => LedgerRuntimeConfig;
+//# sourceMappingURL=runtime-config.d.ts.map

package/dist/runtime-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-config.d.ts","sourceRoot":"","sources":["../src/runtime-config.ts"],"names":[],"mappings":"AAgCA,MAAM,MAAM,mBAAmB,GAAG;IAC9B,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,2BAA2B,EAAE,MAAM,CAAC;IAC7C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,yBAAyB,EAAE,MAAM,CAAC;IAC3C,QAAQ,CAAC,2BAA2B,EAAE,MAAM,CAAC;IAC7C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CACpC,CAAC;AAuDF,eAAO,MAAM,2BAA2B,GAAI,MAAK,MAAM,CAAC,UAAwB,SAE/E,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,MAAK,MAAM,CAAC,UAAwB,KAAG,mBAgB7E,CAAC"}

package/dist/runtime-config.js

@@ -0,0 +1,83 @@
+const DEFAULT_SCAN_BATCH_SIZE = 32;
+const DEFAULT_SCAN_CONCURRENCY = 16;
+const DEFAULT_MAX_PATCH_BYTES = 10 * 1024 * 1024;
+const RUNTIME_CONFIG_ENV_VARS = [
+    'USHMAN_LEDGER_BLOB_HASH_CONCURRENCY',
+    'USHMAN_LEDGER_COVERAGE_FILE_STAT_CONCURRENCY',
+    'USHMAN_LEDGER_MAX_PATCH_BYTES',
+    'USHMAN_LEDGER_READ_INDEX_REBUILD_BATCH_SIZE',
+    'USHMAN_LEDGER_READ_INDEX_REBUILD_CONCURRENCY',
+    'USHMAN_LEDGER_SCAN_BATCH_SIZE',
+    'USHMAN_LEDGER_SCAN_CONCURRENCY',
+];
+const parsePositiveIntegerEnv = ({ defaultValue, env, envVar, }) => {
+    const rawValue = env[envVar];
+    if (!rawValue) {
+        return defaultValue;
+    }
+    if (!/^[1-9]\d*$/u.test(rawValue)) {
+        throw new Error(`Invalid ${envVar} value: ${rawValue}. Expected a positive integer.`);
+    }
+    return Number.parseInt(rawValue, 10);
+};
+let processEnvRuntimeConfigCache;
+const getRuntimeConfigSignature = (env) => RUNTIME_CONFIG_ENV_VARS.map((envVar) => `${envVar}=${env[envVar] ?? ''}`).join('\u0000');
+const buildLedgerRuntimeConfig = (env) => {
+    const scanBatchSize = parsePositiveIntegerEnv({
+        defaultValue: DEFAULT_SCAN_BATCH_SIZE,
+        env,
+        envVar: 'USHMAN_LEDGER_SCAN_BATCH_SIZE',
+    });
+    const scanConcurrency = parsePositiveIntegerEnv({
+        defaultValue: DEFAULT_SCAN_CONCURRENCY,
+        env,
+        envVar: 'USHMAN_LEDGER_SCAN_CONCURRENCY',
+    });
+    return {
+        blobHashConcurrency: parsePositiveIntegerEnv({
+            defaultValue: scanConcurrency,
+            env,
+            envVar: 'USHMAN_LEDGER_BLOB_HASH_CONCURRENCY',
+        }),
+        coverageFileStatConcurrency: parsePositiveIntegerEnv({
+            defaultValue: scanConcurrency,
+            env,
+            envVar: 'USHMAN_LEDGER_COVERAGE_FILE_STAT_CONCURRENCY',
+        }),
+        maxPatchBytes: parsePositiveIntegerEnv({
+            defaultValue: DEFAULT_MAX_PATCH_BYTES,
+            env,
+            envVar: 'USHMAN_LEDGER_MAX_PATCH_BYTES',
+        }),
+        readIndexRebuildBatchSize: parsePositiveIntegerEnv({
+            defaultValue: scanBatchSize,
+            env,
+            envVar: 'USHMAN_LEDGER_READ_INDEX_REBUILD_BATCH_SIZE',
+        }),
+        readIndexRebuildConcurrency: parsePositiveIntegerEnv({
+            defaultValue: scanConcurrency,
+            env,
+            envVar: 'USHMAN_LEDGER_READ_INDEX_REBUILD_CONCURRENCY',
+        }),
+        scanBatchSize,
+        scanConcurrency,
+    };
+};
+export const validateLedgerRuntimeConfig = (env = process.env) => {
+    void getLedgerRuntimeConfig(env);
+};
+export const getLedgerRuntimeConfig = (env = process.env) => {
+    if (env !== process.env) {
+        return buildLedgerRuntimeConfig(env);
+    }
+    const signature = getRuntimeConfigSignature(env);
+    if (processEnvRuntimeConfigCache?.signature === signature) {
+        return processEnvRuntimeConfigCache.config;
+    }
+    const config = buildLedgerRuntimeConfig(env);
+    processEnvRuntimeConfigCache = {
+        config,
+        signature,
+    };
+    return config;
+};

package/dist/schema/entry-read.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entry-read.d.ts","sourceRoot":"","sources":["../../src/schema/entry-read.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAc7B,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAMpC,CAAC;AAQH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAOhC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAMnC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAItC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAOrC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAOlC,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;aAK1B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yDAUjC,CAAC;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAI3C,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAY/B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAW5B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACxE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAClE,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,WAAW,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC"}
+{"version":3,"file":"entry-read.d.ts","sourceRoot":"","sources":["../../src/schema/entry-read.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAc7B,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAMpC,CAAC;AAQH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAOhC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAMnC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAItC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAOrC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAOlC,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;aAK1B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yDAOjC,CAAC;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAI3C,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAY/B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAW5B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACxE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAClE,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,WAAW,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC"}

package/dist/schema/entry-read.js

@@ -1,6 +1,6 @@
 import * as v from 'valibot';
-import { NoteSubkindSchema } from "./note.js";
 import { AgentPatchDiffSchema, ChangeLogFileChangeSchema, ChangeLogParityStatusSchema, ChangeLogSmokeResultSchema, ChangeLogSubkindSchema, ledgerEntryBaseEntries, NonEmptyTrimmedStringSchema, OperatorDecisionPayloadSchema, StripDecisionRevertedPayloadSchema, } from "./entry-core.js";
+import { NoteSubkindSchema } from "./note.js";
 export const ToolInvocationEntrySchema = v.object({
     ...ledgerEntryBaseEntries,
     args: v.optional(v.array(v.string())),

package/dist/schema/entry-write.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entry-write.d.ts","sourceRoot":"","sources":["../../src/schema/entry-write.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAoC7B,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;aAMrC,CAAC;AAUH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8HAUlC,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8HASrC,CAAC;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;aAIvC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;aAOtC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;aAOnC,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;aAK3B,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yDAUlC,CAAC;AAEF,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;aAI5C,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDAkBjC,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kEAW7B,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAC1E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,kBAAkB,CAAC,CAAC"}
+{"version":3,"file":"entry-write.d.ts","sourceRoot":"","sources":["../../src/schema/entry-write.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAoC7B,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;aAMrC,CAAC;AAUH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8HAUlC,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8HASrC,CAAC;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;aAIvC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;aAOtC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;aAOnC,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;aAK3B,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yDAOlC,CAAC;AAEF,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;aAI5C,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDAkBjC,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kEAW7B,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAC1E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/schema/entry-write.js

@@ -1,6 +1,6 @@
 import * as v from 'valibot';
-import { NoteSubkindSchema } from "./note.js";
 import { AgentPatchDiffSchema, ChangeLogFileChangeSchema, ChangeLogParityStatusSchema, ChangeLogSmokeResultSchema, ChangeLogSubkindSchema, NonEmptyTrimmedStringSchema, OperatorDecisionPayloadSchema, recordEntryBaseEntries, StripDecisionRevertedPayloadSchema, } from "./entry-core.js";
+import { NoteSubkindSchema } from "./note.js";
 const validatePatchRecord = (value) => {
     const provided = [value.diff, value.diffPath, value.diffText].filter((entry) => Boolean(entry));
     if (provided.length === 0) {

package/dist/schema/entry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entry.d.ts","sourceRoot":"","sources":["../../src/schema/entry.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAqB,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAE,KAAK,YAAY,EAAsB,MAAM,kBAAkB,CAAC;AAEzE,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AAEjC,eAAO,MAAM,gBAAgB,GAAI,OAAO,OAAO,KAAG,WAAyE,CAAC;AAE5H,eAAO,MAAM,iBAAiB,GAAI,OAAO,OAAO,KAAG,YACa,CAAC"}
+{"version":3,"file":"entry.d.ts","sourceRoot":"","sources":["../../src/schema/entry.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAqB,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAE,KAAK,YAAY,EAAsB,MAAM,kBAAkB,CAAC;AAEzE,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AAEjC,eAAO,MAAM,gBAAgB,GAAI,OAAO,OAAO,KAAG,WACY,CAAC;AAE/D,eAAO,MAAM,iBAAiB,GAAI,OAAO,OAAO,KAAG,YACa,CAAC"}

package/dist/storage/filesystem.d.ts

@@ -5,6 +5,8 @@ export declare const LEDGER_ROOT_SEGMENTS: readonly [".lab", "ledger"];
 export declare const LEDGER_STALE_TEMP_MS = 60000;
 type AtomicWriteTestHook = {
     readonly beforeRename?: () => Promise<void>;
+    readonly beforeWrite?: () => Promise<void>;
+    readonly retainOnThrow?: boolean;
 };
 export type LedgerPaths = {
     readonly blobsDir: string;
@@ -22,10 +24,16 @@ export type LedgerPaths = {
     readonly root: string;
     readonly workspaceRoot: string;
 };
+export type AtomicTextFileWriter = {
+    readonly abort: () => Promise<void>;
+    readonly close: () => Promise<void>;
+    readonly write: (chunk: string) => Promise<void>;
+};
 export declare const resolveLedgerPaths: (workspaceRoot: string) => LedgerPaths;
 export declare const ensureLedgerDirectories: (workspaceRoot: string) => Promise<LedgerPaths>;
 export declare const setAtomicWriteTestHook: (filePath: string, hook: AtomicWriteTestHook | null) => void;
 export declare const writeAtomicTextFile: (filePath: string, text: string) => Promise<void>;
+export declare const createAtomicTextFileWriter: (filePath: string) => Promise<AtomicTextFileWriter>;
 export declare const writeAtomicJsonFile: (filePath: string, value: unknown) => Promise<void>;
 export declare const readManifest: (workspaceRoot: string) => Promise<LedgerManifest>;
 export declare const saveManifest: (workspaceRoot: string, manifest: LedgerManifest) => Promise<void>;

package/dist/storage/filesystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filesystem.d.ts","sourceRoot":"","sources":["../../src/storage/filesystem.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,aAAa,EAAE,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACrE,OAAO,EAAE,KAAK,cAAc,EAAwB,MAAM,uBAAuB,CAAC;AAElF,OAAO,EAAE,aAAa,EAAE,CAAC;AACzB,eAAO,MAAM,oBAAoB,6BAA8B,CAAC;AAChE,eAAO,MAAM,oBAAoB,QAAS,CAAC;AAC3C,KAAK,mBAAmB,GAAG;IACvB,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/C,CAAC;AAaF,MAAM,MAAM,WAAW,GAAG;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,MAAM,CAAC;IAClD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,MAAM,CAAC;IAClD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;IACxC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,4BAA4B,EAAE,MAAM,CAAC;IAC9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,eAAe,MAAM,KAAG,WAkB1D,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAU,eAAe,MAAM,KAAG,OAAO,CAAC,WAAW,CAYxF,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,UAAU,MAAM,EAAE,MAAM,mBAAmB,GAAG,IAAI,SAOxF,CAAC;AAoBF,eAAO,MAAM,mBAAmB,GAAU,UAAU,MAAM,EAAE,MAAM,MAAM,kBAiBvE,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAU,UAAU,MAAM,EAAE,OAAO,OAAO,kBAEzE,CAAC;AAoCF,eAAO,MAAM,YAAY,GAAU,eAAe,MAAM,KAAG,OAAO,CAAC,cAAc,CAmBhF,CAAC;AAEF,eAAO,MAAM,YAAY,GAAU,eAAe,MAAM,EAAE,UAAU,cAAc,kBASjF,CAAC;AAoFF,eAAO,MAAM,qBAAqB,GAAU,eAAe,MAAM,kBAIhE,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAU,eAAe,MAAM,EAAE,OAAO,WAAW,KAAG,OAAO,CAAC,MAAM,EAAE,CAOzG,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,eAAe,MAAM,EAAE,OAAO,WAAW,EAAE,UAAU,MAAM,oBAGnG,CAAC;AAEF,eAAO,MAAM,cAAc,GAAU,eAAe,MAAM,EAAE,OAAO,WAAW,EAAE,UAAU,MAAM,EAAE,OAAO,OAAO,oBAK/G,CAAC"}
+{"version":3,"file":"filesystem.d.ts","sourceRoot":"","sources":["../../src/storage/filesystem.ts"],"names":[],"mappings":"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"}