agentweaver 0.1.14 → 0.1.16

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

@@ -0,0 +1,462 @@
+import path from "node:path";
+import { flowRoutingGroups, flowRoutingKey } from "../pipeline/flow-catalog.js";
+import { loadNamedDeclarativeFlow } from "../pipeline/declarative-flows.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 executorFieldOptions() {
+    return [
+        { value: "codex", label: "codex" },
+        { value: "opencode", label: "opencode" },
+    ];
+}
+function selectedExecutorFromValues(values, fieldId, fallbackExecutor) {
+    const candidate = values[fieldId];
+    return candidate === "codex" || candidate === "opencode" ? 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, validationMessage) {
+    const fields = [
+        {
+            id: "default_route_executor",
+            type: "single-select",
+            label: "Default route executor",
+            required: true,
+            default: draft.defaultRoute.executor,
+            options: executorFieldOptions(),
+        },
+        {
+            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),
+            optionsFromValues: (values) => modelOptionsForExecutor(selectedExecutorFromValues(values, "default_route_executor", draft.defaultRoute.executor)),
+        },
+        ...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: executorFieldOptions(),
+                },
+                {
+                    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),
+                    optionsFromValues: (values) => modelOptionsForExecutor(selectedExecutorFromValues(values, `${group}_executor`, route.executor)),
+                },
+            ];
+        }),
+    ];
+    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) {
+    if (isAllowedModelForExecutor(route.executor, route.model)) {
+        return {
+            route: { ...route },
+            validationErrors: [],
+        };
+    }
+    return {
+        route: {
+            executor: route.executor,
+            model: defaultModelForExecutor(route.executor),
+        },
+        validationErrors: [
+            `${label} model '${route.model}' is not allowed for executor '${route.executor}'. Select a ${route.executor} model.`,
+        ],
+    };
+}
+function normalizeEditableRoutingDraft(draft) {
+    const defaultRoute = normalizeEditableRoute("Default route", draft.defaultRoute);
+    const groups = {};
+    const currentRunOverrides = {};
+    const validationErrors = [...defaultRoute.validationErrors];
+    for (const group of EXECUTION_ROUTING_GROUPS) {
+        const normalizedRoute = normalizeEditableRoute(routingGroupLabel(group), draft.groups[group]);
+        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, prefixSegments = [], ancestry = []) {
+    if (ancestry.includes(flow.absolutePath)) {
+        return [];
+    }
+    const nextAncestry = [...ancestry, flow.absolutePath];
+    const rows = [];
+    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 = loadNamedDeclarativeFlow(nestedFlowName.const, cwd);
+            const nestedFlowLabel = path.basename(nestedFlow.fileName, path.extname(nestedFlow.fileName));
+            rows.push(...collectEffectiveRoutedStepRows(nestedFlow, cwd, routing, [...prefixSegments, stepRef, nestedFlowLabel], nextAncestry));
+        }
+    }
+    return rows;
+}
+export function describeEffectiveRoutingPreview(flowEntry, routing, cwd) {
+    const previewGroups = flowRoutingGroups(flowEntry, cwd);
+    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(collectEffectiveRoutedStepRows(flowEntry.flow, cwd, routing));
+    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 previewGroups = flowRoutingGroups(flowEntry, process.cwd());
+    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);
+    }
+    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);
+    }
+    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);
+    }
+    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 });
+    }
+    else {
+        selectedPreset = { kind: "custom", label: "Custom" };
+        routing = resolveExecutionRouting({
+            defaultRoute: {
+                executor: DEFAULT_LAUNCH_PROFILE.executor,
+                model: DEFAULT_LAUNCH_PROFILE.model,
+            },
+        });
+    }
+    let editorDraft = routingEditorDraftFromRouting(routing);
+    let editorValidationMessage;
+    for (;;) {
+        const previewText = `Preset: ${selectedPreset.label}\n${describeEffectiveRoutingPreview(flowEntry, routing, process.cwd())}`;
+        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, 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);
+        editorDraft = normalizedDraft.draft;
+        if (normalizedDraft.validationErrors.length > 0) {
+            editorValidationMessage = normalizedDraft.validationErrors.join("\n");
+            continue;
+        }
+        try {
+            routing = resolveExecutionRouting({
+                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

@@ -0,0 +1,147 @@
+import { existsSync } from "node:fs";
+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, 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);
+    if (maxIteration === 0) {
+        throw new TaskRunnerError("Plan-revise requires at least one completed design-review iteration, but no design-review artifacts were found.");
+    }
+    for (let iteration = maxIteration; iteration >= 1; iteration -= 1) {
+        const mdPath = designReviewFile(taskKey, iteration);
+        const jsonPath = designReviewJsonFile(taskKey, iteration);
+        if (existsSync(mdPath) && existsSync(jsonPath)) {
+            return iteration;
+        }
+    }
+    const fallbackMd = designReviewFile(taskKey, maxIteration);
+    const fallbackJson = designReviewJsonFile(taskKey, maxIteration);
+    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 resolveOptionalPromptFile(filePath) {
+    if (!existsSync(filePath)) {
+        return {
+            present: false,
+            path: null,
+            promptValue: OPTIONAL_INPUT_NOT_PROVIDED,
+        };
+    }
+    return {
+        present: true,
+        path: 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);
+    const markdownExists = existsSync(markdownPath);
+    const jsonExists = existsSync(jsonPath);
+    if (!markdownExists && !jsonExists) {
+        return {
+            hasQaArtifacts: false,
+            qaFilePath: null,
+            qaJsonFilePath: null,
+            qaFile: OPTIONAL_INPUT_NOT_PROVIDED,
+            qaJsonFile: OPTIONAL_INPUT_NOT_PROVIDED,
+        };
+    }
+    if (!markdownExists || !jsonExists) {
+        requireArtifacts([markdownPath, jsonPath], "Plan-revise accepts QA artifacts only as a complete markdown/JSON pair for the source planning iteration.");
+    }
+    validateStructuredArtifacts([{ path: jsonPath, schemaId: "qa-plan/v1" }], "Plan-revise QA structured artifact is invalid.");
+    return {
+        hasQaArtifacts: true,
+        qaFilePath: markdownPath,
+        qaJsonFilePath: jsonPath,
+        qaFile: markdownPath,
+        qaJsonFile: jsonPath,
+    };
+}
+export function resolvePlanReviseInputContract(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 srcDesignMd = designFile(taskKey, sourcePlanningIteration);
+    const srcDesignJson = designJsonFile(taskKey, sourcePlanningIteration);
+    const srcPlanMd = planFile(taskKey, sourcePlanningIteration);
+    const srcPlanJson = planJsonFile(taskKey, sourcePlanningIteration);
+    requireArtifacts([srcDesignMd, srcDesignJson, srcPlanMd, srcPlanJson], "Plan-revise requires design and plan markdown/JSON artifacts from the source planning iteration.");
+    validateStructuredArtifacts([
+        { path: srcDesignJson, schemaId: "implementation-design/v1" },
+        { path: srcPlanJson, schemaId: "implementation-plan/v1" },
+    ], "Plan-revise source planning structured artifacts are invalid.");
+    const outputIteration = sourcePlanningIteration + 1;
+    const qaArtifacts = resolveOptionalQaPair(taskKey, sourcePlanningIteration);
+    const jiraTask = resolveOptionalPromptFile(jiraTaskFile(taskKey));
+    const jiraAttachmentsManifest = resolveOptionalPromptFile(jiraAttachmentsManifestFile(taskKey));
+    const jiraAttachmentsContext = resolveOptionalPromptFile(jiraAttachmentsContextFile(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,
+        reviewJsonFile: reviewJson,
+        sourcePlanningIteration,
+        outputIteration,
+        designFile: srcDesignMd,
+        designJsonFile: srcDesignJson,
+        planFile: srcPlanMd,
+        planJsonFile: srcPlanJson,
+        ...qaArtifacts,
+        revisedDesignFile: designFile(taskKey, outputIteration),
+        revisedDesignJsonFile: designJsonFile(taskKey, outputIteration),
+        revisedPlanFile: planFile(taskKey, outputIteration),
+        revisedPlanJsonFile: planJsonFile(taskKey, outputIteration),
+        revisedQaFile: qaFile(taskKey, outputIteration),
+        revisedQaJsonFile: qaJsonFile(taskKey, outputIteration),
+        hasJiraTaskFile: jiraTask.present,
+        jiraTaskFilePath: jiraTask.path,
+        jiraTaskFile: jiraTask.promptValue,
+        hasJiraAttachmentsManifestFile: jiraAttachmentsManifest.present,
+        jiraAttachmentsManifestFilePath: jiraAttachmentsManifest.path,
+        jiraAttachmentsManifestFile: jiraAttachmentsManifest.promptValue,
+        hasJiraAttachmentsContextFile: jiraAttachmentsContext.present,
+        jiraAttachmentsContextFilePath: jiraAttachmentsContext.path,
+        jiraAttachmentsContextFile: jiraAttachmentsContext.promptValue,
+        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,
+    };
+}