@exaudeus/workrail 1.7.5 → 1.9.0

package/dist/application/services/compiler/prompt-blocks.d.ts

@@ -0,0 +1,36 @@
+import type { Result } from 'neverthrow';
+export type PromptPart = {
+    readonly kind: 'text';
+    readonly text: string;
+} | {
+    readonly kind: 'ref';
+    readonly refId: string;
+};
+export type PromptValue = string | readonly PromptPart[];
+export interface PromptBlocks {
+    readonly goal?: PromptValue;
+    readonly constraints?: readonly PromptValue[];
+    readonly procedure?: readonly PromptValue[];
+    readonly outputRequired?: Readonly<Record<string, string>>;
+    readonly verify?: readonly PromptValue[];
+}
+export type PromptBlocksRenderError = {
+    readonly code: 'EMPTY_BLOCKS';
+    readonly message: string;
+} | {
+    readonly code: 'UNRESOLVED_REF';
+    readonly refId: string;
+    readonly message: string;
+};
+export declare function renderPromptBlocks(blocks: PromptBlocks): Result<string, PromptBlocksRenderError>;
+import type { WorkflowStepDefinition, LoopStepDefinition } from '../../../types/workflow-definition.js';
+export type PromptBlocksPassError = {
+    readonly code: 'PROMPT_BLOCKS_ERROR';
+    readonly stepId: string;
+    readonly cause: PromptBlocksRenderError;
+} | {
+    readonly code: 'PROMPT_AND_BLOCKS_BOTH_SET';
+    readonly stepId: string;
+    readonly message: string;
+};
+export declare function resolvePromptBlocksPass(steps: readonly (WorkflowStepDefinition | LoopStepDefinition)[]): Result<readonly (WorkflowStepDefinition | LoopStepDefinition)[], PromptBlocksPassError>;

package/dist/application/services/compiler/prompt-blocks.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderPromptBlocks = renderPromptBlocks;
+exports.resolvePromptBlocksPass = resolvePromptBlocksPass;
+const neverthrow_1 = require("neverthrow");
+function resolvePromptValue(value) {
+    if (typeof value === 'string')
+        return (0, neverthrow_1.ok)(value);
+    const parts = [];
+    for (const part of value) {
+        switch (part.kind) {
+            case 'text':
+                parts.push(part.text);
+                break;
+            case 'ref':
+                return (0, neverthrow_1.err)({
+                    code: 'UNRESOLVED_REF',
+                    refId: part.refId,
+                    message: `Unresolved ref '${part.refId}' in prompt blocks. Refs must be resolved before rendering.`,
+                });
+        }
+    }
+    return (0, neverthrow_1.ok)(parts.join(''));
+}
+function resolvePromptValues(values) {
+    const resolved = [];
+    for (const value of values) {
+        const res = resolvePromptValue(value);
+        if (res.isErr())
+            return (0, neverthrow_1.err)(res.error);
+        resolved.push(res.value);
+    }
+    return (0, neverthrow_1.ok)(resolved);
+}
+function renderPromptBlocks(blocks) {
+    const sections = [];
+    if (blocks.goal !== undefined) {
+        const res = resolvePromptValue(blocks.goal);
+        if (res.isErr())
+            return (0, neverthrow_1.err)(res.error);
+        sections.push(`## Goal\n${res.value}`);
+    }
+    if (blocks.constraints !== undefined && blocks.constraints.length > 0) {
+        const res = resolvePromptValues(blocks.constraints);
+        if (res.isErr())
+            return (0, neverthrow_1.err)(res.error);
+        sections.push(`## Constraints\n${res.value.map(c => `- ${c}`).join('\n')}`);
+    }
+    if (blocks.procedure !== undefined && blocks.procedure.length > 0) {
+        const res = resolvePromptValues(blocks.procedure);
+        if (res.isErr())
+            return (0, neverthrow_1.err)(res.error);
+        sections.push(`## Procedure\n${res.value.map((p, i) => `${i + 1}. ${p}`).join('\n')}`);
+    }
+    if (blocks.outputRequired !== undefined && Object.keys(blocks.outputRequired).length > 0) {
+        const entries = Object.entries(blocks.outputRequired)
+            .map(([key, value]) => `- **${key}**: ${value}`)
+            .join('\n');
+        sections.push(`## Output Required\n${entries}`);
+    }
+    if (blocks.verify !== undefined && blocks.verify.length > 0) {
+        const res = resolvePromptValues(blocks.verify);
+        if (res.isErr())
+            return (0, neverthrow_1.err)(res.error);
+        sections.push(`## Verify\n${res.value.map(v => `- ${v}`).join('\n')}`);
+    }
+    if (sections.length === 0) {
+        return (0, neverthrow_1.err)({
+            code: 'EMPTY_BLOCKS',
+            message: 'promptBlocks must contain at least one non-empty section.',
+        });
+    }
+    return (0, neverthrow_1.ok)(sections.join('\n\n'));
+}
+const workflow_definition_js_1 = require("../../../types/workflow-definition.js");
+function resolveStepPromptBlocks(step) {
+    if (step.prompt && step.promptBlocks) {
+        return (0, neverthrow_1.err)({
+            code: 'PROMPT_AND_BLOCKS_BOTH_SET',
+            stepId: step.id,
+            message: `Step '${step.id}' declares both prompt and promptBlocks. Use exactly one.`,
+        });
+    }
+    if (!step.promptBlocks)
+        return (0, neverthrow_1.ok)(step);
+    const renderResult = renderPromptBlocks(step.promptBlocks);
+    if (renderResult.isErr()) {
+        return (0, neverthrow_1.err)({
+            code: 'PROMPT_BLOCKS_ERROR',
+            stepId: step.id,
+            cause: renderResult.error,
+        });
+    }
+    return (0, neverthrow_1.ok)({
+        ...step,
+        prompt: renderResult.value,
+    });
+}
+function resolvePromptBlocksPass(steps) {
+    const resolved = [];
+    for (const step of steps) {
+        if ((0, workflow_definition_js_1.isLoopStepDefinition)(step)) {
+            const loopRes = resolveStepPromptBlocks(step);
+            if (loopRes.isErr())
+                return (0, neverthrow_1.err)(loopRes.error);
+            if (Array.isArray(step.body)) {
+                const bodyResolved = [];
+                for (const bodyStep of step.body) {
+                    const bodyRes = resolveStepPromptBlocks(bodyStep);
+                    if (bodyRes.isErr())
+                        return (0, neverthrow_1.err)(bodyRes.error);
+                    bodyResolved.push(bodyRes.value);
+                }
+                const resolvedLoop = {
+                    ...step,
+                    ...(loopRes.value.prompt !== undefined ? { prompt: loopRes.value.prompt } : {}),
+                    body: bodyResolved,
+                };
+                resolved.push(resolvedLoop);
+            }
+            else {
+                resolved.push({ ...step, ...(loopRes.value.prompt !== undefined ? { prompt: loopRes.value.prompt } : {}) });
+            }
+        }
+        else {
+            const res = resolveStepPromptBlocks(step);
+            if (res.isErr())
+                return (0, neverthrow_1.err)(res.error);
+            resolved.push(res.value);
+        }
+    }
+    return (0, neverthrow_1.ok)(resolved);
+}

package/dist/application/services/compiler/ref-registry.d.ts

@@ -0,0 +1,12 @@
+import type { Result } from 'neverthrow';
+export type RefResolveError = {
+    readonly code: 'UNKNOWN_REF';
+    readonly refId: string;
+    readonly message: string;
+};
+export interface RefRegistry {
+    readonly resolve: (refId: string) => Result<string, RefResolveError>;
+    readonly has: (refId: string) => boolean;
+    readonly knownIds: () => readonly string[];
+}
+export declare function createRefRegistry(): RefRegistry;

package/dist/application/services/compiler/ref-registry.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRefRegistry = createRefRegistry;
+const neverthrow_1 = require("neverthrow");
+const REF_CONTENT = {
+    'wr.refs.memory_usage': [
+        'If Memory MCP tools are available (memory_briefing, memory_store, memory_query):',
+        '- Query Memory for relevant prior knowledge about this workspace before beginning work',
+        '- After completing significant work, store key discoveries and decisions',
+        '- Use descriptive topics and titles so future sessions can find them',
+        '- Do not block on Memory failures — it is advisory, not load-bearing',
+    ].join('\n'),
+    'wr.refs.memory_store': [
+        'If Memory MCP tools are available (memory_store):',
+        '- Store the key findings from this phase with a descriptive topic and title',
+        '- Include file paths, decisions made, and rationale',
+        '- Do not block on Memory failures — continue regardless',
+    ].join('\n'),
+    'wr.refs.memory_query': [
+        'If Memory MCP tools are available (memory_briefing, memory_query):',
+        '- Check Memory for prior context relevant to this task',
+        '- Use workspace-scoped queries to find related past work',
+        '- Do not block on Memory failures — proceed without prior context if unavailable',
+    ].join('\n'),
+};
+function createRefRegistry() {
+    const knownIds = Object.keys(REF_CONTENT);
+    return {
+        resolve(refId) {
+            const content = REF_CONTENT[refId];
+            if (content === undefined) {
+                return (0, neverthrow_1.err)({
+                    code: 'UNKNOWN_REF',
+                    refId,
+                    message: `Unknown ref '${refId}'. Known refs: ${knownIds.join(', ')}`,
+                });
+            }
+            return (0, neverthrow_1.ok)(content);
+        },
+        has(refId) {
+            return refId in REF_CONTENT;
+        },
+        knownIds() {
+            return knownIds;
+        },
+    };
+}

package/dist/application/services/compiler/resolve-refs.d.ts

@@ -0,0 +1,9 @@
+import type { Result } from 'neverthrow';
+import type { RefRegistry, RefResolveError } from './ref-registry.js';
+import type { WorkflowStepDefinition, LoopStepDefinition } from '../../../types/workflow-definition.js';
+export type ResolveRefsPassError = {
+    readonly code: 'REF_RESOLVE_ERROR';
+    readonly stepId: string;
+    readonly cause: RefResolveError;
+};
+export declare function resolveRefsPass(steps: readonly (WorkflowStepDefinition | LoopStepDefinition)[], registry: RefRegistry): Result<readonly (WorkflowStepDefinition | LoopStepDefinition)[], ResolveRefsPassError>;

package/dist/application/services/compiler/resolve-refs.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRefsPass = resolveRefsPass;
+const neverthrow_1 = require("neverthrow");
+const workflow_definition_js_1 = require("../../../types/workflow-definition.js");
+function resolvePromptValueRefs(value, registry) {
+    if (typeof value === 'string')
+        return (0, neverthrow_1.ok)(value);
+    const resolved = [];
+    for (const part of value) {
+        switch (part.kind) {
+            case 'text':
+                resolved.push(part);
+                break;
+            case 'ref': {
+                const res = registry.resolve(part.refId);
+                if (res.isErr())
+                    return (0, neverthrow_1.err)(res.error);
+                resolved.push({ kind: 'text', text: res.value });
+                break;
+            }
+        }
+    }
+    return (0, neverthrow_1.ok)(resolved);
+}
+function resolvePromptValuesRefs(values, registry) {
+    const resolved = [];
+    for (const value of values) {
+        const res = resolvePromptValueRefs(value, registry);
+        if (res.isErr())
+            return (0, neverthrow_1.err)(res.error);
+        resolved.push(res.value);
+    }
+    return (0, neverthrow_1.ok)(resolved);
+}
+function resolveBlockRefs(blocks, registry) {
+    let result = { ...blocks };
+    if (blocks.goal !== undefined) {
+        const res = resolvePromptValueRefs(blocks.goal, registry);
+        if (res.isErr())
+            return (0, neverthrow_1.err)(res.error);
+        result = { ...result, goal: res.value };
+    }
+    if (blocks.constraints !== undefined) {
+        const res = resolvePromptValuesRefs(blocks.constraints, registry);
+        if (res.isErr())
+            return (0, neverthrow_1.err)(res.error);
+        result = { ...result, constraints: res.value };
+    }
+    if (blocks.procedure !== undefined) {
+        const res = resolvePromptValuesRefs(blocks.procedure, registry);
+        if (res.isErr())
+            return (0, neverthrow_1.err)(res.error);
+        result = { ...result, procedure: res.value };
+    }
+    if (blocks.verify !== undefined) {
+        const res = resolvePromptValuesRefs(blocks.verify, registry);
+        if (res.isErr())
+            return (0, neverthrow_1.err)(res.error);
+        result = { ...result, verify: res.value };
+    }
+    return (0, neverthrow_1.ok)(result);
+}
+function resolveStepRefs(step, registry) {
+    if (!step.promptBlocks)
+        return (0, neverthrow_1.ok)(step);
+    const res = resolveBlockRefs(step.promptBlocks, registry);
+    if (res.isErr()) {
+        return (0, neverthrow_1.err)({
+            code: 'REF_RESOLVE_ERROR',
+            stepId: step.id,
+            cause: res.error,
+        });
+    }
+    return (0, neverthrow_1.ok)({ ...step, promptBlocks: res.value });
+}
+function resolveRefsPass(steps, registry) {
+    const resolved = [];
+    for (const step of steps) {
+        if ((0, workflow_definition_js_1.isLoopStepDefinition)(step)) {
+            const loopRes = resolveStepRefs(step, registry);
+            if (loopRes.isErr())
+                return (0, neverthrow_1.err)(loopRes.error);
+            if (Array.isArray(step.body)) {
+                const bodyResolved = [];
+                for (const bodyStep of step.body) {
+                    const bodyRes = resolveStepRefs(bodyStep, registry);
+                    if (bodyRes.isErr())
+                        return (0, neverthrow_1.err)(bodyRes.error);
+                    bodyResolved.push(bodyRes.value);
+                }
+                resolved.push({
+                    ...step,
+                    ...(loopRes.value.promptBlocks ? { promptBlocks: loopRes.value.promptBlocks } : {}),
+                    body: bodyResolved,
+                });
+            }
+            else {
+                resolved.push({
+                    ...step,
+                    ...(loopRes.value.promptBlocks ? { promptBlocks: loopRes.value.promptBlocks } : {}),
+                });
+            }
+        }
+        else {
+            const res = resolveStepRefs(step, registry);
+            if (res.isErr())
+                return (0, neverthrow_1.err)(res.error);
+            resolved.push(res.value);
+        }
+    }
+    return (0, neverthrow_1.ok)(resolved);
+}

package/dist/application/services/workflow-compiler.d.ts

@@ -15,6 +15,7 @@ export interface CompiledWorkflow {
     readonly loopBodyStepIds: ReadonlySet<string>;
 }
 export declare class WorkflowCompiler {
+    private readonly refRegistry;
     compile(workflow: Workflow): Result<CompiledWorkflow, DomainError>;
     private deriveConditionSource;
     private resolveLoopBody;

package/dist/application/services/workflow-compiler.js

@@ -12,9 +12,28 @@ const workflow_1 = require("../../types/workflow");
 const index_1 = require("../../v2/durable-core/schemas/artifacts/index");
 const neverthrow_1 = require("neverthrow");
 const error_1 = require("../../domain/execution/error");
+const prompt_blocks_1 = require("./compiler/prompt-blocks");
+const resolve_refs_1 = require("./compiler/resolve-refs");
+const ref_registry_1 = require("./compiler/ref-registry");
 let WorkflowCompiler = class WorkflowCompiler {
+    constructor() {
+        this.refRegistry = (0, ref_registry_1.createRefRegistry)();
+    }
     compile(workflow) {
-        const steps = workflow.definition.steps;
+        const refsResult = (0, resolve_refs_1.resolveRefsPass)(workflow.definition.steps, this.refRegistry);
+        if (refsResult.isErr()) {
+            const e = refsResult.error;
+            return (0, neverthrow_1.err)(error_1.Err.invalidState(`Step '${e.stepId}': ref resolution error — ${e.cause.message}`));
+        }
+        const blocksResult = (0, prompt_blocks_1.resolvePromptBlocksPass)(refsResult.value);
+        if (blocksResult.isErr()) {
+            const e = blocksResult.error;
+            const message = e.code === 'PROMPT_AND_BLOCKS_BOTH_SET'
+                ? e.message
+                : `Step '${e.stepId}': promptBlocks error — ${e.cause.message}`;
+            return (0, neverthrow_1.err)(error_1.Err.invalidState(message));
+        }
+        const steps = blocksResult.value;
         const stepById = new Map();
         for (const step of steps) {
             if (stepById.has(step.id)) {

package/dist/application/services/workflow-interpreter.js

@@ -386,7 +386,7 @@ let WorkflowInterpreter = class WorkflowInterpreter {
         if (step.guidance && step.guidance.length > 0) {
             promptParts.push(`## Step Guidance\n${step.guidance.map((g) => `- ${g}`).join('\n')}\n`);
         }
-        promptParts.push(step.prompt);
+        promptParts.push(step.prompt ?? '');
         if (instance.loopPath.length > 0) {
             const current = instance.loopPath[instance.loopPath.length - 1];
             promptParts.push(`\n\n## Loop Context\n- Loop: ${current.loopId}\n- Iteration: ${current.iteration + 1}`);

package/dist/manifest.json

@@ -1,6 +1,30 @@
 {
   "distDir": "dist",
   "files": {
+    "application/services/compiler/prompt-blocks.d.ts": {
+      "sha256": "2f40fd7599bd351584505152e9916fdea60891833d22c774c8ac9955f01ccf66",
+      "bytes": 1416
+    },
+    "application/services/compiler/prompt-blocks.js": {
+      "sha256": "8ee0e8f7f23f0b298602b97af71a49eaf4fbdc8e7a2bb588c607c2f36e81ef1a",
+      "bytes": 5201
+    },
+    "application/services/compiler/ref-registry.d.ts": {
+      "sha256": "b93074634a3a26097b9ed35d72351272c567dff184401a95e9f80ea7ae8724a5",
+      "bytes": 428
+    },
+    "application/services/compiler/ref-registry.js": {
+      "sha256": "075b14ab0efd34df85eb9b564362d2415eacffc13f44f1ba54bdc5e8229a7d2e",
+      "bytes": 2008
+    },
+    "application/services/compiler/resolve-refs.d.ts": {
+      "sha256": "64ed63007495f8b95baeb5f867a6b6ac39f097ad5976803b2642defa80ed31bf",
+      "bytes": 581
+    },
+    "application/services/compiler/resolve-refs.js": {
+      "sha256": "9f9e2a44cec6dfd6d870a645b38e4faf52e17c9ef3654fd600ebcd9943f532c5",
+      "bytes": 4214
+    },
     "application/services/enhanced-error-service.d.ts": {
       "sha256": "b6fe8fad92717f0962f87aa9c0f88277bf28fe2b5e3cfd7875612ee57eb8c684",
       "bytes": 601
@@ -42,20 +66,20 @@
       "bytes": 31038
     },
     "application/services/workflow-compiler.d.ts": {
-      "sha256": "dc7b1ed75ee4e90f90c35088d5c336a94d782012e5926fd7c939613e483b23fc",
-      "bytes": 990
+      "sha256": "65d65befc721926c125836692a0982f3cdef57f429326cde1b48e2fbc8593c98",
+      "bytes": 1024
     },
     "application/services/workflow-compiler.js": {
-      "sha256": "f865278e4242867dfd9b679e489d8f2de89f46b578f586a80fc5490ab6c65cdb",
-      "bytes": 5550
+      "sha256": "7d03802161c8802553122be3132efb77dc42214f232d333df73230012a7ff9b5",
+      "bytes": 6581
     },
     "application/services/workflow-interpreter.d.ts": {
       "sha256": "56b5b5ad06d42096deba9f0abe7642c18a355a1e598749aab1730df4e9847674",
       "bytes": 1507
     },
     "application/services/workflow-interpreter.js": {
-      "sha256": "793833a14c6a55bbbe9df4473c301e54140e2c6c6064f24f9d781188b603b502",
-      "bytes": 21396
+      "sha256": "0ea1861801d095d27e1e4c7c97978941b9d48613e28ce3a4c2efe64342814f5c",
+      "bytes": 21402
     },
     "application/services/workflow-service.d.ts": {
       "sha256": "b92da17c6d91c90758ec42b4ee3bc448e5d5b1dfe7351f2fe0f5e1d10a715ec6",
@@ -746,7 +770,7 @@
       "bytes": 7535
     },
     "mcp/output-schemas.d.ts": {
-      "sha256": "5c8256c738cb2b3c193fa3fe955ca3aaf00ae9381e8ef162d1477824db18b137",
+      "sha256": "484a853815de731053618d7d710b6608392aef935239d899824f6a30a16ec3b7",
       "bytes": 51242
     },
     "mcp/output-schemas.js": {
@@ -1058,8 +1082,8 @@
       "bytes": 395
     },
     "types/workflow-definition.d.ts": {
-      "sha256": "350be64b9da13515fc717a3cd72ddf19b3544087a246c7b2e79da0ef5ed3ffef",
-      "bytes": 3614
+      "sha256": "cb7d6be7e9aa0d4b7b17323cd167edad2f616b6a8c2149df6c40e4d965e7d9b8",
+      "bytes": 3744
     },
     "types/workflow-definition.js": {
       "sha256": "e269d62f27b7f37f870183d6b77800b7aa1e22dabc894374bab8f34db049a55b",
@@ -1490,7 +1514,7 @@
       "bytes": 2099
     },
     "v2/durable-core/schemas/compiled-workflow/index.d.ts": {
-      "sha256": "5146bd86e5785117e260276775a3783871c141425a03f4643bf421a00e5b9bf2",
+      "sha256": "d909c13d0d46bba1dcd411a0c53e767cf7e4c8bc5206581344ca1e7315552d95",
       "bytes": 3645
     },
     "v2/durable-core/schemas/compiled-workflow/index.js": {

package/dist/mcp/output-schemas.d.ts

@@ -237,13 +237,13 @@ export declare const V2PendingStepSchema: z.ZodObject<{
     title: z.ZodString;
     prompt: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    title: string;
-    prompt: string;
     stepId: string;
-}, {
-    title: string;
     prompt: string;
+    title: string;
+}, {
     stepId: string;
+    prompt: string;
+    title: string;
 }>;
 export declare const V2PreferencesSchema: z.ZodObject<{
     autonomy: z.ZodEnum<["guided", "full_auto_stop_on_user_deps", "full_auto_never_stop"]>;
@@ -484,13 +484,13 @@ export declare const V2ContinueWorkflowOutputSchema: z.ZodEffects<z.ZodDiscrimin
         title: z.ZodString;
         prompt: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        title: string;
-        prompt: string;
         stepId: string;
-    }, {
-        title: string;
         prompt: string;
+        title: string;
+    }, {
         stepId: string;
+        prompt: string;
+        title: string;
     }>>;
     preferences: z.ZodObject<{
         autonomy: z.ZodEnum<["guided", "full_auto_stop_on_user_deps", "full_auto_never_stop"]>;
@@ -551,9 +551,9 @@ export declare const V2ContinueWorkflowOutputSchema: z.ZodEffects<z.ZodDiscrimin
 }, "strip", z.ZodTypeAny, {
     kind: "ok";
     pending: {
-        title: string;
-        prompt: string;
         stepId: string;
+        prompt: string;
+        title: string;
     } | null;
     isComplete: boolean;
     stateToken: string;
@@ -578,9 +578,9 @@ export declare const V2ContinueWorkflowOutputSchema: z.ZodEffects<z.ZodDiscrimin
 }, {
     kind: "ok";
     pending: {
-        title: string;
-        prompt: string;
         stepId: string;
+        prompt: string;
+        title: string;
     } | null;
     isComplete: boolean;
     stateToken: string;
@@ -613,13 +613,13 @@ export declare const V2ContinueWorkflowOutputSchema: z.ZodEffects<z.ZodDiscrimin
         title: z.ZodString;
         prompt: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        title: string;
-        prompt: string;
         stepId: string;
-    }, {
-        title: string;
         prompt: string;
+        title: string;
+    }, {
         stepId: string;
+        prompt: string;
+        title: string;
     }>>;
     preferences: z.ZodObject<{
         autonomy: z.ZodEnum<["guided", "full_auto_stop_on_user_deps", "full_auto_never_stop"]>;
@@ -886,9 +886,9 @@ export declare const V2ContinueWorkflowOutputSchema: z.ZodEffects<z.ZodDiscrimin
         }[];
     };
     pending: {
-        title: string;
-        prompt: string;
         stepId: string;
+        prompt: string;
+        title: string;
     } | null;
     isComplete: boolean;
     stateToken: string;
@@ -941,9 +941,9 @@ export declare const V2ContinueWorkflowOutputSchema: z.ZodEffects<z.ZodDiscrimin
         }[];
     };
     pending: {
-        title: string;
-        prompt: string;
         stepId: string;
+        prompt: string;
+        title: string;
     } | null;
     isComplete: boolean;
     stateToken: string;
@@ -974,9 +974,9 @@ export declare const V2ContinueWorkflowOutputSchema: z.ZodEffects<z.ZodDiscrimin
 }>]>, {
     kind: "ok";
     pending: {
-        title: string;
-        prompt: string;
         stepId: string;
+        prompt: string;
+        title: string;
     } | null;
     isComplete: boolean;
     stateToken: string;
@@ -1023,9 +1023,9 @@ export declare const V2ContinueWorkflowOutputSchema: z.ZodEffects<z.ZodDiscrimin
         }[];
     };
     pending: {
-        title: string;
-        prompt: string;
         stepId: string;
+        prompt: string;
+        title: string;
     } | null;
     isComplete: boolean;
     stateToken: string;
@@ -1056,9 +1056,9 @@ export declare const V2ContinueWorkflowOutputSchema: z.ZodEffects<z.ZodDiscrimin
 }, {
     kind: "ok";
     pending: {
-        title: string;
-        prompt: string;
         stepId: string;
+        prompt: string;
+        title: string;
     } | null;
     isComplete: boolean;
     stateToken: string;
@@ -1105,9 +1105,9 @@ export declare const V2ContinueWorkflowOutputSchema: z.ZodEffects<z.ZodDiscrimin
         }[];
     };
     pending: {
-        title: string;
-        prompt: string;
         stepId: string;
+        prompt: string;
+        title: string;
     } | null;
     isComplete: boolean;
     stateToken: string;
@@ -1263,13 +1263,13 @@ export declare const V2StartWorkflowOutputSchema: z.ZodEffects<z.ZodObject<{
         title: z.ZodString;
         prompt: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        title: string;
-        prompt: string;
         stepId: string;
-    }, {
-        title: string;
         prompt: string;
+        title: string;
+    }, {
         stepId: string;
+        prompt: string;
+        title: string;
     }>>;
     preferences: z.ZodObject<{
         autonomy: z.ZodEnum<["guided", "full_auto_stop_on_user_deps", "full_auto_never_stop"]>;
@@ -1329,9 +1329,9 @@ export declare const V2StartWorkflowOutputSchema: z.ZodEffects<z.ZodObject<{
     }>>;
 }, "strip", z.ZodTypeAny, {
     pending: {
-        title: string;
-        prompt: string;
         stepId: string;
+        prompt: string;
+        title: string;
     } | null;
     isComplete: boolean;
     stateToken: string;
@@ -1355,9 +1355,9 @@ export declare const V2StartWorkflowOutputSchema: z.ZodEffects<z.ZodObject<{
     checkpointToken?: string | undefined;
 }, {
     pending: {
-        title: string;
-        prompt: string;
         stepId: string;
+        prompt: string;
+        title: string;
     } | null;
     isComplete: boolean;
     stateToken: string;
@@ -1381,9 +1381,9 @@ export declare const V2StartWorkflowOutputSchema: z.ZodEffects<z.ZodObject<{
     checkpointToken?: string | undefined;
 }>, {
     pending: {
-        title: string;
-        prompt: string;
         stepId: string;
+        prompt: string;
+        title: string;
     } | null;
     isComplete: boolean;
     stateToken: string;
@@ -1407,9 +1407,9 @@ export declare const V2StartWorkflowOutputSchema: z.ZodEffects<z.ZodObject<{
     checkpointToken?: string | undefined;
 }, {
     pending: {
-        title: string;
-        prompt: string;
         stepId: string;
+        prompt: string;
+        title: string;
     } | null;
     isComplete: boolean;
     stateToken: string;

package/dist/types/workflow-definition.d.ts

@@ -1,5 +1,6 @@
 import { ValidationCriteria } from './validation';
 import type { ArtifactContractRef } from '../v2/durable-core/schemas/artifacts/index';
+import type { PromptBlocks } from '../application/services/compiler/prompt-blocks.js';
 export interface OutputContract {
     readonly contractRef: ArtifactContractRef;
     readonly required?: boolean;
@@ -7,7 +8,8 @@ export interface OutputContract {
 export interface WorkflowStepDefinition {
     readonly id: string;
     readonly title: string;
-    readonly prompt: string;
+    readonly prompt?: string;
+    readonly promptBlocks?: PromptBlocks;
     readonly agentRole?: string;
     readonly guidance?: readonly string[];
     readonly askForFiles?: boolean;

package/dist/v2/durable-core/schemas/compiled-workflow/index.d.ts

@@ -11,13 +11,13 @@ export declare const CompiledWorkflowSnapshotV1Schema: z.ZodDiscriminatedUnion<"
         title: z.ZodString;
         prompt: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        title: string;
-        prompt: string;
         stepId: string;
-    }, {
-        title: string;
         prompt: string;
+        title: string;
+    }, {
         stepId: string;
+        prompt: string;
+        title: string;
     }>;
 }, "strip", z.ZodTypeAny, {
     name: string;
@@ -27,9 +27,9 @@ export declare const CompiledWorkflowSnapshotV1Schema: z.ZodDiscriminatedUnion<"
     schemaVersion: 1;
     sourceKind: "v1_preview";
     preview: {
-        title: string;
-        prompt: string;
         stepId: string;
+        prompt: string;
+        title: string;
     };
 }, {
     name: string;
@@ -39,9 +39,9 @@ export declare const CompiledWorkflowSnapshotV1Schema: z.ZodDiscriminatedUnion<"
     schemaVersion: 1;
     sourceKind: "v1_preview";
     preview: {
-        title: string;
-        prompt: string;
         stepId: string;
+        prompt: string;
+        title: string;
     };
 }>, z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
@@ -81,13 +81,13 @@ export declare const CompiledWorkflowSnapshotSchema: z.ZodDiscriminatedUnion<"so
         title: z.ZodString;
         prompt: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        title: string;
-        prompt: string;
         stepId: string;
-    }, {
-        title: string;
         prompt: string;
+        title: string;
+    }, {
         stepId: string;
+        prompt: string;
+        title: string;
     }>;
 }, "strip", z.ZodTypeAny, {
     name: string;
@@ -97,9 +97,9 @@ export declare const CompiledWorkflowSnapshotSchema: z.ZodDiscriminatedUnion<"so
     schemaVersion: 1;
     sourceKind: "v1_preview";
     preview: {
-        title: string;
-        prompt: string;
         stepId: string;
+        prompt: string;
+        title: string;
     };
 }, {
     name: string;
@@ -109,9 +109,9 @@ export declare const CompiledWorkflowSnapshotSchema: z.ZodDiscriminatedUnion<"so
     schemaVersion: 1;
     sourceKind: "v1_preview";
     preview: {
-        title: string;
-        prompt: string;
         stepId: string;
+        prompt: string;
+        title: string;
     };
 }>, z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exaudeus/workrail",
-  "version": "1.7.5",
+  "version": "1.9.0",
   "description": "Step-by-step workflow enforcement for AI agents via MCP",
   "license": "MIT",
   "repository": {