agentweaver 0.1.15 → 0.1.17

package/dist/runtime/interactive-execution-routing.js

@@ -0,0 +1,471 @@
+import path from "node:path";
+import { flowRoutingGroups, flowRoutingKey } from "../pipeline/flow-catalog.js";
+import { loadNamedDeclarativeFlow } from "../pipeline/declarative-flows.js";
+import { createPipelineRegistryContext } from "../pipeline/plugin-loader.js";
+import { EXECUTION_ROUTING_GROUPS, } from "../pipeline/execution-routing-config.js";
+import { DEFAULT_LAUNCH_PROFILE, defaultModelForExecutor, isAllowedModelForExecutor, } from "../pipeline/launch-profile-config.js";
+import { FlowInterruptedError, TaskRunnerError } from "../errors.js";
+import { BUILT_IN_EXECUTION_PRESETS, builtInExecutionPresetList, modelOptionsForExecutor, resolveExecutionRouting, resolveStoredExecutionRoutingSnapshot, routingGroupLabel, } from "./execution-routing.js";
+import { getFlowDefaultExecutionRouting, getLastUsedExecutionRouting, getNamedExecutionPresets, saveFlowDefaultExecutionRouting, saveLastUsedExecutionRouting, saveNamedExecutionPreset, } from "./execution-routing-store.js";
+function executionPresetSelectionForm(flowEntry, flowDefaultAvailable, lastUsedAvailable, namedPresetNames) {
+    const options = [];
+    if (flowDefaultAvailable) {
+        options.push({
+            value: "flow-default",
+            label: "Flow default",
+            description: "Use the saved routing snapshot for this flow.",
+        });
+    }
+    if (lastUsedAvailable) {
+        options.push({
+            value: "last-used",
+            label: "Last used",
+            description: "Reuse the most recent routing started for this flow.",
+        });
+    }
+    for (const preset of builtInExecutionPresetList()) {
+        options.push({
+            value: `built-in:${preset.id}`,
+            label: preset.label,
+            description: preset.description,
+        });
+    }
+    for (const name of namedPresetNames) {
+        options.push({
+            value: `named:${name}`,
+            label: `Named preset: ${name}`,
+            description: "Reuse a saved routing snapshot across flows.",
+        });
+    }
+    options.push({
+        value: "custom",
+        label: "Custom",
+        description: "Start from the default route and edit the fallback route plus routing groups manually.",
+    });
+    return {
+        formId: "flow-execution-preset",
+        title: "Execution Routing",
+        description: `Select an execution strategy for '${flowEntry.id}'.`,
+        submitLabel: "Continue",
+        fields: [
+            {
+                id: "preset",
+                type: "single-select",
+                label: "Preset",
+                required: true,
+                default: options[0]?.value ?? "custom",
+                options,
+            },
+        ],
+    };
+}
+function selectedExecutorFromValues(values, fieldId, fallbackExecutor, registryContext) {
+    const candidate = typeof values[fieldId] === "string" ? values[fieldId] : "";
+    return registryContext.executors.getRouting(candidate)?.kind === "llm" ? candidate : fallbackExecutor;
+}
+function routingEditorDraftFromRouting(routing) {
+    return {
+        defaultRoute: {
+            executor: routing.defaultRoute.executor,
+            model: routing.defaultRoute.model,
+        },
+        groups: Object.fromEntries(EXECUTION_ROUTING_GROUPS.map((group) => [
+            group,
+            {
+                executor: routing.groups[group].executor,
+                model: routing.groups[group].model,
+            },
+        ])),
+    };
+}
+function advancedRoutingEditorForm(activeGroups, draft, registryContext, validationMessage) {
+    const executorOptions = registryContext.executors.llmExecutors().map((entry) => ({
+        value: entry.id,
+        label: entry.id,
+    }));
+    const fields = [
+        {
+            id: "default_route_executor",
+            type: "single-select",
+            label: "Default route executor",
+            required: true,
+            default: draft.defaultRoute.executor,
+            options: executorOptions,
+        },
+        {
+            id: "default_route_model",
+            type: "single-select",
+            label: "Default route model",
+            help: "Available models follow the selected default executor.",
+            required: true,
+            default: draft.defaultRoute.model,
+            options: modelOptionsForExecutor(draft.defaultRoute.executor, registryContext.executors),
+            optionsFromValues: (values) => modelOptionsForExecutor(selectedExecutorFromValues(values, "default_route_executor", draft.defaultRoute.executor, registryContext), registryContext.executors),
+        },
+        ...activeGroups.flatMap((group) => {
+            const route = draft.groups[group];
+            return [
+                {
+                    id: `${group}_executor`,
+                    type: "single-select",
+                    label: `${routingGroupLabel(group)} executor`,
+                    required: true,
+                    default: route.executor,
+                    options: executorOptions,
+                },
+                {
+                    id: `${group}_model`,
+                    type: "single-select",
+                    label: `${routingGroupLabel(group)} model`,
+                    help: `Available models follow the selected ${routingGroupLabel(group)} executor.`,
+                    required: true,
+                    default: route.model,
+                    options: modelOptionsForExecutor(route.executor, registryContext.executors),
+                    optionsFromValues: (values) => modelOptionsForExecutor(selectedExecutorFromValues(values, `${group}_executor`, route.executor, registryContext), registryContext.executors),
+                },
+            ];
+        }),
+    ];
+    return {
+        formId: "flow-routing-editor",
+        title: "Advanced Routing",
+        description: validationMessage
+            ? `${activeGroups.length > 0
+                ? "Edit the fallback route plus executor and model by routing group."
+                : "Edit the fallback executor and model used by this flow."}\n\n${validationMessage}`
+            : activeGroups.length > 0
+                ? "Edit the fallback route plus executor and model by routing group."
+                : "Edit the fallback executor and model used by this flow.",
+        submitLabel: "Apply",
+        fields,
+    };
+}
+function routingActionForm(previewText) {
+    return {
+        formId: "flow-routing-action",
+        title: "Routing Preview",
+        description: "Review the effective routing and choose the next action.",
+        preview: previewText,
+        submitLabel: "Continue",
+        fields: [
+            {
+                id: "action",
+                type: "single-select",
+                label: "Action",
+                required: true,
+                default: "start",
+                options: [
+                    { value: "start", label: "Start", description: "Run the flow with the previewed routing." },
+                    { value: "edit", label: "Edit routing", description: "Open the advanced routing editor." },
+                    { value: "cancel", label: "Cancel", description: "Abort launching this flow." },
+                ],
+            },
+        ],
+    };
+}
+function routingPersistenceForm() {
+    return {
+        formId: "flow-routing-persistence",
+        title: "Save Routing",
+        description: "Choose how to persist the edited routing.",
+        submitLabel: "Continue",
+        fields: [
+            {
+                id: "persistence",
+                type: "single-select",
+                label: "Save mode",
+                required: true,
+                default: "current-run",
+                options: [
+                    { value: "current-run", label: "Current run only", description: "Use the edited routing only for this start." },
+                    { value: "flow-default", label: "Flow default", description: "Reuse this routing automatically for this flow." },
+                    { value: "named-preset", label: "Named preset", description: "Save this routing as a reusable preset." },
+                ],
+            },
+        ],
+    };
+}
+function presetNameForm() {
+    return {
+        formId: "flow-routing-preset-name",
+        title: "Preset Name",
+        description: "Enter a reusable name for the routing preset.",
+        submitLabel: "Save",
+        fields: [
+            {
+                id: "name",
+                type: "text",
+                label: "Preset name",
+                required: true,
+            },
+        ],
+    };
+}
+function normalizeEditableRoute(label, route, executors) {
+    if (isAllowedModelForExecutor(route.executor, route.model, executors)) {
+        return {
+            route: { ...route },
+            validationErrors: [],
+        };
+    }
+    return {
+        route: {
+            executor: route.executor,
+            model: defaultModelForExecutor(route.executor, executors),
+        },
+        validationErrors: [
+            `${label} model '${route.model}' is not allowed for executor '${route.executor}'. Select a ${route.executor} model.`,
+        ],
+    };
+}
+function normalizeEditableRoutingDraft(draft, executors) {
+    const defaultRoute = normalizeEditableRoute("Default route", draft.defaultRoute, executors);
+    const groups = {};
+    const currentRunOverrides = {};
+    const validationErrors = [...defaultRoute.validationErrors];
+    for (const group of EXECUTION_ROUTING_GROUPS) {
+        const normalizedRoute = normalizeEditableRoute(routingGroupLabel(group), draft.groups[group], executors);
+        groups[group] = normalizedRoute.route;
+        if (normalizedRoute.route.executor !== defaultRoute.route.executor
+            || normalizedRoute.route.model !== defaultRoute.route.model) {
+            currentRunOverrides[group] = normalizedRoute.route;
+        }
+        validationErrors.push(...normalizedRoute.validationErrors);
+    }
+    return {
+        draft: {
+            defaultRoute: defaultRoute.route,
+            groups,
+        },
+        currentRunOverrides,
+        validationErrors,
+    };
+}
+function normalizedEffectiveStepSignature(row) {
+    const normalizedStep = row.step.replace(/review_iteration_\d+/g, "review_iteration_*");
+    return [normalizedStep, row.group, row.executor, row.model].join("\u0000");
+}
+function collapseRepeatedEffectiveRoutedStepRows(rows) {
+    const seen = new Set();
+    const collapsed = [];
+    for (const row of rows) {
+        const signature = normalizedEffectiveStepSignature(row);
+        if (seen.has(signature)) {
+            continue;
+        }
+        seen.add(signature);
+        collapsed.push(row);
+    }
+    return collapsed;
+}
+function truncateTableCell(value, maxWidth) {
+    if (value.length <= maxWidth) {
+        return value;
+    }
+    if (maxWidth <= 1) {
+        return value.slice(0, maxWidth);
+    }
+    return `${value.slice(0, maxWidth - 1)}…`;
+}
+function formatAsciiTable(headers, rows, maxWidths) {
+    const widths = headers.map((header, index) => Math.min(maxWidths[index] ?? Number.MAX_SAFE_INTEGER, Math.max(header.length, ...rows.map((row) => (row[index] ?? "").length))));
+    const formatRow = (row) => `| ${row.map((cell, index) => truncateTableCell(cell ?? "", widths[index] ?? 1).padEnd(widths[index] ?? 1)).join(" | ")} |`;
+    const separator = `|-${widths.map((width) => "-".repeat(width)).join("-|-")}-|`;
+    return [formatRow(headers), separator, ...rows.map((row) => formatRow(row))];
+}
+function collectEffectiveRoutedStepRows(flow, cwd, routing, registryContext, prefixSegments = [], ancestry = []) {
+    if (ancestry.includes(flow.absolutePath)) {
+        return Promise.resolve([]);
+    }
+    const nextAncestry = [...ancestry, flow.absolutePath];
+    const rows = [];
+    const run = async () => {
+        for (const phase of flow.phases) {
+            for (const step of phase.steps) {
+                const stepRef = `${phase.id}.${step.id}`;
+                if (step.routingGroup) {
+                    const route = routing.groups[step.routingGroup];
+                    rows.push({
+                        step: [...prefixSegments, stepRef].join(" > "),
+                        group: routingGroupLabel(step.routingGroup),
+                        executor: route.executor,
+                        model: route.model,
+                    });
+                }
+                if (step.node !== "flow-run") {
+                    continue;
+                }
+                const nestedFlowName = step.params?.fileName;
+                if (!nestedFlowName || !("const" in nestedFlowName) || typeof nestedFlowName.const !== "string") {
+                    continue;
+                }
+                const nestedFlow = await loadNamedDeclarativeFlow(nestedFlowName.const, cwd, {
+                    ...(registryContext ? { registryContext } : {}),
+                });
+                const nestedFlowLabel = path.basename(nestedFlow.fileName, path.extname(nestedFlow.fileName));
+                rows.push(...await collectEffectiveRoutedStepRows(nestedFlow, cwd, routing, registryContext, [...prefixSegments, stepRef, nestedFlowLabel], nextAncestry));
+            }
+        }
+        return rows;
+    };
+    return run();
+}
+export async function describeEffectiveRoutingPreview(flowEntry, routing, cwd, registryContext) {
+    const previewGroups = await flowRoutingGroups(flowEntry, cwd, {
+        ...(registryContext ? { registryContext } : {}),
+    });
+    const summaryRows = [
+        ["Default", routing.defaultRoute.executor, routing.defaultRoute.model],
+        ...previewGroups.map((group) => [
+            routingGroupLabel(group),
+            routing.groups[group].executor,
+            routing.groups[group].model,
+        ]),
+    ];
+    const lines = [
+        "Effective routes:",
+        ...formatAsciiTable(["Scope", "Executor", "Model"], summaryRows, [18, 12, 36]),
+    ];
+    const routedSteps = collapseRepeatedEffectiveRoutedStepRows(await collectEffectiveRoutedStepRows(flowEntry.flow, cwd, routing, registryContext));
+    if (routedSteps.length === 0) {
+        return lines.join("\n");
+    }
+    return [
+        ...lines,
+        "",
+        "Routed LLM steps:",
+        ...formatAsciiTable(["Step", "Group", "Executor", "Model"], routedSteps.map((row) => [row.step, row.group, row.executor, row.model]), [64, 16, 12, 30]),
+    ].join("\n");
+}
+export async function requestInteractiveExecutionRouting(flowEntry, requestUserInput) {
+    const registryContext = await createPipelineRegistryContext(process.cwd());
+    const previewGroups = await flowRoutingGroups(flowEntry, process.cwd(), { registryContext });
+    const flowKey = flowRoutingKey(flowEntry);
+    const namedPresets = getNamedExecutionPresets();
+    const flowDefault = getFlowDefaultExecutionRouting(flowKey);
+    const lastUsed = getLastUsedExecutionRouting(flowKey);
+    const presetSelection = await requestUserInput(executionPresetSelectionForm(flowEntry, Boolean(flowDefault), Boolean(lastUsed), Object.keys(namedPresets).sort((left, right) => left.localeCompare(right, "en"))));
+    const selectedPresetValue = String(presetSelection.values.preset ?? "custom");
+    let selectedPreset;
+    let routing;
+    if (selectedPresetValue === "flow-default") {
+        if (!flowDefault) {
+            throw new TaskRunnerError("Flow default routing is unavailable.");
+        }
+        selectedPreset = { kind: "flow-default", label: "Flow default" };
+        routing = resolveStoredExecutionRoutingSnapshot(flowDefault.routing, registryContext.executors);
+    }
+    else if (selectedPresetValue === "last-used") {
+        if (!lastUsed) {
+            throw new TaskRunnerError("Last-used routing is unavailable.");
+        }
+        selectedPreset = { kind: "last-used", label: "Last used" };
+        routing = resolveStoredExecutionRoutingSnapshot(lastUsed.routing, registryContext.executors);
+    }
+    else if (selectedPresetValue.startsWith("named:")) {
+        const presetName = selectedPresetValue.slice("named:".length);
+        const namedPreset = namedPresets[presetName];
+        if (!namedPreset) {
+            throw new TaskRunnerError(`Named preset '${presetName}' is unavailable.`);
+        }
+        selectedPreset = { kind: "named", presetId: presetName, label: `Named preset: ${presetName}` };
+        routing = resolveStoredExecutionRoutingSnapshot(namedPreset.routing, registryContext.executors);
+    }
+    else if (selectedPresetValue.startsWith("built-in:")) {
+        const presetId = selectedPresetValue.slice("built-in:".length);
+        const preset = BUILT_IN_EXECUTION_PRESETS[presetId];
+        if (!preset) {
+            throw new TaskRunnerError(`Unknown execution preset '${presetId}'.`);
+        }
+        selectedPreset = { kind: "built-in", presetId, label: preset.label };
+        routing = resolveExecutionRouting({ presetId, executors: registryContext.executors });
+    }
+    else {
+        selectedPreset = { kind: "custom", label: "Custom" };
+        routing = resolveExecutionRouting({
+            executors: registryContext.executors,
+            defaultRoute: {
+                executor: DEFAULT_LAUNCH_PROFILE.executor,
+                model: DEFAULT_LAUNCH_PROFILE.model,
+            },
+        });
+    }
+    let editorDraft = routingEditorDraftFromRouting(routing);
+    let editorValidationMessage;
+    for (;;) {
+        const previewText = `Preset: ${selectedPreset.label}\n${await describeEffectiveRoutingPreview(flowEntry, routing, process.cwd(), registryContext)}`;
+        const actionResult = await requestUserInput(routingActionForm(previewText));
+        const action = String(actionResult.values.action ?? "start");
+        if (action === "cancel") {
+            throw new FlowInterruptedError("Flow launch cancelled.");
+        }
+        if (action === "start") {
+            saveLastUsedExecutionRouting(flowKey, routing, selectedPreset);
+            return { routing, selectedPreset };
+        }
+        const routingFormResult = await requestUserInput(advancedRoutingEditorForm(previewGroups, editorDraft, registryContext, editorValidationMessage));
+        const requestedDefaultRoute = {
+            executor: String(routingFormResult.values.default_route_executor ?? editorDraft.defaultRoute.executor),
+            model: String(routingFormResult.values.default_route_model ?? editorDraft.defaultRoute.model),
+        };
+        const requestedDraft = {
+            defaultRoute: requestedDefaultRoute,
+            groups: Object.fromEntries(EXECUTION_ROUTING_GROUPS.map((group) => {
+                const submittedExecutor = String(routingFormResult.values[`${group}_executor`] ?? editorDraft.groups[group].executor);
+                const submittedModel = String(routingFormResult.values[`${group}_model`] ?? editorDraft.groups[group].model);
+                const inheritedBeforeEdit = editorDraft.groups[group].executor === editorDraft.defaultRoute.executor
+                    && editorDraft.groups[group].model === editorDraft.defaultRoute.model;
+                const groupRoute = inheritedBeforeEdit
+                    && submittedExecutor === editorDraft.groups[group].executor
+                    && submittedModel === editorDraft.groups[group].model
+                    ? requestedDefaultRoute
+                    : { executor: submittedExecutor, model: submittedModel };
+                return [
+                    group,
+                    groupRoute,
+                ];
+            })),
+        };
+        const normalizedDraft = normalizeEditableRoutingDraft(requestedDraft, registryContext.executors);
+        editorDraft = normalizedDraft.draft;
+        if (normalizedDraft.validationErrors.length > 0) {
+            editorValidationMessage = normalizedDraft.validationErrors.join("\n");
+            continue;
+        }
+        try {
+            routing = resolveExecutionRouting({
+                executors: registryContext.executors,
+                defaultRoute: {
+                    executor: normalizedDraft.draft.defaultRoute.executor,
+                    model: normalizedDraft.draft.defaultRoute.model,
+                },
+                currentRunOverrides: normalizedDraft.currentRunOverrides,
+            });
+        }
+        catch (error) {
+            if (error instanceof TaskRunnerError) {
+                editorValidationMessage = error.message;
+                continue;
+            }
+            throw error;
+        }
+        editorDraft = routingEditorDraftFromRouting(routing);
+        editorValidationMessage = undefined;
+        selectedPreset = { kind: "custom", label: "Custom" };
+        const persistenceResult = await requestUserInput(routingPersistenceForm());
+        const persistence = String(persistenceResult.values.persistence ?? "current-run");
+        if (persistence === "flow-default") {
+            selectedPreset = { kind: "flow-default", label: "Flow default" };
+            saveFlowDefaultExecutionRouting(flowKey, routing, selectedPreset);
+        }
+        else if (persistence === "named-preset") {
+            const presetNameResult = await requestUserInput(presetNameForm());
+            const presetName = String(presetNameResult.values.name ?? "").trim();
+            if (!presetName) {
+                throw new TaskRunnerError("Preset name is required.");
+            }
+            selectedPreset = { kind: "named", presetId: presetName, label: `Named preset: ${presetName}` };
+            saveNamedExecutionPreset(presetName, routing, selectedPreset);
+        }
+    }
+}

package/dist/runtime/plan-revise-input-contract.js

@@ -1,9 +1,17 @@
 import { existsSync } from "node:fs";
-import { designFile, designJsonFile, designReviewFile, designReviewJsonFile, jiraAttachmentsContextFile, jiraAttachmentsManifestFile, jiraTaskFile, latestArtifactIteration, planFile, planJsonFile, planningAnswersJsonFile, qaFile, qaJsonFile, requireArtifacts, } from "../artifacts.js";
+import { designFile, designJsonFile, designReviewFile, designReviewJsonFile, instantTaskInputJsonFile, jiraAttachmentsContextFile, jiraAttachmentsManifestFile, jiraTaskFile, latestArtifactIteration, planFile, planJsonFile, planningAnswersJsonFile, qaFile, qaJsonFile, taskContextJsonFile, requireArtifacts, } from "../artifacts.js";
 import { TaskRunnerError } from "../errors.js";
 import { validateStructuredArtifacts } from "../structured-artifacts.js";
+import { resolveLatestCompletedPlanningIteration } from "./planning-bundle.js";
 const OPTIONAL_INPUT_NOT_PROVIDED = "not provided";
-function resolveLatestDesignReviewIteration(taskKey) {
+function resolveLatestDesignReviewIteration(taskKey, sourcePlanningIteration) {
+    if (sourcePlanningIteration !== undefined) {
+        const candidateMd = designReviewFile(taskKey, sourcePlanningIteration);
+        const candidateJson = designReviewJsonFile(taskKey, sourcePlanningIteration);
+        if (existsSync(candidateMd) && existsSync(candidateJson)) {
+            return sourcePlanningIteration;
+        }
+    }
     const latestMd = latestArtifactIteration(taskKey, "design-review", "md");
     const latestJson = latestArtifactIteration(taskKey, "design-review", "json");
     const maxIteration = Math.max(latestMd ?? 0, latestJson ?? 0);
@@ -22,33 +30,6 @@ function resolveLatestDesignReviewIteration(taskKey) {
     requireArtifacts([fallbackMd, fallbackJson], "Plan-revise requires design-review markdown and JSON artifacts from the latest completed design-review run.");
     throw new TaskRunnerError("Unreachable plan-revise design-review artifact resolution state.");
 }
-function resolveLatestCompletedPlanningIteration(taskKey) {
-    const latestDesignMd = latestArtifactIteration(taskKey, "design", "md") ?? 0;
-    const latestDesignJson = latestArtifactIteration(taskKey, "design", "json") ?? 0;
-    const latestPlanMd = latestArtifactIteration(taskKey, "plan", "md") ?? 0;
-    const latestPlanJson = latestArtifactIteration(taskKey, "plan", "json") ?? 0;
-    const maxIteration = Math.max(latestDesignMd, latestDesignJson, latestPlanMd, latestPlanJson);
-    for (let iteration = maxIteration; iteration >= 1; iteration -= 1) {
-        const paths = [
-            designFile(taskKey, iteration),
-            designJsonFile(taskKey, iteration),
-            planFile(taskKey, iteration),
-            planJsonFile(taskKey, iteration),
-        ];
-        if (paths.every((candidate) => existsSync(candidate))) {
-            return iteration;
-        }
-    }
-    const fallbackIteration = maxIteration || 1;
-    const fallbackPaths = [
-        designFile(taskKey, fallbackIteration),
-        designJsonFile(taskKey, fallbackIteration),
-        planFile(taskKey, fallbackIteration),
-        planJsonFile(taskKey, fallbackIteration),
-    ];
-    requireArtifacts(fallbackPaths, "Plan-revise requires design and plan markdown/JSON artifacts from the latest completed planning run.");
-    throw new TaskRunnerError("Unreachable plan-revise planning artifact resolution state.");
-}
 function resolveOptionalPromptFile(filePath) {
     if (!existsSync(filePath)) {
         return {
@@ -63,6 +44,14 @@ function resolveOptionalPromptFile(filePath) {
         promptValue: filePath,
     };
 }
+function resolveOptionalValidatedStructuredFile(filePath, schemaId, message) {
+    const resolved = resolveOptionalPromptFile(filePath);
+    if (!resolved.present) {
+        return resolved;
+    }
+    validateStructuredArtifacts([{ path: filePath, schemaId }], message);
+    return resolved;
+}
 function resolveOptionalQaPair(taskKey, iteration) {
     const markdownPath = qaFile(taskKey, iteration);
     const jsonPath = qaJsonFile(taskKey, iteration);
@@ -90,12 +79,15 @@ function resolveOptionalQaPair(taskKey, iteration) {
     };
 }
 export function resolvePlanReviseInputContract(taskKey) {
-    const reviewIteration = resolveLatestDesignReviewIteration(taskKey);
+    const sourcePlanningIteration = resolveLatestCompletedPlanningIteration(taskKey, {
+        requireQa: false,
+        missingMessage: "Plan-revise requires design and plan markdown/JSON artifacts from the latest completed planning run.",
+    });
+    const reviewIteration = resolveLatestDesignReviewIteration(taskKey, sourcePlanningIteration);
     const reviewMd = designReviewFile(taskKey, reviewIteration);
     const reviewJson = designReviewJsonFile(taskKey, reviewIteration);
     requireArtifacts([reviewMd, reviewJson], "Plan-revise requires design-review markdown and JSON artifacts.");
     validateStructuredArtifacts([{ path: reviewJson, schemaId: "design-review/v1" }], "Plan-revise design-review structured artifact is invalid.");
-    const sourcePlanningIteration = resolveLatestCompletedPlanningIteration(taskKey);
     const srcDesignMd = designFile(taskKey, sourcePlanningIteration);
     const srcDesignJson = designJsonFile(taskKey, sourcePlanningIteration);
     const srcPlanMd = planFile(taskKey, sourcePlanningIteration);
@@ -110,7 +102,12 @@ export function resolvePlanReviseInputContract(taskKey) {
     const jiraTask = resolveOptionalPromptFile(jiraTaskFile(taskKey));
     const jiraAttachmentsManifest = resolveOptionalPromptFile(jiraAttachmentsManifestFile(taskKey));
     const jiraAttachmentsContext = resolveOptionalPromptFile(jiraAttachmentsContextFile(taskKey));
-    const planningAnswers = resolveOptionalPromptFile(planningAnswersJsonFile(taskKey));
+    const planningAnswers = resolveOptionalValidatedStructuredFile(planningAnswersJsonFile(taskKey), "user-input/v1", "Plan-revise planning answers structured artifact is invalid.");
+    const taskContextIteration = latestArtifactIteration(taskKey, "task-context", "json");
+    const taskContext = taskContextIteration === null
+        ? { present: false, path: null, promptValue: OPTIONAL_INPUT_NOT_PROVIDED }
+        : resolveOptionalValidatedStructuredFile(taskContextJsonFile(taskKey, taskContextIteration), "task-context/v1", "Plan-revise task-context structured artifact is invalid.");
+    const taskInput = resolveOptionalValidatedStructuredFile(instantTaskInputJsonFile(taskKey), "user-input/v1", "Plan-revise instant-task input structured artifact is invalid.");
     return {
         reviewIteration,
         reviewFile: reviewMd,
@@ -140,5 +137,11 @@ export function resolvePlanReviseInputContract(taskKey) {
         hasPlanningAnswersJsonFile: planningAnswers.present,
         planningAnswersJsonFilePath: planningAnswers.path,
         planningAnswersJsonFile: planningAnswers.promptValue,
+        hasTaskContextJsonFile: taskContext.present,
+        taskContextJsonFilePath: taskContext.path,
+        taskContextJsonFile: taskContext.promptValue,
+        hasTaskInputJsonFile: taskInput.present,
+        taskInputJsonFilePath: taskInput.path,
+        taskInputJsonFile: taskInput.promptValue,
     };
 }