intentdna 1.9.0 → 1.9.3

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

@@ -1,3 +1,5 @@
+import { resolvePostCheckCommand } from "../compiler/compile.js";
+import { EXECUTABLE_RUN_PLAN_SCHEMA_VERSION, deriveWorkerRuntimeInputNames, parseExecutableRunPlanPayload, } from "./executable-run-plan.js";
 const DEFAULT_RETRYABLE_OUTCOMES = [
     "non_zero_exit",
     "malformed_result",
@@ -114,15 +116,20 @@ function collectConstraints(step, role, variables) {
     for (const checkpoint of step.checkpoints ?? []) {
         constraints.push(checkpointText(checkpoint, variables));
     }
-    return constraints;
+    const bindings = Object.entries(step.canonical_handoff_path_bindings ?? {});
+    return constraints.map((constraint) => bindings.reduce((rendered, [path, replacement]) => rendered.replaceAll(path, replacement), constraint));
 }
 function createOutputContract(step, variables) {
     const outputs = (step.handoff?.produces ?? []).map((artifact) => ({
         name: artifactIdentity(artifact, variables, step.id),
         kind: outputKind(artifact.type),
+        artifact_kind: artifact.type,
         required: artifact.required !== false,
         description: substitute(artifact.description, variables),
-        schema_ref: null,
+        relative_path_template: artifact.path === undefined
+            ? null
+            : substitute(artifact.path, variables),
+        schema_ref: artifact.schema_ref ?? null,
     }));
     const names = new Set();
     for (const output of outputs) {
@@ -133,6 +140,34 @@ function createOutputContract(step, variables) {
     }
     return outputs;
 }
+function createHandoffInputContract(step, variables) {
+    return (step.handoff?.consumes ?? []).map((artifact) => ({
+        name: artifactIdentity(artifact, variables, step.id),
+        source: artifact.from ? "handoff" : "external",
+        mode: handoffMode(artifact.type),
+        artifact_kind: artifact.type,
+        required: artifact.required !== false,
+        description: substitute(artifact.description, variables),
+        relative_path_template: artifact.path === undefined
+            ? null
+            : substitute(artifact.path, variables),
+        schema_ref: artifact.schema_ref ?? null,
+    }));
+}
+function workerResponseContract(role) {
+    if (role.output_schema === undefined)
+        return { kind: "none" };
+    if (typeof role.output_schema === "string") {
+        return { kind: "named", schema_ref: role.output_schema };
+    }
+    return {
+        kind: "document",
+        relative_path_template: role.output_schema.path ?? null,
+        required_sections: role.output_schema.required_sections ?? [],
+        format: (role.output_schema.format ?? null),
+        converter_command: role.output_schema.converter ?? null,
+    };
+}
 function findSourceOutput(sourceStep, outputName, variables) {
     const matches = (sourceStep.handoff?.produces ?? []).filter((artifact) => artifactIdentity(artifact, variables, sourceStep.id) === outputName);
     if (matches.length !== 1) {
@@ -155,8 +190,8 @@ function createHandoffs(step, stepById, variables) {
         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);
+        if (sourceArtifact.type !== artifact.type) {
+            throw new WorkflowPlanAdapterError("invalid_handoff", `handoff '${inputName}' changes artifact kind between '${sourceStep.id}' and '${step.id}'`, step.id);
         }
         const base = {
             binding_id: `${step.id}:${inputName}`,
@@ -172,10 +207,14 @@ function createHandoffs(step, stepById, variables) {
             declarations.push({ ...base, mode, selection: null });
         }
         else if (mode === "structured") {
-            declarations.push({ ...base, mode, schema_ref: null });
+            declarations.push({ ...base, mode, schema_ref: artifact.schema_ref ?? null });
         }
         else {
-            declarations.push({ ...base, mode });
+            declarations.push({
+                ...base,
+                mode,
+                artifact_kind: artifact.type,
+            });
         }
     }
     const bindingIds = new Set();
@@ -225,6 +264,7 @@ function renderBinding(binding) {
             prefix,
             `  Reference kind: ${binding.reference.kind}`,
             `  Reference value: ${binding.reference.value}`,
+            `  Artifact id: ${binding.reference.artifact_id ?? "legacy-unavailable"}`,
         ];
     }
     if (binding.mode === "quote") {
@@ -434,7 +474,10 @@ export function adaptWorkflowPlan(plan, options) {
             constraints: collectConstraints(step, role, variables),
             handoffs,
             external_inputs,
+            handoff_inputs: createHandoffInputContract(step, variables),
+            runtime_input_names: [],
             outputs: createOutputContract(step, variables),
+            response_contract: workerResponseContract(role),
             isolation: isolationForStep(plan.parallel_groups, step.id),
             retry: retryPolicy(plan, step, options, workflowLoop !== null),
         };
@@ -481,3 +524,456 @@ export function adaptWorkflowPlan(plan, options) {
         },
     }));
 }
+const EXECUTABLE_WORKFLOW_RETRY_SEGMENT_ID = "retry:workflow";
+const SUCCEEDED_TERMINAL_NODE_ID = "terminal:succeeded";
+const FAILED_TERMINAL_NODE_ID = "terminal:failed";
+const CANCELLED_TERMINAL_NODE_ID = "terminal:cancelled";
+function workerNodeId(stepId) {
+    return `worker:${stepId}`;
+}
+function gateNodeId(stepId) {
+    return `gate:${stepId}`;
+}
+function gatePassRouteId(stepId) {
+    return `route:gate:${stepId}:pass`;
+}
+function gateFailRouteId(stepId) {
+    return `route:gate:${stepId}:fail`;
+}
+function completionVerifier(stepId, completion, index) {
+    const verifier_id = `verifier:${stepId}:completion:${index}`;
+    if (completion.file_exists !== undefined) {
+        return {
+            verifier_id,
+            subject_node_id: workerNodeId(stepId),
+            kind: "artifact_exists",
+            relative_path_template: completion.file_exists,
+        };
+    }
+    if (completion.file_not_empty !== undefined) {
+        return {
+            verifier_id,
+            subject_node_id: workerNodeId(stepId),
+            kind: "artifact_non_empty",
+            relative_path_template: completion.file_not_empty,
+        };
+    }
+    if (completion.file_contains !== undefined) {
+        return {
+            verifier_id,
+            subject_node_id: workerNodeId(stepId),
+            kind: "artifact_contains",
+            relative_path_template: completion.file_contains.path,
+            pattern: completion.file_contains.pattern,
+        };
+    }
+    if (completion.evaluator_result !== undefined) {
+        return {
+            verifier_id,
+            subject_node_id: workerNodeId(stepId),
+            kind: "evaluator_result",
+            relative_path_template: completion.evaluator_result.path,
+            require_score: completion.evaluator_result.require_score === true,
+        };
+    }
+    return {
+        verifier_id,
+        subject_node_id: workerNodeId(stepId),
+        kind: "command",
+        command: completion.command_success ?? "",
+        relative_working_directory: ".",
+    };
+}
+function checkpointVerifier(stepId, checkpoint, index) {
+    return {
+        verifier_id: `verifier:${stepId}:checkpoint:${index}`,
+        subject_node_id: workerNodeId(stepId),
+        kind: "checkpoint",
+        assertion: checkpoint.assert,
+        command: checkpoint.command ?? null,
+        message: checkpoint.message,
+        action: checkpoint.action ?? "block",
+    };
+}
+function rolePostCheckVerifier(stepId, postCheck, index) {
+    return {
+        verifier_id: `verifier:${stepId}:post-check:${index}`,
+        subject_node_id: workerNodeId(stepId),
+        kind: "checkpoint",
+        assertion: `role_post_check_${index}`,
+        command: resolvePostCheckCommand(postCheck),
+        message: `Post-check failed: ${postCheck}`,
+        action: "warn",
+    };
+}
+function executableVerifiersForStep(step, role) {
+    return [
+        ...(step.completion ?? []).map((completion, index) => (completionVerifier(step.id, completion, index))),
+        ...(step.checkpoints ?? []).map((checkpoint, index) => (checkpointVerifier(step.id, checkpoint, index))),
+        ...(role.post_checks ?? []).map((postCheck, index) => (rolePostCheckVerifier(step.id, postCheck, index))),
+    ];
+}
+function renderExecutableHandoffInput(handoff) {
+    const prefix = `- ${handoff.input_name} (${handoff.mode}, ${handoff.required ? "required" : "optional"}): ${handoff.description}`;
+    if (handoff.mode === "reference") {
+        if (handoff.artifact_kind === "git_commit") {
+            return [
+                prefix,
+                `  Commit id: {{handoff.${handoff.binding_id}.commit_oid}}`,
+                `  Artifact id: {{handoff.${handoff.binding_id}.artifact_id}}`,
+            ];
+        }
+        return [
+            prefix,
+            `  Materialized path: {{handoff.${handoff.binding_id}.materialized_path}}`,
+            `  Artifact id: {{handoff.${handoff.binding_id}.artifact_id}}`,
+        ];
+    }
+    if (handoff.mode === "quote") {
+        return [prefix, `  Exact text: {{handoff.${handoff.binding_id}.exact_text}}`];
+    }
+    if (handoff.mode === "structured") {
+        return [prefix, `  JSON value: {{handoff.${handoff.binding_id}.json}}`];
+    }
+    return [prefix];
+}
+function renderResponseContract(contract) {
+    if (contract.kind === "none")
+        return [];
+    if (contract.kind === "named") {
+        return ["## Response Contract", `- Schema: ${contract.schema_ref}`, ""];
+    }
+    const lines = ["## Response Contract"];
+    if (contract.relative_path_template !== null) {
+        lines.push(`- Output path: ${contract.relative_path_template}`);
+    }
+    if (contract.format !== null)
+        lines.push(`- Final format: ${contract.format}`);
+    for (const section of contract.required_sections) {
+        lines.push(`- Required section: ## ${section}`);
+    }
+    return [...lines, ""];
+}
+function executableStandalonePrompt(plan, adapted) {
+    const { step, role, constraints, handoffs, 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}: ${role.description}`,
+        "",
+        "## Task",
+        step.prompt ?? step.description,
+        "",
+        "## Constraints",
+        ...(constraints.length > 0
+            ? constraints.map((constraint) => `- ${constraint}`)
+            : ["- No additional current-Step constraints are declared."]),
+        "",
+        "## Inputs",
+    ];
+    if (handoffs.length === 0 && externalInputs.length === 0) {
+        lines.push("- None. This Step has no declared upstream delivery.");
+    }
+    else {
+        for (const handoff of handoffs)
+            lines.push(...renderExecutableHandoffInput(handoff));
+        for (const artifact of externalInputs) {
+            lines.push(...renderExternalInput(artifact, {}, step.id));
+        }
+    }
+    lines.push("", "## Outputs", ...renderOutputProtocol(outputs), "", ...renderResponseContract(adapted.response_contract));
+    if (role.success_criteria?.length) {
+        lines.push("## Success Criteria", ...role.success_criteria.map((criterion) => `- ${criterion}`), "");
+    }
+    if (role.failure_modes?.length) {
+        lines.push("## Failure Modes To Avoid", ...role.failure_modes.map((failure) => `- ${failure}`), "");
+    }
+    return lines.join("\n");
+}
+function executableHandoffs(adapted) {
+    return adapted.flatMap((entry) => entry.handoffs.flatMap((handoff) => {
+        if (handoff.mode === "none")
+            return [];
+        const input = entry.handoff_inputs.find((candidate) => candidate.name === handoff.input_name);
+        if (!input || input.source !== "handoff") {
+            throw new WorkflowPlanAdapterError("invalid_handoff", `step '${entry.step.id}' is missing typed input '${handoff.input_name}'`, entry.step.id);
+        }
+        return [{
+                handoff_id: handoff.binding_id,
+                from_node_id: workerNodeId(handoff.source.step_id),
+                output_name: handoff.source.output_name,
+                to_node_id: workerNodeId(entry.step.id),
+                input_name: handoff.input_name,
+                mode: handoff.mode,
+                artifact_kind: input.artifact_kind,
+                required: handoff.required,
+                schema_ref: handoff.mode === "structured" ? handoff.schema_ref : null,
+            }];
+    }));
+}
+/**
+ * Compile a WorkflowPlan into the immutable, provider-neutral plan payload.
+ * The legacy closure-based adapter above remains unchanged until the S8 cutover.
+ */
+export function adaptWorkflowPlanToExecutableRunPlan(plan, options) {
+    if (!options.target_key) {
+        throw new WorkflowPlanAdapterError("invalid_plan", "target_key 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 adapterOptions = {
+        roles: options.roles,
+        variables: {},
+        working_directory: ".",
+        timeout_ms: options.timeout_ms,
+        cancellation_grace_ms: cancellationGrace,
+        retry_initial_delay_ms: options.retry_initial_delay_ms,
+        retry_max_delay_ms: options.retry_max_delay_ms,
+        retryable_outcomes: options.retryable_outcomes,
+    };
+    const workflowLoop = validatePlanRouting(plan, adapterOptions);
+    for (const step of plan.steps) {
+        if (workflowLoop === null && step.run_if !== null) {
+            throw new WorkflowPlanAdapterError("unsupported_routing", `step '${step.id}' uses run_if without a typed retry segment`, step.id);
+        }
+        if (step.blocked_items_path !== undefined) {
+            throw new WorkflowPlanAdapterError("unsupported_routing", `step '${step.id}' uses failure routing not represented by the executable plan`, step.id);
+        }
+        if (step.on_fail === "retry_with_feedback"
+            && (step.max_attempts === undefined || step.max_attempts < 2)) {
+            throw new WorkflowPlanAdapterError("invalid_plan", `step '${step.id}' retry_with_feedback requires max_attempts of at least 2`, step.id);
+        }
+    }
+    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, {});
+        return {
+            step,
+            role,
+            constraints: [
+                ...(options.global_constraints ?? []),
+                ...collectConstraints(step, role, {}),
+            ],
+            handoffs,
+            external_inputs,
+            handoff_inputs: createHandoffInputContract(step, {}),
+            runtime_input_names: [],
+            outputs: createOutputContract(step, {}),
+            response_contract: workerResponseContract(role),
+            isolation: isolationForStep(plan.parallel_groups, step.id),
+            retry: retryPolicy(plan, step, adapterOptions, workflowLoop !== null),
+        };
+    });
+    const verifiersByStep = new Map(adapted.map((entry) => [
+        entry.step.id,
+        executableVerifiersForStep(entry.step, entry.role),
+    ]));
+    const handoffPlan = executableHandoffs(adapted);
+    const effectiveNodeId = (stepId) => ((verifiersByStep.get(stepId)?.length ?? 0) > 0
+        ? gateNodeId(stepId)
+        : workerNodeId(stepId));
+    const dependenciesByStep = new Map(adapted.map((entry) => [
+        entry.step.id,
+        addHandoffDependencies(entry.step, entry.handoffs).map(effectiveNodeId),
+    ]));
+    const dependentSteps = new Map();
+    for (const entry of adapted) {
+        for (const dependency of addHandoffDependencies(entry.step, entry.handoffs)) {
+            const dependents = dependentSteps.get(dependency) ?? [];
+            dependents.push(entry.step.id);
+            dependentSteps.set(dependency, dependents);
+        }
+    }
+    const workerNodes = adapted.map((entry) => {
+        const worker = {
+            kind: "worker",
+            node_id: workerNodeId(entry.step.id),
+            depends_on: dependenciesByStep.get(entry.step.id) ?? [],
+            role: entry.step.role,
+            packet_template: {
+                standalone_prompt: executableStandalonePrompt(plan, entry),
+                constraints: entry.constraints,
+                runtime_input_names: [],
+                handoff_inputs: entry.handoff_inputs,
+                output_contract: entry.outputs,
+                response_contract: entry.response_contract,
+            },
+            workspace: {
+                isolation: entry.isolation,
+                relative_working_directory: ".",
+                read_only: entry.step.enforce?.read_only === true,
+                readable_path_templates: entry.role.scope?.read ?? ["**/*"],
+                writable_path_templates: entry.step.enforce?.read_only === true
+                    ? []
+                    : [
+                        ...(entry.role.scope?.write ?? []),
+                        ...(entry.step.enforce?.additional_write_paths ?? []),
+                    ],
+                scope_relaxation: entry.step.enforce?.relax_after_iteration === undefined
+                    ? null
+                    : {
+                        from_iteration: entry.step.enforce.relax_after_iteration,
+                        effect: "disable_path_scope",
+                    },
+            },
+            tool_policy: {
+                allow: entry.role.tool_permissions?.allow ?? null,
+                deny: entry.role.tool_permissions?.deny ?? [],
+            },
+            attempt_policy: {
+                timeout_ms: options.timeout_ms ?? null,
+                cancellation_grace_ms: cancellationGrace,
+                max_attempts: entry.retry.max_attempts,
+                backoff: entry.retry.backoff,
+                initial_delay_ms: entry.retry.initial_delay_ms,
+                max_delay_ms: entry.retry.max_delay_ms,
+                retryable_outcomes: entry.retry.retryable_outcomes.filter((outcome) => outcome !== "success"),
+                retry_segment_id: workflowLoop?.step_ids.includes(entry.step.id)
+                    ? EXECUTABLE_WORKFLOW_RETRY_SEGMENT_ID
+                    : null,
+            },
+        };
+        return {
+            ...worker,
+            packet_template: {
+                ...worker.packet_template,
+                runtime_input_names: deriveWorkerRuntimeInputNames(worker, verifiersByStep.get(entry.step.id) ?? [], handoffPlan),
+            },
+        };
+    });
+    const routes = [];
+    const gateNodes = adapted.flatMap((entry) => {
+        const verifiers = verifiersByStep.get(entry.step.id) ?? [];
+        if (verifiers.length === 0)
+            return [];
+        const passTargets = dependentSteps.get(entry.step.id)?.map(workerNodeId)
+            ?? [SUCCEEDED_TERMINAL_NODE_ID];
+        routes.push(...passTargets.map((toNodeId, index) => ({
+            route_id: index === 0
+                ? gatePassRouteId(entry.step.id)
+                : `${gatePassRouteId(entry.step.id)}:${index}`,
+            from_node_id: gateNodeId(entry.step.id),
+            to_node_id: toNodeId,
+            condition: {
+                kind: "gate",
+                gate_node_id: gateNodeId(entry.step.id),
+                outcome: "pass",
+            },
+        })), {
+            route_id: gateFailRouteId(entry.step.id),
+            from_node_id: gateNodeId(entry.step.id),
+            to_node_id: FAILED_TERMINAL_NODE_ID,
+            condition: {
+                kind: "gate",
+                gate_node_id: gateNodeId(entry.step.id),
+                outcome: "fail",
+            },
+        });
+        return [{
+                kind: "gate",
+                node_id: gateNodeId(entry.step.id),
+                depends_on: [workerNodeId(entry.step.id)],
+                verifier_ids: verifiers.map((verifier) => verifier.verifier_id),
+                pass_route_ids: passTargets.map((_target, index) => (index === 0
+                    ? gatePassRouteId(entry.step.id)
+                    : `${gatePassRouteId(entry.step.id)}:${index}`)),
+                fail_route_id: gateFailRouteId(entry.step.id),
+            }];
+    });
+    const leafNodeIds = adapted
+        .filter((entry) => (dependentSteps.get(entry.step.id)?.length ?? 0) === 0)
+        .map((entry) => effectiveNodeId(entry.step.id));
+    const retrySegments = workflowLoop === null ? [] : [{
+            retry_segment_id: EXECUTABLE_WORKFLOW_RETRY_SEGMENT_ID,
+            node_ids: workflowLoop.step_ids.flatMap((stepId) => [
+                workerNodeId(stepId),
+                ...((verifiersByStep.get(stepId)?.length ?? 0) > 0 ? [gateNodeId(stepId)] : []),
+            ]),
+            retry_from_node_id: workerNodeId(workflowLoop.retry_from),
+            max_rounds: workflowLoop.max_retries + 1,
+            backoff: workflowLoop.backoff,
+            initial_delay_ms: workflowLoop.initial_delay_ms,
+            max_delay_ms: workflowLoop.max_delay_ms,
+            retryable_outcomes: DEFAULT_RETRYABLE_OUTCOMES,
+        }];
+    const writablePaths = adapted.flatMap((entry) => (entry.step.enforce?.read_only === true
+        ? []
+        : [
+            ...(entry.role.scope?.write ?? []),
+            ...(entry.step.enforce?.additional_write_paths ?? []),
+        ]));
+    const readablePaths = adapted.flatMap((entry) => entry.role.scope?.read ?? ["**/*"]);
+    const allowNetwork = options.allow_network ?? true;
+    const payload = {
+        schema_version: EXECUTABLE_RUN_PLAN_SCHEMA_VERSION,
+        target: { kind: "workflow", key: options.target_key },
+        input_contract: {
+            ...options.input_contract,
+            inputs: options.input_contract.inputs.filter((input) => workerNodes.some((worker) => worker.packet_template.runtime_input_names.includes(input.name))),
+        },
+        nodes: [
+            ...workerNodes,
+            ...gateNodes,
+            {
+                kind: "terminal",
+                node_id: SUCCEEDED_TERMINAL_NODE_ID,
+                depends_on: leafNodeIds,
+                terminal_id: "succeeded",
+            },
+            {
+                kind: "terminal",
+                node_id: FAILED_TERMINAL_NODE_ID,
+                depends_on: [],
+                terminal_id: "failed",
+            },
+            {
+                kind: "terminal",
+                node_id: CANCELLED_TERMINAL_NODE_ID,
+                depends_on: [],
+                terminal_id: "cancelled",
+            },
+        ],
+        routes,
+        retry_segments: retrySegments,
+        terminals: [
+            { terminal_id: "succeeded", status: "succeeded", reason_code: "workflow_completed" },
+            { terminal_id: "failed", status: "failed", reason_code: "workflow_failed" },
+            { terminal_id: "cancelled", status: "cancelled", reason_code: "run_cancelled" },
+        ],
+        verifier_plan: [...verifiersByStep.values()].flat(),
+        handoff_plan: handoffPlan,
+        workspace_policy: {
+            default_isolation: adapted.some((entry) => entry.isolation === "worktree")
+                ? "worktree"
+                : "none",
+            relative_workspace_root: ".",
+            allow_network: allowNetwork,
+            readable_path_templates: [...new Set(readablePaths)],
+            writable_path_templates: [...new Set(writablePaths)],
+        },
+        required_capabilities: {
+            worktree_isolation: adapted.some((entry) => entry.isolation === "worktree"),
+            parallelism: plan.parallel_groups.some((group) => group.step_ids.length > 1),
+            cancellation: false,
+            hook_identity: false,
+            caller_attestation: plan.steps.some((step) => step.canonical_requires_attested_independent_submit === true),
+            human_interaction: false,
+            direct_structured_submission: true,
+            network_policy_enforcement: !allowNetwork,
+        },
+        source_provenance: options.source_provenance,
+    };
+    return parseExecutableRunPlanPayload(payload);
+}

package/dist/runtime/workflow-runtime-manifest.d.ts

@@ -39,6 +39,7 @@ export declare function createWorkflowRuntimeManifest(options: {
         resolvedVariables: Record<string, string>;
         workflowAsset?: string;
         additionalTemplateVariableRefs?: string[];
+        runtimeInputRefs?: string[];
         additionalRuntimeValues?: unknown;
     }>;
     compiledAt: string;

package/dist/runtime/workflow-runtime-manifest.js

@@ -116,12 +116,16 @@ export function createWorkflowRuntimeManifest(options) {
             .filter((name) => !WORKFLOW_RUNTIME_INPUT_VARIABLE_NAMES.has(name))
             .filter((name) => Object.prototype.hasOwnProperty.call(planVariables, name))
             .map((name) => [name, planVariables[name]]));
+        const explicitRuntimeInputRefs = item.runtimeInputRefs ?? [];
+        const explicitRuntimeInputs = new Set(explicitRuntimeInputRefs);
         const undefinedVariableRefs = templateVariableRefs.filter((name) => !WORKFLOW_RUNTIME_INPUT_VARIABLE_NAMES.has(name) &&
+            !explicitRuntimeInputs.has(name) &&
             !Object.prototype.hasOwnProperty.call(planVariables, name));
         if (undefinedVariableRefs.length > 0) {
             throw new Error(`Workflow ${workflow} references undefined template variable(s): ${undefinedVariableRefs.join(", ")}. Declare them in DNA variables or use $ARGUMENTS/task_id for runtime input.`);
         }
         const runtimeInputRefs = templateVariableRefs.filter((name) => WORKFLOW_RUNTIME_INPUT_VARIABLE_NAMES.has(name) ||
+            explicitRuntimeInputs.has(name) ||
             !Object.prototype.hasOwnProperty.call(planVariables, name));
         const requiresArguments = workflowUsesArguments(plan, planVariables) ||
             valueUsesArguments(item.additionalRuntimeValues, planVariables) ||
@@ -132,6 +136,7 @@ export function createWorkflowRuntimeManifest(options) {
             template_variable_refs: templateVariableRefs,
             runtime_input_refs: [
                 ...(requiresArguments ? ["ARGUMENTS"] : []),
+                ...explicitRuntimeInputRefs,
                 ...runtimeInputRefs.filter((name) => name !== "ARGUMENTS"),
             ].filter((name, index, names) => names.indexOf(name) === index).sort(),
             requires_arguments: requiresArguments,

package/dist/runtime/workspace-isolation.d.ts

@@ -5,9 +5,10 @@
  * commit, and leaves preservation or cleanup to an explicit Controller decision.
  * Team naming, CLI parsing, generated shell, and automatic rollback are excluded.
  */
-import type { AttemptId, RunId, StepId } from "./run-contracts.js";
+import type { AttemptId, CanonicalWorkspaceAllocation, CanonicalWorkspacePlan, RunId, StepId } from "./run-contracts.js";
+import type { AllocateAttemptWorkspaceRequest, AttemptWorkspaceAuthorityPort, CommittedWorkspaceAuthorityRequest, WorkspaceMutationAuthority } from "./canonical-run-service.js";
 export type WorkspaceIsolation = "none" | "worktree";
-export type WorkspaceIsolationErrorCode = "invalid_request" | "not_git_repository" | "git_command_failed" | "path_conflict" | "branch_conflict" | "workspace_mismatch" | "unsafe_cleanup_target";
+export type WorkspaceIsolationErrorCode = "invalid_request" | "not_git_repository" | "git_command_failed" | "path_conflict" | "branch_conflict" | "workspace_mismatch" | "workspace_conflict" | "unsafe_cleanup_target";
 export declare class WorkspaceIsolationError extends Error {
     readonly code: WorkspaceIsolationErrorCode;
     constructor(code: WorkspaceIsolationErrorCode, message: string);
@@ -95,8 +96,34 @@ export type WorkspaceLifecycleResult = {
     readonly working_directory: string;
     readonly branch_deleted: boolean;
 };
+/**
+ * Resolve an existing directory below a committed workspace without following
+ * symbolic-link components. This is suitable for verifier/process cwd values.
+ */
+export declare function canonicalWorkspaceDirectory(workspaceRoot: string, relativeDirectory: string, label?: string): Promise<string>;
 export declare function planAttemptWorkspace(request: AttemptWorkspaceRequest): AttemptWorkspacePlan;
 export declare function allocateAttemptWorkspace(plan: AttemptWorkspacePlan): AttemptWorkspaceAllocation;
+export interface LocalAttemptWorkspaceAuthorityOptions {
+    readonly lock_root?: string;
+    readonly lock_wait_ms?: number;
+    readonly lock_stale_ms?: number;
+    readonly lock_retry_ms?: number;
+    readonly lock_heartbeat_ms?: number;
+}
+export declare class LocalAttemptWorkspaceAuthority implements AttemptWorkspaceAuthorityPort {
+    private readonly lockRoot;
+    private readonly lockWaitMs;
+    private readonly lockStaleMs;
+    private readonly lockRetryMs;
+    private readonly lockHeartbeatMs;
+    constructor(options?: LocalAttemptWorkspaceAuthorityOptions);
+    plan(request: AllocateAttemptWorkspaceRequest): Promise<CanonicalWorkspacePlan>;
+    ensureWithExclusiveAuthority<T>(plan: CanonicalWorkspacePlan, operation: (allocation: CanonicalWorkspaceAllocation) => Promise<T>): Promise<T>;
+    withExclusiveMutationAuthority<T>(request: CommittedWorkspaceAuthorityRequest, operation: (authority: WorkspaceMutationAuthority) => Promise<T>): Promise<T>;
+    private nextFencingEpoch;
+    private assertCommittedAllocation;
+    private withLock;
+}
 export declare function inspectAttemptWorkspace(workspace: AttemptWorkspaceAllocation): WorkspaceInspection;
 export declare function applyWorkspaceLifecycleDecision(workspace: AttemptWorkspaceAllocation, decision: WorkspaceLifecycleDecision): WorkspaceLifecycleResult;
 export declare function defaultWorktreeRoot(repositoryRoot: string): string;