@exaudeus/workrail 1.14.1 → 1.15.0

package/dist/application/services/validation-engine.js

@@ -349,9 +349,9 @@ let ValidationEngine = ValidationEngine_1 = class ValidationEngine {
         switch (step.loop.type) {
             case 'while':
             case 'until':
-                if (!step.loop.condition) {
-                    issues.push(`${step.loop.type} loop requires a condition`);
-                    suggestions.push(`Add a condition that evaluates to false (for while) or true (for until) to exit the loop`);
+                if (!step.loop.condition && !step.loop.conditionSource) {
+                    issues.push(`${step.loop.type} loop requires a condition or conditionSource`);
+                    suggestions.push(`Add a conditionSource (preferred) or a condition field to control loop exit`);
                 }
                 break;
             case 'for':

package/dist/manifest.json

@@ -94,8 +94,8 @@
       "bytes": 2030
     },
     "application/services/validation-engine.js": {
-      "sha256": "a2ad656656b8d2554d0a08f6e230c190c72939d11cdba329b8de268d9ad52584",
-      "bytes": 31342
+      "sha256": "19d8d4e058bf27bd2869e96622544f7c342c934aae7b8e2d3371f4b0e71aa49a",
+      "bytes": 31378
     },
     "application/services/workflow-compiler.d.ts": {
       "sha256": "41d0643ae2f07e5ce77a6e02344b5ca5b3c26bde828fbb307528a2ae097ac9d5",
@@ -582,8 +582,8 @@
       "bytes": 838
     },
     "mcp/handler-factory.js": {
-      "sha256": "8cc0d3e1a7871048b9033a90fb63b3dfd91148c16d22ac5336a767ed2d04a10b",
-      "bytes": 3907
+      "sha256": "b9d0b1843530f042c2ef7d33ac614042ee4e775a084ea8de7a4572cacb0519db",
+      "bytes": 4349
     },
     "mcp/handlers/session.d.ts": {
       "sha256": "38926e69a0e4935d1dbcdc53848be9fff0e4d8f96827883da3216f217918fa82",
@@ -686,8 +686,8 @@
       "bytes": 5712
     },
     "mcp/handlers/v2-execution-helpers.js": {
-      "sha256": "9ac62b0d64ea10a89b18e79a01b1f5b05d35e40eddcb7a9f93a3bcbe737e85b3",
-      "bytes": 18751
+      "sha256": "59b6531ca1c0136335d41967b768af9b347f4167aa909ba77cb1bf5b5108e81c",
+      "bytes": 18725
     },
     "mcp/handlers/v2-execution.d.ts": {
       "sha256": "f76cd1bb6a6e25c5a37a1f5b01b1046f4afd41162b620f3be3861509e1fcd1d3",
@@ -814,8 +814,8 @@
       "bytes": 168
     },
     "mcp/server.js": {
-      "sha256": "c29e4ad8a9ed43304654f59725a7dd50a6fe5cd4cde9e7db2678ae9a7ccd0557",
-      "bytes": 12643
+      "sha256": "4ca61965fdf522e5cc839e26220491638f03053a12f23c4eaf000b54b50ab7ad",
+      "bytes": 12934
     },
     "mcp/tool-description-provider.d.ts": {
       "sha256": "1d46abc3112e11b68e57197e846f5708293ec9b2281fa71a9124ee2aad71e41b",
@@ -830,8 +830,8 @@
       "bytes": 132
     },
     "mcp/tool-descriptions.js": {
-      "sha256": "1444469a7f3ac328573cc8af0cca347754e17fb184a832f78405fd4f21ed6350",
-      "bytes": 17534
+      "sha256": "b689f4b8d83398a9ee7cf8ff5b36536bccd458b65040e801de3693937dc4aab6",
+      "bytes": 17639
     },
     "mcp/tool-factory.d.ts": {
       "sha256": "0fe3c6b863b2d7aef0c3d659ff54f3a9ee8a0a3c2005b6565d2f8ad517bc7211",
@@ -881,6 +881,14 @@
       "sha256": "e81dbbcf86f0f8c88edad0b27d78bc93acebd83e52f919cdf69f9c7906233bfc",
       "bytes": 2674
     },
+    "mcp/v2-response-formatter.d.ts": {
+      "sha256": "51d09b828d7dcfa1c82607d4f27030c8913b2c7502ee2fb65c0cfc7618916701",
+      "bytes": 81
+    },
+    "mcp/v2-response-formatter.js": {
+      "sha256": "a2e0b576e49bdf66272dcd56ce91f451456afc236e8957af5e574bb458b30727",
+      "bytes": 6949
+    },
     "mcp/v2/tool-registry.d.ts": {
       "sha256": "d4d4927728c3cab1c014661d499dd0119538371bc6c5e821a4cd31df7abebedf",
       "bytes": 408
@@ -894,8 +902,8 @@
       "bytes": 6567
     },
     "mcp/v2/tools.js": {
-      "sha256": "0d55830445ed414f31f52fc2775ea631fe1cb3f91b04e4dda33850dd2d8572cd",
-      "bytes": 7506
+      "sha256": "8534b0a7c08877b30022914f32b2e7b739aca4112f55762a56c89599df7fa3dd",
+      "bytes": 7875
     },
     "mcp/validation/bounded-json.d.ts": {
       "sha256": "82203ac6123d5c6989606c3b5405aaea99ab829c8958835f9ae3ba45b8bc8fd5",
@@ -1358,16 +1366,16 @@
       "bytes": 935
     },
     "v2/durable-core/domain/prompt-renderer.js": {
-      "sha256": "3dd32e6335bc1aabe24f2477312975af8ef548daf5c7aad5e7f6b4e7aa2f5a78",
-      "bytes": 9074
+      "sha256": "2b086cfb9330221f05c29b6945390855e3bf0efaba8af84671793ad1b26d082b",
+      "bytes": 12378
     },
     "v2/durable-core/domain/reason-model.d.ts": {
       "sha256": "650fcb2d9969a4e6123cccbd4913f4d57aeab21a19bb907aa1e11f95e5a95089",
       "bytes": 3762
     },
     "v2/durable-core/domain/reason-model.js": {
-      "sha256": "23421e96b87cc59fec1a9205979410d27b2607c5b5cb98302902d0bcf32dfe3d",
-      "bytes": 11820
+      "sha256": "7fb414218faac148451a717c9e9a6a18e6aada92d003443d90dd895e7473f9e8",
+      "bytes": 11933
     },
     "v2/durable-core/domain/recap-recovery.d.ts": {
       "sha256": "82e7b20a22d409f729ccf79d345c00a7e27f1898a465dfca4cd789ff7766a3d6",
@@ -1538,12 +1546,12 @@
       "bytes": 1728
     },
     "v2/durable-core/schemas/artifacts/loop-control.d.ts": {
-      "sha256": "2575028ca2f52f4562857edd76696f6a6cd57f7aaa916346b00c76f62fdec498",
-      "bytes": 2743
+      "sha256": "f1201fe5ab9680b11959985bf6004adcd8227de74b8151a6b4457553d6394203",
+      "bytes": 2792
     },
     "v2/durable-core/schemas/artifacts/loop-control.js": {
-      "sha256": "1e0b70991023554e0ea3c858517aee7ffd050ab695a2f31768c4ec3d8de1cf92",
-      "bytes": 2152
+      "sha256": "8f0cb5a113d7700a2a0aca158a7463bd5528b40d2e16dc14d1596e997c5b3b0d",
+      "bytes": 2243
     },
     "v2/durable-core/schemas/compiled-workflow/index.d.ts": {
       "sha256": "d909c13d0d46bba1dcd411a0c53e767cf7e4c8bc5206581344ca1e7315552d95",
@@ -2182,20 +2190,20 @@
       "bytes": 204
     },
     "v2/usecases/console-routes.js": {
-      "sha256": "336dfa1d5fc86889b68ae5363a9f7a5b7832064beada2fc0150cb32c7deb4598",
-      "bytes": 2196
+      "sha256": "317a54962044e3631bb5ce2647c6e8080c065ae0506da52ac4a2352954b9814f",
+      "bytes": 2734
     },
     "v2/usecases/console-service.d.ts": {
-      "sha256": "787b1e01e7e30354f56203822142e825069bd42fba476797df6672c96dd5b555",
-      "bytes": 1083
+      "sha256": "88bf7eb84bad74c048f76038b0d2631d49f2256587e42907fe2df14fc58f67e1",
+      "bytes": 1506
     },
     "v2/usecases/console-service.js": {
-      "sha256": "e3df9ceaf0fcca2e55f7625f4610a053629b360638f469446ab8f576d32be8a9",
-      "bytes": 7183
+      "sha256": "21e129a7eb43523ef10eb941849ca5383ce7c1f4ecbdf2150a11166982c24845",
+      "bytes": 23404
     },
     "v2/usecases/console-types.d.ts": {
-      "sha256": "84c4c839b5285f5a29d85b7b4188e7948f92be1f34e44618cc0c9c85a1c11a18",
-      "bytes": 1799
+      "sha256": "8c2a66a2c3f5c317c9988853a75f04d83358b7ff98ece0d7861528ea4e23402d",
+      "bytes": 3575
     },
     "v2/usecases/console-types.js": {
       "sha256": "d43aa81f5bc89faa359e0f97c814ba25155591ff078fbb9bfd40f8c7c9683230",

package/dist/mcp/handler-factory.js

@@ -7,12 +7,21 @@ const types_js_1 = require("./types.js");
 const index_js_1 = require("./validation/index.js");
 const bounded_json_js_1 = require("./validation/bounded-json.js");
 const v2_execution_helpers_js_1 = require("./handlers/v2-execution-helpers.js");
+const v2_response_formatter_js_1 = require("./v2-response-formatter.js");
+const jsonResponsesOverride = process.env.WORKRAIL_JSON_RESPONSES === 'true';
 function toMcpResult(result) {
     switch (result.type) {
-        case 'success':
+        case 'success': {
+            if (!jsonResponsesOverride) {
+                const nl = (0, v2_response_formatter_js_1.formatV2ExecutionResponse)(result.data);
+                if (nl !== null) {
+                    return { content: [{ type: 'text', text: nl }] };
+                }
+            }
             return {
                 content: [{ type: 'text', text: JSON.stringify(result.data, null, 2) }],
             };
+        }
         case 'error':
             return {
                 content: [{

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

@@ -92,7 +92,7 @@ function mapTokenDecodeErrorToToolError(e) {
         const bech32mErr = e.details.bech32mError;
         if (bech32mErr.code === 'BECH32M_CHECKSUM_FAILED') {
             return (0, types_js_1.errNotRetryable)('TOKEN_INVALID_FORMAT', 'Token corrupted (bech32m checksum failed). Likely copy/paste error.', {
-                suggestion: 'Copy the entire token string exactly as returned. Use triple-click to select the complete line.',
+                suggestion: 'Use the exact token string as returned. Do not truncate or modify it.',
                 details: {
                     errorType: 'corruption_detected',
                     estimatedPosition: bech32mErr.position ?? null,

package/dist/mcp/server.js

@@ -144,6 +144,8 @@ async function startServer() {
             directoryListing: ctx.v2.directoryListing,
             dataDir: ctx.v2.dataDir,
             sessionStore: ctx.v2.sessionStore,
+            snapshotStore: ctx.v2.snapshotStore,
+            pinnedWorkflowStore: ctx.v2.pinnedStore,
         });
         ctx.httpServer.mountRoutes((app) => mountConsoleRoutes(app, consoleService));
         console.error('[Console] v2 Console API routes mounted at /api/v2/');
@@ -229,6 +231,10 @@ async function startServer() {
     processSignals.on('SIGINT', () => shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGINT' }));
     processSignals.on('SIGTERM', () => shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGTERM' }));
     processSignals.on('SIGHUP', () => shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGHUP' }));
+    process.stdin.on('end', () => {
+        console.error('[MCP] stdin closed, initiating shutdown');
+        shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGHUP' });
+    });
     let shutdownStarted = false;
     shutdownEvents.onShutdown((event) => {
         if (shutdownStarted)

package/dist/mcp/tool-descriptions.js

@@ -63,17 +63,15 @@ Remember: inspecting is read-only. Call start_workflow when ready to begin.`,
 
 The workflow represents the user's plan for this task. Each step will tell you exactly what to do. Your job is to execute each step's instructions and report back.
 
-What you'll receive:
-- pending.prompt: The first step's instructions — read this and do what it says
-- nextCall: A pre-built template for your next continue_workflow call (copy its params when done)
-- nextIntent: How to approach this step (usually "perform_pending_then_continue")
-- preferences: Execution mode settings (autonomy level, risk policy)
+The response contains your first step's instructions as the main content, with tokens in a JSON code block at the end. The step title is the heading, and the step prompt is the body.
 
 What to do:
-1. Read pending.prompt and execute the step exactly as described
-2. When done, call continue_workflow using the params from nextCall (it has stateToken and ackToken pre-filled)
-3. Optionally add output.notesMarkdown summarizing your work
-4. Don't predict what comes next - the workflow will tell you
+1. Read the step instructions (the main body of the response) and execute them exactly
+2. When done, call continue_workflow with the stateToken and ackToken from the JSON block at the end
+3. Add output.notesMarkdown documenting your work (see notes guidance below)
+4. Don't predict what comes next — the workflow will tell you
+
+Notes guidance: Write output.notesMarkdown for a human reader who will reference it later. Include what you did, key decisions and trade-offs, what you produced (files, endpoints, test results), and anything notable (risks, open questions, things you deliberately skipped). Use markdown formatting. Be specific — names, paths, numbers. 10–30 lines is ideal; too short is worse than too long.
 
 Workspace anchoring: Pass workspacePath (the "Workspace:" path from your system parameters) so this session can be found by resume_session in future chats. Without it, session discovery may not work.
 
@@ -81,13 +79,13 @@ Context auto-loads: If you provide context at start, WorkRail remembers it. On f
         continue_workflow: `Get the next step in the workflow (WorkRail v2, feature-flagged).
 
 QUICK START — How to call back after completing a step:
-Copy the params from the "nextCall" field of the previous response. It has stateToken and ackToken pre-filled. Just add your output if desired.
+Copy the stateToken and ackToken from the JSON code block at the end of the previous response. Just add your output.
 
 Two modes:
 
 ADVANCE (with ackToken):
 - "I completed the current step; give me the next one"
-- Requires: stateToken + ackToken (both provided in nextCall.params)
+- Requires: stateToken + ackToken (from the JSON block in previous response)
 - Optional: output (your work summary), context (if facts changed)
 - Result: WorkRail advances to next step and returns it
 
@@ -101,22 +99,14 @@ Intent is auto-inferred: ackToken present → advance, ackToken absent → rehyd
 You can set intent explicitly if you prefer, but it's optional.
 
 Reading the response:
-- pending.prompt: The step's instructions — what to do
-- nextCall: Pre-built template for your next call — how to proceed when done (null if workflow complete)
-- nextIntent: How to approach this step — execute it, confirm first, or continue working on it
-
-nextIntent values:
-- "perform_pending_then_continue": Execute this step, then use nextCall to advance
-- "await_user_confirmation": Auto-confirm and proceed (you don't need to wait for user in agent mode)
-- "rehydrate_only": You just recovered state; continue working on the current step, then use nextCall
-- "complete": Workflow finished; nextCall is null
+The response is natural language with your step instructions as the main content. A JSON code block at the end contains the tokens for your next call. The response tells you directly what to do — execute the step, retry with corrections, wait for user input, or acknowledge completion.
 
 Parameters:
-- stateToken (required): From nextCall.params or previous response
-- ackToken (required for advance): From nextCall.params or previous response
+- stateToken (required): From the JSON block in the previous response
+- ackToken (required for advance): From the JSON block in the previous response
 - intent (optional): "advance" or "rehydrate" — auto-inferred from ackToken if omitted
-- context (optional): NEW facts only. Omit if unchanged - WorkRail auto-loads previous context
-- output.notesMarkdown (optional, advance only): Fresh summary of THIS step only - never accumulated
+- context (optional): NEW facts only. Omit if unchanged — WorkRail auto-loads previous context
+- output.notesMarkdown (advance only): Recap of THIS step — what you did, key decisions, what you produced, anything notable. Write for a human reviewer. Use markdown, be specific (names, paths, numbers). 10–30 lines; never accumulate previous steps.
 
 The workflow is the user's structured instructions. Follow each step exactly as described.`,
         checkpoint_workflow: `Save a checkpoint on the current workflow step (WorkRail v2, feature-flagged).
@@ -216,18 +206,14 @@ This is read-only. Call start_workflow when ready to commit to following the wor
 
 The workflow is the USER'S VOICE expressing their plan for this task. Each step is a DIRECT INSTRUCTION from the user (or workflow author representing user intent). You MUST execute each step exactly as specified.
 
-What you receive:
-- pending.prompt: The user's first instruction — execute this EXACTLY as described
-- nextCall: Pre-built template for your next continue_workflow call — copy its params when done
-- nextIntent: How to approach this step (execute, confirm, etc.)
-- preferences: User's execution mode preferences (autonomy, risk tolerance)
+The response contains your first step's instructions as the main content (heading + body), with tokens in a JSON code block at the end.
 
 REQUIRED BEHAVIOR:
-1. Execute the pending step EXACTLY as the prompt describes
-2. When done, call continue_workflow using the params from nextCall (stateToken and ackToken are pre-filled)
-3. Optionally add output.notesMarkdown summarizing your work
+1. Execute the step instructions (the main body of the response) EXACTLY as described
+2. When done, call continue_workflow with the stateToken and ackToken from the JSON block at the end
+3. Add output.notesMarkdown documenting your work — write for a human reader who will reference it later. Include what you did, key decisions/trade-offs, what you produced (files, endpoints, test results), and anything notable (risks, open questions, deliberate omissions). Use markdown formatting, be specific (names, paths, numbers). 10–30 lines; too short is worse than too long.
 4. Round-trip tokens UNCHANGED (don't decode, inspect, or modify them)
-5. Follow the workflow to completion - don't improvise alternative approaches
+5. Follow the workflow to completion — don't improvise alternative approaches
 
 Workspace anchoring (IMPORTANT):
 - Pass workspacePath set to the "Workspace:" value from your system parameters
@@ -240,15 +226,15 @@ Context handling:
 - Only pass context again if facts have CHANGED (e.g., user provided new information)`,
         continue_workflow: `Get your next INSTRUCTION from the workflow (WorkRail v2, feature-flagged).
 
-The workflow represents the USER'S PLAN. The pending step returned is a DIRECT INSTRUCTION you MUST follow.
+The workflow represents the USER'S PLAN. The step returned is a DIRECT INSTRUCTION you MUST follow.
 
-HOW TO CALL — Copy nextCall.params from the previous response. It has stateToken and ackToken pre-filled. Add output if desired.
+HOW TO CALL — Copy the stateToken and ackToken from the JSON code block at the end of the previous response. Add output if desired.
 
 Two modes:
 
 ADVANCE (with ackToken):
 - Purpose: "I completed the current step; give me the next instruction"
-- Requires: stateToken + ackToken (both in nextCall.params from previous response)
+- Requires: stateToken + ackToken (from the JSON block in the previous response)
 - Optional: output (your work summary), context (if facts changed)
 - Result: WorkRail advances to next step
 - Idempotent: Safe to retry with same tokens if unsure
@@ -264,29 +250,21 @@ Intent is auto-inferred: ackToken present → advance, ackToken absent → rehyd
 You can set intent explicitly if you prefer, but it's optional.
 
 REQUIRED BEHAVIOR:
-1. Execute the step EXACTLY as specified in pending.prompt
-2. When done, call continue_workflow using nextCall.params — do NOT construct params manually
-3. Do NOT predict what comes next - call continue_workflow and the workflow will tell you
+1. Execute the step EXACTLY as described in the response body
+2. When done, call continue_workflow with tokens from the JSON block — do NOT construct params manually
+3. Do NOT predict what comes next — call continue_workflow and the workflow will tell you
 4. Do NOT skip steps, combine steps, or improvise your own approach
 
 Reading the response:
-- pending.prompt: The step's instructions — WHAT to do
-- nextCall: Pre-built call template — HOW to proceed when done (null if complete)
-- nextIntent: Step disposition — HOW to approach this step
-
-nextIntent is PRESCRIPTIVE (not advisory):
-- "perform_pending_then_continue": Execute this step, then use nextCall to advance
-- "await_user_confirmation": Auto-confirm and proceed (workflow represents user's intent)
-- "rehydrate_only": State recovery occurred; continue working on current step, then use nextCall
-- "complete": Workflow finished; nextCall is null
+The response is natural language. The step instructions are the main content (heading + body). A JSON code block at the end has the tokens for your next call. The response tells you directly what to do — execute the step, retry with corrections, wait for user input, or acknowledge completion.
 
 Parameters:
-- stateToken (required): From nextCall.params or previous response
-- ackToken (required for advance): From nextCall.params or previous response
+- stateToken (required): From the JSON block in the previous response
+- ackToken (required for advance): From the JSON block in the previous response
 - intent (optional): "advance" or "rehydrate" — auto-inferred from ackToken if omitted
 - context (optional): NEW facts only (auto-merges with previous). Omit if unchanged
-- output.notesMarkdown (optional, advance only): Summary of THIS step only (fresh, never accumulated)
-  
+- output.notesMarkdown (advance only): Recap of THIS step — what you did, key decisions, what you produced, anything notable. Write for a human reviewer. Use markdown, be specific (names, paths, numbers). 10–30 lines; never accumulate previous steps.
+
 The workflow is the user's structured will. Follow it exactly — it may validate, loop, or branch in ways you don't predict.`,
         checkpoint_workflow: `Save a checkpoint on the current workflow step (WorkRail v2, feature-flagged).
 

package/dist/mcp/v2/tools.js

@@ -24,7 +24,13 @@ exports.V2ContinueWorkflowInputShape = zod_1.z.object({
     context: zod_1.z.record(zod_1.z.unknown()).optional().describe('External facts (only if CHANGED since last call). Omit this entirely if no facts changed. WorkRail auto-merges with previous context. Example: if context={branch:"main"} at start, do NOT re-pass it unless branch changed. Pass only NEW or OVERRIDDEN values.'),
     output: zod_1.z
         .object({
-        notesMarkdown: zod_1.z.string().min(1).optional().describe('Summary of work completed in THIS step only — fresh and specific to this step. Do NOT append previous step notes. WorkRail concatenates notes across steps automatically. WRONG: "Phase 0: planning. Phase 1: implemented." RIGHT: "Implemented OAuth2 with 3 endpoints; added token validation middleware." Aim for ≤10 lines.'),
+        notesMarkdown: zod_1.z.string().min(1).optional().describe('Recap of THIS step only (WorkRail concatenates across steps automatically — never repeat earlier notes). ' +
+            'Write for a human reader who will review your work later. Include: ' +
+            '(1) What you did and the key decisions/trade-offs made, ' +
+            '(2) What you found or produced (files changed, endpoints added, test results, etc.), ' +
+            '(3) Anything the reader should know (risks, open questions, things you chose NOT to do and why). ' +
+            'Use markdown: headings, bullet lists, bold for emphasis. Be specific — names, paths, numbers, not vague summaries. ' +
+            'Good length: 10–30 lines. Too short is worse than too long.'),
         artifacts: zod_1.z.array(zod_1.z.unknown()).optional().describe('Optional structured artifacts (schema is workflow/contract-defined)'),
     })
         .optional()

package/dist/mcp/v2-response-formatter.d.ts

@@ -0,0 +1 @@
+export declare function formatV2ExecutionResponse(data: unknown): string | null;

package/dist/mcp/v2-response-formatter.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatV2ExecutionResponse = formatV2ExecutionResponse;
+function isV2ExecutionResponse(data) {
+    if (typeof data !== 'object' || data === null)
+        return false;
+    const d = data;
+    return (typeof d.stateToken === 'string' &&
+        'pending' in d &&
+        typeof d.nextIntent === 'string' &&
+        typeof d.preferences === 'object' && d.preferences !== null);
+}
+function isBlocked(data) {
+    return 'kind' in data && data.kind === 'blocked';
+}
+const AUTONOMY_LABEL = {
+    guided: 'guided mode',
+    full_auto_stop_on_user_deps: 'full autonomy (stop on user deps)',
+    full_auto_never_stop: 'full autonomy (never stop)',
+};
+const RISK_LABEL = {
+    conservative: 'conservative risk',
+    balanced: 'balanced risk',
+    aggressive: 'aggressive risk',
+};
+function formatPreferences(prefs) {
+    const autonomy = AUTONOMY_LABEL[prefs.autonomy] ?? prefs.autonomy;
+    const risk = RISK_LABEL[prefs.riskPolicy] ?? prefs.riskPolicy;
+    return `Preferences: ${autonomy}, ${risk}.`;
+}
+const BLOCKER_HEADING = {
+    USER_ONLY_DEPENDENCY: 'User Input Required',
+    MISSING_REQUIRED_OUTPUT: 'Missing Required Output',
+    INVALID_REQUIRED_OUTPUT: 'Invalid Output',
+    MISSING_REQUIRED_NOTES: 'Missing Required Notes',
+    MISSING_CONTEXT_KEY: 'Missing Context',
+    CONTEXT_BUDGET_EXCEEDED: 'Context Budget Exceeded',
+    REQUIRED_CAPABILITY_UNKNOWN: 'Unknown Capability Required',
+    REQUIRED_CAPABILITY_UNAVAILABLE: 'Capability Unavailable',
+    INVARIANT_VIOLATION: 'Invariant Violation',
+    STORAGE_CORRUPTION_DETECTED: 'Storage Error',
+};
+const PERSONA_USER = '---------\nUSER\n---------';
+const PERSONA_SYSTEM = '---------\nSYSTEM\n---------';
+function formatTokenBlock(data) {
+    const params = {};
+    if (data.nextCall) {
+        params.stateToken = data.nextCall.params.stateToken;
+        if (data.nextCall.params.ackToken) {
+            params.ackToken = data.nextCall.params.ackToken;
+        }
+    }
+    else {
+        params.stateToken = data.stateToken;
+    }
+    const lines = [];
+    lines.push('```json');
+    lines.push(JSON.stringify(params));
+    lines.push('```');
+    if (data.checkpointToken) {
+        lines.push('');
+        lines.push(`Checkpoint token (for \`checkpoint_workflow\`): \`${data.checkpointToken}\``);
+    }
+    return lines.join('\n');
+}
+function formatComplete(_data) {
+    return [
+        PERSONA_SYSTEM,
+        '',
+        '# Workflow Complete',
+        '',
+        'The workflow has finished. No further steps to execute.',
+    ].join('\n');
+}
+function formatBlocked(data) {
+    if (data.retryable) {
+        return formatBlockedRetryable(data);
+    }
+    return formatBlockedNonRetryable(data);
+}
+function formatBlockedRetryable(data) {
+    const firstBlocker = data.blockers.blockers[0];
+    const heading = firstBlocker ? (BLOCKER_HEADING[firstBlocker.code] ?? firstBlocker.code) : 'Blocked';
+    const lines = [];
+    lines.push(PERSONA_SYSTEM);
+    lines.push('');
+    lines.push(`# Blocked: ${heading}`);
+    if (data.pending)
+        lines.push(`<!-- stepId: ${data.pending.stepId} -->`);
+    lines.push('');
+    for (const b of data.blockers.blockers) {
+        lines.push(b.message);
+        if (b.suggestedFix) {
+            lines.push('');
+            lines.push(`**What to do:** ${b.suggestedFix}`);
+        }
+        lines.push('');
+    }
+    if (data.validation) {
+        if (data.validation.issues.length > 0) {
+            lines.push('**Issues:**');
+            for (const issue of data.validation.issues)
+                lines.push(`- ${issue}`);
+            lines.push('');
+        }
+        if (data.validation.suggestions.length > 0) {
+            lines.push('**Suggestions:**');
+            for (const s of data.validation.suggestions)
+                lines.push(`- ${s}`);
+            lines.push('');
+        }
+    }
+    lines.push('Retry with corrected output:');
+    lines.push('');
+    lines.push(formatTokenBlock(data));
+    return lines.join('\n');
+}
+function formatBlockedNonRetryable(data) {
+    const firstBlocker = data.blockers.blockers[0];
+    const heading = firstBlocker ? (BLOCKER_HEADING[firstBlocker.code] ?? firstBlocker.code) : 'Blocked';
+    const lines = [];
+    lines.push(PERSONA_SYSTEM);
+    lines.push('');
+    lines.push(`# Blocked: ${heading}`);
+    if (data.pending)
+        lines.push(`<!-- stepId: ${data.pending.stepId} -->`);
+    lines.push('');
+    for (const b of data.blockers.blockers) {
+        lines.push(b.message);
+        if (b.suggestedFix) {
+            lines.push('');
+            lines.push(`**What to do:** ${b.suggestedFix}`);
+        }
+        lines.push('');
+    }
+    lines.push('You cannot proceed without resolving this. Inform the user and wait for their response, then call `continue_workflow` with the updated context.');
+    lines.push('');
+    lines.push(formatTokenBlock(data));
+    return lines.join('\n');
+}
+function formatRehydrate(data) {
+    const lines = [];
+    if (data.pending) {
+        lines.push(PERSONA_USER);
+        lines.push('');
+        lines.push(`# ${data.pending.title} (resumed)`);
+        lines.push(`<!-- stepId: ${data.pending.stepId} -->`);
+        lines.push('');
+        lines.push(data.pending.prompt);
+        lines.push('');
+    }
+    lines.push(PERSONA_SYSTEM);
+    lines.push('');
+    if (!data.pending) {
+        lines.push('# State Recovered');
+        lines.push('');
+        lines.push('No pending step. The workflow may be complete or waiting for external input.');
+        lines.push('');
+    }
+    lines.push('Continue working on this step. When done, call `continue_workflow` to advance.');
+    lines.push('');
+    lines.push(formatTokenBlock(data));
+    return lines.join('\n');
+}
+function formatSuccess(data) {
+    const lines = [];
+    if (data.pending) {
+        lines.push(PERSONA_USER);
+        lines.push('');
+        lines.push(`# ${data.pending.title}`);
+        lines.push(`<!-- stepId: ${data.pending.stepId} -->`);
+        lines.push('');
+        lines.push(data.pending.prompt);
+        lines.push('');
+    }
+    lines.push(PERSONA_SYSTEM);
+    lines.push('');
+    lines.push('Execute this step, then call `continue_workflow` to advance.');
+    lines.push('');
+    lines.push('Include `output.notesMarkdown` documenting your work — what you did, key decisions, what you produced, and anything notable.');
+    lines.push('');
+    lines.push(formatTokenBlock(data));
+    lines.push('');
+    lines.push(formatPreferences(data.preferences));
+    return lines.join('\n');
+}
+function formatV2ExecutionResponse(data) {
+    if (!isV2ExecutionResponse(data))
+        return null;
+    if (data.nextIntent === 'complete' && !data.pending) {
+        return formatComplete(data);
+    }
+    if (isBlocked(data)) {
+        return formatBlocked(data);
+    }
+    if (data.nextIntent === 'rehydrate_only') {
+        return formatRehydrate(data);
+    }
+    return formatSuccess(data);
+}