@exaudeus/workrail 0.9.0 → 0.10.0

package/dist/manifest.json

@@ -881,6 +881,14 @@
       "sha256": "f329b3749ee778224555e6d4eadfed232ddb216a3348ff8b69984a0ee2bf6e6c",
       "bytes": 1042
     },
+    "v2/durable-core/ids/with-healthy-session-lock.d.ts": {
+      "sha256": "dc1812850b9ce69c0135d575b0994ac4fa7b874bf9db7a1838b6a3390ef31ae2",
+      "bytes": 320
+    },
+    "v2/durable-core/ids/with-healthy-session-lock.js": {
+      "sha256": "d43aa81f5bc89faa359e0f97c814ba25155591ff078fbb9bfd40f8c7c9683230",
+      "bytes": 77
+    },
     "v2/durable-core/schemas/compiled-workflow/index.d.ts": {
       "sha256": "caab753a39b7abc1e3c52bfd2fca93402a8a1b11c2ef13aaf5c2c0a86f7ba135",
       "bytes": 1171
@@ -890,16 +898,16 @@
       "bytes": 621
     },
     "v2/durable-core/schemas/session/events.d.ts": {
-      "sha256": "9e76fa1f16a30799f79b609434bff483e71203115e81c741d39c251dacf8254f",
-      "bytes": 61807
+      "sha256": "8de8d8904b67ca93d985c1e215f216d929612fb14357888f88ff270f6ac3c40f",
+      "bytes": 61834
     },
     "v2/durable-core/schemas/session/events.js": {
-      "sha256": "5647ebba23a5421457bd66611253a51ace9adb67020557cb08d8066e19dc7670",
-      "bytes": 14796
+      "sha256": "411228cda7ef149d25413c668e858d5691810cff8e6ce64913bf8e0cb1cfda2a",
+      "bytes": 15007
     },
     "v2/durable-core/schemas/session/index.d.ts": {
-      "sha256": "a005aad0fcd3cd5c7134f834c4dc49e01ac2672945ef7e38324fc8fc4f024751",
-      "bytes": 179
+      "sha256": "f4f500d33d212760f480d91fafd4474f7b12f9239a6c5e9c2d80d0fe96207b65",
+      "bytes": 259
     },
     "v2/durable-core/schemas/session/index.js": {
       "sha256": "0a3d9ba129a52c33d7e01f4366e15956b637ca5de327c6c8deb449c91bac0e92",
@@ -913,6 +921,14 @@
       "sha256": "735b3f6cbc7e266e882812b359754268c5eca7102f698fbe0fcb49f57f599cd3",
       "bytes": 1237
     },
+    "v2/durable-core/schemas/session/session-health.d.ts": {
+      "sha256": "33e927808b1b6a1f31de141289493b1359ec12943873a8fc970e0fe33775f263",
+      "bytes": 665
+    },
+    "v2/durable-core/schemas/session/session-health.js": {
+      "sha256": "d43aa81f5bc89faa359e0f97c814ba25155591ff078fbb9bfd40f8c7c9683230",
+      "bytes": 77
+    },
     "v2/infra/local/crypto/index.d.ts": {
       "sha256": "d2f6cc8e812bd4fb5c83e59f46c4b5588baa1bf33c029239d8162f8669a64370",
       "bytes": 279
@@ -954,12 +970,12 @@
       "bytes": 1640
     },
     "v2/infra/local/session-store/index.d.ts": {
-      "sha256": "74b5492e4d87f40883fad6bfad2e8fb60a0f4897dc51d84e09071600df6115e9",
-      "bytes": 1229
+      "sha256": "bd6a47ede5fc58a72b18031d57bd7357d4657f11d06aee2c2d08391be51b213d",
+      "bytes": 1467
     },
     "v2/infra/local/session-store/index.js": {
-      "sha256": "66512ea01106dab9f208870c54522322d7705cc26cbcfbfd9d623302935445dd",
-      "bytes": 16065
+      "sha256": "3b844370c4cff55b53dd18401eec7e14fb5e5c34d7b851650eb6dfb81fc97b77",
+      "bytes": 21855
     },
     "v2/infra/local/sha256/index.d.ts": {
       "sha256": "8a727b7e54a38275ca6f9f1b8730f97cfc0a212df035df1bdc58e716e6824230",
@@ -994,8 +1010,8 @@
       "bytes": 77
     },
     "v2/ports/session-event-log-store.port.d.ts": {
-      "sha256": "ccc7cf95569aa03c96d88982c21c55078f2fc7b72d1911870b0db595fa299e00",
-      "bytes": 1368
+      "sha256": "ffd5706ab752e9264c394b4960ea821fc96838b4111a38c9fb223972f568f45a",
+      "bytes": 1991
     },
     "v2/ports/session-event-log-store.port.js": {
       "sha256": "d43aa81f5bc89faa359e0f97c814ba25155591ff078fbb9bfd40f8c7c9683230",
@@ -1074,12 +1090,12 @@
       "bytes": 2315
     },
     "v2/projections/session-health.d.ts": {
-      "sha256": "06dc992814e11965cbfe337c65253cb21ddea6efe0301ad818dfe21d03463c4d",
-      "bytes": 621
+      "sha256": "0a7096bfc0d32eea9743c34a0b982e32f7eeec9e63ec7af10e27ec21be246630",
+      "bytes": 327
     },
     "v2/projections/session-health.js": {
-      "sha256": "b1f13d193fdbe2fdd97c7786412666d33e8e57d762e8ee105bda7647384920ea",
-      "bytes": 573
+      "sha256": "56d9fbed93ce1fa71ba8ab39f5fa49c4b221936dfec9339c15bd5aca2b4c878e",
+      "bytes": 550
     },
     "v2/read-only/v1-to-v2-shim.d.ts": {
       "sha256": "bc778fe2034ce1691eb089ed9415fcd162dcddfc4a9f95106200b7822d15a22c",
@@ -1088,6 +1104,14 @@
     "v2/read-only/v1-to-v2-shim.js": {
       "sha256": "e88caca3921758d1ed3806c9cb7d4ea35cc3f32689fbead2f2c96101fbbfc6e9",
       "bytes": 1498
+    },
+    "v2/usecases/execution-session-gate.d.ts": {
+      "sha256": "30ea073d1728abf3b71ae8c501c3fa6ecd26fde16074719349f875342ac29fdd",
+      "bytes": 2038
+    },
+    "v2/usecases/execution-session-gate.js": {
+      "sha256": "d7d6430b622e45d31d38bd71c6f7c914d2c3b4f6ebf68a0368d6d372867031e9",
+      "bytes": 7606
     }
   }
 }

package/dist/v2/durable-core/ids/with-healthy-session-lock.d.ts

@@ -0,0 +1,7 @@
+import type { SessionLockHandleV2 } from '../../ports/session-lock.port.js';
+declare const withHealthySessionLockBrand: unique symbol;
+export type WithHealthySessionLock = SessionLockHandleV2 & {
+    readonly assertHeld: () => boolean;
+    readonly [withHealthySessionLockBrand]: 'WithHealthySessionLock';
+};
+export {};

package/dist/v2/durable-core/ids/with-healthy-session-lock.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/v2/durable-core/schemas/session/events.d.ts

@@ -281,12 +281,12 @@ export declare const DomainEventV1Schema: z.ZodDiscriminatedUnion<"kind", [z.Zod
         nodeKind: z.ZodEnum<["step", "checkpoint"]>;
         parentNodeId: z.ZodNullable<z.ZodString>;
         workflowHash: z.ZodString;
-        snapshotRef: z.ZodString;
+        snapshotRef: z.ZodEffects<z.ZodString, never, string>;
     }, "strip", z.ZodTypeAny, {
         workflowHash: string;
         nodeKind: "step" | "checkpoint";
         parentNodeId: string | null;
-        snapshotRef: string;
+        snapshotRef: never;
     }, {
         workflowHash: string;
         nodeKind: "step" | "checkpoint";
@@ -300,7 +300,7 @@ export declare const DomainEventV1Schema: z.ZodDiscriminatedUnion<"kind", [z.Zod
         workflowHash: string;
         nodeKind: "step" | "checkpoint";
         parentNodeId: string | null;
-        snapshotRef: string;
+        snapshotRef: never;
     };
     v: 1;
     eventId: string;

package/dist/v2/durable-core/schemas/session/events.js

@@ -3,10 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DomainEventV1Schema = exports.DomainEventEnvelopeV1Schema = void 0;
 const zod_1 = require("zod");
 const json_zod_js_1 = require("../../canonical/json-zod.js");
+const index_js_1 = require("../../ids/index.js");
 const sha256DigestSchema = zod_1.z
     .string()
     .regex(/^sha256:[0-9a-f]{64}$/, 'Expected sha256:<64 hex chars>')
     .describe('sha256 digest in WorkRail v2 format');
+const snapshotRefSchema = sha256DigestSchema
+    .transform((v) => (0, index_js_1.asSnapshotRef)((0, index_js_1.asSha256Digest)(v)))
+    .describe('SnapshotRef (content-addressed sha256 ref)');
 exports.DomainEventEnvelopeV1Schema = zod_1.z.object({
     v: zod_1.z.literal(1),
     eventId: zod_1.z.string().min(1),
@@ -34,7 +38,7 @@ const NodeCreatedDataV1Schema = zod_1.z.object({
     nodeKind: NodeKindSchema,
     parentNodeId: zod_1.z.string().min(1).nullable(),
     workflowHash: sha256DigestSchema,
-    snapshotRef: sha256DigestSchema,
+    snapshotRef: snapshotRefSchema,
 });
 const EdgeKindSchema = zod_1.z.enum(['acked_step', 'checkpoint']);
 const EdgeCauseKindSchema = zod_1.z.enum(['idempotent_replay', 'intentional_fork', 'non_tip_advance', 'checkpoint_created']);
@@ -114,14 +118,14 @@ const BlockerReportV1Schema = zod_1.z
     .superRefine((v, ctx) => {
     const keyFor = (b) => {
         const p = b.pointer;
-        const ptrStable = b.pointer.kind === 'context_key'
+        const ptrStable = p.kind === 'context_key'
             ? p.key
-            : b.pointer.kind === 'output_contract'
+            : p.kind === 'output_contract'
                 ? p.contractRef
-                : b.pointer.kind === 'capability'
+                : p.kind === 'capability'
                     ? p.capability
                     : p.stepId;
-        return `${b.code}|${b.pointer.kind}|${String(ptrStable)}`;
+        return `${b.code}|${p.kind}|${String(ptrStable)}`;
     };
     for (let i = 1; i < v.blockers.length; i++) {
         if (keyFor(v.blockers[i - 1]) > keyFor(v.blockers[i])) {

package/dist/v2/durable-core/schemas/session/index.d.ts

@@ -1,2 +1,3 @@
 export { ManifestRecordV1Schema, type ManifestRecordV1 } from './manifest.js';
 export { DomainEventEnvelopeV1Schema, DomainEventV1Schema, type DomainEventV1 } from './events.js';
+export type { CorruptionReasonV2, SessionHealthV2 } from './session-health.js';

package/dist/v2/durable-core/schemas/session/session-health.d.ts

@@ -0,0 +1,25 @@
+export type CorruptionReasonV2 = {
+    readonly code: 'digest_mismatch';
+    readonly message: string;
+} | {
+    readonly code: 'non_contiguous_indices';
+    readonly message: string;
+} | {
+    readonly code: 'missing_attested_segment';
+    readonly message: string;
+} | {
+    readonly code: 'unknown_schema_version';
+    readonly message: string;
+};
+export type SessionHealthV2 = {
+    readonly kind: 'healthy';
+} | {
+    readonly kind: 'corrupt_tail';
+    readonly reason: CorruptionReasonV2;
+} | {
+    readonly kind: 'corrupt_head';
+    readonly reason: CorruptionReasonV2;
+} | {
+    readonly kind: 'unknown_version';
+    readonly reason: CorruptionReasonV2;
+};

package/dist/v2/durable-core/schemas/session/session-health.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/v2/infra/local/session-store/index.d.ts

@@ -2,20 +2,21 @@ import type { ResultAsync } from 'neverthrow';
 import type { DataDirPortV2 } from '../../../ports/data-dir.port.js';
 import type { FileSystemPortV2 } from '../../../ports/fs.port.js';
 import type { Sha256PortV2 } from '../../../ports/sha256.port.js';
-import type { SessionLockPortV2 } from '../../../ports/session-lock.port.js';
-import type { AppendPlanV2, SessionEventLogStoreError, LoadedSessionTruthV2, SessionEventLogStorePortV2 } from '../../../ports/session-event-log-store.port.js';
+import type { AppendPlanV2, LoadedValidatedPrefixV2, SessionEventLogStoreError, LoadedSessionTruthV2, SessionEventLogAppendStorePortV2, SessionEventLogReadonlyStorePortV2 } from '../../../ports/session-event-log-store.port.js';
 import type { SessionId } from '../../../durable-core/ids/index.js';
-export declare class LocalSessionEventLogStoreV2 implements SessionEventLogStorePortV2 {
+import type { WithHealthySessionLock } from '../../../durable-core/ids/with-healthy-session-lock.js';
+export declare class LocalSessionEventLogStoreV2 implements SessionEventLogReadonlyStorePortV2, SessionEventLogAppendStorePortV2 {
     private readonly dataDir;
     private readonly fs;
     private readonly sha256;
-    private readonly lock;
-    constructor(dataDir: DataDirPortV2, fs: FileSystemPortV2, sha256: Sha256PortV2, lock: SessionLockPortV2);
-    append(sessionId: SessionId, plan: AppendPlanV2): ResultAsync<void, SessionEventLogStoreError>;
+    constructor(dataDir: DataDirPortV2, fs: FileSystemPortV2, sha256: Sha256PortV2);
+    append(lock: WithHealthySessionLock, plan: AppendPlanV2): ResultAsync<void, SessionEventLogStoreError>;
     load(sessionId: SessionId): ResultAsync<LoadedSessionTruthV2, SessionEventLogStoreError>;
+    loadValidatedPrefix(sessionId: SessionId): ResultAsync<LoadedValidatedPrefixV2, SessionEventLogStoreError>;
     private appendImpl;
     private loadImpl;
     private readManifestOrEmpty;
+    private loadValidatedPrefixImpl;
     private loadTruthOrEmpty;
     private appendManifestRecords;
     private unwrap;

package/dist/v2/infra/local/session-store/index.js

@@ -11,14 +11,19 @@ class StoreFailure extends Error {
     }
 }
 class LocalSessionEventLogStoreV2 {
-    constructor(dataDir, fs, sha256, lock) {
+    constructor(dataDir, fs, sha256) {
         this.dataDir = dataDir;
         this.fs = fs;
         this.sha256 = sha256;
-        this.lock = lock;
     }
-    append(sessionId, plan) {
-        return neverthrow_1.ResultAsync.fromPromise(this.appendImpl(sessionId, plan), (e) => {
+    append(lock, plan) {
+        if (!lock.assertHeld()) {
+            return (0, neverthrow_1.errAsync)({
+                code: 'SESSION_STORE_INVARIANT_VIOLATION',
+                message: 'WithHealthySessionLock used after gate callback ended (witness misuse-after-release)',
+            });
+        }
+        return neverthrow_1.ResultAsync.fromPromise(this.appendImpl(lock.sessionId, plan), (e) => {
             if (e instanceof StoreFailure)
                 return e.storeError;
             return { code: 'SESSION_STORE_IO_ERROR', message: e instanceof Error ? e.message : String(e) };
@@ -31,134 +36,148 @@ class LocalSessionEventLogStoreV2 {
             return { code: 'SESSION_STORE_IO_ERROR', message: e instanceof Error ? e.message : String(e) };
         });
     }
+    loadValidatedPrefix(sessionId) {
+        return neverthrow_1.ResultAsync.fromPromise(this.loadValidatedPrefixImpl(sessionId), (e) => {
+            if (e instanceof StoreFailure)
+                return e.storeError;
+            return { code: 'SESSION_STORE_IO_ERROR', message: e instanceof Error ? e.message : String(e) };
+        });
+    }
     async appendImpl(sessionId, plan) {
-        const lockHandle = await this.unwrap(this.lock.acquire(sessionId), mapLockError);
-        try {
-            const sessionDir = this.dataDir.sessionDir(sessionId);
-            const eventsDir = this.dataDir.sessionEventsDir(sessionId);
-            const manifestPath = this.dataDir.sessionManifestPath(sessionId);
-            await this.unwrap(this.fs.mkdirp(eventsDir), mapFsToStoreError);
-            const { manifest, events: existingEvents } = await this.loadTruthOrEmpty(sessionId);
-            validateManifestContiguityOrThrow(manifest);
-            const existingByDedupeKey = new Set(existingEvents.map((e) => e.dedupeKey));
-            const allExist = plan.events.every((e) => existingByDedupeKey.has(e.dedupeKey));
-            if (allExist) {
-                return;
-            }
-            const anyExist = plan.events.some((e) => existingByDedupeKey.has(e.dedupeKey));
-            if (anyExist && !allExist) {
-                throw new StoreFailure({
-                    code: 'SESSION_STORE_INVARIANT_VIOLATION',
-                    message: 'Partial dedupeKey collision detected (some events exist, some do not); this is an invariant violation',
-                });
-            }
-            const expectedFirstEventIndex = nextEventIndexFromManifest(manifest);
-            validateAppendPlanOrThrow(sessionId, plan, expectedFirstEventIndex);
-            const first = plan.events[0].eventIndex;
-            const last = plan.events[plan.events.length - 1].eventIndex;
-            const segmentRelPath = segmentRelPathFor(first, last);
-            const segmentPath = `${sessionDir}/${segmentRelPath}`;
-            const tmpPath = `${segmentPath}.tmp`;
-            const segmentBytes = concatJsonlRecords(plan.events);
-            const tmpHandle = await this.unwrap(this.fs.openWriteTruncate(tmpPath), mapFsToStoreError);
-            await this.unwrap(this.fs.writeAll(tmpHandle.fd, segmentBytes), mapFsToStoreError);
-            await this.unwrap(this.fs.fsyncFile(tmpHandle.fd), mapFsToStoreError);
-            await this.unwrap(this.fs.closeFile(tmpHandle.fd), mapFsToStoreError);
-            await this.unwrap(this.fs.rename(tmpPath, segmentPath), mapFsToStoreError);
-            await this.unwrap(this.fs.fsyncDir(eventsDir), mapFsToStoreError);
-            const digest = this.sha256.sha256(segmentBytes);
-            const segClosed = {
+        const sessionDir = this.dataDir.sessionDir(sessionId);
+        const eventsDir = this.dataDir.sessionEventsDir(sessionId);
+        const manifestPath = this.dataDir.sessionManifestPath(sessionId);
+        await this.unwrap(this.fs.mkdirp(eventsDir), mapFsToStoreError);
+        const { manifest, events: existingEvents } = await this.loadTruthOrEmpty(sessionId);
+        validateManifestContiguityOrThrow(manifest);
+        const existingByDedupeKey = new Set(existingEvents.map((e) => e.dedupeKey));
+        const allExist = plan.events.every((e) => existingByDedupeKey.has(e.dedupeKey));
+        if (allExist) {
+            return;
+        }
+        const anyExist = plan.events.some((e) => existingByDedupeKey.has(e.dedupeKey));
+        if (anyExist && !allExist) {
+            throw new StoreFailure({
+                code: 'SESSION_STORE_INVARIANT_VIOLATION',
+                message: 'Partial dedupeKey collision detected (some events exist, some do not); this is an invariant violation',
+            });
+        }
+        const expectedFirstEventIndex = nextEventIndexFromManifest(manifest);
+        validateAppendPlanOrThrow(sessionId, plan, expectedFirstEventIndex);
+        const first = plan.events[0].eventIndex;
+        const last = plan.events[plan.events.length - 1].eventIndex;
+        const segmentRelPath = segmentRelPathFor(first, last);
+        const segmentPath = `${sessionDir}/${segmentRelPath}`;
+        const tmpPath = `${segmentPath}.tmp`;
+        const segmentBytes = concatJsonlRecords(plan.events);
+        const tmpHandle = await this.unwrap(this.fs.openWriteTruncate(tmpPath), mapFsToStoreError);
+        await this.unwrap(this.fs.writeAll(tmpHandle.fd, segmentBytes), mapFsToStoreError);
+        await this.unwrap(this.fs.fsyncFile(tmpHandle.fd), mapFsToStoreError);
+        await this.unwrap(this.fs.closeFile(tmpHandle.fd), mapFsToStoreError);
+        await this.unwrap(this.fs.rename(tmpPath, segmentPath), mapFsToStoreError);
+        await this.unwrap(this.fs.fsyncDir(eventsDir), mapFsToStoreError);
+        const digest = this.sha256.sha256(segmentBytes);
+        const segClosed = {
+            v: 1,
+            manifestIndex: nextManifestIndex(manifest),
+            sessionId,
+            kind: 'segment_closed',
+            firstEventIndex: first,
+            lastEventIndex: last,
+            segmentRelPath,
+            sha256: digest,
+            bytes: segmentBytes.length,
+        };
+        await this.appendManifestRecords(manifestPath, [segClosed]);
+        const pins = sortedPins(plan.snapshotPins);
+        if (pins.length > 0) {
+            const startIndex = segClosed.manifestIndex + 1;
+            const records = pins.map((p, i) => ({
                 v: 1,
-                manifestIndex: nextManifestIndex(manifest),
+                manifestIndex: startIndex + i,
                 sessionId,
-                kind: 'segment_closed',
-                firstEventIndex: first,
-                lastEventIndex: last,
-                segmentRelPath,
-                sha256: digest,
-                bytes: segmentBytes.length,
-            };
-            await this.appendManifestRecords(manifestPath, [segClosed]);
-            const pins = sortedPins(plan.snapshotPins);
-            if (pins.length > 0) {
-                const startIndex = segClosed.manifestIndex + 1;
-                const records = pins.map((p, i) => ({
-                    v: 1,
-                    manifestIndex: startIndex + i,
-                    sessionId,
-                    kind: 'snapshot_pinned',
-                    eventIndex: p.eventIndex,
-                    snapshotRef: p.snapshotRef,
-                    createdByEventId: p.createdByEventId,
-                }));
-                await this.appendManifestRecords(manifestPath, records);
-            }
-        }
-        finally {
-            await this.lock.release(lockHandle).match(() => undefined, () => undefined);
+                kind: 'snapshot_pinned',
+                eventIndex: p.eventIndex,
+                snapshotRef: p.snapshotRef,
+                createdByEventId: p.createdByEventId,
+            }));
+            await this.appendManifestRecords(manifestPath, records);
         }
     }
     async loadImpl(sessionId) {
-        const lockHandle = await this.unwrap(this.lock.acquire(sessionId), mapLockError);
-        try {
-            const sessionDir = this.dataDir.sessionDir(sessionId);
-            const manifestPath = this.dataDir.sessionManifestPath(sessionId);
-            const manifest = await this.readManifestOrEmpty(sessionId);
-            validateManifestContiguityOrThrow(manifest);
-            validateSegmentClosedContiguityOrThrow(manifest);
-            const segments = manifest.filter((m) => m.kind === 'segment_closed');
-            const events = [];
-            for (const seg of segments) {
-                const segmentPath = `${sessionDir}/${seg.segmentRelPath}`;
-                const bytes = await this.unwrap(this.fs.readFileBytes(segmentPath), mapFsToStoreError);
-                const actual = this.sha256.sha256(bytes);
-                if (actual !== seg.sha256) {
-                    throw new StoreFailure({
-                        code: 'SESSION_STORE_CORRUPTION_DETECTED',
-                        message: `Segment digest mismatch: ${seg.segmentRelPath}`,
-                    });
-                }
-                const parsed = parseJsonlLines(bytes, index_js_1.DomainEventV1Schema);
-                if (parsed.length === 0) {
-                    throw new StoreFailure({
-                        code: 'SESSION_STORE_CORRUPTION_DETECTED',
-                        message: `Empty segment referenced by manifest: ${seg.segmentRelPath}`,
-                    });
-                }
-                if (parsed[0].eventIndex !== seg.firstEventIndex || parsed[parsed.length - 1].eventIndex !== seg.lastEventIndex) {
+        const sessionDir = this.dataDir.sessionDir(sessionId);
+        const manifest = await this.readManifestOrEmpty(sessionId);
+        validateManifestContiguityOrThrow(manifest);
+        validateSegmentClosedContiguityOrThrow(manifest);
+        const segments = manifest.filter((m) => m.kind === 'segment_closed');
+        const events = [];
+        for (const seg of segments) {
+            const segmentPath = `${sessionDir}/${seg.segmentRelPath}`;
+            const bytes = await this.fs.readFileBytes(segmentPath).match((v) => v, (e) => {
+                if (e.code === 'FS_NOT_FOUND') {
                     throw new StoreFailure({
                         code: 'SESSION_STORE_CORRUPTION_DETECTED',
-                        message: `Segment bounds mismatch: ${seg.segmentRelPath}`,
+                        location: 'tail',
+                        reason: { code: 'missing_attested_segment', message: `Missing attested segment: ${seg.segmentRelPath}` },
+                        message: `Missing attested segment: ${seg.segmentRelPath}`,
                     });
                 }
-                for (let i = 1; i < parsed.length; i++) {
-                    if (parsed[i].eventIndex !== parsed[i - 1].eventIndex + 1) {
-                        throw new StoreFailure({
-                            code: 'SESSION_STORE_CORRUPTION_DETECTED',
-                            message: `Non-contiguous eventIndex inside segment: ${seg.segmentRelPath}`,
-                        });
-                    }
-                }
-                events.push(...parsed);
+                throw new StoreFailure(mapFsToStoreError(e));
+            });
+            const actual = this.sha256.sha256(bytes);
+            if (actual !== seg.sha256) {
+                throw new StoreFailure({
+                    code: 'SESSION_STORE_CORRUPTION_DETECTED',
+                    location: 'tail',
+                    reason: { code: 'digest_mismatch', message: `Segment digest mismatch: ${seg.segmentRelPath}` },
+                    message: `Segment digest mismatch: ${seg.segmentRelPath}`,
+                });
+            }
+            const parsed = parseJsonlLines(bytes, index_js_1.DomainEventV1Schema);
+            if (parsed.length === 0) {
+                throw new StoreFailure({
+                    code: 'SESSION_STORE_CORRUPTION_DETECTED',
+                    location: 'tail',
+                    reason: { code: 'non_contiguous_indices', message: `Empty segment referenced by manifest: ${seg.segmentRelPath}` },
+                    message: `Empty segment referenced by manifest: ${seg.segmentRelPath}`,
+                });
+            }
+            if (parsed[0].eventIndex !== seg.firstEventIndex || parsed[parsed.length - 1].eventIndex !== seg.lastEventIndex) {
+                throw new StoreFailure({
+                    code: 'SESSION_STORE_CORRUPTION_DETECTED',
+                    location: 'tail',
+                    reason: { code: 'non_contiguous_indices', message: `Segment bounds mismatch: ${seg.segmentRelPath}` },
+                    message: `Segment bounds mismatch: ${seg.segmentRelPath}`,
+                });
             }
-            const expectedPins = extractSnapshotPinsFromEvents(events);
-            const actualPins = new Set(manifest
-                .filter((m) => m.kind === 'snapshot_pinned')
-                .map((p) => `${p.eventIndex}:${p.createdByEventId}:${p.snapshotRef}`));
-            for (const ep of expectedPins) {
-                const key = `${ep.eventIndex}:${ep.createdByEventId}:${ep.snapshotRef}`;
-                if (!actualPins.has(key)) {
+            for (let i = 1; i < parsed.length; i++) {
+                if (parsed[i].eventIndex !== parsed[i - 1].eventIndex + 1) {
                     throw new StoreFailure({
                         code: 'SESSION_STORE_CORRUPTION_DETECTED',
-                        message: `Missing snapshot_pinned for introduced snapshotRef (pin-after-close violation): ${key}`,
+                        location: 'tail',
+                        reason: { code: 'non_contiguous_indices', message: `Non-contiguous eventIndex inside segment: ${seg.segmentRelPath}` },
+                        message: `Non-contiguous eventIndex inside segment: ${seg.segmentRelPath}`,
                     });
                 }
             }
-            return { manifest, events };
+            events.push(...parsed);
         }
-        finally {
-            await this.lock.release(lockHandle).match(() => undefined, () => undefined);
+        const expectedPins = extractSnapshotPinsFromEvents(events);
+        const actualPins = new Set(manifest
+            .filter((m) => m.kind === 'snapshot_pinned')
+            .map((p) => `${p.eventIndex}:${p.createdByEventId}:${p.snapshotRef}`));
+        for (const ep of expectedPins) {
+            const key = `${ep.eventIndex}:${ep.createdByEventId}:${ep.snapshotRef}`;
+            if (!actualPins.has(key)) {
+                throw new StoreFailure({
+                    code: 'SESSION_STORE_CORRUPTION_DETECTED',
+                    location: 'tail',
+                    reason: { code: 'missing_attested_segment', message: `Missing snapshot_pinned for introduced snapshotRef: ${key}` },
+                    message: `Missing snapshot_pinned for introduced snapshotRef: ${key}`,
+                });
+            }
         }
+        return { manifest, events };
     }
     async readManifestOrEmpty(sessionId) {
         const manifestPath = this.dataDir.sessionManifestPath(sessionId);
@@ -171,6 +190,94 @@ class LocalSessionEventLogStoreV2 {
             return [];
         return parseJsonlText(raw, index_js_1.ManifestRecordV1Schema);
     }
+    async loadValidatedPrefixImpl(sessionId) {
+        const sessionDir = this.dataDir.sessionDir(sessionId);
+        const manifestPath = this.dataDir.sessionManifestPath(sessionId);
+        const raw = await this.fs.readFileUtf8(manifestPath).match((v) => v, (e) => {
+            if (e.code === 'FS_NOT_FOUND')
+                return '';
+            throw new StoreFailure(mapFsToStoreError(e));
+        });
+        if (raw.trim() === '')
+            return { truth: { manifest: [], events: [] }, isComplete: true, tailReason: null };
+        const lines = raw.split('\n').filter((l) => l.trim() !== '');
+        const manifest = [];
+        let isComplete = true;
+        let tailReason = null;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                isComplete = false;
+                tailReason = { code: 'non_contiguous_indices', message: 'Invalid JSON in manifest (corrupt tail)' };
+                break;
+            }
+            const validated = index_js_1.ManifestRecordV1Schema.safeParse(parsed);
+            if (!validated.success) {
+                isComplete = false;
+                tailReason = { code: 'unknown_schema_version', message: 'Unknown manifest schema version (corrupt tail)' };
+                break;
+            }
+            if (validated.data.manifestIndex !== i) {
+                isComplete = false;
+                tailReason = { code: 'non_contiguous_indices', message: 'Non-contiguous manifestIndex in prefix (corrupt tail)' };
+                break;
+            }
+            manifest.push(validated.data);
+        }
+        if (manifest.length === 0) {
+            throw new StoreFailure({
+                code: 'SESSION_STORE_CORRUPTION_DETECTED',
+                location: 'head',
+                reason: { code: 'non_contiguous_indices', message: 'No validated manifest prefix' },
+                message: 'No validated manifest prefix',
+            });
+        }
+        const segments = manifest.filter((m) => m.kind === 'segment_closed');
+        const events = [];
+        for (const seg of segments) {
+            const segmentPath = `${sessionDir}/${seg.segmentRelPath}`;
+            const bytes = await this.fs.readFileBytes(segmentPath).match((v) => v, (e) => {
+                if (e.code === 'FS_NOT_FOUND')
+                    return null;
+                throw new StoreFailure(mapFsToStoreError(e));
+            });
+            if (bytes === null) {
+                isComplete = false;
+                tailReason ?? (tailReason = { code: 'missing_attested_segment', message: `Missing attested segment: ${seg.segmentRelPath}` });
+                break;
+            }
+            const actual = this.sha256.sha256(bytes);
+            if (actual !== seg.sha256) {
+                isComplete = false;
+                tailReason ?? (tailReason = { code: 'digest_mismatch', message: `Segment digest mismatch: ${seg.segmentRelPath}` });
+                break;
+            }
+            const parsed = parseJsonlLines(bytes, index_js_1.DomainEventV1Schema);
+            if (parsed.length === 0) {
+                isComplete = false;
+                tailReason ?? (tailReason = { code: 'non_contiguous_indices', message: `Empty segment referenced by manifest: ${seg.segmentRelPath}` });
+                break;
+            }
+            if (parsed[0].eventIndex !== seg.firstEventIndex || parsed[parsed.length - 1].eventIndex !== seg.lastEventIndex) {
+                isComplete = false;
+                tailReason ?? (tailReason = { code: 'non_contiguous_indices', message: `Segment bounds mismatch: ${seg.segmentRelPath}` });
+                break;
+            }
+            for (let i = 1; i < parsed.length; i++) {
+                if (parsed[i].eventIndex !== parsed[i - 1].eventIndex + 1) {
+                    isComplete = false;
+                    tailReason ?? (tailReason = { code: 'non_contiguous_indices', message: `Non-contiguous eventIndex inside segment: ${seg.segmentRelPath}` });
+                    break;
+                }
+            }
+            events.push(...parsed);
+        }
+        return { truth: { manifest, events }, isComplete, tailReason };
+    }
     async loadTruthOrEmpty(sessionId) {
         const manifest = await this.readManifestOrEmpty(sessionId);
         if (manifest.length === 0)
@@ -200,12 +307,6 @@ class LocalSessionEventLogStoreV2 {
     }
 }
 exports.LocalSessionEventLogStoreV2 = LocalSessionEventLogStoreV2;
-function mapLockError(e) {
-    if (e.code === 'SESSION_LOCK_BUSY') {
-        return { code: 'SESSION_STORE_LOCK_BUSY', message: e.message, retry: e.retry };
-    }
-    return { code: 'SESSION_STORE_IO_ERROR', message: e.message };
-}
 function mapFsToStoreError(e) {
     return { code: 'SESSION_STORE_IO_ERROR', message: e.message };
 }
@@ -226,6 +327,11 @@ function validateManifestContiguityOrThrow(manifest) {
         if (manifest[i].manifestIndex !== expected) {
             throw new StoreFailure({
                 code: 'SESSION_STORE_CORRUPTION_DETECTED',
+                location: i === 0 ? 'head' : 'tail',
+                reason: {
+                    code: 'non_contiguous_indices',
+                    message: `Non-contiguous manifestIndex at position ${i} (expected ${expected}, got ${manifest[i].manifestIndex})`,
+                },
                 message: `Non-contiguous manifestIndex at position ${i} (expected ${expected}, got ${manifest[i].manifestIndex})`,
             });
         }
@@ -239,6 +345,11 @@ function validateSegmentClosedContiguityOrThrow(manifest) {
         if (cur.firstEventIndex !== prev.lastEventIndex + 1) {
             throw new StoreFailure({
                 code: 'SESSION_STORE_CORRUPTION_DETECTED',
+                location: 'tail',
+                reason: {
+                    code: 'non_contiguous_indices',
+                    message: `Non-contiguous segment_closed bounds (expected firstEventIndex=${prev.lastEventIndex + 1}, got ${cur.firstEventIndex})`,
+                },
                 message: `Non-contiguous segment_closed bounds (expected firstEventIndex=${prev.lastEventIndex + 1}, got ${cur.firstEventIndex})`,
             });
         }
@@ -327,11 +438,21 @@ function parseJsonlText(text, schema) {
             parsed = JSON.parse(raw);
         }
         catch {
-            throw new StoreFailure({ code: 'SESSION_STORE_CORRUPTION_DETECTED', message: `Invalid JSONL at line ${i}` });
+            throw new StoreFailure({
+                code: 'SESSION_STORE_CORRUPTION_DETECTED',
+                location: i === 0 ? 'head' : 'tail',
+                reason: { code: 'non_contiguous_indices', message: `Invalid JSONL at line ${i}` },
+                message: `Invalid JSONL at line ${i}`,
+            });
         }
         const validated = schema.safeParse(parsed);
         if (!validated.success) {
-            throw new StoreFailure({ code: 'SESSION_STORE_CORRUPTION_DETECTED', message: `Invalid record at line ${i}` });
+            throw new StoreFailure({
+                code: 'SESSION_STORE_CORRUPTION_DETECTED',
+                location: i === 0 ? 'head' : 'tail',
+                reason: { code: 'unknown_schema_version', message: `Invalid record at line ${i}` },
+                message: `Invalid record at line ${i}`,
+            });
         }
         out.push(validated.data);
     }
@@ -346,13 +467,7 @@ function extractSnapshotPinsFromEvents(events) {
     for (const e of events) {
         if (e.kind !== 'node_created')
             continue;
-        const data = e.data;
-        if (typeof data !== 'object' || data === null)
-            continue;
-        const snap = data.snapshotRef;
-        if (typeof snap === 'string') {
-            out.push({ snapshotRef: snap, eventIndex: e.eventIndex, createdByEventId: e.eventId });
-        }
+        out.push({ snapshotRef: e.data.snapshotRef, eventIndex: e.eventIndex, createdByEventId: e.eventId });
     }
     return out;
 }

package/dist/v2/ports/session-event-log-store.port.d.ts

@@ -1,6 +1,8 @@
 import type { ResultAsync } from 'neverthrow';
 import type { SessionId, SnapshotRef } from '../durable-core/ids/index.js';
 import type { DomainEventV1, ManifestRecordV1 } from '../durable-core/schemas/session/index.js';
+import type { WithHealthySessionLock } from '../durable-core/ids/with-healthy-session-lock.js';
+import type { CorruptionReasonV2 } from '../durable-core/schemas/session/session-health.js';
 export interface SnapshotPinV2 {
     readonly snapshotRef: SnapshotRef;
     readonly eventIndex: number;
@@ -23,6 +25,8 @@ export type SessionEventLogStoreError = {
 } | {
     readonly code: 'SESSION_STORE_CORRUPTION_DETECTED';
     readonly message: string;
+    readonly location: 'head' | 'tail';
+    readonly reason: CorruptionReasonV2;
 } | {
     readonly code: 'SESSION_STORE_INVARIANT_VIOLATION';
     readonly message: string;
@@ -31,7 +35,15 @@ export interface LoadedSessionTruthV2 {
     readonly manifest: readonly ManifestRecordV1[];
     readonly events: readonly DomainEventV1[];
 }
-export interface SessionEventLogStorePortV2 {
-    append(sessionId: SessionId, plan: AppendPlanV2): ResultAsync<void, SessionEventLogStoreError>;
+export type LoadedValidatedPrefixV2 = {
+    readonly truth: LoadedSessionTruthV2;
+    readonly isComplete: boolean;
+    readonly tailReason: CorruptionReasonV2 | null;
+};
+export interface SessionEventLogReadonlyStorePortV2 {
     load(sessionId: SessionId): ResultAsync<LoadedSessionTruthV2, SessionEventLogStoreError>;
+    loadValidatedPrefix(sessionId: SessionId): ResultAsync<LoadedValidatedPrefixV2, SessionEventLogStoreError>;
+}
+export interface SessionEventLogAppendStorePortV2 {
+    append(lock: WithHealthySessionLock, plan: AppendPlanV2): ResultAsync<void, SessionEventLogStoreError>;
 }

package/dist/v2/projections/session-health.d.ts

@@ -1,18 +1,4 @@
 import type { Result } from 'neverthrow';
 import type { LoadedSessionTruthV2 } from '../ports/session-event-log-store.port.js';
-export type SessionHealthV2 = {
-    readonly kind: 'healthy';
-} | {
-    readonly kind: 'corrupted';
-    readonly reason: {
-        readonly code: 'MANIFEST_INVALID';
-        readonly message: string;
-    } | {
-        readonly code: 'EVENT_LOG_INVALID';
-        readonly message: string;
-    } | {
-        readonly code: 'RUN_DAG_INVALID';
-        readonly message: string;
-    };
-};
+import type { SessionHealthV2 } from '../durable-core/schemas/session/session-health.js';
 export declare function projectSessionHealthV2(truth: LoadedSessionTruthV2): Result<SessionHealthV2, never>;

package/dist/v2/projections/session-health.js

@@ -6,10 +6,7 @@ const run_dag_js_1 = require("./run-dag.js");
 function projectSessionHealthV2(truth) {
     const dag = (0, run_dag_js_1.projectRunDagV2)(truth.events);
     if (dag.isErr()) {
-        return (0, neverthrow_1.ok)({
-            kind: 'corrupted',
-            reason: { code: 'RUN_DAG_INVALID', message: dag.error.message },
-        });
+        return (0, neverthrow_1.ok)({ kind: 'corrupt_tail', reason: { code: 'non_contiguous_indices', message: dag.error.message } });
     }
     return (0, neverthrow_1.ok)({ kind: 'healthy' });
 }

package/dist/v2/usecases/execution-session-gate.d.ts

@@ -0,0 +1,53 @@
+import type { ResultAsync } from 'neverthrow';
+import type { SessionId } from '../durable-core/ids/index.js';
+import type { WithHealthySessionLock } from '../durable-core/ids/with-healthy-session-lock.js';
+import type { SessionHealthV2 } from '../durable-core/schemas/session/session-health.js';
+import type { SessionLockPortV2 } from '../ports/session-lock.port.js';
+import type { SessionEventLogReadonlyStorePortV2, SessionEventLogStoreError } from '../ports/session-event-log-store.port.js';
+export type ExecutionSessionGateErrorV2 = {
+    readonly code: 'SESSION_LOCKED';
+    readonly message: string;
+    readonly sessionId: SessionId;
+    readonly retry: {
+        readonly kind: 'retryable';
+        readonly afterMs: number;
+    };
+} | {
+    readonly code: 'SESSION_LOCK_REENTRANT';
+    readonly message: string;
+    readonly sessionId: SessionId;
+} | {
+    readonly code: 'LOCK_ACQUIRE_FAILED';
+    readonly message: string;
+    readonly sessionId: SessionId;
+} | {
+    readonly code: 'LOCK_RELEASE_FAILED';
+    readonly message: string;
+    readonly sessionId: SessionId;
+    readonly retry: {
+        readonly kind: 'retryable';
+        readonly afterMs: number;
+    };
+} | {
+    readonly code: 'SESSION_NOT_HEALTHY';
+    readonly message: string;
+    readonly sessionId: SessionId;
+    readonly health: SessionHealthV2;
+} | {
+    readonly code: 'SESSION_LOAD_FAILED';
+    readonly message: string;
+    readonly sessionId: SessionId;
+    readonly cause: SessionEventLogStoreError;
+} | {
+    readonly code: 'GATE_CALLBACK_FAILED';
+    readonly message: string;
+    readonly sessionId: SessionId;
+};
+export declare class ExecutionSessionGateV2 {
+    private readonly lock;
+    private readonly store;
+    private readonly activeSessions;
+    private readonly activeWitnessTokens;
+    constructor(lock: SessionLockPortV2, store: SessionEventLogReadonlyStorePortV2);
+    withHealthySessionLock<T, E>(sessionId: SessionId, fn: (lock: WithHealthySessionLock) => ResultAsync<T, E>): ResultAsync<T, ExecutionSessionGateErrorV2 | E>;
+}

package/dist/v2/usecases/execution-session-gate.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionSessionGateV2 = void 0;
+const neverthrow_1 = require("neverthrow");
+const session_health_js_1 = require("../projections/session-health.js");
+class ExecutionSessionGateV2 {
+    constructor(lock, store) {
+        this.lock = lock;
+        this.store = store;
+        this.activeSessions = new Set();
+        this.activeWitnessTokens = new Set();
+    }
+    withHealthySessionLock(sessionId, fn) {
+        if (this.activeSessions.has(sessionId)) {
+            return (0, neverthrow_1.errAsync)({ code: 'SESSION_LOCK_REENTRANT', message: `Re-entrant gate call for session: ${sessionId}`, sessionId });
+        }
+        this.activeSessions.add(sessionId);
+        const witnessToken = Symbol(`withHealthySessionLock:${sessionId}`);
+        this.activeWitnessTokens.add(witnessToken);
+        const doWork = async () => {
+            const precheckResult = await this.store.loadValidatedPrefix(sessionId).match((v) => ({ kind: 'available', prefix: v }), (e) => {
+                if (e.code === 'SESSION_STORE_CORRUPTION_DETECTED') {
+                    const health = e.location === 'head'
+                        ? { kind: 'corrupt_head', reason: e.reason }
+                        : { kind: 'corrupt_tail', reason: e.reason };
+                    throw new GateFailure({
+                        code: 'SESSION_NOT_HEALTHY',
+                        message: 'Session is not healthy',
+                        sessionId,
+                        health,
+                    });
+                }
+                return { kind: 'unavailable' };
+            });
+            const pre = precheckResult.kind === 'available' ? precheckResult.prefix : null;
+            if (pre !== null) {
+                if (!pre.isComplete) {
+                    throw new GateFailure({
+                        code: 'SESSION_NOT_HEALTHY',
+                        message: 'Session is not healthy (validated prefix indicates corrupt tail)',
+                        sessionId,
+                        health: {
+                            kind: 'corrupt_tail',
+                            reason: pre.tailReason ?? { code: 'non_contiguous_indices', message: 'Validated prefix stopped early (corrupt tail)' },
+                        },
+                    });
+                }
+                const preHealth = (0, session_health_js_1.projectSessionHealthV2)(pre.truth).match((h) => h, () => ({ kind: 'corrupt_tail', reason: { code: 'non_contiguous_indices', message: 'unknown' } }));
+                if (preHealth.kind !== 'healthy') {
+                    throw new GateFailure({
+                        code: 'SESSION_NOT_HEALTHY',
+                        message: 'Session is not healthy',
+                        sessionId,
+                        health: preHealth,
+                    });
+                }
+            }
+            const handle = await this.lock.acquire(sessionId).match((h) => h, (e) => {
+                if (e.code === 'SESSION_LOCK_BUSY') {
+                    throw new GateFailure({
+                        code: 'SESSION_LOCKED',
+                        message: `Session is locked; retry in 1–3 seconds; if this persists >10s, ensure no other WorkRail process is running for this session.`,
+                        sessionId,
+                        retry: { kind: 'retryable', afterMs: 1000 },
+                    });
+                }
+                throw new GateFailure({ code: 'LOCK_ACQUIRE_FAILED', message: e.message, sessionId });
+            });
+            try {
+                const truth = await this.store.load(sessionId).match((v) => v, (e) => {
+                    if (e.code === 'SESSION_STORE_CORRUPTION_DETECTED') {
+                        const health = e.location === 'head'
+                            ? { kind: 'corrupt_head', reason: e.reason }
+                            : { kind: 'corrupt_tail', reason: e.reason };
+                        throw new GateFailure({
+                            code: 'SESSION_NOT_HEALTHY',
+                            message: 'Session is not healthy',
+                            sessionId,
+                            health,
+                        });
+                    }
+                    throw new GateFailure({
+                        code: 'SESSION_LOAD_FAILED',
+                        message: `Failed to load session`,
+                        sessionId,
+                        cause: e,
+                    });
+                });
+                const health = (0, session_health_js_1.projectSessionHealthV2)(truth).match((h) => h, () => {
+                    return { kind: 'corrupt_tail', reason: { code: 'non_contiguous_indices', message: 'unknown' } };
+                });
+                if (health.kind !== 'healthy') {
+                    throw new GateFailure({
+                        code: 'SESSION_NOT_HEALTHY',
+                        message: `Session is not healthy`,
+                        sessionId,
+                        health,
+                    });
+                }
+                const witness = {
+                    ...handle,
+                    assertHeld: () => this.activeWitnessTokens.has(witnessToken),
+                };
+                let callback;
+                try {
+                    callback = fn(witness);
+                }
+                catch (e) {
+                    throw new GateFailure({
+                        code: 'GATE_CALLBACK_FAILED',
+                        message: e instanceof Error ? e.message : String(e),
+                        sessionId,
+                    });
+                }
+                const res = await callback.match((v) => ({ ok: true, value: v }), (e) => ({ ok: false, error: e }));
+                if (!res.ok) {
+                    throw new GateFailure(res.error);
+                }
+                return res.value;
+            }
+            catch (e) {
+                if (e instanceof GateFailure)
+                    throw e;
+                throw new GateFailure({
+                    code: 'GATE_CALLBACK_FAILED',
+                    message: e instanceof Error ? e.message : String(e),
+                    sessionId,
+                });
+            }
+            finally {
+                await this.lock.release(handle).match(() => undefined, () => {
+                    throw new GateFailure({
+                        code: 'LOCK_RELEASE_FAILED',
+                        message: 'Failed to release session lock; retry in 1–3 seconds; if this persists >10s, ensure no other WorkRail process is running for this session.',
+                        sessionId,
+                        retry: { kind: 'retryable', afterMs: 1000 },
+                    });
+                });
+            }
+        };
+        return neverthrow_1.ResultAsync.fromPromise((async () => {
+            try {
+                return await doWork();
+            }
+            finally {
+                this.activeSessions.delete(sessionId);
+                this.activeWitnessTokens.delete(witnessToken);
+            }
+        })(), (e) => {
+            if (e instanceof GateFailure)
+                return e.error;
+            return {
+                code: 'GATE_CALLBACK_FAILED',
+                message: e instanceof Error ? e.message : String(e),
+                sessionId,
+            };
+        });
+    }
+}
+exports.ExecutionSessionGateV2 = ExecutionSessionGateV2;
+class GateFailure extends Error {
+    constructor(error) {
+        const msg = error?.message;
+        super(typeof msg === 'string' ? msg : 'GateFailure');
+        this.error = error;
+    }
+}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@exaudeus/workrail",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Step-by-step workflow enforcement for AI agents via MCP",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/EtienneBBeaulac/workrail.git"
+    "url": "git+https://github.com/EtienneBBeaulac/workrail.git"
   },
   "bugs": {
     "url": "https://github.com/EtienneBBeaulac/workrail/issues"