ushman-ledger 1.2.1 → 1.3.0

package/dist/schema/entry-read.js

@@ -1,5 +1,5 @@
 import * as v from 'valibot';
-import { AgentPatchDiffSchema, ChangeLogFileChangeSchema, ChangeLogParityStatusSchema, ChangeLogSmokeResultSchema, ChangeLogSubkindSchema, ledgerEntryBaseEntries, NonEmptyTrimmedStringSchema, OperatorDecisionPayloadSchema, StripDecisionRevertedPayloadSchema, } from "./entry-core.js";
+import { AgentPatchDiffSchema, ChangeLogFileChangeSchema, ChangeLogParityStatusSchema, ChangeLogSmokeResultSchema, ChangeLogSubkindSchema, ledgerEntryBaseEntries, NonEmptyTrimmedStringSchema, OperatorDecisionPayloadSchema, StageWriteStageSchema, StripDecisionRevertedPayloadSchema, WorkspaceRelativePathSchema, } from "./entry-core.js";
 import { NoteSubkindSchema } from "./note.js";
 export const ToolInvocationEntrySchema = v.object({
     ...ledgerEntryBaseEntries,
@@ -8,6 +8,13 @@ export const ToolInvocationEntrySchema = v.object({
     exitCode: v.optional(v.pipe(v.number(), v.integer())),
     kind: v.literal('tool-invocation'),
 });
+export const StageWriteEntrySchema = v.object({
+    ...ledgerEntryBaseEntries,
+    filePath: WorkspaceRelativePathSchema,
+    kind: v.literal('stage-write'),
+    rationale: NonEmptyTrimmedStringSchema,
+    stage: StageWriteStageSchema,
+});
 const patchEntryEntries = {
     ...ledgerEntryBaseEntries,
     diff: AgentPatchDiffSchema,
@@ -80,6 +87,7 @@ export const ChangeLogEntrySchema = v.object({
 });
 export const LedgerEntrySchema = v.variant('kind', [
     ToolInvocationEntrySchema,
+    StageWriteEntrySchema,
     AgentPatchEntrySchema,
     OperatorPatchEntrySchema,
     OperatorDecisionEntrySchema,

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

@@ -25,6 +25,32 @@ export declare const ToolInvocationRecordSchema: v.ObjectSchema<{
     readonly phase: v.PicklistSchema<readonly ["capture", "intake", "seed", "vendor-extract", "cleanup", "parity", "characterize", "equiv", "analyze", "recover", "ship", "migration"], undefined>;
     readonly summary: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
 }, undefined>;
+export declare const StageWriteRecordSchema: v.ObjectSchema<{
+    readonly filePath: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.CheckAction<string, "Expected a normalized workspace-relative path.">]>;
+    readonly kind: v.LiteralSchema<"stage-write", undefined>;
+    readonly rationale: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+    readonly stage: v.PicklistSchema<readonly ["intake", "seed", "vendor-extract", "cleanup", "candidate-promotion"], undefined>;
+    readonly details: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
+    readonly emitter: v.ObjectSchema<{
+        readonly tool: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+        readonly user: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+        readonly version: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+    }, undefined>;
+    readonly idempotencyKey: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+    readonly links: v.OptionalSchema<v.ObjectWithRestSchema<{
+        readonly affectedFiles: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.CheckAction<string, "Expected a normalized workspace-relative path.">]>, undefined>, undefined>;
+        readonly blobs: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly briefId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly correctsLedgerId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly gitRef: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly idempotencyKey: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly stripDecisionId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly supersedesLedgerId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly validatorVerdictId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, v.UnknownSchema, undefined>, undefined>;
+    readonly phase: v.PicklistSchema<readonly ["capture", "intake", "seed", "vendor-extract", "cleanup", "parity", "characterize", "equiv", "analyze", "recover", "ship", "migration"], undefined>;
+    readonly summary: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+}, undefined>;
 export declare const AgentPatchRecordSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly agent: v.ObjectSchema<{
         readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
@@ -459,6 +485,31 @@ export declare const LedgerRecordSchema: v.VariantSchema<"kind", [v.ObjectSchema
     }, v.UnknownSchema, undefined>, undefined>;
     readonly phase: v.PicklistSchema<readonly ["capture", "intake", "seed", "vendor-extract", "cleanup", "parity", "characterize", "equiv", "analyze", "recover", "ship", "migration"], undefined>;
     readonly summary: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+}, undefined>, v.ObjectSchema<{
+    readonly filePath: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.CheckAction<string, "Expected a normalized workspace-relative path.">]>;
+    readonly kind: v.LiteralSchema<"stage-write", undefined>;
+    readonly rationale: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+    readonly stage: v.PicklistSchema<readonly ["intake", "seed", "vendor-extract", "cleanup", "candidate-promotion"], undefined>;
+    readonly details: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
+    readonly emitter: v.ObjectSchema<{
+        readonly tool: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+        readonly user: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+        readonly version: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+    }, undefined>;
+    readonly idempotencyKey: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+    readonly links: v.OptionalSchema<v.ObjectWithRestSchema<{
+        readonly affectedFiles: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.CheckAction<string, "Expected a normalized workspace-relative path.">]>, undefined>, undefined>;
+        readonly blobs: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly briefId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly correctsLedgerId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly gitRef: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly idempotencyKey: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly stripDecisionId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly supersedesLedgerId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly validatorVerdictId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, v.UnknownSchema, undefined>, undefined>;
+    readonly phase: v.PicklistSchema<readonly ["capture", "intake", "seed", "vendor-extract", "cleanup", "parity", "characterize", "equiv", "analyze", "recover", "ship", "migration"], undefined>;
+    readonly summary: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
 }, undefined>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly agent: v.ObjectSchema<{
         readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"entry-write.d.ts","sourceRoot":"","sources":["../../src/schema/entry-write.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAsC7B,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;aAMrC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;aAMjC,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kEAY7B,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,5 +1,5 @@
 import * as v from 'valibot';
-import { AgentPatchDiffSchema, ChangeLogFileChangeSchema, ChangeLogParityStatusSchema, ChangeLogSmokeResultSchema, ChangeLogSubkindSchema, NonEmptyTrimmedStringSchema, OperatorDecisionPayloadSchema, recordEntryBaseEntries, StripDecisionRevertedPayloadSchema, } from "./entry-core.js";
+import { AgentPatchDiffSchema, ChangeLogFileChangeSchema, ChangeLogParityStatusSchema, ChangeLogSmokeResultSchema, ChangeLogSubkindSchema, NonEmptyTrimmedStringSchema, OperatorDecisionPayloadSchema, recordEntryBaseEntries, StageWriteStageSchema, StripDecisionRevertedPayloadSchema, WorkspaceRelativePathSchema, } from "./entry-core.js";
 import { NoteSubkindSchema } from "./note.js";
 const validatePatchRecord = (value) => {
     const provided = [value.diff, value.diffPath, value.diffText].filter((entry) => Boolean(entry));
@@ -19,6 +19,13 @@ export const ToolInvocationRecordSchema = v.object({
     exitCode: v.optional(v.pipe(v.number(), v.integer())),
     kind: v.literal('tool-invocation'),
 });
+export const StageWriteRecordSchema = v.object({
+    ...recordEntryBaseEntries,
+    filePath: WorkspaceRelativePathSchema,
+    kind: v.literal('stage-write'),
+    rationale: NonEmptyTrimmedStringSchema,
+    stage: StageWriteStageSchema,
+});
 const patchRecordEntries = {
     ...recordEntryBaseEntries,
     diff: v.optional(AgentPatchDiffSchema),
@@ -93,6 +100,7 @@ export const ChangeLogRecordSchema = v.pipe(v.object({
 }), v.check((value) => value.subkind !== 'rollback' || Boolean(value.rollsBack), 'change-log rollback records require rollsBack'));
 export const LedgerRecordSchema = v.variant('kind', [
     ToolInvocationRecordSchema,
+    StageWriteRecordSchema,
     AgentPatchRecordSchema,
     OperatorPatchRecordSchema,
     OperatorDecisionRecordSchema,

package/dist/storage/filesystem.d.ts

@@ -5,13 +5,25 @@ 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;
 };
+type AtomicTempFileRegistration = {
+    readonly remove: () => Promise<void>;
+};
+type AtomicWriteOptions = {
+    readonly registerTempFile?: (context: {
+        readonly finalPath: string;
+        readonly tempPath: string;
+    }) => Promise<AtomicTempFileRegistration>;
+};
 export type LedgerPaths = {
     readonly blobsDir: string;
+    readonly externalTempFilesDir: string;
     readonly lockFile: (phase: LedgerPhase) => string;
     readonly manifestLockFile: string;
     readonly manifestFile: string;
+    readonly pendingCommitQuarantineDir: string;
     readonly pendingCommitsDir: string;
     readonly pendingArchivesDir: string;
     readonly phaseDir: (phase: LedgerPhase) => string;
@@ -31,9 +43,10 @@ export type AtomicTextFileWriter = {
 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 writeAtomicTextFile: (filePath: string, text: string, options?: AtomicWriteOptions) => Promise<void>;
+export declare const createAtomicTextFileWriter: (filePath: string, options?: AtomicWriteOptions) => Promise<AtomicTextFileWriter>;
 export declare const writeAtomicJsonFile: (filePath: string, value: unknown) => Promise<void>;
+export declare const createExternalTempFileRegistrar: (workspaceRoot: string) => NonNullable<AtomicWriteOptions["registerTempFile"]>;
 export declare const readManifest: (workspaceRoot: string) => Promise<LedgerManifest>;
 export declare const saveManifest: (workspaceRoot: string, manifest: LedgerManifest) => Promise<void>;
 export declare const cleanupStaleTempFiles: (workspaceRoot: string) => 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":"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"}
+{"version":3,"file":"filesystem.d.ts","sourceRoot":"","sources":["../../src/storage/filesystem.ts"],"names":[],"mappings":"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"}

package/dist/storage/filesystem.js

@@ -3,6 +3,7 @@ import { mkdir, open, readdir, readFile, rename, rm, stat } from 'node:fs/promis
 import path from 'node:path';
 import * as v from 'valibot';
 import { stableStringify } from "../json.js";
+import { isProcessAlive } from "../process.js";
 import { readLabManifestMin } from "../lab-min.js";
 import { LEDGER_PHASES } from "../schema/entry.js";
 import { LedgerManifestSchema } from "../schema/manifest.js";
@@ -35,13 +36,22 @@ const runAtomicWriteTestHook = async (filePath) => {
         throw error;
     }
 };
+const runAtomicWriteWriteTestHook = async (filePath) => {
+    const { hook } = getAtomicWriteTestHook(filePath);
+    if (!hook?.beforeWrite) {
+        return;
+    }
+    await hook.beforeWrite();
+};
 export const resolveLedgerPaths = (workspaceRoot) => {
     const root = path.join(workspaceRoot, ...LEDGER_ROOT_SEGMENTS);
     return {
         blobsDir: path.join(root, 'blobs'),
+        externalTempFilesDir: path.join(root, 'external-temp-files'),
         lockFile: (phase) => path.join(root, phase, '.lock'),
         manifestFile: path.join(root, 'manifest.json'),
         manifestLockFile: path.join(root, '.manifest.lock'),
+        pendingCommitQuarantineDir: path.join(root, 'pending-quarantine'),
         pendingArchivesDir: path.join(root, 'pending-archives'),
         pendingCommitsDir: path.join(root, 'pending'),
         phaseDir: (phase) => path.join(root, phase),
@@ -58,7 +68,9 @@ export const ensureLedgerDirectories = async (workspaceRoot) => {
     const paths = resolveLedgerPaths(workspaceRoot);
     await mkdir(paths.root, { recursive: true });
     await mkdir(paths.blobsDir, { recursive: true });
+    await mkdir(paths.externalTempFilesDir, { recursive: true });
     await mkdir(paths.pendingCommitsDir, { recursive: true });
+    await mkdir(paths.pendingCommitQuarantineDir, { recursive: true });
     await mkdir(paths.pendingArchivesDir, { recursive: true });
     await Promise.all(LEDGER_PHASES.map(async (phase) => {
         await mkdir(paths.phaseDir(phase), { recursive: true });
@@ -73,6 +85,36 @@ export const setAtomicWriteTestHook = (filePath, hook) => {
     }
     atomicWriteTestHooks.set(key, hook);
 };
+const withPrimaryErrorPreserved = (error, cleanupError) => {
+    if (error instanceof Error) {
+        const errorWithCause = error;
+        if (errorWithCause.cause === undefined) {
+            Object.defineProperty(errorWithCause, 'cause', {
+                configurable: true,
+                enumerable: false,
+                value: cleanupError,
+                writable: true,
+            });
+        }
+        return error;
+    }
+    return new Error(String(error), { cause: cleanupError });
+};
+const removeTempRegistration = async (tempRegistration) => {
+    if (!tempRegistration) {
+        return;
+    }
+    await tempRegistration.remove();
+};
+const throwWithTempRegistrationCleanup = async ({ error, tempRegistration, }) => {
+    try {
+        await removeTempRegistration(tempRegistration);
+    }
+    catch (cleanupError) {
+        throw withPrimaryErrorPreserved(error, cleanupError);
+    }
+    throw error;
+};
 const createManifest = async (workspaceRoot) => {
     const labManifest = await readLabManifestMin(workspaceRoot);
     const now = new Date().toISOString();
@@ -90,31 +132,75 @@ const createManifest = async (workspaceRoot) => {
         workspaceId: labManifest.workspaceId,
     });
 };
-export const writeAtomicTextFile = async (filePath, text) => {
+export const writeAtomicTextFile = async (filePath, text, options = {}) => {
     await mkdir(path.dirname(filePath), { recursive: true });
     const tempPath = `${filePath}.tmp.${process.pid}.${Date.now()}.${randomUUID()}`;
-    const handle = await open(tempPath, 'w');
+    const tempRegistration = await options.registerTempFile?.({ finalPath: filePath, tempPath });
+    let handle;
     try {
-        await handle.writeFile(text, 'utf8');
-        await handle.sync();
+        handle = await open(tempPath, 'w');
+    }
+    catch (error) {
+        await throwWithTempRegistrationCleanup({
+            error,
+            tempRegistration,
+        });
+    }
+    const fileHandle = handle;
+    if (!fileHandle) {
+        throw new Error(`Failed to open atomic temp file: ${tempPath}`);
+    }
+    let writeError;
+    try {
+        await fileHandle.writeFile(text, 'utf8');
+        await fileHandle.sync();
+    }
+    catch (error) {
+        writeError = error;
     }
     finally {
-        await handle.close();
+        await fileHandle.close();
+    }
+    if (writeError) {
+        await rm(tempPath, { force: true });
+        await throwWithTempRegistrationCleanup({
+            error: writeError,
+            tempRegistration,
+        });
     }
     await runAtomicWriteTestHook(filePath);
     try {
         await rename(tempPath, filePath);
+        await removeTempRegistration(tempRegistration);
     }
     catch (error) {
         await rm(tempPath, { force: true });
-        throw error;
+        await throwWithTempRegistrationCleanup({
+            error,
+            tempRegistration,
+        });
     }
 };
-export const createAtomicTextFileWriter = async (filePath) => {
+export const createAtomicTextFileWriter = async (filePath, options = {}) => {
     await mkdir(path.dirname(filePath), { recursive: true });
     const tempPath = `${filePath}.tmp.${process.pid}.${Date.now()}.${randomUUID()}`;
-    const handle = await open(tempPath, 'w');
+    const tempRegistration = await options.registerTempFile?.({ finalPath: filePath, tempPath });
+    let handle;
+    try {
+        handle = await open(tempPath, 'w');
+    }
+    catch (error) {
+        await throwWithTempRegistrationCleanup({
+            error,
+            tempRegistration,
+        });
+    }
+    const fileHandle = handle;
+    if (!fileHandle) {
+        throw new Error(`Failed to open atomic temp file: ${tempPath}`);
+    }
     let completed = false;
+    let pendingWriteError;
     let writeChain = Promise.resolve();
     const finalizeHandle = async () => {
         if (completed) {
@@ -125,34 +211,61 @@ export const createAtomicTextFileWriter = async (filePath) => {
     };
     const waitForWrites = async () => {
         await writeChain;
+        if (pendingWriteError) {
+            throw pendingWriteError;
+        }
     };
     return {
         abort: async () => {
             if (!(await finalizeHandle())) {
                 return;
             }
-            await waitForWrites();
-            await handle.close();
+            let writeError;
+            try {
+                await waitForWrites();
+            }
+            catch (error) {
+                writeError = error;
+            }
+            await fileHandle.close();
             await rm(tempPath, { force: true });
+            await throwWithTempRegistrationCleanup({
+                error: writeError,
+                tempRegistration,
+            });
         },
         close: async () => {
             if (!(await finalizeHandle())) {
                 return;
             }
-            await waitForWrites();
             try {
-                await handle.sync();
+                await waitForWrites();
+            }
+            catch (error) {
+                await fileHandle.close();
+                await rm(tempPath, { force: true });
+                await throwWithTempRegistrationCleanup({
+                    error,
+                    tempRegistration,
+                });
+            }
+            try {
+                await fileHandle.sync();
             }
             finally {
-                await handle.close();
+                await fileHandle.close();
             }
             await runAtomicWriteTestHook(filePath);
             try {
                 await rename(tempPath, filePath);
+                await removeTempRegistration(tempRegistration);
             }
             catch (error) {
                 await rm(tempPath, { force: true });
-                throw error;
+                await throwWithTempRegistrationCleanup({
+                    error,
+                    tempRegistration,
+                });
             }
         },
         write: async (chunk) => {
@@ -160,9 +273,12 @@ export const createAtomicTextFileWriter = async (filePath) => {
                 if (completed || chunk.length === 0) {
                     return;
                 }
-                await handle.writeFile(chunk, 'utf8');
+                await runAtomicWriteWriteTestHook(filePath);
+                await fileHandle.write(chunk, undefined, 'utf8');
+            });
+            writeChain = nextWrite.catch((error) => {
+                pendingWriteError ??= error;
             });
-            writeChain = nextWrite.then(() => undefined, () => undefined);
             await nextWrite;
         },
     };
@@ -170,6 +286,26 @@ export const createAtomicTextFileWriter = async (filePath) => {
 export const writeAtomicJsonFile = async (filePath, value) => {
     await writeAtomicTextFile(filePath, `${stableStringify(value, true)}\n`);
 };
+const EXTERNAL_TEMP_FILE_SCHEMA_VERSION = 'ushman-ledger-external-temp-file/v1';
+const ExternalTempFileRecordSchema = v.object({
+    createdAt: v.pipe(v.string(), v.isoTimestamp()),
+    finalPath: v.pipe(v.string(), v.minLength(1)),
+    schemaVersion: v.literal(EXTERNAL_TEMP_FILE_SCHEMA_VERSION),
+    tempPath: v.pipe(v.string(), v.minLength(1)),
+});
+export const createExternalTempFileRegistrar = (workspaceRoot) => async ({ finalPath, tempPath }) => {
+    const paths = await ensureLedgerDirectories(workspaceRoot);
+    const recordPath = path.join(paths.externalTempFilesDir, `${process.pid}.${Date.now()}.${randomUUID()}.json`);
+    await writeAtomicJsonFile(recordPath, v.parse(ExternalTempFileRecordSchema, {
+        createdAt: new Date().toISOString(),
+        finalPath: path.resolve(finalPath),
+        schemaVersion: EXTERNAL_TEMP_FILE_SCHEMA_VERSION,
+        tempPath: path.resolve(tempPath),
+    }));
+    return {
+        remove: async () => rm(recordPath, { force: true }),
+    };
+};
 const parseManifestText = (filePath, text) => {
     try {
         return v.parse(LedgerManifestSchema, JSON.parse(text));
@@ -238,22 +374,6 @@ const parseTempOwnerPid = (fileName) => {
     }
     return Number.parseInt(match[1], 10);
 };
-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;
-    }
-};
 const resolveFinalPathFromTemp = (filePath) => {
     const fileName = path.basename(filePath);
     const tempMarkerIndex = fileName.lastIndexOf('.tmp.');
@@ -274,10 +394,12 @@ const cleanupStaleTempFile = async (fullPath) => {
         throw error;
     }
     const ownerPid = parseTempOwnerPid(path.basename(fullPath));
-    if (Date.now() - fileStat.mtimeMs < LEDGER_STALE_TEMP_MS) {
-        return;
+    if (ownerPid !== null) {
+        if (isProcessAlive(ownerPid)) {
+            return;
+        }
     }
-    if (ownerPid !== null && isProcessAlive(ownerPid)) {
+    else if (Date.now() - fileStat.mtimeMs < LEDGER_STALE_TEMP_MS) {
         return;
     }
     const finalPath = resolveFinalPathFromTemp(fullPath);
@@ -295,6 +417,73 @@ const cleanupStaleTempFile = async (fullPath) => {
     }
     await rm(fullPath, { force: true });
 };
+const readExternalTempFileRecord = async (recordPath) => {
+    try {
+        const text = await readFile(recordPath, 'utf8');
+        return {
+            kind: 'valid',
+            record: v.parse(ExternalTempFileRecordSchema, JSON.parse(text)),
+        };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return {
+                kind: 'missing',
+            };
+        }
+        return {
+            kind: 'invalid',
+        };
+    }
+};
+const pathExists = async (filePath) => {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+};
+const isTrackedAtomicTempRecord = (record) => path.dirname(record.tempPath) === path.dirname(record.finalPath) &&
+    path.basename(record.tempPath).startsWith(`${path.basename(record.finalPath)}.tmp.`);
+const quarantineInvalidExternalTempRecord = async (recordPath) => {
+    const quarantinedPath = `${recordPath}.invalid.${Date.now()}.${randomUUID()}`;
+    try {
+        await rename(recordPath, quarantinedPath);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return;
+        }
+        throw error;
+    }
+};
+const cleanupTrackedExternalTempFile = async (recordPath) => {
+    const recordResult = await readExternalTempFileRecord(recordPath);
+    if (recordResult.kind === 'missing') {
+        return;
+    }
+    if (recordResult.kind === 'invalid') {
+        await quarantineInvalidExternalTempRecord(recordPath);
+        return;
+    }
+    if (!isTrackedAtomicTempRecord(recordResult.record)) {
+        await quarantineInvalidExternalTempRecord(recordPath);
+        return;
+    }
+    if (!(await pathExists(recordResult.record.tempPath))) {
+        await rm(recordPath, { force: true });
+        return;
+    }
+    await cleanupStaleTempFile(recordResult.record.tempPath);
+    if (!(await pathExists(recordResult.record.tempPath))) {
+        await rm(recordPath, { force: true });
+    }
+};
 const listLedgerTempFiles = async (root) => {
     const entries = await readdir(root, { withFileTypes: true });
     const tempFiles = [];
@@ -312,8 +501,16 @@ const listLedgerTempFiles = async (root) => {
 };
 export const cleanupStaleTempFiles = async (workspaceRoot) => {
     const paths = await ensureLedgerDirectories(workspaceRoot);
-    const tempFiles = await listLedgerTempFiles(paths.root);
-    await Promise.all(tempFiles.map(async (filePath) => cleanupStaleTempFile(filePath)));
+    const [tempFiles, externalTempRecords] = await Promise.all([
+        listLedgerTempFiles(paths.root),
+        readdir(paths.externalTempFilesDir, { withFileTypes: true }),
+    ]);
+    await Promise.all([
+        ...tempFiles.map(async (filePath) => cleanupStaleTempFile(filePath)),
+        ...externalTempRecords
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+            .map(async (entry) => cleanupTrackedExternalTempFile(path.join(paths.externalTempFilesDir, entry.name))),
+    ]);
 };
 export const readPhaseEntryFileNames = async (workspaceRoot, phase) => {
     const paths = await ensureLedgerDirectories(workspaceRoot);

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

@@ -1 +1 @@
-{"version":3,"file":"lock.d.ts","sourceRoot":"","sources":["../../src/storage/lock.ts"],"names":[],"mappings":"AAGA,KAAK,WAAW,GAAG;IACf,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,CAAC,EAAE;QACjB,QAAQ,CAAC,qBAAqB,CAAC,EAAE,CAAC,OAAO,EAAE;YAAE,QAAQ,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAA;SAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;KACtG,CAAC;IACF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC9B,CAAC;AAqLF,MAAM,MAAM,UAAU,GAAG;IACrB,QAAQ,CAAC,eAAe,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9C,QAAQ,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACzC,CAAC;AA+BF,eAAO,MAAM,WAAW,GAAU,UAAU,MAAM,EAAE,UAAS,OAAO,CAAC,WAAW,CAAM,KAAG,OAAO,CAAC,UAAU,CAgD1G,CAAC"}
+{"version":3,"file":"lock.d.ts","sourceRoot":"","sources":["../../src/storage/lock.ts"],"names":[],"mappings":"AAIA,KAAK,WAAW,GAAG;IACf,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,CAAC,EAAE;QACjB,QAAQ,CAAC,qBAAqB,CAAC,EAAE,CAAC,OAAO,EAAE;YAAE,QAAQ,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAA;SAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;KACtG,CAAC;IACF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC9B,CAAC;AAyMF,MAAM,MAAM,UAAU,GAAG;IACrB,QAAQ,CAAC,eAAe,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9C,QAAQ,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACzC,CAAC;AAkCF,eAAO,MAAM,WAAW,GAAU,UAAU,MAAM,EAAE,UAAS,OAAO,CAAC,WAAW,CAAM,KAAG,OAAO,CAAC,UAAU,CAgD1G,CAAC"}