@exaudeus/workrail 2.1.0 → 3.1.0

package/dist/mcp/handlers/v2-execution/continue-advance.d.ts

@@ -26,4 +26,6 @@ export declare function handleAdvanceIntent(args: {
         readonly mintEventId: () => string;
     };
     readonly sha256: Sha256PortV2;
+    readonly aliasStore: import('../../../v2/ports/token-alias-store.port.js').TokenAliasStorePortV2;
+    readonly entropy: import('../../../v2/ports/random-entropy.port.js').RandomEntropyPortV2;
 }): RA<z.infer<typeof V2ContinueWorkflowOutputSchema>, ContinueWorkflowError>;

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

@@ -11,7 +11,7 @@ const constants_js_1 = require("../../../v2/durable-core/constants.js");
 const replay_js_1 = require("./replay.js");
 const advance_js_1 = require("./advance.js");
 function handleAdvanceIntent(args) {
-    const { input, sessionId, runId, nodeId, attemptId, workflowHashRef, truth, gate, sessionStore, snapshotStore, pinnedStore, tokenCodecPorts, idFactory, sha256 } = args;
+    const { input, sessionId, runId, nodeId, attemptId, workflowHashRef, truth, gate, sessionStore, snapshotStore, pinnedStore, tokenCodecPorts, idFactory, sha256, aliasStore, entropy } = args;
     const dedupeKey = `advance_recorded:${sessionId}:${nodeId}:${attemptId}`;
     const runStarted = truth.events.find((e) => e.kind === constants_js_1.EVENT_KIND.RUN_STARTED && e.scope.runId === String(runId));
     if (!runStarted) {
@@ -85,12 +85,12 @@ function handleAdvanceIntent(args) {
                 nodeId,
                 workflowHash,
                 attemptId,
-                inputStateToken: input.stateToken,
-                inputAckToken: input.ackToken,
                 pinnedWorkflow,
                 snapshotStore,
                 sha256,
                 tokenCodecPorts,
+                aliasStore,
+                entropy,
             });
         }
         return gate
@@ -162,12 +162,12 @@ function handleAdvanceIntent(args) {
                 nodeId,
                 workflowHash,
                 attemptId,
-                inputStateToken: input.stateToken,
-                inputAckToken: input.ackToken,
                 pinnedWorkflow,
                 snapshotStore,
                 sha256,
                 tokenCodecPorts,
+                aliasStore,
+                entropy,
             });
         });
     });

package/dist/mcp/handlers/v2-execution/continue-rehydrate.d.ts

@@ -19,4 +19,6 @@ export declare function handleRehydrateIntent(args: {
     readonly idFactory: {
         readonly mintAttemptId: () => import('../../../v2/durable-core/tokens/index.js').AttemptId;
     };
+    readonly aliasStore: import('../../../v2/ports/token-alias-store.port.js').TokenAliasStorePortV2;
+    readonly entropy: import('../../../v2/ports/random-entropy.port.js').RandomEntropyPortV2;
 }): RA<z.infer<typeof V2ContinueWorkflowOutputSchema>, ContinueWorkflowError>;

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

@@ -16,7 +16,7 @@ const v2_state_conversion_js_1 = require("../v2-state-conversion.js");
 const constants_js_1 = require("../../../v2/durable-core/constants.js");
 const index_js_2 = require("./index.js");
 function handleRehydrateIntent(args) {
-    const { input, sessionId, runId, nodeId, workflowHashRef, truth, tokenCodecPorts, pinnedStore, snapshotStore, idFactory } = args;
+    const { input, sessionId, runId, nodeId, workflowHashRef, truth, tokenCodecPorts, pinnedStore, snapshotStore, idFactory, aliasStore, entropy } = args;
     const runStarted = truth.events.find((e) => e.kind === constants_js_1.EVENT_KIND.RUN_STARTED && e.scope.runId === String(runId));
     const workflowId = runStarted?.data.workflowId;
     if (!runStarted || typeof workflowId !== 'string' || workflowId.trim() === '') {
@@ -75,28 +75,24 @@ function handleRehydrateIntent(args) {
             const nextIntent = (0, v2_state_conversion_js_1.deriveNextIntent)({ rehydrateOnly: true, isComplete, pending: null });
             return (0, neverthrow_1.okAsync)(output_schemas_js_1.V2ContinueWorkflowOutputSchema.parse({
                 kind: 'ok',
-                stateToken: input.stateToken,
                 isComplete,
                 pending: null,
                 preferences,
                 nextIntent,
-                nextCall: (0, index_js_2.buildNextCall)({ stateToken: input.stateToken, ackToken: undefined, isComplete, pending: null }),
+                nextCall: null,
             }));
         }
         const attemptId = (0, v2_token_ops_js_1.newAttemptId)(idFactory);
-        const ackTokenRes = (0, v2_token_ops_js_1.signTokenOrErr)({
-            payload: { tokenVersion: 1, tokenKind: 'ack', sessionId, runId, nodeId, attemptId },
-            ports: tokenCodecPorts,
-        });
-        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)
+        const entryBase = {
+            sessionId: String(sessionId),
+            runId: String(runId),
+            nodeId: String(nodeId),
+            attemptId: String(attemptId),
+            workflowHashRef: String(workflowHashRef),
+        };
+        return (0, v2_token_ops_js_1.mintContinueAndCheckpointTokens)({ entry: entryBase, ports: tokenCodecPorts, aliasStore, entropy })
+            .mapErr((failure) => ({ kind: 'token_signing_failed', cause: failure }))
+            .andThen(({ continueToken: continueTokenValue, checkpointToken: checkpointTokenValue }) => pinnedStore.get(workflowHash)
             .mapErr((cause) => ({ kind: 'pinned_workflow_store_failed', cause }))
             .andThen((pinned) => {
             if (!pinned)
@@ -131,15 +127,14 @@ function handleRehydrateIntent(args) {
             const nextIntent = (0, v2_state_conversion_js_1.deriveNextIntent)({ rehydrateOnly: true, isComplete, pending: meta });
             return (0, neverthrow_1.okAsync)(output_schemas_js_1.V2ContinueWorkflowOutputSchema.parse({
                 kind: 'ok',
-                stateToken: input.stateToken,
-                ackToken: ackTokenRes.value,
-                checkpointToken: checkpointTokenRes.value,
+                continueToken: continueTokenValue,
+                checkpointToken: checkpointTokenValue,
                 isComplete,
-                pending: { stepId: meta.stepId, title: meta.title, prompt: meta.prompt },
+                pending: (0, output_schemas_js_1.toPendingStep)(meta),
                 preferences,
                 nextIntent,
-                nextCall: (0, index_js_2.buildNextCall)({ stateToken: input.stateToken, ackToken: ackTokenRes.value, isComplete, pending: meta }),
+                nextCall: (0, index_js_2.buildNextCall)({ continueToken: continueTokenValue, isComplete, pending: meta }),
             }));
-        });
+        }));
     });
 }

package/dist/mcp/handlers/v2-execution/index.d.ts

@@ -1,31 +1,24 @@
-import type { ToolContext, ToolResult } from '../../types.js';
+import type { ToolContext, ToolResult, V2ToolContext } from '../../types.js';
 import type { V2ContinueWorkflowInput, V2StartWorkflowInput } from '../../v2/tools.js';
-type NextCallAdvance = {
+import { V2ContinueWorkflowOutputSchema } from '../../output-schemas.js';
+import { ResultAsync as RA } from 'neverthrow';
+import { type ContinueWorkflowError } from '../v2-execution-helpers.js';
+import * as z from 'zod';
+type NextCallTemplate = {
     readonly tool: 'continue_workflow';
     readonly params: {
-        readonly intent: 'advance';
-        readonly stateToken: string;
-        readonly ackToken: string;
+        readonly continueToken: string;
     };
 };
-type NextCallRehydrate = {
-    readonly tool: 'continue_workflow';
-    readonly params: {
-        readonly intent: 'rehydrate';
-        readonly stateToken: string;
-    };
-};
-type NextCallTemplate = NextCallAdvance | NextCallRehydrate;
 export declare function buildNextCall(args: {
-    readonly stateToken: string;
-    readonly ackToken: string | undefined;
+    readonly continueToken?: string;
     readonly isComplete: boolean;
     readonly pending: {
         readonly stepId: string;
     } | null;
-    readonly retryable?: boolean;
-    readonly retryAckToken?: string;
+    readonly retryContinueToken?: string;
 }): NextCallTemplate | null;
 export declare function handleV2StartWorkflow(input: V2StartWorkflowInput, ctx: ToolContext): Promise<ToolResult<unknown>>;
 export declare function handleV2ContinueWorkflow(input: V2ContinueWorkflowInput, ctx: ToolContext): Promise<ToolResult<unknown>>;
+export declare function executeContinueWorkflow(input: V2ContinueWorkflowInput, ctx: V2ToolContext): RA<z.infer<typeof V2ContinueWorkflowOutputSchema>, ContinueWorkflowError>;
 export {};

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildNextCall = buildNextCall;
 exports.handleV2StartWorkflow = handleV2StartWorkflow;
 exports.handleV2ContinueWorkflow = handleV2ContinueWorkflow;
+exports.executeContinueWorkflow = executeContinueWorkflow;
 const types_js_1 = require("../../types.js");
 const index_js_1 = require("../../../v2/durable-core/tokens/index.js");
 const index_js_2 = require("../../../v2/durable-core/ids/index.js");
@@ -16,18 +17,13 @@ const continue_advance_js_1 = require("./continue-advance.js");
 function buildNextCall(args) {
     if (args.isComplete && !args.pending)
         return null;
-    if (args.retryable && args.retryAckToken) {
-        return {
-            tool: 'continue_workflow',
-            params: { intent: 'advance', stateToken: args.stateToken, ackToken: args.retryAckToken },
-        };
+    if (args.retryContinueToken) {
+        return { tool: 'continue_workflow', params: { continueToken: args.retryContinueToken } };
     }
-    if (!args.ackToken)
-        return null;
-    return {
-        tool: 'continue_workflow',
-        params: { intent: 'advance', stateToken: args.stateToken, ackToken: args.ackToken },
-    };
+    if (args.continueToken) {
+        return { tool: 'continue_workflow', params: { continueToken: args.continueToken } };
+    }
+    return null;
 }
 async function handleV2StartWorkflow(input, ctx) {
     const guard = (0, types_js_1.requireV2Context)(ctx);
@@ -42,61 +38,55 @@ async function handleV2ContinueWorkflow(input, ctx) {
     return executeContinueWorkflow(input, guard.ctx).match((payload) => (0, types_js_1.success)(payload), (e) => (0, v2_execution_helpers_js_1.mapContinueWorkflowErrorToToolError)(e));
 }
 function executeContinueWorkflow(input, ctx) {
-    const { gate, sessionStore, snapshotStore, pinnedStore, sha256, tokenCodecPorts, idFactory } = ctx.v2;
-    const stateRes = (0, v2_token_ops_js_1.parseStateTokenOrFail)(input.stateToken, tokenCodecPorts);
-    if (!stateRes.ok)
-        return (0, neverthrow_1.errAsync)({ kind: 'validation_failed', failure: stateRes.failure });
-    const state = stateRes.token;
+    const { gate, sessionStore, snapshotStore, pinnedStore, sha256, tokenCodecPorts, idFactory, tokenAliasStore, entropy } = ctx.v2;
     const ctxCheck = (0, v2_context_budget_js_1.checkContextBudget)({ tool: 'continue_workflow', context: input.context });
     if (!ctxCheck.ok)
         return (0, neverthrow_1.errAsync)({ kind: 'validation_failed', failure: ctxCheck.error });
-    const sessionId = (0, index_js_2.asSessionId)(state.payload.sessionId);
-    const runId = (0, index_js_2.asRunId)(state.payload.runId);
-    const nodeId = (0, index_js_2.asNodeId)(state.payload.nodeId);
-    const workflowHashRef = state.payload.workflowHashRef;
-    if (input.intent === 'rehydrate') {
+    return (0, v2_token_ops_js_1.parseContinueTokenOrFail)(input.continueToken, tokenCodecPorts, tokenAliasStore)
+        .mapErr((failure) => ({ kind: 'validation_failed', failure }))
+        .andThen((resolved) => {
+        const sessionId = (0, index_js_2.asSessionId)(resolved.sessionId);
+        const runId = (0, index_js_2.asRunId)(resolved.runId);
+        const nodeId = (0, index_js_2.asNodeId)(resolved.nodeId);
+        const workflowHashRef = resolved.workflowHashRef;
+        if (input.intent === 'rehydrate') {
+            return sessionStore.load(sessionId)
+                .mapErr((cause) => ({ kind: 'session_load_failed', cause }))
+                .andThen((truth) => (0, continue_rehydrate_js_1.handleRehydrateIntent)({
+                input,
+                sessionId,
+                runId,
+                nodeId,
+                workflowHashRef,
+                truth,
+                tokenCodecPorts,
+                pinnedStore,
+                snapshotStore,
+                idFactory,
+                aliasStore: tokenAliasStore,
+                entropy,
+            }));
+        }
+        const attemptId = (0, index_js_1.asAttemptId)(resolved.attemptId);
         return sessionStore.load(sessionId)
             .mapErr((cause) => ({ kind: 'session_load_failed', cause }))
-            .andThen((truth) => (0, continue_rehydrate_js_1.handleRehydrateIntent)({
+            .andThen((truth) => (0, continue_advance_js_1.handleAdvanceIntent)({
             input,
             sessionId,
             runId,
             nodeId,
+            attemptId,
             workflowHashRef,
             truth,
-            tokenCodecPorts,
-            pinnedStore,
+            gate,
+            sessionStore,
             snapshotStore,
+            pinnedStore,
+            tokenCodecPorts,
             idFactory,
+            sha256,
+            aliasStore: tokenAliasStore,
+            entropy,
         }));
-    }
-    if (!input.ackToken) {
-        return (0, neverthrow_1.errAsync)({ kind: 'validation_failed', failure: (0, types_js_1.error)('VALIDATION_ERROR', 'ackToken is required for advance intent') });
-    }
-    const ackRes = (0, v2_token_ops_js_1.parseAckTokenOrFail)(input.ackToken, tokenCodecPorts);
-    if (!ackRes.ok)
-        return (0, neverthrow_1.errAsync)({ kind: 'validation_failed', failure: ackRes.failure });
-    const ack = ackRes.token;
-    const scopeRes = (0, index_js_1.assertTokenScopeMatchesStateBinary)(state, ack);
-    if (scopeRes.isErr())
-        return (0, neverthrow_1.errAsync)({ kind: 'validation_failed', failure: (0, v2_execution_helpers_js_1.mapTokenDecodeErrorToToolError)(scopeRes.error) });
-    const attemptId = (0, index_js_1.asAttemptId)(ack.payload.attemptId);
-    return sessionStore.load(sessionId)
-        .mapErr((cause) => ({ kind: 'session_load_failed', cause }))
-        .andThen((truth) => (0, continue_advance_js_1.handleAdvanceIntent)({
-        input,
-        sessionId,
-        runId,
-        nodeId,
-        attemptId,
-        workflowHashRef,
-        truth,
-        gate,
-        sessionStore,
-        snapshotStore,
-        pinnedStore,
-        tokenCodecPorts,
-        idFactory,
-        sha256,
-    }));
+    });
 }

package/dist/mcp/handlers/v2-execution/replay.d.ts

@@ -10,19 +10,6 @@ import type { TokenCodecPorts } from '../../../v2/durable-core/tokens/token-code
 import { ResultAsync as RA } from 'neverthrow';
 import { type ContinueWorkflowError } from '../v2-execution-helpers.js';
 import * as z from 'zod';
-export declare function buildBlockedReplayResponse(args: {
-    readonly sessionId: SessionId;
-    readonly runId: RunId;
-    readonly nodeId: NodeId;
-    readonly attemptId: AttemptId;
-    readonly blockers: import('../../../v2/durable-core/schemas/session/blockers.js').BlockerReportV1;
-    readonly snapshot: ExecutionSnapshotFileV1 | null;
-    readonly truth: LoadedSessionTruthV2;
-    readonly workflow: ReturnType<typeof createWorkflow>;
-    readonly inputStateToken: string;
-    readonly inputAckToken: string;
-    readonly ports: TokenCodecPorts;
-}): RA<z.infer<typeof V2ContinueWorkflowOutputSchema>, ContinueWorkflowError>;
 export declare function buildAdvancedReplayResponse(args: {
     readonly sessionId: SessionId;
     readonly runId: RunId;
@@ -35,6 +22,8 @@ export declare function buildAdvancedReplayResponse(args: {
     readonly workflowHash: WorkflowHash;
     readonly ports: TokenCodecPorts;
     readonly sha256: Sha256PortV2;
+    readonly aliasStore: import('../../../v2/ports/token-alias-store.port.js').TokenAliasStorePortV2;
+    readonly entropy: import('../../../v2/ports/random-entropy.port.js').RandomEntropyPortV2;
 }): RA<z.infer<typeof V2ContinueWorkflowOutputSchema>, ContinueWorkflowError>;
 export declare function replayFromRecordedAdvance(args: {
     readonly recordedEvent: Extract<DomainEventV1, {
@@ -46,10 +35,10 @@ export declare function replayFromRecordedAdvance(args: {
     readonly nodeId: NodeId;
     readonly workflowHash: WorkflowHash;
     readonly attemptId: AttemptId;
-    readonly inputStateToken: string;
-    readonly inputAckToken: string;
     readonly pinnedWorkflow: ReturnType<typeof createWorkflow>;
     readonly snapshotStore: import('../../../v2/ports/snapshot-store.port.js').SnapshotStorePortV2;
     readonly sha256: Sha256PortV2;
     readonly tokenCodecPorts: TokenCodecPorts;
+    readonly aliasStore: import('../../../v2/ports/token-alias-store.port.js').TokenAliasStorePortV2;
+    readonly entropy: import('../../../v2/ports/random-entropy.port.js').RandomEntropyPortV2;
 }): RA<z.infer<typeof V2ContinueWorkflowOutputSchema>, ContinueWorkflowError>;

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

@@ -1,12 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildBlockedReplayResponse = buildBlockedReplayResponse;
 exports.buildAdvancedReplayResponse = buildAdvancedReplayResponse;
 exports.replayFromRecordedAdvance = replayFromRecordedAdvance;
 const output_schemas_js_1 = require("../../output-schemas.js");
 const snapshot_state_js_1 = require("../../../v2/durable-core/projections/snapshot-state.js");
-const index_js_1 = require("../../../v2/durable-core/tokens/index.js");
-const index_js_2 = require("../../../v2/durable-core/ids/index.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 neverthrow_1 = require("neverthrow");
 const validation_loader_js_1 = require("../../../v2/durable-core/domain/validation-loader.js");
@@ -15,54 +13,10 @@ const prompt_renderer_js_1 = require("../../../v2/durable-core/domain/prompt-ren
 const v2_token_ops_js_1 = require("../v2-token-ops.js");
 const v2_state_conversion_js_1 = require("../v2-state-conversion.js");
 const constants_js_1 = require("../../../v2/durable-core/constants.js");
-const index_js_3 = require("./index.js");
-function buildBlockedReplayResponse(args) {
-    const { sessionId, runId, nodeId, attemptId, blockers, snapshot, truth, workflow, inputStateToken, inputAckToken, ports } = args;
-    const pendingNow = snapshot ? (0, snapshot_state_js_1.derivePendingStep)(snapshot.enginePayload.engineState) : null;
-    const isCompleteNow = snapshot ? (0, snapshot_state_js_1.deriveIsComplete)(snapshot.enginePayload.engineState) : false;
-    let metaOrNull = null;
-    if (pendingNow) {
-        const result = (0, prompt_renderer_js_1.renderPendingPrompt)({
-            workflow,
-            stepId: String(pendingNow.stepId),
-            loopPath: pendingNow.loopPath,
-            truth,
-            runId: (0, index_js_2.asRunId)(String(runId)),
-            nodeId: (0, index_js_2.asNodeId)(String(nodeId)),
-            rehydrateOnly: false,
-        });
-        if (result.isErr()) {
-            return (0, neverthrow_1.errAsync)({ kind: 'prompt_render_failed', message: result.error.message });
-        }
-        metaOrNull = result.value;
-    }
-    const preferences = (0, v2_execution_helpers_js_1.derivePreferencesOrDefault)({ truth, runId, nodeId });
-    const nextIntent = (0, v2_state_conversion_js_1.deriveNextIntent)({ rehydrateOnly: false, isComplete: isCompleteNow, pending: metaOrNull });
-    const replayCheckpointTokenRes = pendingNow
-        ? (0, v2_token_ops_js_1.signTokenOrErr)({
-            payload: { tokenVersion: 1, tokenKind: 'checkpoint', sessionId, runId, nodeId, attemptId },
-            ports,
-        })
-        : (0, neverthrow_1.ok)(undefined);
-    return (0, neverthrow_1.okAsync)(output_schemas_js_1.V2ContinueWorkflowOutputSchema.parse({
-        kind: 'blocked',
-        stateToken: inputStateToken,
-        ackToken: inputAckToken,
-        checkpointToken: replayCheckpointTokenRes.isOk() ? replayCheckpointTokenRes.value : undefined,
-        isComplete: isCompleteNow,
-        pending: metaOrNull ? { stepId: metaOrNull.stepId, title: metaOrNull.title, prompt: metaOrNull.prompt } : null,
-        preferences,
-        nextIntent,
-        nextCall: (0, index_js_3.buildNextCall)({ stateToken: inputStateToken, ackToken: inputAckToken, isComplete: isCompleteNow, pending: metaOrNull }),
-        blockers,
-        retryable: undefined,
-        retryAckToken: undefined,
-        validation: (0, validation_loader_js_1.loadValidationResultV1)(truth.events, `validation_${String(attemptId)}`).unwrapOr(null) ?? undefined,
-    }));
-}
+const index_js_2 = require("./index.js");
 function buildAdvancedReplayResponse(args) {
-    const { sessionId, runId, toNodeId, attemptId, toSnapshot, workflow, truth, workflowHash, ports, sha256 } = args;
-    const toNodeIdBranded = (0, index_js_2.asNodeId)(String(toNodeId));
+    const { sessionId, runId, toNodeId, attemptId, toSnapshot, workflow, truth, workflowHash, ports, sha256, aliasStore, entropy } = args;
+    const toNodeIdBranded = (0, index_js_1.asNodeId)(String(toNodeId));
     const pending = (0, snapshot_state_js_1.derivePendingStep)(toSnapshot.enginePayload.engineState);
     const isComplete = (0, snapshot_state_js_1.deriveIsComplete)(toSnapshot.enginePayload.engineState);
     const nextAttemptIdRes = (0, v2_token_ops_js_1.attemptIdForNextNode)(attemptId, sha256);
@@ -70,55 +24,39 @@ function buildAdvancedReplayResponse(args) {
         return (0, neverthrow_1.errAsync)({ kind: 'invariant_violation', message: `Failed to derive next attemptId: ${nextAttemptIdRes.error.message}` });
     }
     const nextAttemptId = nextAttemptIdRes.value;
-    const nextAckTokenRes = pending
-        ? (0, v2_token_ops_js_1.signTokenOrErr)({
-            payload: { tokenVersion: 1, tokenKind: 'ack', sessionId, runId, nodeId: toNodeIdBranded, attemptId: nextAttemptId },
-            ports,
-        })
-        : (0, neverthrow_1.ok)(undefined);
-    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,
-        })
-        : (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.' });
     }
-    const nextStateTokenRes = (0, v2_token_ops_js_1.signTokenOrErr)({
-        payload: { tokenVersion: 1, tokenKind: 'state', sessionId, runId, nodeId: toNodeIdBranded, workflowHashRef: wfRefRes.value },
-        ports,
-    });
-    if (nextStateTokenRes.isErr()) {
-        return (0, neverthrow_1.errAsync)({ kind: 'token_signing_failed', cause: nextStateTokenRes.error });
-    }
+    const entryBase = {
+        sessionId: String(sessionId),
+        runId: String(runId),
+        nodeId: String(toNodeIdBranded),
+        attemptId: String(nextAttemptId),
+        workflowHashRef: String(wfRefRes.value),
+    };
+    const nextTokensMint = (0, v2_token_ops_js_1.mintContinueAndCheckpointTokens)({ entry: entryBase, ports, aliasStore, entropy })
+        .mapErr((failure) => ({ kind: 'token_signing_failed', cause: failure }));
     if (toSnapshot.enginePayload.engineState.kind === 'blocked') {
         const blocked = toSnapshot.enginePayload.engineState.blocked;
         const blockers = blocked.blockers;
         const retryable = blocked.kind === 'retryable_block';
-        const retryAckTokenRes = retryable
-            ? (0, v2_token_ops_js_1.signTokenOrErr)({
-                payload: {
-                    tokenVersion: 1,
-                    tokenKind: 'ack',
-                    sessionId,
-                    runId,
-                    nodeId: toNodeIdBranded,
-                    attemptId: (0, index_js_1.asAttemptId)(String(blocked.retryAttemptId)),
+        const retryContinueMint = retryable
+            ? (0, v2_token_ops_js_1.mintContinueAndCheckpointTokens)({
+                entry: {
+                    aliasSlot: 'retry',
+                    sessionId: String(sessionId),
+                    runId: String(runId),
+                    nodeId: String(toNodeIdBranded),
+                    attemptId: String(blocked.retryAttemptId),
+                    workflowHashRef: String(wfRefRes.value),
                 },
                 ports,
-            })
-            : (0, neverthrow_1.ok)(undefined);
-        if (retryAckTokenRes.isErr()) {
-            return (0, neverthrow_1.errAsync)({ kind: 'token_signing_failed', cause: retryAckTokenRes.error });
-        }
+                aliasStore,
+                entropy,
+            }).map((tokens) => tokens.continueToken)
+                .mapErr((failure) => ({ kind: 'token_signing_failed', cause: failure }))
+            : (0, neverthrow_1.okAsync)(undefined);
         const validation = (0, validation_loader_js_1.loadValidationResultV1)(truth.events, String(blocked.validationRef)).unwrapOr(null) ?? undefined;
         let blockedMeta = null;
         if (pending) {
@@ -127,8 +65,8 @@ function buildAdvancedReplayResponse(args) {
                 stepId: String(pending.stepId),
                 loopPath: pending.loopPath,
                 truth,
-                runId: (0, index_js_2.asRunId)(String(runId)),
-                nodeId: (0, index_js_2.asNodeId)(String(toNodeIdBranded)),
+                runId: (0, index_js_1.asRunId)(String(runId)),
+                nodeId: (0, index_js_1.asNodeId)(String(toNodeIdBranded)),
                 rehydrateOnly: false,
             });
             if (result.isErr()) {
@@ -138,21 +76,20 @@ function buildAdvancedReplayResponse(args) {
         }
         const preferences = (0, v2_execution_helpers_js_1.derivePreferencesOrDefault)({ truth, runId, nodeId: toNodeIdBranded });
         const nextIntent = (0, v2_state_conversion_js_1.deriveNextIntent)({ rehydrateOnly: false, isComplete, pending: blockedMeta });
-        return (0, neverthrow_1.okAsync)(output_schemas_js_1.V2ContinueWorkflowOutputSchema.parse({
+        return nextTokensMint.andThen((nextTokens) => retryContinueMint.andThen((retryContinueToken) => (0, neverthrow_1.okAsync)(output_schemas_js_1.V2ContinueWorkflowOutputSchema.parse({
             kind: 'blocked',
-            stateToken: nextStateTokenRes.value,
-            ackToken: pending ? nextAckTokenRes.value : undefined,
-            checkpointToken: pending ? nextCheckpointTokenRes.value : undefined,
+            continueToken: pending ? nextTokens.continueToken : undefined,
+            checkpointToken: pending ? nextTokens.checkpointToken : undefined,
             isComplete,
-            pending: blockedMeta ? { stepId: blockedMeta.stepId, title: blockedMeta.title, prompt: blockedMeta.prompt } : null,
+            pending: (0, output_schemas_js_1.toPendingStep)(blockedMeta),
             preferences,
             nextIntent,
-            nextCall: (0, index_js_3.buildNextCall)({ stateToken: nextStateTokenRes.value, ackToken: pending ? nextAckTokenRes.value : undefined, isComplete, pending: blockedMeta, retryable, retryAckToken: retryAckTokenRes.value }),
+            nextCall: (0, index_js_2.buildNextCall)({ continueToken: pending ? nextTokens.continueToken : undefined, isComplete, pending: blockedMeta, retryContinueToken }),
             blockers,
             retryable,
-            retryAckToken: retryAckTokenRes.value,
+            retryContinueToken,
             validation,
-        }));
+        }))));
     }
     let okMeta = null;
     if (pending) {
@@ -161,8 +98,8 @@ function buildAdvancedReplayResponse(args) {
             stepId: String(pending.stepId),
             loopPath: pending.loopPath,
             truth,
-            runId: (0, index_js_2.asRunId)(String(runId)),
-            nodeId: (0, index_js_2.asNodeId)(String(toNodeIdBranded)),
+            runId: (0, index_js_1.asRunId)(String(runId)),
+            nodeId: (0, index_js_1.asNodeId)(String(toNodeIdBranded)),
             rehydrateOnly: false,
         });
         if (result.isErr()) {
@@ -172,41 +109,26 @@ function buildAdvancedReplayResponse(args) {
     }
     const preferences = (0, v2_execution_helpers_js_1.derivePreferencesOrDefault)({ truth, runId, nodeId: toNodeIdBranded });
     const nextIntent = (0, v2_state_conversion_js_1.deriveNextIntent)({ rehydrateOnly: false, isComplete, pending: okMeta });
-    return (0, neverthrow_1.okAsync)(output_schemas_js_1.V2ContinueWorkflowOutputSchema.parse({
+    return nextTokensMint.andThen((nextTokens) => (0, neverthrow_1.okAsync)(output_schemas_js_1.V2ContinueWorkflowOutputSchema.parse({
         kind: 'ok',
-        stateToken: nextStateTokenRes.value,
-        ackToken: pending ? nextAckTokenRes.value : undefined,
-        checkpointToken: pending ? nextCheckpointTokenRes.value : undefined,
+        continueToken: pending ? nextTokens.continueToken : undefined,
+        checkpointToken: pending ? nextTokens.checkpointToken : undefined,
         isComplete,
-        pending: okMeta ? { stepId: okMeta.stepId, title: okMeta.title, prompt: okMeta.prompt } : null,
+        pending: (0, output_schemas_js_1.toPendingStep)(okMeta),
         preferences,
         nextIntent,
-        nextCall: (0, index_js_3.buildNextCall)({ stateToken: nextStateTokenRes.value, ackToken: pending ? nextAckTokenRes.value : undefined, isComplete, pending: okMeta }),
-    }));
+        nextCall: (0, index_js_2.buildNextCall)({ continueToken: pending ? nextTokens.continueToken : undefined, isComplete, pending: okMeta }),
+    })));
 }
 function replayFromRecordedAdvance(args) {
-    const { recordedEvent, truth, sessionId, runId, nodeId, workflowHash, attemptId, inputStateToken, inputAckToken, pinnedWorkflow, snapshotStore, sha256, tokenCodecPorts, } = args;
+    const { recordedEvent, truth, sessionId, runId, nodeId, workflowHash, attemptId, pinnedWorkflow, snapshotStore, sha256, tokenCodecPorts, aliasStore, entropy, } = args;
     if (recordedEvent.data.outcome.kind === 'blocked') {
-        const blockers = recordedEvent.data.outcome.blockers;
-        const snapNode = truth.events.find((e) => e.kind === constants_js_1.EVENT_KIND.NODE_CREATED && e.scope?.nodeId === String(nodeId));
-        const snapRA = snapNode
-            ? snapshotStore.getExecutionSnapshotV1(snapNode.data.snapshotRef).mapErr((cause) => ({ kind: 'snapshot_load_failed', cause }))
-            : (0, neverthrow_1.okAsync)(null);
-        return snapRA.andThen((snapshot) => buildBlockedReplayResponse({
-            sessionId,
-            runId,
-            nodeId,
-            attemptId,
-            blockers,
-            snapshot,
-            truth,
-            workflow: pinnedWorkflow,
-            inputStateToken,
-            inputAckToken,
-            ports: tokenCodecPorts,
-        }));
+        return (0, neverthrow_1.errAsync)({
+            kind: 'invariant_violation',
+            message: 'Legacy blocked advance_recorded outcomes are no longer supported. Sessions must be re-created.',
+        });
     }
-    const toNodeId = (0, index_js_2.asNodeId)(String(recordedEvent.data.outcome.toNodeId));
+    const toNodeId = (0, index_js_1.asNodeId)(String(recordedEvent.data.outcome.toNodeId));
     const toNode = truth.events.find((e) => e.kind === constants_js_1.EVENT_KIND.NODE_CREATED && e.scope?.nodeId === String(toNodeId));
     if (!toNode) {
         return (0, neverthrow_1.errAsync)({
@@ -236,6 +158,8 @@ function replayFromRecordedAdvance(args) {
             workflowHash,
             ports: tokenCodecPorts,
             sha256,
+            aliasStore,
+            entropy,
         });
     });
 }

package/dist/mcp/handlers/v2-execution/start.d.ts

@@ -45,9 +45,10 @@ export declare function mintStartTokens(args: {
     readonly attemptId: import('../../../v2/durable-core/tokens/index.js').AttemptId;
     readonly workflowHashRef: import('../../../v2/durable-core/ids/index.js').WorkflowHashRef;
     readonly ports: TokenCodecPorts;
+    readonly aliasStore: import('../../../v2/ports/token-alias-store.port.js').TokenAliasStorePortV2;
+    readonly entropy: import('../../../v2/ports/random-entropy.port.js').RandomEntropyPortV2;
 }): RA<{
-    readonly stateToken: string;
-    readonly ackToken: string;
+    readonly continueToken: string;
     readonly checkpointToken: string;
 }, StartWorkflowError>;
 export declare function executeStartWorkflow(input: import('../../v2/tools.js').V2StartWorkflowInput, ctx: V2ToolContext): RA<z.infer<typeof V2StartWorkflowOutputSchema>, StartWorkflowError>;