@exaudeus/workrail 3.5.0 → 3.6.1

package/dist/mcp/transports/stdio-entry.js

@@ -36,6 +36,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.startStdioServer = startStdioServer;
 const server_js_1 = require("../server.js");
 const shutdown_hooks_js_1 = require("./shutdown-hooks.js");
+const INITIAL_ROOTS_TIMEOUT_MS = 1000;
+async function fetchInitialRootsWithTimeout(server) {
+    return Promise.race([
+        server.listRoots(),
+        new Promise((resolve) => {
+            setTimeout(() => resolve(null), INITIAL_ROOTS_TIMEOUT_MS);
+        }),
+    ]);
+}
 async function startStdioServer() {
     const { server, ctx, rootsManager } = await (0, server_js_1.composeServer)();
     const { StdioServerTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/server/stdio.js')));
@@ -52,15 +61,19 @@ async function startStdioServer() {
     });
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    try {
-        const result = await server.listRoots();
+    console.error('[Transport] WorkRail MCP Server running on stdio');
+    void fetchInitialRootsWithTimeout(server)
+        .then((result) => {
+        if (result == null) {
+            console.error('[Roots] Initial roots probe timed out; workspace context will use server CWD fallback');
+            return;
+        }
         rootsManager.updateRootUris(result.roots.map((r) => r.uri));
         console.error(`[Roots] Initial workspace roots: ${result.roots.map((r) => r.uri).join(', ') || '(none)'}`);
-    }
-    catch {
+    })
+        .catch(() => {
         console.error('[Roots] Client does not support roots/list; workspace context will use server CWD fallback');
-    }
-    console.error('[Transport] WorkRail MCP Server running on stdio');
+    });
     (0, shutdown_hooks_js_1.wireShutdownHooks)({
         onBeforeTerminate: async () => {
             await ctx.httpServer?.stop();

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

@@ -1 +1,11 @@
-export declare function formatV2ExecutionResponse(data: unknown): string | null;
+import { type FormattedSupplement } from './response-supplements.js';
+export interface FormattedReferences {
+    readonly kind: 'references';
+    readonly text: string;
+}
+export interface FormattedResponse {
+    readonly primary: string;
+    readonly references?: FormattedReferences;
+    readonly supplements?: readonly FormattedSupplement[];
+}
+export declare function formatV2ExecutionResponse(data: unknown): FormattedResponse | null;

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatV2ExecutionResponse = formatV2ExecutionResponse;
+const render_envelope_js_1 = require("./render-envelope.js");
+const response_supplements_js_1 = require("./response-supplements.js");
 function isV2ExecutionResponse(data) {
     if (typeof data !== 'object' || data === null)
         return false;
@@ -207,9 +209,160 @@ function formatSuccess(data) {
     }
     return lines.join('\n');
 }
+function isCleanResponseFormat() {
+    return process.env.WORKRAIL_CLEAN_RESPONSE_FORMAT === 'true';
+}
+const CLEAN_ADVANCE_FOOTERS = [
+    'WorkRail: when done, call continue_workflow with your notes. Token:',
+    'WorkRail: advance with continue_workflow when ready. Include your notes. Token:',
+    'WorkRail: call continue_workflow with your notes to move on. Token:',
+    'WorkRail: finished? continue_workflow with notes. Token:',
+];
+const CLEAN_REHYDRATE_FOOTERS = [
+    'WorkRail: you are resuming this step. When ready, call continue_workflow with your notes. Token:',
+    'WorkRail: picking up where you left off. Advance with continue_workflow and notes. Token:',
+    'WorkRail: resuming. Call continue_workflow with notes when done. Token:',
+];
+function pickFooter(variants, stepId) {
+    if (!stepId)
+        return variants[0];
+    let hash = 0;
+    for (let i = 0; i < stepId.length; i++) {
+        hash = ((hash << 5) - hash + stepId.charCodeAt(i)) | 0;
+    }
+    return variants[Math.abs(hash) % variants.length];
+}
+function formatCleanComplete(_data) {
+    return 'Workflow complete. No further steps.';
+}
+function formatCleanBlocked(data) {
+    const firstBlocker = data.blockers.blockers[0];
+    const heading = firstBlocker ? (BLOCKER_HEADING[firstBlocker.code] ?? firstBlocker.code) : 'Blocked';
+    const lines = [`Blocked: ${heading}`, ''];
+    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('');
+        }
+    }
+    const token = data.retryContinueToken ?? data.nextCall?.params.continueToken ?? data.continueToken;
+    if (token) {
+        lines.push(`WorkRail: retry with corrected output. Token: ${token}`);
+    }
+    return lines.join('\n');
+}
+function formatCleanRehydrate(data) {
+    const lines = [];
+    if (data.pending) {
+        lines.push(data.pending.prompt);
+        lines.push('');
+    }
+    const token = data.nextCall?.params.continueToken ?? data.continueToken;
+    lines.push('---');
+    if (token) {
+        const footer = pickFooter(CLEAN_REHYDRATE_FOOTERS, data.pending?.stepId);
+        lines.push(`${footer} ${token}`);
+    }
+    const driftBlock = formatBindingDriftWarnings(data);
+    if (driftBlock) {
+        lines.push(driftBlock);
+    }
+    return lines.join('\n');
+}
+function formatCleanSuccess(data) {
+    const lines = [];
+    if (data.pending) {
+        lines.push(data.pending.prompt);
+        lines.push('');
+    }
+    const token = data.nextCall?.params.continueToken ?? data.continueToken;
+    lines.push('---');
+    if (token) {
+        const footer = pickFooter(CLEAN_ADVANCE_FOOTERS, data.pending?.stepId);
+        lines.push(`${footer} ${token}`);
+    }
+    const driftBlock = formatBindingDriftWarnings(data);
+    if (driftBlock) {
+        lines.push(driftBlock);
+    }
+    return lines.join('\n');
+}
+function deriveRenderInput(data) {
+    const envelope = (0, render_envelope_js_1.getV2ExecutionRenderEnvelope)(data);
+    if (envelope != null) {
+        return isV2ExecutionResponse(envelope.response)
+            ? { response: envelope.response, lifecycle: envelope.lifecycle, contentEnvelope: envelope.contentEnvelope }
+            : null;
+    }
+    return isV2ExecutionResponse(data)
+        ? { response: data, lifecycle: 'advance' }
+        : null;
+}
+function renderReferencesSection(contentEnvelope, lifecycle) {
+    if (contentEnvelope == null)
+        return null;
+    const refs = contentEnvelope.references;
+    if (refs.length === 0)
+        return null;
+    switch (lifecycle) {
+        case 'start': {
+            const lines = ['Workflow References:', ''];
+            for (const ref of refs) {
+                const displayPath = ref.status === 'resolved' ? ref.resolvedPath : ref.source;
+                const statusTag = ref.status === 'unresolved' ? ' [unresolved]' : ref.status === 'pinned' ? ' [pinned]' : '';
+                const authority = ref.authoritative ? ' (authoritative)' : '';
+                const resolveTag = ref.resolveFrom === 'package' ? ' [package]' : '';
+                lines.push(`- **${ref.title}**${authority}${statusTag}${resolveTag}`);
+                lines.push(`  Path: ${displayPath}`);
+                lines.push(`  Purpose: ${ref.purpose}`);
+                lines.push('');
+            }
+            return { kind: 'references', text: lines.join('\n').trimEnd() };
+        }
+        case 'rehydrate': {
+            const lines = ['Workflow References (reminder):', ''];
+            for (const ref of refs) {
+                const displayPath = ref.status === 'resolved' ? ref.resolvedPath : ref.source;
+                const statusTag = ref.status === 'unresolved' ? ' [unresolved]' : ref.status === 'pinned' ? ' [pinned]' : '';
+                const resolveTag = ref.resolveFrom === 'package' ? ' [package]' : '';
+                lines.push(`- ${ref.title}${statusTag}${resolveTag}: ${displayPath}`);
+            }
+            return { kind: 'references', text: lines.join('\n').trimEnd() };
+        }
+        case 'advance':
+            return null;
+    }
+}
 function formatV2ExecutionResponse(data) {
-    if (!isV2ExecutionResponse(data))
+    const renderInput = deriveRenderInput(data);
+    if (!renderInput)
         return null;
+    const cleanFormat = isCleanResponseFormat();
+    const { response, lifecycle, contentEnvelope } = renderInput;
+    const references = renderReferencesSection(contentEnvelope, lifecycle);
+    if (cleanFormat) {
+        return {
+            ...formatV2Clean(response),
+            ...(references != null ? { references } : {}),
+            supplements: (0, response_supplements_js_1.buildResponseSupplements)({ lifecycle, cleanFormat }),
+        };
+    }
+    return {
+        primary: formatV2Classic(response),
+        ...(references != null ? { references } : {}),
+    };
+}
+function formatV2Classic(data) {
     if (data.nextIntent === 'complete' && !data.pending) {
         return formatComplete(data);
     }
@@ -221,3 +374,17 @@ function formatV2ExecutionResponse(data) {
     }
     return formatSuccess(data);
 }
+function formatV2Clean(data) {
+    if (data.nextIntent === 'complete' && !data.pending) {
+        return { primary: formatCleanComplete(data) };
+    }
+    if (isBlocked(data)) {
+        return { primary: formatCleanBlocked(data) };
+    }
+    if (data.nextIntent === 'rehydrate_only') {
+        return { primary: formatCleanRehydrate(data) };
+    }
+    return {
+        primary: formatCleanSuccess(data),
+    };
+}

package/dist/mcp/workflow-protocol-contracts.js

@@ -51,10 +51,10 @@ exports.START_WORKFLOW_PROTOCOL = {
     },
     descriptions: {
         standard: {
-            purpose: 'Start a WorkRail v2 workflow and begin following its step-by-step instructions.',
-            whenToUse: 'Use this when you found the right workflow and are ready to execute it. The response body is the current step; the structured response includes the token(s) for your next call.',
+            purpose: 'Start a WorkRail v2 workflow. Treat WorkRail as a separate live system the user is actively using to direct this task. The returned step is what the user wants you to do now.',
+            whenToUse: 'Use this when you found the right workflow and are ready to execute it. The response is the current instruction coming from WorkRail for this task.',
             rules: [
-                'Follow the returned step exactly; it represents the user\'s plan for the task.',
+                'Follow the returned step exactly; treat it as the user\'s current instruction.',
                 'When the step is done, call continue_workflow with the returned continueToken.',
                 'Only pass context on later continue_workflow calls if facts changed.',
             ],
@@ -65,8 +65,8 @@ exports.START_WORKFLOW_PROTOCOL = {
             returns: 'Step instructions plus continueToken and checkpointToken in the structured response.',
         },
         authoritative: {
-            purpose: 'Begin executing the selected WorkRail v2 workflow.',
-            whenToUse: 'Call this once you have chosen the workflow you will follow. The returned step is a direct instruction from the user or workflow author.',
+            purpose: 'Begin executing the selected WorkRail v2 workflow. Treat WorkRail as a separate live system the user is actively using to direct this task. The returned step is what the user wants you to do now.',
+            whenToUse: 'Call this once you have chosen the workflow. The returned step is a direct instruction from the user.',
             rules: [
                 'Execute the returned step exactly as written.',
                 'When the step is complete, call continue_workflow with the returned continueToken.',
@@ -90,13 +90,14 @@ exports.CONTINUE_WORKFLOW_PROTOCOL = {
     },
     descriptions: {
         standard: {
-            purpose: 'Advance or rehydrate the current WorkRail v2 step using the single-token protocol.',
+            purpose: 'Advance or rehydrate the current WorkRail v2 step using the single-token protocol. Use this to send your completion back to WorkRail and receive the user\'s next instruction from that system.',
             whenToUse: 'Use this after completing a step, or to recover the current step after lost context.',
             rules: [
                 'Advance by sending output (and intent: "advance" if you want to be explicit).',
                 'Rehydrate by omitting output (and intent: "rehydrate" if you want to be explicit).',
                 'Put changed facts under context only.',
                 'Round-trip continueToken exactly as returned by WorkRail; use the single-token API only.',
+                'Notes (output.notesMarkdown): write for a human reader. Include what you did and key decisions, what you produced (files, tests, numbers), and anything notable (risks, open questions, deliberate omissions). Use markdown headings, bullets, bold, code refs. Be specific. Scope: THIS step only (WorkRail concatenates automatically). 10-30 lines ideal. Omitting notes blocks the step.',
             ],
             examplePayload: {
                 continueToken: 'ct_...',
@@ -107,13 +108,14 @@ exports.CONTINUE_WORKFLOW_PROTOCOL = {
             returns: 'The next step, or the same current step when rehydrating.',
         },
         authoritative: {
-            purpose: 'Continue the active WorkRail v2 workflow with the canonical single-token API.',
+            purpose: 'Continue the active WorkRail v2 workflow with the canonical single-token API. Use this to send your completion back to WorkRail and receive the user\'s next instruction from that system.',
             whenToUse: 'Call this after you complete the current step, or call it in rehydrate mode to recover the current step without advancing.',
             rules: [
                 'Use continueToken exactly as returned by WorkRail.',
                 'Use the single-token API only.',
                 'Advance by sending output; rehydrate by omitting output.',
                 'Put updated facts in context only.',
+                'Notes (output.notesMarkdown): write for a human reader. Include what you did and key decisions, what you produced (files, tests, numbers), and anything notable (risks, open questions, deliberate omissions). Use markdown headings, bullets, bold, code refs. Be specific. Scope: THIS step only (WorkRail concatenates automatically). 10-30 lines ideal. Omitting notes blocks the step.',
             ],
             examplePayload: {
                 continueToken: 'ct_...',

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

@@ -1,10 +1,16 @@
 import { ValidationCriteria } from './validation';
 import type { ArtifactContractRef } from '../v2/durable-core/schemas/artifacts/index';
 import type { PromptBlocks } from '../application/services/compiler/prompt-blocks.js';
+import type { Condition } from '../utils/condition-evaluator.js';
 export interface OutputContract {
     readonly contractRef: ArtifactContractRef;
     readonly required?: boolean;
 }
+export interface PromptFragment {
+    readonly id: string;
+    readonly when?: Condition;
+    readonly text: string;
+}
 export interface WorkflowStepDefinition {
     readonly id: string;
     readonly title: string;
@@ -19,6 +25,7 @@ export interface WorkflowStepDefinition {
     readonly outputContract?: OutputContract;
     readonly notesOptional?: boolean;
     readonly templateCall?: TemplateCall;
+    readonly promptFragments?: readonly PromptFragment[];
     readonly functionDefinitions?: readonly FunctionDefinition[];
     readonly functionCalls?: readonly FunctionCall[];
     readonly functionReferences?: readonly string[];
@@ -79,6 +86,14 @@ export interface WorkflowRecommendedPreferences {
     readonly recommendedAutonomy?: 'guided' | 'full_auto_stop_on_user_deps' | 'full_auto_never_stop';
     readonly recommendedRiskPolicy?: 'conservative' | 'balanced' | 'aggressive';
 }
+export interface WorkflowReference {
+    readonly id: string;
+    readonly title: string;
+    readonly source: string;
+    readonly purpose: string;
+    readonly authoritative: boolean;
+    readonly resolveFrom?: 'workspace' | 'package';
+}
 export interface WorkflowDefinition {
     readonly id: string;
     readonly name: string;
@@ -92,6 +107,7 @@ export interface WorkflowDefinition {
     readonly recommendedPreferences?: WorkflowRecommendedPreferences;
     readonly features?: readonly string[];
     readonly extensionPoints?: readonly ExtensionPoint[];
+    readonly references?: readonly WorkflowReference[];
 }
 export declare function isLoopStepDefinition(step: WorkflowStepDefinition | LoopStepDefinition): step is LoopStepDefinition;
 export declare function isWorkflowStepDefinition(step: WorkflowStepDefinition | LoopStepDefinition): step is WorkflowStepDefinition;

package/dist/types/workflow-definition.js

@@ -34,5 +34,6 @@ function createWorkflowDefinition(definition) {
         metaGuidance: definition.metaGuidance ? Object.freeze([...definition.metaGuidance]) : undefined,
         functionDefinitions: definition.functionDefinitions ? Object.freeze([...definition.functionDefinitions]) : undefined,
         extensionPoints: definition.extensionPoints ? Object.freeze([...definition.extensionPoints]) : undefined,
+        references: definition.references ? Object.freeze(definition.references.map(ref => Object.freeze({ ...ref }))) : undefined,
     });
 }

package/dist/utils/condition-evaluator.d.ts

@@ -13,6 +13,7 @@ export interface Condition {
     startsWith?: string;
     endsWith?: string;
     matches?: string;
+    in?: unknown[];
     and?: Condition[];
     or?: Condition[];
     not?: Condition;

package/dist/utils/condition-evaluator.js

@@ -98,6 +98,12 @@ function evaluateConditionUnsafe(condition, context) {
                 return false;
             }
         }
+        if (condition.in !== undefined) {
+            if (!Array.isArray(condition.in)) {
+                throw new Error('in operator requires an array');
+            }
+            return condition.in.some(item => lenientEquals(value, item));
+        }
         return !!value;
     }
     if (condition.and !== undefined) {
@@ -124,6 +130,7 @@ function validateCondition(condition) {
     const supportedKeys = [
         'var', 'equals', 'not_equals', 'gt', 'gte', 'lt', 'lte',
         'contains', 'startsWith', 'endsWith', 'matches',
+        'in',
         'and', 'or', 'not'
     ];
     const conditionKeys = Object.keys(condition);

package/dist/v2/durable-core/domain/context-template-resolver.d.ts

@@ -0,0 +1,2 @@
+export declare const CONTEXT_TOKEN_PATTERN: RegExp;
+export declare function resolveContextTemplates(template: string, context: Record<string, unknown>): string;

package/dist/v2/durable-core/domain/context-template-resolver.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTEXT_TOKEN_PATTERN = void 0;
+exports.resolveContextTemplates = resolveContextTemplates;
+exports.CONTEXT_TOKEN_PATTERN = /\{\{(?!wr\.)([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)\}\}/;
+const CONTEXT_TOKEN_RE_G = new RegExp(exports.CONTEXT_TOKEN_PATTERN.source, 'g');
+function resolveDotPath(base, path) {
+    let current = base;
+    for (const segment of path) {
+        if (current === null || typeof current !== 'object')
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+}
+function resolveContextTemplates(template, context) {
+    if (!template.includes('{{'))
+        return template;
+    return template.replace(CONTEXT_TOKEN_RE_G, (_match, dotPath) => {
+        const value = resolveDotPath(context, dotPath.split('.'));
+        if (value === undefined || value === null) {
+            return `[unset: ${dotPath}]`;
+        }
+        return String(value);
+    });
+}

package/dist/v2/durable-core/domain/prompt-renderer.d.ts

@@ -1,5 +1,6 @@
 import type { Result } from 'neverthrow';
 import type { Workflow } from '../../../types/workflow.js';
+import type { PromptFragment } from '../../../types/workflow-definition.js';
 import type { LoadedSessionTruthV2 } from '../../ports/session-event-log-store.port.js';
 import type { LoopPathFrameV1 } from '../schemas/execution-snapshot/index.js';
 import type { NodeId, RunId } from '../ids/index.js';
@@ -7,6 +8,7 @@ export type PromptRenderError = {
     readonly code: 'RENDER_FAILED';
     readonly message: string;
 };
+export declare function assembleFragmentedPrompt(fragments: readonly PromptFragment[], context: Record<string, unknown>): string;
 export interface StepMetadata {
     readonly stepId: string;
     readonly title: string;

package/dist/v2/durable-core/domain/prompt-renderer.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.assembleFragmentedPrompt = assembleFragmentedPrompt;
 exports.renderPendingPrompt = renderPendingPrompt;
 const neverthrow_1 = require("neverthrow");
 const workflow_js_1 = require("../../../types/workflow.js");
@@ -11,6 +12,9 @@ const function_definition_expander_js_1 = require("./function-definition-expande
 const constants_js_1 = require("../constants.js");
 const validation_requirements_extractor_js_1 = require("./validation-requirements-extractor.js");
 const index_js_2 = require("../schemas/artifacts/index.js");
+const run_context_js_1 = require("../../projections/run-context.js");
+const condition_evaluator_js_1 = require("../../../utils/condition-evaluator.js");
+const context_template_resolver_js_1 = require("./context-template-resolver.js");
 function buildNonTipSections(args) {
     const sections = [];
     const childSummary = (0, recap_recovery_js_1.buildChildSummary)({ nodeId: args.nodeId, dag: args.run });
@@ -55,6 +59,12 @@ function buildFunctionDefsSections(args) {
     }
     return [];
 }
+function hasPriorNotesInRun(args) {
+    return args.truth.events.some((e) => e.kind === constants_js_1.EVENT_KIND.NODE_OUTPUT_APPENDED &&
+        e.scope.runId === args.runId &&
+        e.data.outputChannel === constants_js_1.OUTPUT_CHANNEL.RECAP &&
+        e.data.payload.payloadKind === constants_js_1.PAYLOAD_KIND.NOTES);
+}
 function buildRecoverySections(args) {
     const isTip = args.run.tipNodeIds.includes(String(args.nodeId));
     return [
@@ -114,18 +124,35 @@ function applyPromptBudget(combinedPrompt) {
     const decoder = new TextDecoder('utf-8');
     return decoder.decode(truncatedBytes) + markerText + omissionNote;
 }
-function resolveParentLoopMaxIterations(workflow, stepId) {
+function resolveParentLoopStep(workflow, stepId) {
     for (const step of workflow.definition.steps) {
         if ((0, workflow_js_1.isLoopStepDefinition)(step) && Array.isArray(step.body)) {
             for (const bodyStep of step.body) {
-                if (bodyStep.id === stepId) {
-                    return step.loop.maxIterations;
-                }
+                if (bodyStep.id === stepId)
+                    return step;
             }
         }
     }
     return undefined;
 }
+function buildLoopRenderContext(loopStep, iteration, sessionContext) {
+    const iterationVar = loopStep.loop.iterationVar || 'currentIteration';
+    const forEachVars = () => {
+        if (loopStep.loop.type !== 'forEach' || !loopStep.loop.items)
+            return {};
+        const items = sessionContext[loopStep.loop.items];
+        if (!Array.isArray(items))
+            return {};
+        return {
+            [loopStep.loop.itemVar || 'currentItem']: items[iteration],
+            [loopStep.loop.indexVar || 'currentIndex']: iteration,
+        };
+    };
+    return {
+        [iterationVar]: iteration + 1,
+        ...forEachVars(),
+    };
+}
 function buildScopeInstruction(iteration, maxIterations) {
     if (iteration <= 1)
         return 'Focus on what the first pass missed — do not re-litigate settled findings.';
@@ -139,6 +166,15 @@ function buildLoopContextBanner(args) {
     const current = args.loopPath[args.loopPath.length - 1];
     const iterationNumber = current.iteration + 1;
     const maxIter = args.maxIterations;
+    if (args.cleanFormat) {
+        if (current.iteration === 0) {
+            const bound = maxIter !== undefined ? ` (up to ${maxIter} passes)` : '';
+            return `This is an iterative step${bound}. A decision step after your work determines whether another pass is needed.\n\n`;
+        }
+        const ofMax = maxIter !== undefined ? ` of ${maxIter}` : '';
+        const scope = buildScopeInstruction(current.iteration, maxIter);
+        return `Pass ${iterationNumber}${ofMax}. ${scope} Build on your previous work.\n\n`;
+    }
     if (current.iteration === 0) {
         const bound = maxIter !== undefined ? ` (up to ${maxIter} passes)` : '';
         return [
@@ -184,6 +220,12 @@ function formatOutputContractRequirements(outputContract) {
             ];
     }
 }
+function assembleFragmentedPrompt(fragments, context) {
+    return fragments
+        .filter(f => (0, condition_evaluator_js_1.evaluateCondition)(f.when, context))
+        .map(f => (0, context_template_resolver_js_1.resolveContextTemplates)(f.text, context))
+        .join('\n\n');
+}
 function loadRecoveryProjections(args) {
     const dagRes = (0, run_dag_js_1.projectRunDagV2)(args.truth.events);
     if (dagRes.isErr()) {
@@ -208,8 +250,6 @@ function renderPendingPrompt(args) {
             message: `Step '${args.stepId}' not found in workflow '${args.workflow.definition.id}'`,
         });
     }
-    const baseTitle = step.title;
-    const basePrompt = step.prompt;
     const agentRole = step.agentRole;
     const requireConfirmation = Boolean(step.requireConfirmation);
     const functionReferences = step.functionReferences ?? [];
@@ -217,22 +257,51 @@ function renderPendingPrompt(args) {
         ? step.outputContract
         : undefined;
     const isExitStep = outputContract?.contractRef === index_js_2.LOOP_CONTROL_CONTRACT_REF;
-    const maxIterations = resolveParentLoopMaxIterations(args.workflow, args.stepId);
-    const loopBanner = buildLoopContextBanner({ loopPath: args.loopPath, isExitStep, maxIterations });
+    const loopStep = resolveParentLoopStep(args.workflow, args.stepId);
+    const maxIterations = loopStep?.loop.maxIterations;
+    const sessionContext = (0, run_context_js_1.projectRunContextV2)(args.truth.events).match((ok) => (ok.byRunId[String(args.runId)]?.context ?? {}), (e) => {
+        console.warn(`[prompt-renderer] Context projection failed for step '${args.stepId}' — ` +
+            `{{varName}} tokens will render as [unset:...]: ${e.message}`);
+        return {};
+    });
+    const loopIterationFrame = args.loopPath.at(-1);
+    const loopRenderContext = loopStep && loopIterationFrame
+        ? buildLoopRenderContext(loopStep, loopIterationFrame.iteration, sessionContext)
+        : {};
+    const renderContext = { ...sessionContext, ...loopRenderContext };
+    const basePrompt = (0, context_template_resolver_js_1.resolveContextTemplates)(step.prompt ?? '', renderContext);
+    const baseTitle = (0, context_template_resolver_js_1.resolveContextTemplates)(step.title, renderContext);
+    const cleanResponseFormat = process.env.WORKRAIL_CLEAN_RESPONSE_FORMAT === 'true';
+    const loopBanner = buildLoopContextBanner({ loopPath: args.loopPath, isExitStep, maxIterations, cleanFormat: cleanResponseFormat });
     const validationCriteria = step.validationCriteria;
     const requirements = (0, validation_requirements_extractor_js_1.extractValidationRequirements)(validationCriteria);
     const requirementsSection = requirements.length > 0
-        ? `\n\n**OUTPUT REQUIREMENTS:**\n${requirements.map(r => `- ${r}`).join('\n')}`
+        ? cleanResponseFormat
+            ? `\n\n${requirements.map(r => `- ${r}`).join('\n')}`
+            : `\n\n**OUTPUT REQUIREMENTS:**\n${requirements.map(r => `- ${r}`).join('\n')}`
         : '';
     const contractRequirements = formatOutputContractRequirements(outputContract);
     const contractSection = contractRequirements.length > 0
-        ? `\n\n**OUTPUT REQUIREMENTS (System):**\n${contractRequirements.map(r => `- ${r}`).join('\n')}`
+        ? cleanResponseFormat
+            ? `\n\n${contractRequirements.map(r => `- ${r}`).join('\n')}`
+            : `\n\n**OUTPUT REQUIREMENTS (System):**\n${contractRequirements.map(r => `- ${r}`).join('\n')}`
         : '';
     const isNotesOptional = outputContract !== undefined ||
         ('notesOptional' in step && step.notesOptional === true);
-    const notesSection = isNotesOptional
-        ? ''
-        : '\n\n**NOTES REQUIRED (System):** You must include `output.notesMarkdown` when advancing. ' +
+    const notesSection = (() => {
+        if (isNotesOptional)
+            return '';
+        if (cleanResponseFormat) {
+            return '';
+        }
+        const hasPriorNotes = hasPriorNotesInRun({ truth: args.truth, runId: args.runId });
+        if (hasPriorNotes && !args.rehydrateOnly) {
+            return '\n\n**NOTES REQUIRED (System):** Include `output.notesMarkdown` when advancing.\n\n' +
+                'Scope: this step only — WorkRail concatenates notes automatically.\n' +
+                'Include: what you did, what you produced, and anything notable.\n' +
+                'Be specific. Omitting notes will block this step.';
+        }
+        return '\n\n**NOTES REQUIRED (System):** You must include `output.notesMarkdown` when advancing. ' +
             'These notes are displayed to the user in a markdown viewer and serve as the durable record of your work. Write them for a human reader.\n\n' +
             'Include:\n' +
             '- **What you did** and the key decisions or trade-offs you made\n' +
@@ -260,7 +329,15 @@ function renderPendingPrompt(args) {
             '> ### Open questions\n' +
             '> - Should refresh tokens be rotated on every use? Current impl reuses until expiry.\n\n' +
             'Omitting notes will block this step — use the `retryAckToken` to fix and retry.';
-    const enhancedPrompt = loopBanner + basePrompt + requirementsSection + contractSection + notesSection;
+    })();
+    const promptFragments = 'promptFragments' in step
+        ? step.promptFragments
+        : undefined;
+    const fragmentSuffix = promptFragments && promptFragments.length > 0
+        ? assembleFragmentedPrompt(promptFragments, renderContext)
+        : '';
+    const enhancedPrompt = loopBanner + basePrompt + requirementsSection + contractSection + notesSection
+        + (fragmentSuffix ? '\n\n' + fragmentSuffix : '');
     if (!args.rehydrateOnly) {
         return (0, neverthrow_1.ok)({ stepId: args.stepId, title: baseTitle, prompt: enhancedPrompt, agentRole, requireConfirmation });
     }
@@ -288,7 +365,8 @@ function renderPendingPrompt(args) {
     if (sections.length === 0) {
         return (0, neverthrow_1.ok)({ stepId: args.stepId, title: baseTitle, prompt: enhancedPrompt, agentRole, requireConfirmation });
     }
-    const recoveryText = `## Recovery Context\n\n${sections.join('\n\n')}`;
+    const recoveryHeader = cleanResponseFormat ? 'Your previous work:' : '## Recovery Context';
+    const recoveryText = `${recoveryHeader}\n\n${sections.join('\n\n')}`;
     const combinedPrompt = `${enhancedPrompt}\n\n${recoveryText}`;
     const finalPrompt = applyPromptBudget(combinedPrompt);
     return (0, neverthrow_1.ok)({ stepId: args.stepId, title: baseTitle, prompt: finalPrompt, agentRole, requireConfirmation });