@exaudeus/workrail 2.0.0 → 3.0.0

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

@@ -12,7 +12,7 @@ import { type StartWorkflowError } from '../v2-execution-helpers.js';
 import * as z from 'zod';
 export declare function loadAndPinWorkflow(args: {
     readonly workflowId: string;
-    readonly workflowService: import('../../../application/services/workflow-service.js').WorkflowService;
+    readonly workflowReader: Pick<import('../../../types/storage.js').IWorkflowReader, 'getWorkflowById'>;
     readonly crypto: Sha256PortV2;
     readonly pinnedStore: import('../../../v2/ports/pinned-workflow-store.port.js').PinnedWorkflowStorePortV2;
     readonly validationPipelineDeps: ValidationPipelineDepsPhase1a;
@@ -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>;

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

@@ -23,9 +23,10 @@ const v2_execution_helpers_js_1 = require("../v2-execution-helpers.js");
 const constants_js_1 = require("../../../v2/durable-core/constants.js");
 const index_js_2 = require("./index.js");
 const start_construction_js_1 = require("../../../v2/durable-core/domain/start-construction.js");
+const request_workflow_reader_js_1 = require("../shared/request-workflow-reader.js");
 function loadAndPinWorkflow(args) {
-    const { workflowId, workflowService, crypto, pinnedStore, validationPipelineDeps } = args;
-    return neverthrow_1.ResultAsync.fromPromise(workflowService.getWorkflowById(workflowId), (e) => ({
+    const { workflowId, workflowReader, crypto, pinnedStore, validationPipelineDeps } = args;
+    return neverthrow_1.ResultAsync.fromPromise(workflowReader.getWorkflowById(workflowId), (e) => ({
         kind: 'precondition_failed',
         message: e instanceof Error ? e.message : String(e),
     }))
@@ -182,54 +183,35 @@ function buildInitialEvents(args) {
     return mutableEvents;
 }
 function mintStartTokens(args) {
-    const { sessionId, runId, nodeId, attemptId, workflowHashRef, ports } = args;
-    const statePayload = {
-        tokenVersion: 1,
-        tokenKind: 'state',
-        sessionId,
-        runId,
-        nodeId,
-        workflowHashRef,
+    const { sessionId, runId, nodeId, attemptId, workflowHashRef, ports, aliasStore, entropy } = args;
+    const entryBase = {
+        sessionId: String(sessionId),
+        runId: String(runId),
+        nodeId: String(nodeId),
+        attemptId: String(attemptId),
+        workflowHashRef: String(workflowHashRef),
     };
-    const ackPayload = {
-        tokenVersion: 1,
-        tokenKind: 'ack',
-        sessionId,
-        runId,
-        nodeId,
-        attemptId,
-    };
-    const checkpointPayload = {
-        tokenVersion: 1,
-        tokenKind: 'checkpoint',
-        sessionId,
-        runId,
-        nodeId,
-        attemptId,
-    };
-    const stateTokenRes = (0, v2_token_ops_js_1.signTokenOrErr)({ payload: statePayload, ports });
-    if (stateTokenRes.isErr()) {
-        return (0, neverthrow_1.errAsync)({ kind: 'token_signing_failed', cause: stateTokenRes.error });
-    }
-    const ackTokenRes = (0, v2_token_ops_js_1.signTokenOrErr)({ payload: ackPayload, ports });
-    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: checkpointPayload, ports });
-    if (checkpointTokenRes.isErr()) {
-        return (0, neverthrow_1.errAsync)({ kind: 'token_signing_failed', cause: checkpointTokenRes.error });
-    }
-    return (0, neverthrow_1.okAsync)({
-        stateToken: stateTokenRes.value,
-        ackToken: ackTokenRes.value,
-        checkpointToken: checkpointTokenRes.value,
-    });
+    return (0, v2_token_ops_js_1.mintContinueAndCheckpointTokens)({ entry: entryBase, ports, aliasStore, entropy })
+        .mapErr((failure) => ({
+        kind: 'token_signing_failed',
+        cause: failure,
+    }));
 }
 function executeStartWorkflow(input, ctx) {
-    const { gate, sessionStore, snapshotStore, pinnedStore, crypto, tokenCodecPorts, idFactory, validationPipelineDeps } = ctx.v2;
+    const { gate, sessionStore, snapshotStore, pinnedStore, crypto, tokenCodecPorts, idFactory, validationPipelineDeps, tokenAliasStore, entropy } = ctx.v2;
+    const workflowReader = (0, request_workflow_reader_js_1.hasRequestWorkspaceSignal)({
+        workspacePath: input.workspacePath,
+        resolvedRootUris: ctx.v2.resolvedRootUris,
+    })
+        ? (0, request_workflow_reader_js_1.createWorkflowReaderForRequest)({
+            featureFlags: ctx.featureFlags,
+            workspacePath: input.workspacePath,
+            resolvedRootUris: ctx.v2.resolvedRootUris,
+        })
+        : ctx.workflowService;
     return loadAndPinWorkflow({
         workflowId: input.workflowId,
-        workflowService: ctx.workflowService,
+        workflowReader,
         crypto,
         pinnedStore,
         validationPipelineDeps,
@@ -304,6 +286,8 @@ function executeStartWorkflow(input, ctx) {
             attemptId,
             workflowHashRef: wfRefRes.value,
             ports: tokenCodecPorts,
+            aliasStore: tokenAliasStore,
+            entropy,
         }).andThen((tokens) => {
             const metaResult = (0, prompt_renderer_js_1.renderPendingPrompt)({
                 workflow: pinnedWorkflow,
@@ -321,18 +305,17 @@ function executeStartWorkflow(input, ctx) {
                 });
             }
             const meta = metaResult.value;
-            const pending = { stepId: meta.stepId, title: meta.title, prompt: meta.prompt };
+            const pending = (0, output_schemas_js_1.toPendingStep)(meta);
             const preferences = v2_execution_helpers_js_1.defaultPreferences;
             const nextIntent = (0, v2_state_conversion_js_1.deriveNextIntent)({ rehydrateOnly: false, isComplete: false, pending: meta });
             return (0, neverthrow_1.okAsync)(output_schemas_js_1.V2StartWorkflowOutputSchema.parse({
-                stateToken: tokens.stateToken,
-                ackToken: tokens.ackToken,
+                continueToken: tokens.continueToken,
                 checkpointToken: tokens.checkpointToken,
                 isComplete: false,
                 pending,
                 preferences,
                 nextIntent,
-                nextCall: (0, index_js_2.buildNextCall)({ stateToken: tokens.stateToken, ackToken: tokens.ackToken, isComplete: false, pending }),
+                nextCall: (0, index_js_2.buildNextCall)({ continueToken: tokens.continueToken, isComplete: false, pending }),
             }));
         });
     });

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

@@ -1,38 +1,59 @@
+import type { ResultAsync } from 'neverthrow';
 import type { Result } from 'neverthrow';
 import { type ParsedTokenV1Binary, type TokenDecodeErrorV2, type TokenVerifyErrorV2, type TokenSignErrorV2, type TokenPayloadV1, type AttemptId } from '../../v2/durable-core/tokens/index.js';
 import type { TokenCodecPorts } from '../../v2/durable-core/tokens/token-codec-ports.js';
 import type { Sha256PortV2 } from '../../v2/ports/sha256.port.js';
 import { type ToolFailure } from './v2-execution-helpers.js';
+import type { TokenAliasStorePortV2, TokenAliasEntryV2 } from '../../v2/ports/token-alias-store.port.js';
+import type { RandomEntropyPortV2 } from '../../v2/ports/random-entropy.port.js';
+import type { StateTokenPayloadV1, AckTokenPayloadV1, CheckpointTokenPayloadV1 } from '../../v2/durable-core/tokens/payloads.js';
 export type StateTokenInput = ParsedTokenV1Binary & {
-    readonly payload: import('../../v2/durable-core/tokens/payloads.js').StateTokenPayloadV1;
+    readonly payload: StateTokenPayloadV1;
 };
 export type AckTokenInput = ParsedTokenV1Binary & {
-    readonly payload: import('../../v2/durable-core/tokens/payloads.js').AckTokenPayloadV1;
+    readonly payload: 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;
-} | {
-    ok: false;
-    failure: ToolFailure;
-};
-export declare function parseAckTokenOrFail(raw: string, ports: TokenCodecPorts): {
-    ok: true;
-    token: AckTokenInput;
-} | {
-    ok: false;
-    failure: ToolFailure;
-};
-export declare function parseCheckpointTokenOrFail(raw: string, ports: TokenCodecPorts): {
-    ok: true;
-    token: CheckpointTokenInput;
-} | {
-    ok: false;
-    failure: ToolFailure;
+    readonly payload: CheckpointTokenPayloadV1;
 };
+export interface ContinueTokenResolved {
+    readonly sessionId: string;
+    readonly runId: string;
+    readonly nodeId: string;
+    readonly attemptId: string;
+    readonly workflowHashRef: string;
+}
+export declare function parseStateTokenOrFail(raw: string, ports: TokenCodecPorts, aliasStore: TokenAliasStorePortV2): ResultAsync<StateTokenInput, ToolFailure>;
+export declare function parseAckTokenOrFail(raw: string, ports: TokenCodecPorts, aliasStore: TokenAliasStorePortV2): ResultAsync<AckTokenInput, ToolFailure>;
+export declare function parseCheckpointTokenOrFail(raw: string, ports: TokenCodecPorts, aliasStore: TokenAliasStorePortV2): ResultAsync<CheckpointTokenInput, ToolFailure>;
+export declare function parseContinueTokenOrFail(raw: string, ports: TokenCodecPorts, aliasStore: TokenAliasStorePortV2): ResultAsync<ContinueTokenResolved, ToolFailure>;
+export interface ContinueAndCheckpointTokens {
+    readonly continueToken: string;
+    readonly checkpointToken: string;
+}
+export declare function mintContinueAndCheckpointTokens(args: Omit<MintShortTokenTripleArgs, 'entry'> & {
+    readonly entry: Omit<TokenAliasEntryV2, 'nonceHex' | 'tokenKind'>;
+}): ResultAsync<ContinueAndCheckpointTokens, ToolFailure>;
+export interface ShortTokenTriple {
+    readonly stateToken: string;
+    readonly ackToken: string;
+    readonly checkpointToken: string;
+}
+export interface MintShortTokenTripleArgs {
+    readonly entry: Omit<TokenAliasEntryV2, 'nonceHex' | 'tokenKind'>;
+    readonly ports: TokenCodecPorts;
+    readonly aliasStore: TokenAliasStorePortV2;
+    readonly entropy: RandomEntropyPortV2;
+}
+export declare function mintShortTokenTriple(args: MintShortTokenTripleArgs): ResultAsync<ShortTokenTriple, ToolFailure>;
+export interface MintSingleShortTokenArgs {
+    readonly kind: import('../../v2/durable-core/tokens/short-token.js').ShortTokenKind;
+    readonly entry: Omit<TokenAliasEntryV2, 'nonceHex' | 'tokenKind'>;
+    readonly ports: TokenCodecPorts;
+    readonly aliasStore: TokenAliasStorePortV2;
+    readonly entropy: RandomEntropyPortV2;
+}
+export declare function mintSingleShortToken(args: MintSingleShortTokenArgs): ResultAsync<string, ToolFailure>;
 export declare function newAttemptId(idFactory: {
     readonly mintAttemptId: () => AttemptId;
 }): AttemptId;