@exaudeus/workrail 0.17.0 → 1.1.0

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

@@ -44,6 +44,7 @@ const index_js_1 = require("../../v2/durable-core/tokens/index.js");
 const index_js_2 = require("../../v2/durable-core/tokens/index.js");
 const workflow_js_1 = require("../../types/workflow.js");
 const index_js_3 = require("../../v2/durable-core/ids/index.js");
+const workflow_hash_ref_js_1 = require("../../v2/durable-core/ids/workflow-hash-ref.js");
 const attempt_id_derivation_js_1 = require("../../v2/durable-core/ids/attempt-id-derivation.js");
 const neverthrow_1 = require("neverthrow");
 const v1_to_v2_shim_js_1 = require("../../v2/read-only/v1-to-v2-shim.js");
@@ -53,10 +54,19 @@ const constants_js_1 = require("../../v2/durable-core/constants.js");
 const notes_markdown_js_1 = require("../../v2/durable-core/domain/notes-markdown.js");
 const outputs_js_1 = require("../../v2/durable-core/domain/outputs.js");
 const ack_advance_append_plan_js_1 = require("../../v2/durable-core/domain/ack-advance-append-plan.js");
+const blocking_decision_js_1 = require("../../v2/durable-core/domain/blocking-decision.js");
+const reason_model_js_1 = require("../../v2/durable-core/domain/reason-model.js");
+const validation_criteria_validator_js_1 = require("../../v2/durable-core/domain/validation-criteria-validator.js");
+const preferences_js_1 = require("../../v2/projections/preferences.js");
+const run_context_js_1 = require("../../v2/projections/run-context.js");
+const context_merge_js_1 = require("../../v2/durable-core/domain/context-merge.js");
+const prompt_renderer_js_1 = require("../../v2/durable-core/domain/prompt-renderer.js");
 const workflow_source_js_1 = require("../../types/workflow-source.js");
 const workflow_definition_js_1 = require("../../types/workflow-definition.js");
 const workflow_compiler_js_1 = require("../../application/services/workflow-compiler.js");
 const workflow_interpreter_js_1 = require("../../application/services/workflow-interpreter.js");
+const validation_engine_js_1 = require("../../application/services/validation-engine.js");
+const enhanced_loop_validator_js_1 = require("../../application/services/enhanced-loop-validator.js");
 const v2_execution_helpers_js_1 = require("./v2-execution-helpers.js");
 function normalizeTokenErrorMessage(message) {
     return message.split(os.homedir()).join('~');
@@ -238,18 +248,7 @@ function mapInternalErrorToToolError(e) {
     }
 }
 function replayFromRecordedAdvance(args) {
-    const { recordedEvent, truth, sessionId, runId, nodeId, workflowHash, attemptId, inputStateToken, inputAckToken, pinnedWorkflow, snapshotStore, keyring, sha256, hmac, base64url, } = args;
-    const checkpointTokenRes = signTokenOrErr({
-        unsignedPrefix: 'chk.v1.',
-        payload: { tokenVersion: 1, tokenKind: 'checkpoint', sessionId, runId, nodeId, attemptId },
-        keyring,
-        hmac,
-        base64url,
-    });
-    if (checkpointTokenRes.isErr()) {
-        return (0, neverthrow_1.errAsync)({ kind: 'token_signing_failed', cause: checkpointTokenRes.error });
-    }
-    const checkpointToken = checkpointTokenRes.value;
+    const { recordedEvent, truth, sessionId, runId, nodeId, workflowHash, attemptId, inputStateToken, inputAckToken, pinnedWorkflow, snapshotStore, sha256, tokenCodecPorts, } = args;
     if (recordedEvent.data.outcome.kind === 'blocked') {
         const blockers = recordedEvent.data.outcome.blockers;
         const snapNode = truth.events.find((e) => e.kind === 'node_created' && e.scope?.nodeId === String(nodeId));
@@ -259,15 +258,32 @@ function replayFromRecordedAdvance(args) {
         return snapRA.map((snap) => {
             const pendingNow = snap ? (0, snapshot_state_js_1.derivePendingStep)(snap.enginePayload.engineState) : null;
             const isCompleteNow = snap ? (0, snapshot_state_js_1.deriveIsComplete)(snap.enginePayload.engineState) : false;
+            const meta = pendingNow
+                ? (0, prompt_renderer_js_1.renderPendingPrompt)({
+                    workflow: pinnedWorkflow,
+                    stepId: String(pendingNow.stepId),
+                    loopPath: pendingNow.loopPath,
+                    truth,
+                    runId: (0, index_js_3.asRunId)(String(runId)),
+                    nodeId: (0, index_js_3.asNodeId)(String(nodeId)),
+                    rehydrateOnly: false,
+                }).unwrapOr({
+                    stepId: String(pendingNow.stepId),
+                    title: String(pendingNow.stepId),
+                    prompt: `Pending step: ${String(pendingNow.stepId)}`,
+                    requireConfirmation: false,
+                })
+                : null;
+            const preferences = derivePreferencesForNode({ truth, runId, nodeId });
+            const nextIntent = deriveNextIntent({ rehydrateOnly: false, isComplete: isCompleteNow, pending: meta });
             return output_schemas_js_1.V2ContinueWorkflowOutputSchema.parse({
                 kind: 'blocked',
                 stateToken: inputStateToken,
                 ackToken: inputAckToken,
-                checkpointToken,
                 isComplete: isCompleteNow,
-                pending: pendingNow
-                    ? { stepId: String(pendingNow.stepId), title: String(pendingNow.stepId), prompt: `Pending step: ${String(pendingNow.stepId)}` }
-                    : null,
+                pending: meta ? { stepId: meta.stepId, title: meta.title, prompt: meta.prompt } : null,
+                preferences,
+                nextIntent,
                 blockers,
             });
         });
@@ -296,44 +312,52 @@ function replayFromRecordedAdvance(args) {
         const pending = (0, snapshot_state_js_1.derivePendingStep)(snap.enginePayload.engineState);
         const isComplete = (0, snapshot_state_js_1.deriveIsComplete)(snap.enginePayload.engineState);
         const nextAttemptId = attemptIdForNextNode(attemptId, sha256);
-        const nextAckTokenRes = signTokenOrErr({
-            unsignedPrefix: 'ack.v1.',
-            payload: { tokenVersion: 1, tokenKind: 'ack', sessionId, runId, nodeId: toNodeIdBranded, attemptId: nextAttemptId },
-            keyring,
-            hmac,
-            base64url,
-        });
+        const nextAckTokenRes = pending
+            ? signTokenOrErr({
+                payload: { tokenVersion: 1, tokenKind: 'ack', sessionId, runId, nodeId: toNodeIdBranded, attemptId: nextAttemptId },
+                ports: tokenCodecPorts,
+            })
+            : (0, neverthrow_1.ok)(undefined);
         if (nextAckTokenRes.isErr()) {
             return (0, neverthrow_1.errAsync)({ kind: 'token_signing_failed', cause: nextAckTokenRes.error });
         }
-        const nextCheckpointTokenRes = signTokenOrErr({
-            unsignedPrefix: 'chk.v1.',
-            payload: { tokenVersion: 1, tokenKind: 'checkpoint', sessionId, runId, nodeId: toNodeIdBranded, attemptId: nextAttemptId },
-            keyring,
-            hmac,
-            base64url,
-        });
-        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 = signTokenOrErr({
-            unsignedPrefix: 'st.v1.',
-            payload: { tokenVersion: 1, tokenKind: 'state', sessionId, runId, nodeId: toNodeIdBranded, workflowHash },
-            keyring,
-            hmac,
-            base64url,
+            payload: { tokenVersion: 1, tokenKind: 'state', sessionId, runId, nodeId: toNodeIdBranded, workflowHashRef: wfRefRes.value },
+            ports: tokenCodecPorts,
         });
         if (nextStateTokenRes.isErr()) {
             return (0, neverthrow_1.errAsync)({ kind: 'token_signing_failed', cause: nextStateTokenRes.error });
         }
-        const { stepId, title, prompt } = extractStepMetadata(pinnedWorkflow, pending ? String(pending.stepId) : null);
+        const meta = pending
+            ? (0, prompt_renderer_js_1.renderPendingPrompt)({
+                workflow: pinnedWorkflow,
+                stepId: String(pending.stepId),
+                loopPath: pending.loopPath,
+                truth,
+                runId: (0, index_js_3.asRunId)(String(runId)),
+                nodeId: (0, index_js_3.asNodeId)(String(toNodeIdBranded)),
+                rehydrateOnly: false,
+            }).unwrapOr({
+                stepId: String(pending.stepId),
+                title: String(pending.stepId),
+                prompt: `Pending step: ${String(pending.stepId)}`,
+                requireConfirmation: false,
+            })
+            : { stepId: '', title: '', prompt: '', requireConfirmation: false };
+        const preferences = derivePreferencesForNode({ truth, runId, nodeId: toNodeIdBranded });
+        const nextIntent = deriveNextIntent({ rehydrateOnly: false, isComplete, pending: pending ? meta : null });
         return (0, neverthrow_1.okAsync)(output_schemas_js_1.V2ContinueWorkflowOutputSchema.parse({
             kind: 'ok',
             stateToken: nextStateTokenRes.value,
-            ackToken: nextAckTokenRes.value,
-            checkpointToken: nextCheckpointTokenRes.value,
+            ackToken: pending ? nextAckTokenRes.value : undefined,
             isComplete,
-            pending: stepId ? { stepId, title, prompt } : null,
+            pending: pending ? { stepId: meta.stepId, title: meta.title, prompt: meta.prompt } : null,
+            preferences,
+            nextIntent,
         }));
     });
 }
@@ -365,69 +389,171 @@ function advanceAndRecord(args) {
         if (!pendingStep) {
             return errAsync({ kind: 'no_pending_step' });
         }
-        const event = { kind: 'step_completed', stepInstanceId: pendingStep };
-        const advanced = interpreter.applyEvent(currentState, event);
-        if (advanced.isErr()) {
-            return errAsync({ kind: 'advance_apply_failed', message: advanced.error.message });
-        }
-        const ctxObj = inputContext && typeof inputContext === 'object' && inputContext !== null && !Array.isArray(inputContext)
+        const storedContextRes = (0, run_context_js_1.projectRunContextV2)(truth.events);
+        const storedContext = storedContextRes.isOk() ? storedContextRes.value.byRunId[String(runId)]?.context : undefined;
+        const inputContextObj = inputContext && typeof inputContext === 'object' && inputContext !== null && !Array.isArray(inputContext)
             ? inputContext
-            : {};
-        const nextRes = interpreter.next(compiledWf.value, advanced.value, ctxObj);
-        if (nextRes.isErr()) {
-            return errAsync({ kind: 'advance_next_failed', message: nextRes.error.message });
+            : undefined;
+        const mergedContextRes = (0, context_merge_js_1.mergeContext)(storedContext, inputContextObj);
+        if (mergedContextRes.isErr()) {
+            return errAsync({
+                kind: 'invariant_violation',
+                message: `Context merge failed: ${mergedContextRes.error.message}`,
+            });
         }
-        const out = nextRes.value;
-        const newEngineState = fromV1ExecutionState(out.state);
-        const snapshotFile = {
-            v: 1,
-            kind: 'execution_snapshot',
-            enginePayload: { v: 1, engineState: newEngineState },
-        };
-        return snapshotStore.putExecutionSnapshotV1(snapshotFile).andThen((newSnapshotRef) => {
-            const toNodeId = String(idFactory.mintNodeId());
-            const nextEventIndex = truth.events.length === 0 ? 0 : truth.events[truth.events.length - 1].eventIndex + 1;
-            const evtAdvanceRecorded = idFactory.mintEventId();
-            const evtNodeCreated = idFactory.mintEventId();
-            const evtEdgeCreated = idFactory.mintEventId();
-            const hasChildren = truth.events.some((e) => e.kind === 'edge_created' && e.data.fromNodeId === String(nodeId));
-            const causeKind = hasChildren ? 'non_tip_advance' : 'intentional_fork';
-            const outputId = (0, index_js_1.asOutputId)(`out_recap_${String(attemptId)}`);
-            const outputsToAppend = inputOutput?.notesMarkdown
+        const ctxObj = mergedContextRes.value;
+        const step = (0, workflow_js_1.getStepById)(pinnedWorkflow, String(pendingStep.stepId));
+        const validationCriteria = step && typeof step === 'object' && step !== null ? step.validationCriteria : undefined;
+        const notesMarkdown = inputOutput?.notesMarkdown;
+        const validator = validationCriteria ? new validation_engine_js_1.ValidationEngine(new enhanced_loop_validator_js_1.EnhancedLoopValidator()) : null;
+        const validationRes = validator && notesMarkdown
+            ? neverthrow_1.ResultAsync.fromPromise(validator.validate(notesMarkdown, validationCriteria, ctxObj), (cause) => ({ kind: 'advance_apply_failed', message: String(cause) }))
+            : (0, neverthrow_1.okAsync)(undefined);
+        return validationRes.andThen((validation) => {
+            const outputRequirement = (0, validation_criteria_validator_js_1.getOutputRequirementStatusV1)({
+                validationCriteria,
+                notesMarkdown,
+                validation,
+            });
+            const reasonsRes = (0, blocking_decision_js_1.detectBlockingReasonsV1)({ outputRequirement });
+            if (reasonsRes.isErr()) {
+                return errAsync({ kind: 'invariant_violation', message: reasonsRes.error.message });
+            }
+            const reasons = reasonsRes.value;
+            const parentByNodeId = {};
+            for (const e of truth.events) {
+                if (e.kind !== 'node_created')
+                    continue;
+                if (e.scope?.runId !== String(runId))
+                    continue;
+                parentByNodeId[String(e.scope.nodeId)] = e.data.parentNodeId;
+            }
+            const prefs = (0, preferences_js_1.projectPreferencesV2)(truth.events, parentByNodeId);
+            const autonomy = prefs.isOk() ? prefs.value.byNodeId[String(nodeId)]?.effective.autonomy ?? 'guided' : 'guided';
+            const shouldBlockNow = reasons.length > 0 && (0, reason_model_js_1.shouldBlock)(autonomy, reasons);
+            if (shouldBlockNow) {
+                const blockersRes = (0, reason_model_js_1.buildBlockerReport)(reasons);
+                if (blockersRes.isErr()) {
+                    return errAsync({ kind: 'invariant_violation', message: blockersRes.error.message });
+                }
+                const nextEventIndex = truth.events.length === 0 ? 0 : truth.events[truth.events.length - 1].eventIndex + 1;
+                const evtAdvanceRecorded = idFactory.mintEventId();
+                const planRes = (0, ack_advance_append_plan_js_1.buildAckAdvanceAppendPlanV1)({
+                    sessionId: String(sessionId),
+                    runId: String(runId),
+                    fromNodeId: String(nodeId),
+                    workflowHash,
+                    attemptId: String(attemptId),
+                    nextEventIndex,
+                    outcome: { kind: 'blocked', blockers: blockersRes.value },
+                    minted: { advanceRecordedEventId: evtAdvanceRecorded },
+                });
+                if (planRes.isErr())
+                    return errAsync({ kind: 'invariant_violation', message: planRes.error.message });
+                return sessionStore.append(lock, planRes.value);
+            }
+            const allowNotesAppend = validationCriteria
+                ? Boolean(notesMarkdown && validation && validation.valid)
+                : Boolean(notesMarkdown);
+            const gapEventsToAppend = autonomy === 'full_auto_never_stop' && reasons.length > 0
+                ? reasons.map((r, idx) => {
+                    const g = (0, reason_model_js_1.reasonToGap)(r);
+                    const gapId = `gap_${String(attemptId)}_${idx}`;
+                    return {
+                        v: 1,
+                        eventId: idFactory.mintEventId(),
+                        kind: 'gap_recorded',
+                        dedupeKey: `gap_recorded:${String(sessionId)}:${gapId}`,
+                        scope: { runId: String(runId), nodeId: String(nodeId) },
+                        data: {
+                            gapId,
+                            severity: g.severity,
+                            reason: g.reason,
+                            summary: g.summary,
+                            resolution: { kind: 'unresolved' },
+                        },
+                    };
+                })
+                : [];
+            const contextSetEvents = inputContextObj
                 ? [
                     {
-                        outputId: String(outputId),
-                        outputChannel: 'recap',
-                        payload: {
-                            payloadKind: 'notes',
-                            notesMarkdown: (0, notes_markdown_js_1.toNotesMarkdownV1)(inputOutput.notesMarkdown),
+                        v: 1,
+                        eventId: idFactory.mintEventId(),
+                        kind: 'context_set',
+                        dedupeKey: `context_set:${String(sessionId)}:${String(runId)}:${idFactory.mintEventId()}`,
+                        scope: { runId: String(runId) },
+                        data: {
+                            contextId: idFactory.mintEventId(),
+                            context: mergedContextRes.value,
+                            source: 'agent_delta',
                         },
                     },
                 ]
                 : [];
-            const normalizedOutputs = (0, outputs_js_1.normalizeOutputsForAppend)(outputsToAppend);
-            const outputEventIds = normalizedOutputs.map(() => idFactory.mintEventId());
-            const planRes = (0, ack_advance_append_plan_js_1.buildAckAdvanceAppendPlanV1)({
-                sessionId: String(sessionId),
-                runId: String(runId),
-                fromNodeId: String(nodeId),
-                workflowHash,
-                attemptId: String(attemptId),
-                nextEventIndex,
-                toNodeId,
-                snapshotRef: newSnapshotRef,
-                causeKind,
-                minted: {
-                    advanceRecordedEventId: evtAdvanceRecorded,
-                    nodeCreatedEventId: evtNodeCreated,
-                    edgeCreatedEventId: evtEdgeCreated,
-                    outputEventIds,
-                },
-                outputsToAppend,
+            const extraEventsToAppend = [...gapEventsToAppend, ...contextSetEvents];
+            const event = { kind: 'step_completed', stepInstanceId: pendingStep };
+            const advanced = interpreter.applyEvent(currentState, event);
+            if (advanced.isErr()) {
+                return errAsync({ kind: 'advance_apply_failed', message: advanced.error.message });
+            }
+            const nextRes = interpreter.next(compiledWf.value, advanced.value, ctxObj);
+            if (nextRes.isErr()) {
+                return errAsync({ kind: 'advance_next_failed', message: nextRes.error.message });
+            }
+            const out = nextRes.value;
+            const newEngineState = fromV1ExecutionState(out.state);
+            const snapshotFile = {
+                v: 1,
+                kind: 'execution_snapshot',
+                enginePayload: { v: 1, engineState: newEngineState },
+            };
+            return snapshotStore.putExecutionSnapshotV1(snapshotFile).andThen((newSnapshotRef) => {
+                const toNodeId = String(idFactory.mintNodeId());
+                const nextEventIndex = truth.events.length === 0 ? 0 : truth.events[truth.events.length - 1].eventIndex + 1;
+                const evtAdvanceRecorded = idFactory.mintEventId();
+                const evtNodeCreated = idFactory.mintEventId();
+                const evtEdgeCreated = idFactory.mintEventId();
+                const hasChildren = truth.events.some((e) => e.kind === 'edge_created' && e.data.fromNodeId === String(nodeId));
+                const causeKind = hasChildren ? 'non_tip_advance' : 'intentional_fork';
+                const outputId = (0, index_js_1.asOutputId)(`out_recap_${String(attemptId)}`);
+                const outputsToAppend = allowNotesAppend && inputOutput?.notesMarkdown
+                    ? [
+                        {
+                            outputId: String(outputId),
+                            outputChannel: 'recap',
+                            payload: {
+                                payloadKind: 'notes',
+                                notesMarkdown: (0, notes_markdown_js_1.toNotesMarkdownV1)(inputOutput.notesMarkdown),
+                            },
+                        },
+                    ]
+                    : [];
+                const normalizedOutputs = (0, outputs_js_1.normalizeOutputsForAppend)(outputsToAppend);
+                const outputEventIds = normalizedOutputs.map(() => idFactory.mintEventId());
+                const planRes = (0, ack_advance_append_plan_js_1.buildAckAdvanceAppendPlanV1)({
+                    sessionId: String(sessionId),
+                    runId: String(runId),
+                    fromNodeId: String(nodeId),
+                    workflowHash,
+                    attemptId: String(attemptId),
+                    nextEventIndex,
+                    extraEventsToAppend,
+                    toNodeId,
+                    snapshotRef: newSnapshotRef,
+                    causeKind,
+                    minted: {
+                        advanceRecordedEventId: evtAdvanceRecorded,
+                        nodeCreatedEventId: evtNodeCreated,
+                        edgeCreatedEventId: evtEdgeCreated,
+                        outputEventIds,
+                    },
+                    outputsToAppend,
+                });
+                if (planRes.isErr())
+                    return errAsync({ kind: 'invariant_violation', message: planRes.error.message });
+                return sessionStore.append(lock, planRes.value);
             });
-            if (planRes.isErr())
-                return errAsync({ kind: 'invariant_violation', message: planRes.error.message });
-            return sessionStore.append(lock, planRes.value);
         });
     });
 }
@@ -447,7 +573,37 @@ function extractStepMetadata(workflow, stepId, options) {
     const prompt = hasStringProp(step, 'prompt')
         ? String(step.prompt)
         : options?.defaultPrompt ?? (stepId ? `Pending step: ${stepId}` : '');
-    return { stepId: resolvedStepId, title, prompt };
+    const requireConfirmation = typeof step === 'object' && step !== null && 'requireConfirmation' in step
+        ? Boolean(step.requireConfirmation)
+        : false;
+    return { stepId: resolvedStepId, title, prompt, requireConfirmation };
+}
+const defaultPreferences = { autonomy: 'guided', riskPolicy: 'conservative' };
+function derivePreferencesForNode(args) {
+    const parentByNodeId = {};
+    for (const e of args.truth.events) {
+        if (e.kind !== 'node_created')
+            continue;
+        if (e.scope?.runId !== String(args.runId))
+            continue;
+        parentByNodeId[String(e.scope.nodeId)] = e.data.parentNodeId;
+    }
+    const prefs = (0, preferences_js_1.projectPreferencesV2)(args.truth.events, parentByNodeId);
+    if (prefs.isErr())
+        return defaultPreferences;
+    const p = prefs.value.byNodeId[String(args.nodeId)]?.effective;
+    if (!p)
+        return defaultPreferences;
+    return { autonomy: p.autonomy, riskPolicy: p.riskPolicy };
+}
+function deriveNextIntent(args) {
+    if (args.isComplete && !args.pending)
+        return 'complete';
+    if (args.rehydrateOnly)
+        return 'rehydrate_only';
+    if (!args.pending)
+        return 'complete';
+    return args.pending.requireConfirmation ? 'await_user_confirmation' : 'perform_pending_then_continue';
 }
 function internalError(message, suggestion) {
     return (0, types_js_1.errNotRetryable)('INTERNAL_ERROR', normalizeTokenErrorMessage(message), suggestion ? { suggestion } : undefined);
@@ -496,38 +652,38 @@ function snapshotStoreErrorToToolError(e, suggestion) {
 function pinnedWorkflowStoreErrorToToolError(e, suggestion) {
     return internalError(`Pinned workflow store error: ${e.message}`, suggestion);
 }
-function parseStateTokenOrFail(raw, keyring, hmac, base64url) {
-    const parsedRes = (0, index_js_1.parseTokenV1)(raw, base64url);
+function parseStateTokenOrFail(raw, ports) {
+    const parsedRes = (0, index_js_1.parseTokenV1Binary)(raw, ports);
     if (parsedRes.isErr()) {
         return { ok: false, failure: (0, v2_execution_helpers_js_1.mapTokenDecodeErrorToToolError)(parsedRes.error) };
     }
-    const verified = (0, index_js_1.verifyTokenSignatureV1)(parsedRes.value, keyring, hmac, base64url);
+    const verified = (0, index_js_1.verifyTokenSignatureV1Binary)(parsedRes.value, ports);
     if (verified.isErr()) {
         return { ok: false, failure: (0, v2_execution_helpers_js_1.mapTokenVerifyErrorToToolError)(verified.error) };
     }
     if (parsedRes.value.payload.tokenKind !== 'state') {
         return {
             ok: false,
-            failure: (0, types_js_1.errNotRetryable)('TOKEN_INVALID_FORMAT', 'Expected a state token (st.v1.*).', {
+            failure: (0, types_js_1.errNotRetryable)('TOKEN_INVALID_FORMAT', 'Expected a state token (st1...).', {
                 suggestion: 'Use the stateToken returned by WorkRail.',
             }),
         };
     }
     return { ok: true, token: parsedRes.value };
 }
-function parseAckTokenOrFail(raw, keyring, hmac, base64url) {
-    const parsedRes = (0, index_js_1.parseTokenV1)(raw, base64url);
+function parseAckTokenOrFail(raw, ports) {
+    const parsedRes = (0, index_js_1.parseTokenV1Binary)(raw, ports);
     if (parsedRes.isErr()) {
         return { ok: false, failure: (0, v2_execution_helpers_js_1.mapTokenDecodeErrorToToolError)(parsedRes.error) };
     }
-    const verified = (0, index_js_1.verifyTokenSignatureV1)(parsedRes.value, keyring, hmac, base64url);
+    const verified = (0, index_js_1.verifyTokenSignatureV1Binary)(parsedRes.value, ports);
     if (verified.isErr()) {
         return { ok: false, failure: (0, v2_execution_helpers_js_1.mapTokenVerifyErrorToToolError)(verified.error) };
     }
     if (parsedRes.value.payload.tokenKind !== 'ack') {
         return {
             ok: false,
-            failure: (0, types_js_1.errNotRetryable)('TOKEN_INVALID_FORMAT', 'Expected an ack token (ack.v1.*).', {
+            failure: (0, types_js_1.errNotRetryable)('TOKEN_INVALID_FORMAT', 'Expected an ack token (ack1...).', {
                 suggestion: 'Use the ackToken returned by WorkRail.',
             }),
         };
@@ -541,13 +697,10 @@ function attemptIdForNextNode(parentAttemptId, sha256) {
     return (0, attempt_id_derivation_js_1.deriveChildAttemptId)(parentAttemptId, sha256);
 }
 function signTokenOrErr(args) {
-    const bytes = (0, index_js_2.encodeTokenPayloadV1)(args.payload);
-    if (bytes.isErr())
-        return (0, neverthrow_1.err)(bytes.error);
-    const token = (0, index_js_2.signTokenV1)(args.unsignedPrefix, bytes.value, args.keyring, args.hmac, args.base64url);
+    const token = (0, index_js_2.signTokenV1Binary)(args.payload, args.ports);
     if (token.isErr())
         return (0, neverthrow_1.err)(token.error);
-    return (0, neverthrow_1.ok)(String(token.value));
+    return (0, neverthrow_1.ok)(token.value);
 }
 function toV1ExecutionState(engineState) {
     if (engineState.kind === 'init')
@@ -630,7 +783,7 @@ function executeStartWorkflow(input, ctx) {
     if (!ctx.v2) {
         return (0, neverthrow_1.errAsync)({ kind: 'precondition_failed', message: 'v2 tools disabled', suggestion: 'Enable v2Tools flag' });
     }
-    const { gate, sessionStore, snapshotStore, pinnedStore, keyring, crypto, hmac, base64url, idFactory } = ctx.v2;
+    const { gate, sessionStore, snapshotStore, pinnedStore, crypto, tokenCodecPorts, idFactory } = ctx.v2;
     if (!idFactory) {
         return (0, neverthrow_1.errAsync)({
             kind: 'precondition_failed',
@@ -638,6 +791,13 @@ function executeStartWorkflow(input, ctx) {
             suggestion: 'Reinitialize v2 tool context (idFactory must be provided when v2Tools are enabled).',
         });
     }
+    if (!tokenCodecPorts) {
+        return (0, neverthrow_1.errAsync)({
+            kind: 'precondition_failed',
+            message: 'v2 context missing tokenCodecPorts dependency',
+            suggestion: 'Reinitialize v2 tool context (tokenCodecPorts must be provided when v2Tools are enabled).',
+        });
+    }
     const ctxCheck = checkContextBudget({ tool: 'start_workflow', context: input.context });
     if (!ctxCheck.ok)
         return (0, neverthrow_1.errAsync)({ kind: 'validation_failed', failure: ctxCheck.error });
@@ -708,7 +868,11 @@ function executeStartWorkflow(input, ctx) {
             const evtRunStarted = idFactory.mintEventId();
             const evtNodeCreated = idFactory.mintEventId();
             return gate.withHealthySessionLock(sessionId, (lock) => {
-                const eventsArray = [
+                const evtPreferencesChanged = idFactory.mintEventId();
+                const changeId = idFactory.mintEventId();
+                const evtContextSet = idFactory.mintEventId();
+                const contextId = idFactory.mintEventId();
+                const baseEvents = [
                     {
                         v: 1,
                         eventId: evtSessionCreated,
@@ -756,7 +920,47 @@ function executeStartWorkflow(input, ctx) {
                             snapshotRef,
                         },
                     },
+                    {
+                        v: 1,
+                        eventId: evtPreferencesChanged,
+                        eventIndex: 3,
+                        sessionId,
+                        kind: 'preferences_changed',
+                        dedupeKey: `preferences_changed:${sessionId}:${runId}:${nodeId}:${changeId}`,
+                        scope: { runId, nodeId },
+                        data: {
+                            changeId,
+                            source: 'system',
+                            delta: [
+                                { key: 'autonomy', value: defaultPreferences.autonomy },
+                                { key: 'riskPolicy', value: defaultPreferences.riskPolicy },
+                            ],
+                            effective: {
+                                autonomy: defaultPreferences.autonomy,
+                                riskPolicy: defaultPreferences.riskPolicy,
+                            },
+                        },
+                    },
                 ];
+                const eventsArray = input.context
+                    ? [
+                        ...baseEvents,
+                        {
+                            v: 1,
+                            eventId: evtContextSet,
+                            eventIndex: 4,
+                            sessionId,
+                            kind: 'context_set',
+                            dedupeKey: `context_set:${sessionId}:${runId}:${contextId}`,
+                            scope: { runId },
+                            data: {
+                                contextId,
+                                context: input.context,
+                                source: 'initial',
+                            },
+                        },
+                    ]
+                    : baseEvents;
                 return sessionStore.append(lock, {
                     events: eventsArray,
                     snapshotPins: [{ snapshotRef, eventIndex: 2, createdByEventId: evtNodeCreated }],
@@ -767,13 +971,21 @@ function executeStartWorkflow(input, ctx) {
         });
     })
         .andThen(({ pinnedWorkflow, firstStep, workflowHash, sessionId, runId, nodeId }) => {
+        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 the pinned workflowHash is a valid sha256 digest.',
+            });
+        }
         const statePayload = {
             tokenVersion: 1,
             tokenKind: 'state',
             sessionId,
             runId,
             nodeId,
-            workflowHash,
+            workflowHashRef: wfRefRes.value,
         };
         const attemptId = newAttemptId(idFactory);
         const ackPayload = {
@@ -784,31 +996,37 @@ function executeStartWorkflow(input, ctx) {
             nodeId,
             attemptId,
         };
-        const checkpointPayload = {
-            tokenVersion: 1,
-            tokenKind: 'checkpoint',
-            sessionId,
-            runId,
-            nodeId,
-            attemptId,
-        };
-        const stateToken = signTokenOrErr({ unsignedPrefix: 'st.v1.', payload: statePayload, keyring, hmac, base64url });
+        const stateToken = signTokenOrErr({ payload: statePayload, ports: tokenCodecPorts });
         if (stateToken.isErr())
             return (0, neverthrow_1.errAsync)({ kind: 'token_signing_failed', cause: stateToken.error });
-        const ackToken = signTokenOrErr({ unsignedPrefix: 'ack.v1.', payload: ackPayload, keyring, hmac, base64url });
+        const ackToken = signTokenOrErr({ payload: ackPayload, ports: tokenCodecPorts });
         if (ackToken.isErr())
             return (0, neverthrow_1.errAsync)({ kind: 'token_signing_failed', cause: ackToken.error });
-        const checkpointToken = signTokenOrErr({ unsignedPrefix: 'chk.v1.', payload: checkpointPayload, keyring, hmac, base64url });
-        if (checkpointToken.isErr())
-            return (0, neverthrow_1.errAsync)({ kind: 'token_signing_failed', cause: checkpointToken.error });
-        const { stepId, title, prompt } = extractStepMetadata(pinnedWorkflow, firstStep.id);
-        const pending = { stepId, title, prompt };
+        const metaRes = (0, prompt_renderer_js_1.renderPendingPrompt)({
+            workflow: pinnedWorkflow,
+            stepId: firstStep.id,
+            loopPath: [],
+            truth: { events: [], manifest: [] },
+            runId: (0, index_js_3.asRunId)(String(runId)),
+            nodeId: (0, index_js_3.asNodeId)(String(nodeId)),
+            rehydrateOnly: false,
+        });
+        const meta = metaRes.isOk() ? metaRes.value : {
+            stepId: firstStep.id,
+            title: firstStep.title,
+            prompt: firstStep.prompt,
+            requireConfirmation: Boolean(firstStep.requireConfirmation),
+        };
+        const pending = { stepId: meta.stepId, title: meta.title, prompt: meta.prompt };
+        const preferences = defaultPreferences;
+        const nextIntent = deriveNextIntent({ rehydrateOnly: false, isComplete: false, pending: meta });
         return (0, neverthrow_1.okAsync)(output_schemas_js_1.V2StartWorkflowOutputSchema.parse({
             stateToken: stateToken.value,
             ackToken: ackToken.value,
-            checkpointToken: checkpointToken.value,
             isComplete: false,
             pending,
+            preferences,
+            nextIntent,
         }));
     });
 }
@@ -819,7 +1037,7 @@ function executeContinueWorkflow(input, ctx) {
     if (!ctx.v2) {
         return (0, neverthrow_1.errAsync)({ kind: 'precondition_failed', message: 'v2 tools disabled', suggestion: 'Enable v2Tools flag' });
     }
-    const { gate, sessionStore, snapshotStore, pinnedStore, keyring, sha256, crypto, hmac, base64url, idFactory } = ctx.v2;
+    const { gate, sessionStore, snapshotStore, pinnedStore, sha256, tokenCodecPorts, idFactory } = ctx.v2;
     if (!sha256 || !idFactory) {
         return (0, neverthrow_1.errAsync)({
             kind: 'precondition_failed',
@@ -827,7 +1045,14 @@ function executeContinueWorkflow(input, ctx) {
             suggestion: 'Reinitialize v2 tool context (sha256 and idFactory must be provided when v2Tools are enabled).',
         });
     }
-    const stateRes = parseStateTokenOrFail(input.stateToken, keyring, hmac, base64url);
+    if (!tokenCodecPorts) {
+        return (0, neverthrow_1.errAsync)({
+            kind: 'precondition_failed',
+            message: 'v2 context missing tokenCodecPorts dependency',
+            suggestion: 'Reinitialize v2 tool context (tokenCodecPorts must be provided when v2Tools are enabled).',
+        });
+    }
+    const stateRes = parseStateTokenOrFail(input.stateToken, tokenCodecPorts);
     if (!stateRes.ok)
         return (0, neverthrow_1.errAsync)({ kind: 'validation_failed', failure: stateRes.failure });
     const state = stateRes.token;
@@ -837,7 +1062,7 @@ function executeContinueWorkflow(input, ctx) {
     const sessionId = (0, index_js_3.asSessionId)(state.payload.sessionId);
     const runId = (0, index_js_3.asRunId)(state.payload.runId);
     const nodeId = (0, index_js_3.asNodeId)(state.payload.nodeId);
-    const workflowHash = (0, index_js_3.asWorkflowHash)((0, index_js_3.asSha256Digest)(state.payload.workflowHash));
+    const workflowHashRef = state.payload.workflowHashRef;
     if (!input.ackToken) {
         return sessionStore.load(sessionId)
             .mapErr((cause) => ({ kind: 'session_load_failed', cause }))
@@ -851,7 +1076,16 @@ function executeContinueWorkflow(input, ctx) {
                     suggestion: 'Use start_workflow to mint a new run, or use a stateToken returned by WorkRail for an existing run.',
                 });
             }
-            if (String(runStarted.data.workflowHash) !== String(workflowHash)) {
+            const workflowHash = runStarted.data.workflowHash;
+            const expectedRefRes = (0, workflow_hash_ref_js_1.deriveWorkflowHashRef)(workflowHash);
+            if (expectedRefRes.isErr()) {
+                return (0, neverthrow_1.errAsync)({
+                    kind: 'precondition_failed',
+                    message: expectedRefRes.error.message,
+                    suggestion: 'Re-pin the workflow via start_workflow.',
+                });
+            }
+            if (String(expectedRefRes.value) !== String(workflowHashRef)) {
                 return (0, neverthrow_1.errAsync)({ kind: 'precondition_failed', message: 'workflowHash mismatch for this run.', suggestion: 'Use the stateToken returned by WorkRail for this run.' });
             }
             const nodeCreated = truth.events.find((e) => e.kind === 'node_created' && e.scope.nodeId === String(nodeId) && e.scope.runId === String(runId));
@@ -862,7 +1096,15 @@ function executeContinueWorkflow(input, ctx) {
                     suggestion: 'Use a stateToken returned by WorkRail for an existing node.',
                 });
             }
-            if (String(nodeCreated.data.workflowHash) !== String(workflowHash)) {
+            const expectedNodeRefRes = (0, workflow_hash_ref_js_1.deriveWorkflowHashRef)(nodeCreated.data.workflowHash);
+            if (expectedNodeRefRes.isErr()) {
+                return (0, neverthrow_1.errAsync)({
+                    kind: 'precondition_failed',
+                    message: expectedNodeRefRes.error.message,
+                    suggestion: 'Re-pin the workflow via start_workflow.',
+                });
+            }
+            if (String(expectedNodeRefRes.value) !== String(workflowHashRef)) {
                 return (0, neverthrow_1.errAsync)({ kind: 'precondition_failed', message: 'workflowHash mismatch for this node.', suggestion: 'Use the stateToken returned by WorkRail for this node.' });
             }
             return snapshotStore.getExecutionSnapshotV1(nodeCreated.data.snapshotRef)
@@ -878,40 +1120,30 @@ function executeContinueWorkflow(input, ctx) {
                 const engineState = snapshot.enginePayload.engineState;
                 const pending = (0, snapshot_state_js_1.derivePendingStep)(engineState);
                 const isComplete = (0, snapshot_state_js_1.deriveIsComplete)(engineState);
-                const attemptId = newAttemptId(idFactory);
-                const ackTokenRes = signTokenOrErr({
-                    unsignedPrefix: 'ack.v1.',
-                    payload: { tokenVersion: 1, tokenKind: 'ack', sessionId, runId, nodeId, attemptId },
-                    keyring,
-                    hmac,
-                    base64url,
-                });
-                if (ackTokenRes.isErr())
-                    return (0, neverthrow_1.errAsync)({ kind: 'token_signing_failed', cause: ackTokenRes.error });
-                const checkpointTokenRes = signTokenOrErr({
-                    unsignedPrefix: 'chk.v1.',
-                    payload: { tokenVersion: 1, tokenKind: 'checkpoint', sessionId, runId, nodeId, attemptId },
-                    keyring,
-                    hmac,
-                    base64url,
-                });
-                if (checkpointTokenRes.isErr())
-                    return (0, neverthrow_1.errAsync)({ kind: 'token_signing_failed', cause: checkpointTokenRes.error });
                 if (!pending) {
+                    const preferences = derivePreferencesForNode({ truth, runId, nodeId });
+                    const nextIntent = deriveNextIntent({ rehydrateOnly: true, isComplete, pending: null });
                     return (0, neverthrow_1.okAsync)(output_schemas_js_1.V2ContinueWorkflowOutputSchema.parse({
                         kind: 'ok',
                         stateToken: input.stateToken,
-                        ackToken: ackTokenRes.value,
-                        checkpointToken: checkpointTokenRes.value,
                         isComplete,
                         pending: null,
+                        preferences,
+                        nextIntent,
                     }));
                 }
+                const attemptId = newAttemptId(idFactory);
+                const ackTokenRes = 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 });
                 return pinnedStore.get(workflowHash)
                     .mapErr((cause) => ({ kind: 'pinned_workflow_store_failed', cause }))
                     .andThen((pinned) => {
                     if (!pinned)
-                        return (0, neverthrow_1.errAsync)({ kind: 'pinned_workflow_missing', workflowHash: (0, index_js_3.asWorkflowHash)((0, index_js_3.asSha256Digest)(String(workflowHash))) });
+                        return (0, neverthrow_1.errAsync)({ kind: 'pinned_workflow_missing', workflowHash });
                     if (pinned.sourceKind !== 'v1_pinned')
                         return (0, neverthrow_1.errAsync)({ kind: 'precondition_failed', message: 'Pinned workflow snapshot is read-only (v1_preview) and cannot be executed.' });
                     if (!(0, workflow_definition_js_1.hasWorkflowDefinitionShape)(pinned.definition)) {
@@ -922,24 +1154,43 @@ function executeContinueWorkflow(input, ctx) {
                         });
                     }
                     const wf = (0, workflow_js_1.createWorkflow)(pinned.definition, (0, workflow_source_js_1.createBundledSource)());
-                    const { stepId, title, prompt } = extractStepMetadata(wf, String(pending.stepId));
+                    const metaRes = (0, prompt_renderer_js_1.renderPendingPrompt)({
+                        workflow: wf,
+                        stepId: String(pending.stepId),
+                        loopPath: pending.loopPath,
+                        truth,
+                        runId: (0, index_js_3.asRunId)(String(runId)),
+                        nodeId: (0, index_js_3.asNodeId)(String(nodeId)),
+                        rehydrateOnly: true,
+                    });
+                    if (metaRes.isErr()) {
+                        return (0, neverthrow_1.errAsync)({
+                            kind: 'invariant_violation',
+                            message: `Prompt rendering failed: ${metaRes.error.message}`,
+                            suggestion: 'Retry; if this persists, treat as invariant violation.',
+                        });
+                    }
+                    const meta = metaRes.value;
+                    const preferences = derivePreferencesForNode({ truth, runId, nodeId });
+                    const nextIntent = 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,
                         isComplete,
-                        pending: { stepId, title, prompt },
+                        pending: { stepId: meta.stepId, title: meta.title, prompt: meta.prompt },
+                        preferences,
+                        nextIntent,
                     }));
                 });
             });
         });
     }
-    const ackRes = parseAckTokenOrFail(input.ackToken, keyring, hmac, base64url);
+    const ackRes = 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.assertTokenScopeMatchesState)(state, ack);
+    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);
@@ -947,6 +1198,53 @@ function executeContinueWorkflow(input, ctx) {
     return sessionStore.load(sessionId)
         .mapErr((cause) => ({ kind: 'session_load_failed', cause }))
         .andThen((truth) => {
+        const runStarted = truth.events.find((e) => e.kind === 'run_started' && e.scope.runId === String(runId));
+        if (!runStarted) {
+            return (0, neverthrow_1.errAsync)({
+                kind: 'token_unknown_node',
+                message: 'No durable run state was found for this token (missing run_started).',
+                suggestion: 'Use start_workflow to mint a new run, or use tokens returned by WorkRail for an existing run.',
+            });
+        }
+        const workflowHash = runStarted.data.workflowHash;
+        const refRes = (0, workflow_hash_ref_js_1.deriveWorkflowHashRef)(workflowHash);
+        if (refRes.isErr()) {
+            return (0, neverthrow_1.errAsync)({
+                kind: 'precondition_failed',
+                message: refRes.error.message,
+                suggestion: 'Re-pin the workflow via start_workflow.',
+            });
+        }
+        if (String(refRes.value) !== String(workflowHashRef)) {
+            return (0, neverthrow_1.errAsync)({
+                kind: 'precondition_failed',
+                message: 'workflowHash mismatch for this run.',
+                suggestion: 'Use the stateToken returned by WorkRail for this run.',
+            });
+        }
+        const nodeCreated = truth.events.find((e) => e.kind === 'node_created' && e.scope.nodeId === String(nodeId) && e.scope.runId === String(runId));
+        if (!nodeCreated) {
+            return (0, neverthrow_1.errAsync)({
+                kind: 'token_unknown_node',
+                message: 'No durable node state was found for this token (missing node_created).',
+                suggestion: 'Use tokens returned by WorkRail for an existing node.',
+            });
+        }
+        const nodeRefRes = (0, workflow_hash_ref_js_1.deriveWorkflowHashRef)(nodeCreated.data.workflowHash);
+        if (nodeRefRes.isErr()) {
+            return (0, neverthrow_1.errAsync)({
+                kind: 'precondition_failed',
+                message: nodeRefRes.error.message,
+                suggestion: 'Re-pin the workflow via start_workflow.',
+            });
+        }
+        if (String(nodeRefRes.value) !== String(workflowHashRef)) {
+            return (0, neverthrow_1.errAsync)({
+                kind: 'precondition_failed',
+                message: 'workflowHash mismatch for this node.',
+                suggestion: 'Use the stateToken returned by WorkRail for this node.',
+            });
+        }
         const existing = truth.events.find((e) => e.kind === 'advance_recorded' && e.dedupeKey === dedupeKey);
         return pinnedStore.get(workflowHash)
             .mapErr((cause) => ({ kind: 'pinned_workflow_store_failed', cause }))
@@ -976,10 +1274,8 @@ function executeContinueWorkflow(input, ctx) {
                     inputAckToken: input.ackToken,
                     pinnedWorkflow,
                     snapshotStore,
-                    keyring,
                     sha256,
-                    hmac,
-                    base64url,
+                    tokenCodecPorts,
                 });
             }
             return gate
@@ -1050,10 +1346,8 @@ function executeContinueWorkflow(input, ctx) {
                     inputAckToken: input.ackToken,
                     pinnedWorkflow,
                     snapshotStore,
-                    keyring,
                     sha256,
-                    hmac,
-                    base64url,
+                    tokenCodecPorts,
                 });
             });
         });