@exaudeus/workrail 1.3.0 → 1.5.0

package/dist/manifest.json

@@ -553,6 +553,14 @@
       "sha256": "d22e4b954022e82bf3017b5fca7101c0499f76fdad1efb86131f189bc9c4602b",
       "bytes": 22251
     },
+    "mcp/handlers/v2-checkpoint.d.ts": {
+      "sha256": "97e1d3ddcb5f92137312c6516b6c4ff2f18dec7a7a83657db30198aedd67e7e1",
+      "bytes": 259
+    },
+    "mcp/handlers/v2-checkpoint.js": {
+      "sha256": "20a8d8524bb64a641d4c82ecabadf70ba84c599636808ba4fe19d594d1f04b8c",
+      "bytes": 9123
+    },
     "mcp/handlers/v2-context-budget.d.ts": {
       "sha256": "cbad1741a183d52c9cbe558be2e09f776843d1f3ec8cd28d6d0d230668e4298c",
       "bytes": 674
@@ -582,8 +590,16 @@
       "bytes": 944
     },
     "mcp/handlers/v2-execution.js": {
-      "sha256": "dccf1b219b0962743cd53ef5c1fca00d356161df388b42524ddf7380ec1c371b",
-      "bytes": 48280
+      "sha256": "561e34c59e1640dd419644b1abc750b2750e8a99bce000abef593e5047badc23",
+      "bytes": 50334
+    },
+    "mcp/handlers/v2-resume.d.ts": {
+      "sha256": "d88f6c35bcaf946666c837b72fda3702a2ebab5e478eb90f7b4b672a0e5fa24f",
+      "bytes": 471
+    },
+    "mcp/handlers/v2-resume.js": {
+      "sha256": "b4ce6f9cc3dffef91ca7da2e428d659c4ff79ceaf984c87d672290215936db97",
+      "bytes": 2771
     },
     "mcp/handlers/v2-state-conversion.d.ts": {
       "sha256": "e8d70753ed1b83d9396864ef50929ba32cb008bda24bcb2ce624df24adb72570",
@@ -594,12 +610,12 @@
       "bytes": 5216
     },
     "mcp/handlers/v2-token-ops.d.ts": {
-      "sha256": "64b143576c2741497f393513bb2d04010f3754c8d066c47cbff5819d072f8eea",
-      "bytes": 1504
+      "sha256": "2101c6f44398909b045adf0904dcec10448bb0fd69d85eab352488ee752959e0",
+      "bytes": 1853
     },
     "mcp/handlers/v2-token-ops.js": {
-      "sha256": "27d5b08e3ce3ba984a8258cfbbede7e525039cbcde55a411c74f3c0fd60f91bf",
-      "bytes": 2851
+      "sha256": "c786c2a8de7240989b2368762552373a2c3d397edd47122144c51e31a22d6203",
+      "bytes": 3817
     },
     "mcp/handlers/v2-workflow.d.ts": {
       "sha256": "9fbd4d44854e2060c54982b21e72c608970bb2bd107bb15a8388b26c6b492e55",
@@ -626,20 +642,20 @@
       "bytes": 7535
     },
     "mcp/output-schemas.d.ts": {
-      "sha256": "2e26bc2e2f457dcd2325bbab67a19ce4ed81896eb87b0981094f68c76937f08c",
-      "bytes": 42678
+      "sha256": "f18366a180449212d9a2b280dc9706f4f96a77ccead38bf11035c3859121fd84",
+      "bytes": 45137
     },
     "mcp/output-schemas.js": {
-      "sha256": "11fbd471a6b56aa8df3c3d002e4d660da3d034b4fbab82871d810c1d25152283",
-      "bytes": 10346
+      "sha256": "e7aeb43d06950e4a9ed1fa4ecd56418dc7eb32f54453634701b5dc39456eb3e8",
+      "bytes": 11565
     },
     "mcp/server.d.ts": {
       "sha256": "bec49b8d07e189a53db7100d2f0e1e84ffe03150f04e1b06908ee3282982b4a2",
       "bytes": 168
     },
     "mcp/server.js": {
-      "sha256": "8c7afb047807dd5fcd461b813b7bc714ea375d0999dfe9a7c901bf1462798455",
-      "bytes": 9940
+      "sha256": "37ab570be76b379a4076e78e5bc82a06b7ee1fc73d3d5010ad48b5650e54365a",
+      "bytes": 10631
     },
     "mcp/tool-description-provider.d.ts": {
       "sha256": "1d46abc3112e11b68e57197e846f5708293ec9b2281fa71a9124ee2aad71e41b",
@@ -654,8 +670,8 @@
       "bytes": 132
     },
     "mcp/tool-descriptions.js": {
-      "sha256": "4a713e4cad3b59077c42d95c78b5a1b68b93830def6f0d39db4ed79562c8a6e3",
-      "bytes": 14568
+      "sha256": "76d25a3a2bba38227ad199c4d1240769b6b14411ebecf965e9e00eaac2f2e01c",
+      "bytes": 16389
     },
     "mcp/tool-factory.d.ts": {
       "sha256": "0fe3c6b863b2d7aef0c3d659ff54f3a9ee8a0a3c2005b6565d2f8ad517bc7211",
@@ -670,28 +686,28 @@
       "bytes": 5976
     },
     "mcp/tools.js": {
-      "sha256": "0af59932b32bad5ebc9cbc925279d325350c91b43085561d0d218035250b641a",
-      "bytes": 8020
+      "sha256": "aa364f3e613fc61a39fc7336a723231da06852d92ec7840a95327aa370e42e1c",
+      "bytes": 8360
     },
     "mcp/types.d.ts": {
-      "sha256": "9e29d5ae4ec1f80640f073f0d58b603158fe5b22897f44c1c77ed4abaef374f9",
-      "bytes": 3638
+      "sha256": "564136878ad3e71300d5e82913590b1f43d3dfbafab36479c9a590853cd07a0a",
+      "bytes": 4050
     },
     "mcp/types.js": {
       "sha256": "0c12576fd0053115ff096fe26b38f77f1e830b7ec4781aaf94564827c4c9e81a",
       "bytes": 1253
     },
     "mcp/types/tool-description-types.d.ts": {
-      "sha256": "7d0fb489a829f7d21ed0d3fe9cef221ff71b63619054070287bc790bf5142a28",
-      "bytes": 782
+      "sha256": "80984afa5283a0d651ff22c0c9b2d3ff14c85087aeaf735d306ae291d8cdfe4d",
+      "bytes": 823
     },
     "mcp/types/tool-description-types.js": {
-      "sha256": "a1c1fdd901bf6a074d9a48cef09e0020c59d9838bfb8754ed2aaf9c23191a533",
-      "bytes": 750
+      "sha256": "40c1e5f76edcbfbdf18f203dae2f295cce191b6af670436aeff5bc65d74d1a6b",
+      "bytes": 799
     },
     "mcp/types/workflow-tool-edition.d.ts": {
-      "sha256": "7407d318a9f0cc7d6dc81d7cb003e474b3a31a52bf3e600e07ee94f556e2555a",
-      "bytes": 1470
+      "sha256": "ebde63f0ea9de501946d75e050c9676c03d08b77b27ad858d88600249e480f6c",
+      "bytes": 1513
     },
     "mcp/types/workflow-tool-edition.js": {
       "sha256": "2dfd26acd3da2c249b728e7fc48c7eab3dc675f786e7689dbdeec53c25589369",
@@ -710,16 +726,16 @@
       "bytes": 408
     },
     "mcp/v2/tool-registry.js": {
-      "sha256": "8c94984fed94f049daeb01559a2490b7db6fedac2544b3e7e50a60b8c7dfa561",
-      "bytes": 2121
+      "sha256": "4b192604ddafd986416865041db7e395d205da6fa1d398bec07646900f6ce28c",
+      "bytes": 3078
     },
     "mcp/v2/tools.d.ts": {
-      "sha256": "a262c0c17ff9474f017ac1e83d4458c773791604ec4f344f777dcdbefff9318b",
-      "bytes": 3263
+      "sha256": "5da50237fcbce6240737441d134c8070256a23649b387d5c3438b41b2705905e",
+      "bytes": 4156
     },
     "mcp/v2/tools.js": {
-      "sha256": "00c6710f31a9cb42215a1427f48b3e22a1065996dfdaaaf4ae2389f3c23e9aa5",
-      "bytes": 5221
+      "sha256": "5c9b958f1a9eb609557ed5867fc9ea131a2a0a4aaf52ff05a38246dffe2b359d",
+      "bytes": 6435
     },
     "mcp/validation/bounded-json.d.ts": {
       "sha256": "82203ac6123d5c6989606c3b5405aaea99ab829c8958835f9ae3ba45b8bc8fd5",
@@ -1521,13 +1537,21 @@
       "sha256": "02d0ad7e3b8c615c6fa3fead6698664d282b2375ea3fc8bd563c12cc7853691c",
       "bytes": 3012
     },
+    "v2/infra/local/directory-listing/index.d.ts": {
+      "sha256": "18fd3d9d74c5541fe95f01be6dd276c6cf6ecf1426fcd0ad1e695d756d9ef93e",
+      "bytes": 429
+    },
+    "v2/infra/local/directory-listing/index.js": {
+      "sha256": "1930cb982b9034f46751a000011ea069b6e03becd898973afad4b74e6ebc1759",
+      "bytes": 566
+    },
     "v2/infra/local/fs/index.d.ts": {
-      "sha256": "d830aed74ebb3372ea5efa21ec96680cd188fc76dea6078286f5788b3736d2bf",
-      "bytes": 1252
+      "sha256": "fe3f06badea2d62e9ade3954f716d0b7aa4778c4d49e5fb9f6f58db6d2e9429a",
+      "bytes": 1323
     },
     "v2/infra/local/fs/index.js": {
-      "sha256": "97ce973a4bd48aa43e890fb18dc7b8c8b3f8451400539bf15b4c79f3680e2ba3",
-      "bytes": 7045
+      "sha256": "05fcd1345b3f003c19a13ee8db4ef657f23815c253e4fa36fa4bd7092f0a0b68",
+      "bytes": 7179
     },
     "v2/infra/local/hmac-sha256/index.d.ts": {
       "sha256": "dda3865510dfaf2f13947410d998da6ffecc9a2e728b3574f81e69d5db859815",
@@ -1585,6 +1609,14 @@
       "sha256": "53b9ee8545d99e23cfeecb12b39d202fc552c3e89de9fe71b5d1aaaf9afa6d95",
       "bytes": 29559
     },
+    "v2/infra/local/session-summary-provider/index.d.ts": {
+      "sha256": "8843c26694d12147c322a4ff1f220cef53774c1ea7087241cb6badd12a360fda",
+      "bytes": 1069
+    },
+    "v2/infra/local/session-summary-provider/index.js": {
+      "sha256": "d75b34ff09b4e5b0e4cd1b75b67c4efe643db0231afc919da54c29034c1c5c1d",
+      "bytes": 5566
+    },
     "v2/infra/local/sha256/index.d.ts": {
       "sha256": "8a727b7e54a38275ca6f9f1b8730f97cfc0a212df035df1bdc58e716e6824230",
       "bytes": 246
@@ -1657,9 +1689,17 @@
       "sha256": "d43aa81f5bc89faa359e0f97c814ba25155591ff078fbb9bfd40f8c7c9683230",
       "bytes": 77
     },
+    "v2/ports/directory-listing.port.d.ts": {
+      "sha256": "3184229b7793bbd3100611c6308d33a96145c4dc63ba451d8c29ff507084e7b4",
+      "bytes": 207
+    },
+    "v2/ports/directory-listing.port.js": {
+      "sha256": "d43aa81f5bc89faa359e0f97c814ba25155591ff078fbb9bfd40f8c7c9683230",
+      "bytes": 77
+    },
     "v2/ports/fs.port.d.ts": {
-      "sha256": "e752765aa1154de19c720590410a370c3ae485d73363dd66cf9cc17fcf75c103",
-      "bytes": 1534
+      "sha256": "e4d80716cbfe86352f9017480af31f21e25dfea97c7449b384fe64237bba961d",
+      "bytes": 1605
     },
     "v2/ports/fs.port.js": {
       "sha256": "d43aa81f5bc89faa359e0f97c814ba25155591ff078fbb9bfd40f8c7c9683230",
@@ -1713,6 +1753,14 @@
       "sha256": "d43aa81f5bc89faa359e0f97c814ba25155591ff078fbb9bfd40f8c7c9683230",
       "bytes": 77
     },
+    "v2/ports/session-summary-provider.port.d.ts": {
+      "sha256": "41861cb0e70ca81e0d931d9f504226c9c7361f59db21a8beab95c2b8ed13cb57",
+      "bytes": 400
+    },
+    "v2/ports/session-summary-provider.port.js": {
+      "sha256": "d43aa81f5bc89faa359e0f97c814ba25155591ff078fbb9bfd40f8c7c9683230",
+      "bytes": 77
+    },
     "v2/ports/sha256.port.d.ts": {
       "sha256": "2ca3e0558992a96614d005582e1f38435de4335df82f8231f69eabf191272022",
       "bytes": 145
@@ -1809,6 +1857,14 @@
       "sha256": "c8190e4899ba9695c7c7a9e58e872d4a56c90dcb4dfde659d6c2801a8cb895a7",
       "bytes": 732
     },
+    "v2/projections/resume-ranking.d.ts": {
+      "sha256": "50ef48d0b195f89f01c0051be453666e6a680e356ca9c328a754aced90ee8d7a",
+      "bytes": 2337
+    },
+    "v2/projections/resume-ranking.js": {
+      "sha256": "4253bd05c81e4b5a95b3472cca9ea3c2d7e9e28fdaabe95c984a1165ecc3a69c",
+      "bytes": 4232
+    },
     "v2/projections/run-context.d.ts": {
       "sha256": "7bdc4b2bacfb4b42005b7a83d7ddaf8a8d414bed90b948c02dbeeacd741b31cc",
       "bytes": 909
@@ -1849,6 +1905,14 @@
       "sha256": "6ea788b80605db6d2057b3d5e520be48ace8afe6d8f37bf55cef00ba1471a6b7",
       "bytes": 1935
     },
+    "v2/usecases/enumerate-sessions.d.ts": {
+      "sha256": "6043d64b45360dfc6a15b822d9f013a0832127596706bf81569dfce256236d2d",
+      "bytes": 499
+    },
+    "v2/usecases/enumerate-sessions.js": {
+      "sha256": "99e135a7c7411ce850c9dd89963ef6a05d3488078d6c6b2c540cb2d2043a2e89",
+      "bytes": 526
+    },
     "v2/usecases/execution-session-gate.d.ts": {
       "sha256": "339c4a8e02a77416e725e063a57d39a20788244498ae2c7a31dc48d111af6280",
       "bytes": 2084
@@ -1872,6 +1936,14 @@
     "v2/usecases/import-session.js": {
       "sha256": "9b9c8922cc2e6d6904f564c35ff0e402a2e755187f36ee7e54e76826f51bed5c",
       "bytes": 2788
+    },
+    "v2/usecases/resume-session.d.ts": {
+      "sha256": "02eec4908e02dc591bff06b0d38d686aad64719694fd353670b2b1d17d8f9543",
+      "bytes": 434
+    },
+    "v2/usecases/resume-session.js": {
+      "sha256": "db50776bbbd18f0a07c0c1b0d94689f78596d980824f4fe73f5cbe47a62d0d60",
+      "bytes": 393
     }
   }
 }

package/dist/mcp/handlers/v2-checkpoint.d.ts

@@ -0,0 +1,3 @@
+import type { ToolContext, ToolResult } from '../types.js';
+import type { V2CheckpointWorkflowInput } from '../v2/tools.js';
+export declare function handleV2CheckpointWorkflow(input: V2CheckpointWorkflowInput, ctx: ToolContext): Promise<ToolResult<unknown>>;

package/dist/mcp/handlers/v2-checkpoint.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleV2CheckpointWorkflow = handleV2CheckpointWorkflow;
+const neverthrow_1 = require("neverthrow");
+const types_js_1 = require("../types.js");
+const output_schemas_js_1 = require("../output-schemas.js");
+const v2_token_ops_js_1 = require("./v2-token-ops.js");
+const index_js_1 = require("../../v2/durable-core/ids/index.js");
+const workflow_hash_ref_js_1 = require("../../v2/durable-core/ids/workflow-hash-ref.js");
+const index_js_2 = require("../../v2/durable-core/schemas/session/index.js");
+function findNodeCreated(events, nodeId) {
+    return events.find((e) => e.kind === 'node_created' && e.scope?.nodeId === String(nodeId));
+}
+function mintStateTokenForNode(originalNode, sessionId, runId, nodeId, tokenCodecPorts) {
+    const wfRefRes = (0, workflow_hash_ref_js_1.deriveWorkflowHashRef)(originalNode.data.workflowHash);
+    if (wfRefRes.isErr()) {
+        return { ok: false, error: { kind: 'precondition_failed', message: 'Cannot derive workflowHashRef for stateToken.' } };
+    }
+    const stateTokenRes = (0, v2_token_ops_js_1.signTokenOrErr)({
+        payload: { tokenVersion: 1, tokenKind: 'state', sessionId, runId, nodeId, workflowHashRef: wfRefRes.value },
+        ports: tokenCodecPorts,
+    });
+    if (stateTokenRes.isErr()) {
+        return { ok: false, error: { kind: 'token_signing_failed', cause: stateTokenRes.error } };
+    }
+    return { ok: true, value: stateTokenRes.value };
+}
+function validateEvents(rawEvents) {
+    const validated = [];
+    for (const raw of rawEvents) {
+        const parsed = index_js_2.DomainEventV1Schema.safeParse(raw);
+        if (!parsed.success) {
+            return { issues: parsed.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join('; ') };
+        }
+        validated.push(parsed.data);
+    }
+    return validated;
+}
+function isGateError(e) {
+    return typeof e === 'object' && e !== null && 'code' in e && typeof e.code === 'string' && !('kind' in e);
+}
+async function handleV2CheckpointWorkflow(input, ctx) {
+    return executeCheckpoint(input, ctx).match((payload) => (0, types_js_1.success)(payload), (e) => mapCheckpointErrorToToolError(e));
+}
+function executeCheckpoint(input, ctx) {
+    if (!ctx.v2) {
+        return (0, neverthrow_1.errAsync)({ kind: 'precondition_failed', message: 'v2 tools disabled' });
+    }
+    const { gate, sessionStore, tokenCodecPorts, idFactory } = ctx.v2;
+    if (!tokenCodecPorts) {
+        return (0, neverthrow_1.errAsync)({ kind: 'precondition_failed', message: 'v2 context missing tokenCodecPorts' });
+    }
+    if (!idFactory) {
+        return (0, neverthrow_1.errAsync)({ kind: 'precondition_failed', message: 'v2 context missing idFactory' });
+    }
+    const tokenRes = (0, v2_token_ops_js_1.parseCheckpointTokenOrFail)(input.checkpointToken, tokenCodecPorts);
+    if (!tokenRes.ok) {
+        return (0, neverthrow_1.errAsync)({ kind: 'validation_failed', failure: tokenRes.failure });
+    }
+    const token = tokenRes.token;
+    const sessionId = (0, index_js_1.asSessionId)(String(token.payload.sessionId));
+    const runId = (0, index_js_1.asRunId)(String(token.payload.runId));
+    const nodeId = (0, index_js_1.asNodeId)(String(token.payload.nodeId));
+    const attemptId = (0, index_js_1.asAttemptId)(String(token.payload.attemptId));
+    const dedupeKey = `checkpoint:${String(sessionId)}:${String(runId)}:${String(nodeId)}:${String(attemptId)}`;
+    return gate.withHealthySessionLock(sessionId, (lock) => {
+        return sessionStore.load(sessionId)
+            .mapErr((cause) => ({ kind: 'store_failed', cause }))
+            .andThen((truth) => {
+            const originalNode = findNodeCreated(truth.events, nodeId);
+            if (!originalNode) {
+                return (0, neverthrow_1.errAsync)({ kind: 'missing_node_or_run' });
+            }
+            const alreadyRecorded = truth.events.some((e) => e.dedupeKey === dedupeKey);
+            if (alreadyRecorded) {
+                return replayCheckpoint(truth.events, dedupeKey, originalNode, sessionId, runId, nodeId, tokenCodecPorts);
+            }
+            return writeCheckpoint(truth, dedupeKey, originalNode, sessionId, runId, nodeId, idFactory.mintNodeId(), () => idFactory.mintEventId(), lock, sessionStore, tokenCodecPorts);
+        });
+    }).mapErr((gateErr) => {
+        if (isGateError(gateErr)) {
+            return { kind: 'gate_failed', cause: gateErr };
+        }
+        return gateErr;
+    });
+}
+function replayCheckpoint(events, dedupeKey, originalNode, sessionId, runId, nodeId, tokenCodecPorts) {
+    const existingCheckpointNode = events.find((e) => e.kind === 'node_created' && e.dedupeKey === `checkpoint_node:${dedupeKey}`);
+    const checkpointNodeId = existingCheckpointNode
+        ? String(existingCheckpointNode.scope?.nodeId ?? 'unknown')
+        : 'unknown';
+    const tokenResult = mintStateTokenForNode(originalNode, sessionId, runId, nodeId, tokenCodecPorts);
+    if (!tokenResult.ok)
+        return (0, neverthrow_1.errAsync)(tokenResult.error);
+    return (0, neverthrow_1.okAsync)(output_schemas_js_1.V2CheckpointWorkflowOutputSchema.parse({
+        checkpointNodeId,
+        stateToken: tokenResult.value,
+    }));
+}
+function writeCheckpoint(truth, dedupeKey, originalNode, sessionId, runId, nodeId, checkpointNodeId, mintEventId, lock, sessionStore, tokenCodecPorts) {
+    const nodeCreatedEventId = mintEventId();
+    const edgeCreatedEventId = mintEventId();
+    const rawEvents = [
+        {
+            v: 1,
+            eventId: nodeCreatedEventId,
+            eventIndex: truth.events.length,
+            sessionId: String(sessionId),
+            kind: 'node_created',
+            dedupeKey: `checkpoint_node:${dedupeKey}`,
+            scope: { runId: String(runId), nodeId: String(checkpointNodeId) },
+            data: {
+                nodeKind: 'checkpoint',
+                parentNodeId: String(nodeId),
+                workflowHash: originalNode.data.workflowHash,
+                snapshotRef: originalNode.data.snapshotRef,
+            },
+        },
+        {
+            v: 1,
+            eventId: edgeCreatedEventId,
+            eventIndex: truth.events.length + 1,
+            sessionId: String(sessionId),
+            kind: 'edge_created',
+            dedupeKey,
+            scope: { runId: String(runId) },
+            data: {
+                edgeKind: 'checkpoint',
+                fromNodeId: String(nodeId),
+                toNodeId: String(checkpointNodeId),
+                cause: {
+                    kind: 'checkpoint_created',
+                    eventId: String(nodeCreatedEventId),
+                },
+            },
+        },
+    ];
+    const validated = validateEvents(rawEvents);
+    if ('issues' in validated) {
+        return (0, neverthrow_1.errAsync)({ kind: 'event_schema_invalid', issues: validated.issues });
+    }
+    const snapshotPins = [{
+            snapshotRef: originalNode.data.snapshotRef,
+            eventIndex: truth.events.length,
+            createdByEventId: nodeCreatedEventId,
+        }];
+    return sessionStore.append(lock, { events: validated, snapshotPins })
+        .mapErr((cause) => ({ kind: 'store_failed', cause }))
+        .andThen(() => {
+        const tokenResult = mintStateTokenForNode(originalNode, sessionId, runId, nodeId, tokenCodecPorts);
+        if (!tokenResult.ok)
+            return (0, neverthrow_1.errAsync)(tokenResult.error);
+        return (0, neverthrow_1.okAsync)(output_schemas_js_1.V2CheckpointWorkflowOutputSchema.parse({
+            checkpointNodeId: String(checkpointNodeId),
+            stateToken: tokenResult.value,
+        }));
+    });
+}
+function mapCheckpointErrorToToolError(e) {
+    switch (e.kind) {
+        case 'precondition_failed':
+            return (0, types_js_1.errNotRetryable)('PRECONDITION_FAILED', e.message);
+        case 'token_signing_failed':
+            return (0, types_js_1.errNotRetryable)('INTERNAL_ERROR', 'Failed to sign token.');
+        case 'validation_failed':
+            return e.failure;
+        case 'missing_node_or_run':
+            return (0, types_js_1.errNotRetryable)('TOKEN_UNKNOWN_NODE', 'No durable node state found for this checkpointToken. Use a checkpointToken returned by WorkRail.');
+        case 'event_schema_invalid':
+            return (0, types_js_1.errNotRetryable)('INTERNAL_ERROR', `Checkpoint events failed schema validation: ${e.issues}`);
+        case 'gate_failed': {
+            const code = e.cause.code;
+            if (code === 'SESSION_LOCKED' || code === 'SESSION_LOCK_REENTRANT') {
+                return (0, types_js_1.errNotRetryable)('TOKEN_SESSION_LOCKED', `Session is locked: ${code}`);
+            }
+            if (code === 'SESSION_NOT_HEALTHY') {
+                return (0, types_js_1.errNotRetryable)('SESSION_NOT_HEALTHY', 'Session is not healthy.');
+            }
+            return (0, types_js_1.errNotRetryable)('INTERNAL_ERROR', `Session gate error: ${code}`);
+        }
+        case 'store_failed':
+            return (0, types_js_1.errNotRetryable)('INTERNAL_ERROR', `Session store error: ${e.cause.code}`);
+    }
+}

package/dist/mcp/handlers/v2-execution.js

@@ -70,10 +70,17 @@ function replayFromRecordedAdvance(args) {
                 : null;
             const preferences = (0, v2_state_conversion_js_1.derivePreferencesForNode)({ truth, runId, nodeId });
             const nextIntent = (0, v2_state_conversion_js_1.deriveNextIntent)({ rehydrateOnly: false, isComplete: isCompleteNow, pending: meta });
+            const replayCheckpointTokenRes = pendingNow
+                ? (0, v2_token_ops_js_1.signTokenOrErr)({
+                    payload: { tokenVersion: 1, tokenKind: 'checkpoint', sessionId, runId, nodeId, attemptId },
+                    ports: tokenCodecPorts,
+                })
+                : (0, neverthrow_1.ok)(undefined);
             return output_schemas_js_1.V2ContinueWorkflowOutputSchema.parse({
                 kind: 'blocked',
                 stateToken: inputStateToken,
                 ackToken: inputAckToken,
+                checkpointToken: replayCheckpointTokenRes.isOk() ? replayCheckpointTokenRes.value : undefined,
                 isComplete: isCompleteNow,
                 pending: meta ? { stepId: meta.stepId, title: meta.title, prompt: meta.prompt } : null,
                 preferences,
@@ -119,6 +126,15 @@ function replayFromRecordedAdvance(args) {
         if (nextAckTokenRes.isErr()) {
             return (0, neverthrow_1.errAsync)({ kind: 'token_signing_failed', cause: nextAckTokenRes.error });
         }
+        const nextCheckpointTokenRes = pending
+            ? (0, v2_token_ops_js_1.signTokenOrErr)({
+                payload: { tokenVersion: 1, tokenKind: 'checkpoint', sessionId, runId, nodeId: toNodeIdBranded, attemptId: nextAttemptId },
+                ports: tokenCodecPorts,
+            })
+            : (0, neverthrow_1.ok)(undefined);
+        if (nextCheckpointTokenRes.isErr()) {
+            return (0, neverthrow_1.errAsync)({ kind: 'token_signing_failed', cause: nextCheckpointTokenRes.error });
+        }
         const wfRefRes = (0, workflow_hash_ref_js_1.deriveWorkflowHashRef)(workflowHash);
         if (wfRefRes.isErr()) {
             return (0, neverthrow_1.errAsync)({ kind: 'precondition_failed', message: wfRefRes.error.message, suggestion: 'Ensure workflowHash is a valid sha256 digest.' });
@@ -173,6 +189,7 @@ function replayFromRecordedAdvance(args) {
                 kind: 'blocked',
                 stateToken: nextStateTokenRes.value,
                 ackToken: pending ? nextAckTokenRes.value : undefined,
+                checkpointToken: pending ? nextCheckpointTokenRes.value : undefined,
                 isComplete,
                 pending: meta ? { stepId: meta.stepId, title: meta.title, prompt: meta.prompt } : null,
                 preferences,
@@ -206,6 +223,7 @@ function replayFromRecordedAdvance(args) {
             kind: 'ok',
             stateToken: nextStateTokenRes.value,
             ackToken: pending ? nextAckTokenRes.value : undefined,
+            checkpointToken: pending ? nextCheckpointTokenRes.value : undefined,
             isComplete,
             pending: pending ? { stepId: meta.stepId, title: meta.title, prompt: meta.prompt } : null,
             preferences,
@@ -508,6 +526,12 @@ function executeStartWorkflow(input, ctx) {
         const ackToken = (0, v2_token_ops_js_1.signTokenOrErr)({ payload: ackPayload, ports: tokenCodecPorts });
         if (ackToken.isErr())
             return (0, neverthrow_1.errAsync)({ kind: 'token_signing_failed', cause: ackToken.error });
+        const checkpointToken = (0, v2_token_ops_js_1.signTokenOrErr)({
+            payload: { tokenVersion: 1, tokenKind: 'checkpoint', sessionId, runId, nodeId, attemptId },
+            ports: tokenCodecPorts,
+        });
+        if (checkpointToken.isErr())
+            return (0, neverthrow_1.errAsync)({ kind: 'token_signing_failed', cause: checkpointToken.error });
         const metaRes = (0, prompt_renderer_js_1.renderPendingPrompt)({
             workflow: pinnedWorkflow,
             stepId: firstStep.id,
@@ -529,6 +553,7 @@ function executeStartWorkflow(input, ctx) {
         return (0, neverthrow_1.okAsync)(output_schemas_js_1.V2StartWorkflowOutputSchema.parse({
             stateToken: stateToken.value,
             ackToken: ackToken.value,
+            checkpointToken: checkpointToken.value,
             isComplete: false,
             pending,
             preferences,
@@ -647,6 +672,12 @@ function executeContinueWorkflow(input, ctx) {
                 });
                 if (ackTokenRes.isErr())
                     return (0, neverthrow_1.errAsync)({ kind: 'token_signing_failed', cause: ackTokenRes.error });
+                const checkpointTokenRes = (0, v2_token_ops_js_1.signTokenOrErr)({
+                    payload: { tokenVersion: 1, tokenKind: 'checkpoint', sessionId, runId, nodeId, attemptId },
+                    ports: tokenCodecPorts,
+                });
+                if (checkpointTokenRes.isErr())
+                    return (0, neverthrow_1.errAsync)({ kind: 'token_signing_failed', cause: checkpointTokenRes.error });
                 return pinnedStore.get(workflowHash)
                     .mapErr((cause) => ({ kind: 'pinned_workflow_store_failed', cause }))
                     .andThen((pinned) => {
@@ -685,6 +716,7 @@ function executeContinueWorkflow(input, ctx) {
                         kind: 'ok',
                         stateToken: input.stateToken,
                         ackToken: ackTokenRes.value,
+                        checkpointToken: checkpointTokenRes.value,
                         isComplete,
                         pending: { stepId: meta.stepId, title: meta.title, prompt: meta.prompt },
                         preferences,

package/dist/mcp/handlers/v2-resume.d.ts

@@ -0,0 +1,8 @@
+import type { z } from 'zod';
+import type { V2ResumeSessionInput } from '../v2/tools.js';
+import type { ToolContext, ToolResult } from '../types.js';
+import { V2ResumeSessionOutputSchema } from '../output-schemas.js';
+type ResumeInput = z.infer<typeof V2ResumeSessionInput>;
+type ResumeOutput = z.infer<typeof V2ResumeSessionOutputSchema>;
+export declare function handleV2ResumeSession(input: ResumeInput, ctx: ToolContext): Promise<ToolResult<ResumeOutput>>;
+export {};

package/dist/mcp/handlers/v2-resume.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleV2ResumeSession = handleV2ResumeSession;
+const types_js_1 = require("../types.js");
+const output_schemas_js_1 = require("../output-schemas.js");
+const v2_token_ops_js_1 = require("./v2-token-ops.js");
+const index_js_1 = require("../../v2/durable-core/ids/index.js");
+const resume_session_js_1 = require("../../v2/usecases/resume-session.js");
+function anchorValue(anchors, key) {
+    const anchor = anchors.find((a) => a.key === key);
+    return anchor?.value;
+}
+async function handleV2ResumeSession(input, ctx) {
+    const v2 = ctx.v2;
+    if (!v2) {
+        return (0, types_js_1.errNotRetryable)('INTERNAL_ERROR', 'v2 dependencies not available');
+    }
+    if (!v2.sessionSummaryProvider) {
+        return (0, types_js_1.errNotRetryable)('INTERNAL_ERROR', 'resume_session requires sessionSummaryProvider port');
+    }
+    let anchors = [];
+    if (v2.workspaceAnchor) {
+        const anchorRes = await v2.workspaceAnchor.resolveAnchors();
+        if (anchorRes.isOk()) {
+            anchors = anchorRes.value;
+        }
+    }
+    const query = {
+        gitHeadSha: input.gitHeadSha ?? anchorValue(anchors, 'git_head_sha'),
+        gitBranch: input.gitBranch ?? anchorValue(anchors, 'git_branch'),
+        freeTextQuery: input.query,
+    };
+    const resumeResult = await (0, resume_session_js_1.resumeSession)(query, v2.sessionSummaryProvider);
+    if (resumeResult.isErr()) {
+        return (0, types_js_1.errNotRetryable)('INTERNAL_ERROR', `Resume failed: ${resumeResult.error.message}`);
+    }
+    const candidates = resumeResult.value;
+    const outputCandidates = [];
+    for (const candidate of candidates) {
+        const stateTokenRes = (0, v2_token_ops_js_1.signTokenOrErr)({
+            payload: {
+                tokenVersion: 1,
+                tokenKind: 'state',
+                sessionId: candidate.sessionId,
+                runId: (0, index_js_1.asRunId)(candidate.runId),
+                nodeId: (0, index_js_1.asNodeId)(candidate.preferredTipNodeId),
+                workflowHashRef: (0, index_js_1.asWorkflowHashRef)(''),
+            },
+            ports: v2.tokenCodecPorts,
+        });
+        if (stateTokenRes.isErr()) {
+            continue;
+        }
+        outputCandidates.push({
+            sessionId: candidate.sessionId,
+            runId: candidate.runId,
+            stateToken: stateTokenRes.value,
+            snippet: candidate.snippet,
+            whyMatched: [...candidate.whyMatched],
+        });
+    }
+    const output = output_schemas_js_1.V2ResumeSessionOutputSchema.parse({
+        candidates: outputCandidates,
+        totalEligible: candidates.length,
+    });
+    return {
+        type: 'success',
+        data: output,
+    };
+}

package/dist/mcp/handlers/v2-token-ops.d.ts

@@ -9,6 +9,9 @@ export type StateTokenInput = ParsedTokenV1Binary & {
 export type AckTokenInput = ParsedTokenV1Binary & {
     readonly payload: import('../../v2/durable-core/tokens/payloads.js').AckTokenPayloadV1;
 };
+export type CheckpointTokenInput = ParsedTokenV1Binary & {
+    readonly payload: import('../../v2/durable-core/tokens/payloads.js').CheckpointTokenPayloadV1;
+};
 export declare function parseStateTokenOrFail(raw: string, ports: TokenCodecPorts): {
     ok: true;
     token: StateTokenInput;
@@ -23,6 +26,13 @@ export declare function parseAckTokenOrFail(raw: string, ports: TokenCodecPorts)
     ok: false;
     failure: ToolFailure;
 };
+export declare function parseCheckpointTokenOrFail(raw: string, ports: TokenCodecPorts): {
+    ok: true;
+    token: CheckpointTokenInput;
+} | {
+    ok: false;
+    failure: ToolFailure;
+};
 export declare function newAttemptId(idFactory: {
     readonly mintAttemptId: () => AttemptId;
 }): AttemptId;