intentdna 1.8.6 → 1.8.7

package/dist/runtime/worker-executor.d.ts

@@ -0,0 +1,19 @@
+import type { ProviderEvent, StepPacket } from "./run-contracts.js";
+import type { ExecutionProvider, WorkerExecution } from "./execution-provider.js";
+export interface WorkerExecutorOptions {
+    readonly cancellationSignal?: AbortSignal;
+    readonly cancellationReason?: string | null;
+    readonly maxOutputBytes?: number;
+    readonly maxProcessCount?: number;
+    readonly processLimitPollMs?: number;
+    readonly onProcessStart?: (processId: number) => void | Promise<void>;
+    readonly now?: () => Date;
+}
+export interface WorkerExecutionWithEvents extends WorkerExecution {
+    readonly events: readonly ProviderEvent[];
+}
+/**
+ * Execute exactly one standalone Step attempt with one provider process.
+ * Controller retry and task/run policy are intentionally outside this boundary.
+ */
+export declare function executeWorkerAttempt(packet: StepPacket, provider: ExecutionProvider, options?: WorkerExecutorOptions): Promise<WorkerExecutionWithEvents>;

package/dist/runtime/worker-executor.js

@@ -0,0 +1,194 @@
+import { randomUUID } from "node:crypto";
+import { runProcessTree, } from "./process-tree.js";
+function eventId() {
+    return randomUUID();
+}
+function resourceLimitError(processResult) {
+    if (processResult.outputLimitExceeded)
+        return "provider output limit exceeded";
+    if (processResult.processLimitExceeded)
+        return "provider process limit exceeded";
+    return null;
+}
+function processOutcome(processResult, timeoutMs) {
+    if (processResult.cancelled) {
+        return {
+            kind: "cancelled",
+            exit_code: processResult.status,
+            signal: processResult.signal,
+            reason: processResult.cancellationReason,
+        };
+    }
+    if (processResult.timedOut) {
+        return {
+            kind: "timeout",
+            exit_code: processResult.status,
+            signal: processResult.signal,
+            timeout_ms: timeoutMs ?? 0,
+        };
+    }
+    if (processResult.error) {
+        return {
+            kind: "launch_error",
+            exit_code: null,
+            signal: null,
+            error: processResult.error.message,
+        };
+    }
+    const limitError = resourceLimitError(processResult);
+    if (limitError) {
+        return {
+            kind: "malformed_result",
+            exit_code: processResult.status,
+            signal: null,
+            error: limitError,
+        };
+    }
+    if (processResult.signal !== null) {
+        return {
+            kind: "signal",
+            exit_code: null,
+            signal: processResult.signal,
+        };
+    }
+    if (processResult.status !== 0) {
+        return {
+            kind: "non_zero_exit",
+            exit_code: processResult.status ?? -1,
+            signal: null,
+        };
+    }
+    return null;
+}
+function terminationEventReason(reason) {
+    if (reason === "cancellation")
+        return "cancellation";
+    if (reason === "timeout")
+        return "timeout";
+    return "process_limit";
+}
+/**
+ * Execute exactly one standalone Step attempt with one provider process.
+ * Controller retry and task/run policy are intentionally outside this boundary.
+ */
+export async function executeWorkerAttempt(packet, provider, options = {}) {
+    const now = options.now ?? (() => new Date());
+    const events = [];
+    let sequence = 0;
+    const pushEvent = (event) => {
+        events.push({
+            ...event,
+            run_id: packet.run_id,
+            step_id: packet.step_id,
+            attempt_id: packet.attempt_id,
+            worker_session_id: packet.worker_session_id,
+            event_id: eventId(),
+            sequence: ++sequence,
+            occurred_at: now().toISOString(),
+        });
+    };
+    const launch = provider.createLaunch(packet);
+    const startedAt = now().toISOString();
+    pushEvent({ type: "launch_started", provider: provider.name });
+    let processStartObservation = Promise.resolve();
+    let processStartFailed = false;
+    let processStartError;
+    const processResult = await runProcessTree(launch.command, launch.args, {
+        cwd: launch.cwd,
+        env: launch.env,
+        stdin: launch.stdin ?? undefined,
+        timeoutMs: packet.execution.timeout_ms ?? undefined,
+        cancellationSignal: options.cancellationSignal,
+        cancellationReason: options.cancellationReason,
+        cancellationGraceMs: packet.execution.cancellation_grace_ms,
+        maxOutputBytes: options.maxOutputBytes,
+        maxProcessCount: options.maxProcessCount,
+        processLimitPollMs: options.processLimitPollMs,
+        cleanupOnParentExit: true,
+        onProcessStart: (processId) => {
+            pushEvent({ type: "process_started", process_id: processId });
+            processStartObservation = Promise.resolve(options.onProcessStart?.(processId)).catch((error) => {
+                processStartFailed = true;
+                processStartError = error;
+            });
+        },
+        onStdout: (text) => {
+            pushEvent({ type: "stdout", text });
+        },
+        onStderr: (text) => {
+            pushEvent({ type: "stderr", text });
+        },
+        onTerminationRequested: (reason) => {
+            pushEvent({
+                type: "termination_requested",
+                reason: terminationEventReason(reason),
+            });
+        },
+    });
+    await processStartObservation;
+    if (processStartFailed) {
+        throw processStartError instanceof Error
+            ? processStartError
+            : new Error(String(processStartError ?? "process start observer failed"));
+    }
+    let providerSessionId = null;
+    let outputs = [];
+    let outcome = processOutcome(processResult, packet.execution.timeout_ms);
+    if (outcome === null) {
+        try {
+            const parsed = provider.parseResult({
+                packet,
+                stdout: processResult.stdout,
+                stderr: processResult.stderr,
+            });
+            providerSessionId = parsed.provider_session_id;
+            outputs = parsed.outputs;
+            outcome = { kind: "success", exit_code: 0, signal: null };
+            pushEvent({
+                type: "session_started",
+                provider_session_id: providerSessionId,
+            });
+        }
+        catch (error) {
+            outcome = {
+                kind: "malformed_result",
+                exit_code: processResult.status,
+                signal: null,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    if (outcome === null) {
+        outcome = {
+            kind: "launch_error",
+            exit_code: null,
+            signal: null,
+            error: "worker execution completed without a terminal outcome",
+        };
+    }
+    pushEvent({
+        type: "process_exited",
+        exit_code: processResult.status,
+        signal: processResult.signal,
+    });
+    const completedAt = now().toISOString();
+    const result = {
+        run_id: packet.run_id,
+        step_id: packet.step_id,
+        attempt_id: packet.attempt_id,
+        worker_session_id: packet.worker_session_id,
+        provider: provider.name,
+        provider_session_id: providerSessionId,
+        started_at: startedAt,
+        completed_at: completedAt,
+        outcome,
+        outputs,
+        stdout_reference: null,
+        stderr_reference: null,
+    };
+    return {
+        worker_session_id: packet.worker_session_id,
+        result,
+        events,
+    };
+}

package/dist/runtime/workflow-plan-adapter.d.ts

@@ -0,0 +1,26 @@
+import type { RoleDef, WorkflowPlan, WorkflowStep } from "../schema/types.js";
+import type { ControllerStepDefinition, MaterializeStepPacketInput } from "./run-controller.js";
+import type { TerminalOutcomeKind } from "./run-contracts.js";
+export type WorkflowPlanAdapterErrorCode = "invalid_plan" | "missing_role" | "invalid_handoff" | "unsupported_routing";
+export declare class WorkflowPlanAdapterError extends Error {
+    readonly code: WorkflowPlanAdapterErrorCode;
+    readonly step_id: string | null;
+    constructor(code: WorkflowPlanAdapterErrorCode, message: string, stepId?: string | null);
+}
+export interface WorkflowPlanAdapterOptions {
+    readonly roles: Readonly<Record<string, RoleDef>>;
+    readonly variables?: Readonly<Record<string, string>>;
+    readonly working_directory: string;
+    readonly working_directory_for_step?: (step: WorkflowStep, input: MaterializeStepPacketInput) => string;
+    readonly timeout_ms?: number | null;
+    readonly cancellation_grace_ms?: number;
+    readonly retry_initial_delay_ms?: number;
+    readonly retry_max_delay_ms?: number | null;
+    readonly retryable_outcomes?: readonly TerminalOutcomeKind[];
+}
+/**
+ * Adapt one compiled workflow plan into Controller definitions. Every
+ * materializer creates a self-contained packet from Controller-resolved inputs;
+ * no provider transcript or prior-session state is accepted by this API.
+ */
+export declare function adaptWorkflowPlan(plan: WorkflowPlan, options: WorkflowPlanAdapterOptions): readonly ControllerStepDefinition[];

package/dist/runtime/workflow-plan-adapter.js

@@ -0,0 +1,416 @@
+const DEFAULT_RETRYABLE_OUTCOMES = [
+    "non_zero_exit",
+    "malformed_result",
+    "timeout",
+    "signal",
+    "launch_error",
+];
+export class WorkflowPlanAdapterError extends Error {
+    code;
+    step_id;
+    constructor(code, message, stepId = null) {
+        super(message);
+        this.name = "WorkflowPlanAdapterError";
+        this.code = code;
+        this.step_id = stepId;
+    }
+}
+function substitute(value, variables) {
+    return value.replace(/\{\{(\w+)\}\}/g, (match, key) => (Object.prototype.hasOwnProperty.call(variables, key)
+        ? variables[key]
+        : match));
+}
+function artifactIdentity(artifact, variables, stepId) {
+    const identity = artifact.artifact_id
+        ?? artifact.name
+        ?? artifact.path
+        ?? (artifact.type === "git_commit" ? "git_commit" : undefined);
+    if (!identity) {
+        throw new WorkflowPlanAdapterError("invalid_handoff", `handoff artifact '${artifact.description}' has no stable identity`, stepId);
+    }
+    return substitute(identity, variables);
+}
+function handoffMode(type) {
+    if (type === "summary")
+        return "quote";
+    if (type === "state")
+        return "structured";
+    return "reference";
+}
+function outputKind(type) {
+    if (type === "summary")
+        return "text";
+    if (type === "state")
+        return "structured";
+    return "reference";
+}
+function requireNonNegativeInteger(value, field) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new WorkflowPlanAdapterError("invalid_plan", `${field} must be a non-negative safe integer`);
+    }
+}
+function isolationForStep(groups, stepId) {
+    return groups.find((group) => group.step_ids.includes(stepId))?.isolation
+        ?? "none";
+}
+function completionText(completion, variables) {
+    if (completion.file_exists !== undefined) {
+        return `Required file exists: ${substitute(completion.file_exists, variables)}`;
+    }
+    if (completion.file_not_empty !== undefined) {
+        return `Required file is not empty: ${substitute(completion.file_not_empty, variables)}`;
+    }
+    if (completion.file_contains !== undefined) {
+        return `Required file ${substitute(completion.file_contains.path, variables)} contains /${completion.file_contains.pattern}/`;
+    }
+    return `Required command succeeds: ${substitute(completion.command_success ?? "", variables)}`;
+}
+function checkpointText(checkpoint, variables) {
+    const command = checkpoint.command
+        ? `; command: ${substitute(checkpoint.command, variables)}`
+        : "";
+    return `Checkpoint ${checkpoint.assert} (${checkpoint.action ?? "block"}): ${substitute(checkpoint.message, variables)}${command}`;
+}
+function collectConstraints(step, role, variables) {
+    const constraints = [];
+    for (const instruction of role.instructions ?? []) {
+        constraints.push(substitute(instruction, variables));
+    }
+    if (role.scope?.read) {
+        constraints.push(`Readable paths: ${role.scope.read.map((path) => substitute(path, variables)).join(", ")}`);
+    }
+    if (role.scope?.write) {
+        constraints.push(`Writable paths: ${role.scope.write.map((path) => substitute(path, variables)).join(", ") || "(none)"}`);
+    }
+    if (role.tool_permissions?.allow) {
+        constraints.push(`Allowed tools: ${role.tool_permissions.allow.join(", ")}`);
+    }
+    if (role.tool_permissions?.deny) {
+        constraints.push(`Denied tools: ${role.tool_permissions.deny.join(", ")}`);
+    }
+    for (const postCheck of role.post_checks ?? []) {
+        constraints.push(`Required role post-check: ${substitute(postCheck, variables)}`);
+    }
+    if (step.enforce?.read_only) {
+        constraints.push("This Step is read-only; do not modify files.");
+    }
+    if (step.enforce?.additional_write_paths?.length) {
+        constraints.push(`Additional writable paths: ${step.enforce.additional_write_paths
+            .map((path) => substitute(path, variables))
+            .join(", ")}`);
+    }
+    if (step.enforce?.relax_after_iteration !== undefined) {
+        constraints.push(`Scope relaxation is permitted only after iteration ${step.enforce.relax_after_iteration}.`);
+    }
+    for (const completion of step.completion ?? []) {
+        constraints.push(completionText(completion, variables));
+    }
+    for (const checkpoint of step.checkpoints ?? []) {
+        constraints.push(checkpointText(checkpoint, variables));
+    }
+    return constraints;
+}
+function createOutputContract(step, variables) {
+    const outputs = (step.handoff?.produces ?? []).map((artifact) => ({
+        name: artifactIdentity(artifact, variables, step.id),
+        kind: outputKind(artifact.type),
+        required: artifact.required !== false,
+        description: substitute(artifact.description, variables),
+        schema_ref: null,
+    }));
+    const names = new Set();
+    for (const output of outputs) {
+        if (names.has(output.name)) {
+            throw new WorkflowPlanAdapterError("invalid_handoff", `step '${step.id}' declares duplicate output '${output.name}'`, step.id);
+        }
+        names.add(output.name);
+    }
+    return outputs;
+}
+function findSourceOutput(sourceStep, outputName, variables) {
+    const matches = (sourceStep.handoff?.produces ?? []).filter((artifact) => artifactIdentity(artifact, variables, sourceStep.id) === outputName);
+    if (matches.length !== 1) {
+        throw new WorkflowPlanAdapterError("invalid_handoff", `step '${sourceStep.id}' must declare exactly one output named '${outputName}'`, sourceStep.id);
+    }
+    return matches[0];
+}
+function createHandoffs(step, stepById, variables) {
+    const declarations = [];
+    const externalInputs = [];
+    for (const artifact of step.handoff?.consumes ?? []) {
+        if (!artifact.from) {
+            externalInputs.push(artifact);
+            continue;
+        }
+        const sourceStep = stepById.get(artifact.from);
+        if (!sourceStep || artifact.from === step.id) {
+            throw new WorkflowPlanAdapterError("invalid_handoff", `step '${step.id}' declares invalid handoff source '${artifact.from}'`, step.id);
+        }
+        const inputName = artifactIdentity(artifact, variables, step.id);
+        const sourceArtifact = findSourceOutput(sourceStep, inputName, variables);
+        const mode = handoffMode(artifact.type);
+        if (handoffMode(sourceArtifact.type) !== mode) {
+            throw new WorkflowPlanAdapterError("invalid_handoff", `handoff '${inputName}' changes mode between '${sourceStep.id}' and '${step.id}'`, step.id);
+        }
+        const base = {
+            binding_id: `${step.id}:${inputName}`,
+            input_name: inputName,
+            required: artifact.required !== false,
+            description: substitute(artifact.description, variables),
+            source: {
+                step_id: sourceStep.id,
+                output_name: inputName,
+            },
+        };
+        if (mode === "quote") {
+            declarations.push({ ...base, mode, selection: null });
+        }
+        else if (mode === "structured") {
+            declarations.push({ ...base, mode, schema_ref: null });
+        }
+        else {
+            declarations.push({ ...base, mode });
+        }
+    }
+    const bindingIds = new Set();
+    const inputNames = new Set();
+    for (const declaration of declarations) {
+        if (bindingIds.has(declaration.binding_id)
+            || inputNames.has(declaration.input_name)) {
+            throw new WorkflowPlanAdapterError("invalid_handoff", `step '${step.id}' declares duplicate handoff '${declaration.input_name}'`, step.id);
+        }
+        bindingIds.add(declaration.binding_id);
+        inputNames.add(declaration.input_name);
+    }
+    return { handoffs: declarations, external_inputs: externalInputs };
+}
+function retryPolicy(plan, step, options) {
+    const initialDelay = options.retry_initial_delay_ms ?? 0;
+    const maxDelay = options.retry_max_delay_ms ?? null;
+    requireNonNegativeInteger(initialDelay, "retry_initial_delay_ms");
+    if (maxDelay !== null)
+        requireNonNegativeInteger(maxDelay, "retry_max_delay_ms");
+    const maxAttempts = step.max_attempts ?? plan.retry.max_retries + 1;
+    if (!Number.isSafeInteger(maxAttempts) || maxAttempts < 1) {
+        throw new WorkflowPlanAdapterError("invalid_plan", `step '${step.id}' has an invalid max attempt count`, step.id);
+    }
+    return {
+        max_attempts: maxAttempts,
+        backoff: plan.retry.backoff,
+        initial_delay_ms: initialDelay,
+        max_delay_ms: maxDelay,
+        retryable_outcomes: options.retryable_outcomes
+            ?? DEFAULT_RETRYABLE_OUTCOMES,
+    };
+}
+function addHandoffDependencies(step, handoffs) {
+    const dependencies = new Set(step.depends_on);
+    for (const handoff of handoffs) {
+        if (handoff.mode !== "none")
+            dependencies.add(handoff.source.step_id);
+    }
+    return [...dependencies].map((dependency) => dependency);
+}
+function renderBinding(binding) {
+    const prefix = `- ${binding.input_name} (${binding.mode}, ${binding.required ? "required" : "optional"}): ${binding.description}`;
+    if (binding.mode === "reference") {
+        return [
+            prefix,
+            `  Reference kind: ${binding.reference.kind}`,
+            `  Reference value: ${binding.reference.value}`,
+        ];
+    }
+    if (binding.mode === "quote") {
+        return [
+            prefix,
+            `  Exact text JSON (${binding.exact_text.length} UTF-16 code units): ${JSON.stringify(binding.exact_text)}`,
+        ];
+    }
+    if (binding.mode === "structured") {
+        return [
+            prefix,
+            `  Schema: ${binding.schema_ref ?? "(none)"}`,
+            `  JSON value: ${JSON.stringify(binding.value)}`,
+        ];
+    }
+    return [prefix, `  Reason: ${binding.reason ?? "no upstream delivery declared"}`];
+}
+function renderExternalInput(artifact, variables, stepId) {
+    const name = artifactIdentity(artifact, variables, stepId);
+    const lines = [
+        `- ${name} (external ${handoffMode(artifact.type)}, ${artifact.required === false ? "optional" : "required"}): ${substitute(artifact.description, variables)}`,
+    ];
+    if (artifact.path) {
+        lines.push(`  Declared path: ${substitute(artifact.path, variables)}`);
+    }
+    return lines;
+}
+function renderOutputProtocol(outputs) {
+    if (outputs.length === 0) {
+        return ["No handoff output is declared. Return only the Step result."];
+    }
+    if (outputs.length === 1 && outputs[0].kind === "text") {
+        return [
+            `Return the exact textual output '${outputs[0].name}' as the final response.`,
+            `Description: ${outputs[0].description}`,
+        ];
+    }
+    return [
+        "Return one JSON object with an `outputs` array matching these declarations exactly:",
+        ...outputs.map((output) => (`- ${output.name}: kind=${output.kind}, required=${String(output.required)}, schema_ref=${output.schema_ref ?? "null"}; ${output.description}`)),
+        "Reference values use {\"name\":\"...\",\"kind\":\"reference\",\"reference\":{\"kind\":\"file|directory|artifact|uri\",\"value\":\"...\"}}.",
+        "Text values use {\"name\":\"...\",\"kind\":\"text\",\"text\":\"...\"}.",
+        "Structured values use {\"name\":\"...\",\"kind\":\"structured\",\"value\":<JSON>,\"schema_ref\":null}.",
+    ];
+}
+function standalonePrompt(plan, adapted, bindings, variables) {
+    const { step, role, constraints, external_inputs: externalInputs, outputs } = adapted;
+    const lines = [
+        `# ${plan.name}: ${step.id}`,
+        "",
+        "You are executing one standalone workflow Step in an independent session.",
+        "Use only the task, constraints, and declared inputs below. Do not rely on or request previous conversation history.",
+        "Complete only this Step and stop after returning its declared result.",
+        "",
+        "## Role",
+        `${step.role}: ${substitute(role.description, variables)}`,
+        "",
+        "## Task",
+        substitute(step.prompt ?? step.description, variables),
+        "",
+        "## Constraints",
+        ...(constraints.length > 0
+            ? constraints.map((constraint) => `- ${constraint}`)
+            : ["- No additional current-Step constraints are declared."]),
+        "",
+        "## Inputs",
+    ];
+    if (bindings.length === 0 && externalInputs.length === 0) {
+        lines.push("- None. This Step has no declared upstream delivery.");
+    }
+    else {
+        for (const binding of bindings)
+            lines.push(...renderBinding(binding));
+        for (const artifact of externalInputs) {
+            lines.push(...renderExternalInput(artifact, variables, step.id));
+        }
+    }
+    lines.push("", "## Outputs", ...renderOutputProtocol(outputs), "");
+    if (role.success_criteria?.length) {
+        lines.push("## Success Criteria", ...role.success_criteria.map((criterion) => `- ${substitute(criterion, variables)}`), "");
+    }
+    if (role.failure_modes?.length) {
+        lines.push("## Failure Modes To Avoid", ...role.failure_modes.map((failure) => `- ${substitute(failure, variables)}`), "");
+    }
+    return lines.join("\n");
+}
+function validatePlanRouting(plan) {
+    if (plan.transitions.length > 0) {
+        throw new WorkflowPlanAdapterError("unsupported_routing", "conditional workflow transitions cannot be represented by the Foundation Controller dependency contract");
+    }
+    if (plan.retry.retry_from !== null) {
+        throw new WorkflowPlanAdapterError("unsupported_routing", "workflow retry_from cannot be represented by per-Step Foundation retries");
+    }
+    for (const step of plan.steps) {
+        if (step.optional) {
+            throw new WorkflowPlanAdapterError("unsupported_routing", `step '${step.id}' is optional, which the Foundation Controller cannot preserve on failure`, step.id);
+        }
+        if (step.run_if !== null && plan.retry.max_retries > 0) {
+            throw new WorkflowPlanAdapterError("unsupported_routing", `step '${step.id}' uses run_if across retry rounds, which the Foundation Controller cannot evaluate`, step.id);
+        }
+        if (step.on_fail === "handoff"
+            || step.on_fail === "skip"
+            || step.handoff_to !== undefined
+            || step.max_handoffs !== undefined
+            || step.on_handoff_exhausted !== undefined) {
+            throw new WorkflowPlanAdapterError("unsupported_routing", `step '${step.id}' uses legacy failure routing not represented by the Foundation Controller`, step.id);
+        }
+    }
+}
+function runsInSingleRound(condition) {
+    if (condition === null)
+        return true;
+    const equal = condition.match(/^round\s*==\s*(\d+)$/);
+    if (equal)
+        return Number(equal[1]) === 1;
+    const greater = condition.match(/^round\s*>\s*(\d+)$/);
+    if (greater)
+        return 1 > Number(greater[1]);
+    const greaterOrEqual = condition.match(/^round\s*>=\s*(\d+)$/);
+    if (greaterOrEqual)
+        return 1 >= Number(greaterOrEqual[1]);
+    if (condition === "retry")
+        return false;
+    return true;
+}
+/**
+ * Adapt one compiled workflow plan into Controller definitions. Every
+ * materializer creates a self-contained packet from Controller-resolved inputs;
+ * no provider transcript or prior-session state is accepted by this API.
+ */
+export function adaptWorkflowPlan(plan, options) {
+    validatePlanRouting(plan);
+    if (!options.working_directory) {
+        throw new WorkflowPlanAdapterError("invalid_plan", "working_directory must be non-empty");
+    }
+    const cancellationGrace = options.cancellation_grace_ms ?? 5_000;
+    requireNonNegativeInteger(cancellationGrace, "cancellation_grace_ms");
+    if (options.timeout_ms !== undefined && options.timeout_ms !== null) {
+        requireNonNegativeInteger(options.timeout_ms, "timeout_ms");
+    }
+    const variables = options.variables ?? {};
+    const stepById = new Map(plan.steps.map((step) => [step.id, step]));
+    const adapted = plan.steps.map((step) => {
+        const role = options.roles[step.role];
+        if (!role) {
+            throw new WorkflowPlanAdapterError("missing_role", `step '${step.id}' references missing role '${step.role}'`, step.id);
+        }
+        const { handoffs, external_inputs } = createHandoffs(step, stepById, variables);
+        return {
+            step,
+            role,
+            constraints: collectConstraints(step, role, variables),
+            handoffs,
+            external_inputs,
+            outputs: createOutputContract(step, variables),
+            isolation: isolationForStep(plan.parallel_groups, step.id),
+            retry: retryPolicy(plan, step, options),
+        };
+    });
+    return adapted.map((entry) => ({
+        step_id: entry.step.id,
+        dependencies: addHandoffDependencies(entry.step, entry.handoffs),
+        initially_skipped: !runsInSingleRound(entry.step.run_if),
+        retry_policy: entry.retry,
+        handoffs: entry.handoffs,
+        materialize_packet(input) {
+            const workingDirectory = options.working_directory_for_step?.(entry.step, input) ?? options.working_directory;
+            if (!workingDirectory) {
+                throw new WorkflowPlanAdapterError("invalid_plan", `step '${entry.step.id}' resolved an empty working directory`, entry.step.id);
+            }
+            return {
+                packet_version: 1,
+                run_id: input.run_id,
+                step_id: input.step_id,
+                attempt_id: input.attempt_id,
+                worker_session_id: input.worker_session_id,
+                attempt_number: input.attempt_number,
+                role: entry.step.role,
+                constraints: entry.constraints,
+                standalone_prompt: standalonePrompt(plan, entry, input.input_bindings, variables),
+                input_bindings: input.input_bindings,
+                output_contract: entry.outputs,
+                workspace: {
+                    isolation: entry.isolation,
+                    working_directory: workingDirectory,
+                },
+                execution: {
+                    timeout_ms: options.timeout_ms ?? null,
+                    cancellation_grace_ms: cancellationGrace,
+                    retry: input.retry_policy,
+                },
+                created_at: input.created_at,
+            };
+        },
+    }));
+}