agentweaver 0.1.14 → 0.1.16

package/dist/pipeline/nodes/design-review-verdict-node.js

@@ -0,0 +1,36 @@
+import { existsSync, readFileSync } from "node:fs";
+import { TaskRunnerError } from "../../errors.js";
+import { validateStructuredArtifacts } from "../../structured-artifacts.js";
+import { designReviewJsonFile, latestArtifactIteration } from "../../artifacts.js";
+function readVerdictFile(path) {
+    if (!existsSync(path)) {
+        throw new TaskRunnerError(`Design review verdict file not found: ${path}`);
+    }
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        throw new TaskRunnerError(`Failed to parse design review verdict JSON: ${path}`);
+    }
+}
+export const designReviewVerdictNode = {
+    kind: "design-review-verdict",
+    version: 1,
+    async run(_context, params) {
+        const iteration = params.iteration ?? latestArtifactIteration(params.taskKey, "design-review", "json") ?? 1;
+        const jsonPath = designReviewJsonFile(params.taskKey, iteration);
+        validateStructuredArtifacts([{ path: jsonPath, schemaId: "design-review/v1" }], "Design review verdict is invalid or missing.");
+        const verdict = readVerdictFile(jsonPath);
+        const status = (verdict?.status ?? "needs_revision");
+        const canProceed = status === "approved" || status === "approved_with_warnings";
+        const needsRevision = status === "needs_revision";
+        return {
+            value: {
+                status,
+                canProceed,
+                needsRevision,
+                verdict: verdict?.summary ?? `Design review status: ${status}`,
+            },
+        };
+    },
+};

package/dist/pipeline/nodes/ensure-summary-json-node.js

@@ -0,0 +1,70 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { TaskRunnerError } from "../../errors.js";
+import { buildLogicalKeyForPayload } from "../../artifact-manifest.js";
+function toSummaryText(markdown) {
+    return markdown
+        .replace(/\r\n/g, "\n")
+        .replace(/^#{1,6}\s+/gm, "")
+        .replace(/^\s*[-*+]\s+/gm, "- ")
+        .replace(/`([^`]*)`/g, "$1")
+        .replace(/\*\*(.*?)\*\*/g, "$1")
+        .replace(/__(.*?)__/g, "$1")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+function hasValidSummaryArtifact(outputFile) {
+    if (!existsSync(outputFile)) {
+        return false;
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(outputFile, "utf8"));
+        return typeof parsed.summary === "string" && parsed.summary.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+export const ensureSummaryJsonNode = {
+    kind: "ensure-summary-json",
+    version: 1,
+    async run(context, params) {
+        if (hasValidSummaryArtifact(params.outputFile)) {
+            return {
+                value: {
+                    outputFile: params.outputFile,
+                    created: false,
+                    repaired: false,
+                },
+            };
+        }
+        if (!existsSync(params.markdownFile)) {
+            throw new TaskRunnerError(`Cannot create summary JSON ${params.outputFile}: markdown source ${params.markdownFile} was not found.`);
+        }
+        const summary = toSummaryText(readFileSync(params.markdownFile, "utf8"));
+        if (!summary) {
+            throw new TaskRunnerError(`Cannot create summary JSON ${params.outputFile}: markdown source ${params.markdownFile} is empty.`);
+        }
+        mkdirSync(path.dirname(params.outputFile), { recursive: true });
+        const repaired = existsSync(params.outputFile);
+        writeFileSync(params.outputFile, `${JSON.stringify({ summary }, null, 2)}\n`, "utf8");
+        return {
+            value: {
+                outputFile: params.outputFile,
+                created: !repaired,
+                repaired,
+            },
+            outputs: [
+                {
+                    kind: "artifact",
+                    path: params.outputFile,
+                    required: true,
+                    manifest: {
+                        publish: true,
+                        logicalKey: buildLogicalKeyForPayload(context.issueKey, params.outputFile),
+                    },
+                },
+            ],
+        };
+    },
+};

package/dist/pipeline/nodes/fetch-gitlab-diff-node.js

@@ -1,3 +1,4 @@
+import { buildLogicalKeyForPayload } from "../../artifact-manifest.js";
 import { toExecutorContext } from "../types.js";
 export const fetchGitLabDiffNode = {
     kind: "fetch-gitlab-diff",
@@ -12,8 +13,24 @@ export const fetchGitLabDiffNode = {
         return {
             value,
             outputs: [
-                { kind: "artifact", path: params.outputFile, required: true },
-                { kind: "artifact", path: params.outputJsonFile, required: true },
+                {
+                    kind: "artifact",
+                    path: params.outputFile,
+                    required: true,
+                    manifest: {
+                        publish: true,
+                        logicalKey: buildLogicalKeyForPayload(context.issueKey, params.outputFile),
+                    },
+                },
+                {
+                    kind: "artifact",
+                    path: params.outputJsonFile,
+                    required: true,
+                    manifest: {
+                        publish: true,
+                        logicalKey: buildLogicalKeyForPayload(context.issueKey, params.outputJsonFile),
+                    },
+                },
             ],
         };
     },

package/dist/pipeline/nodes/fetch-gitlab-review-node.js

@@ -1,3 +1,4 @@
+import { buildLogicalKeyForPayload } from "../../artifact-manifest.js";
 import { toExecutorContext } from "../types.js";
 export const fetchGitLabReviewNode = {
     kind: "fetch-gitlab-review",
@@ -12,8 +13,24 @@ export const fetchGitLabReviewNode = {
         return {
             value,
             outputs: [
-                { kind: "artifact", path: params.outputFile, required: true },
-                { kind: "artifact", path: params.outputJsonFile, required: true },
+                {
+                    kind: "artifact",
+                    path: params.outputFile,
+                    required: true,
+                    manifest: {
+                        publish: true,
+                        logicalKey: buildLogicalKeyForPayload(context.issueKey, params.outputFile),
+                    },
+                },
+                {
+                    kind: "artifact",
+                    path: params.outputJsonFile,
+                    required: true,
+                    manifest: {
+                        publish: true,
+                        logicalKey: buildLogicalKeyForPayload(context.issueKey, params.outputJsonFile),
+                    },
+                },
             ],
         };
     },

package/dist/pipeline/nodes/flow-run-node.js

@@ -1,6 +1,25 @@
 import { printInfo } from "../../tui.js";
+import { resolveDesignReviewInputContract } from "../../runtime/design-review-input-contract.js";
+import { resolvePlanReviseInputContract } from "../../runtime/plan-revise-input-contract.js";
+import { inspectReviewInputContract } from "../../runtime/review-input-contract.js";
 import { runExpandedPhase } from "../declarative-flow-runner.js";
 import { loadNamedDeclarativeFlow } from "../declarative-flows.js";
+import { isFlowRunResumeEnvelope } from "../flow-run-resume.js";
+import { withCanonicalReviewLoopParams } from "../review-iteration.js";
+import { ARTIFACT_LINEAGE_REF_PATHS_PARAM } from "../value-resolver.js";
+function withArtifactLineageRefPaths(params, lineageRefs) {
+    if (Object.keys(lineageRefs).length === 0) {
+        return params;
+    }
+    const existing = params[ARTIFACT_LINEAGE_REF_PATHS_PARAM];
+    const merged = existing && typeof existing === "object" && !Array.isArray(existing)
+        ? { ...existing, ...lineageRefs }
+        : lineageRefs;
+    return {
+        ...params,
+        [ARTIFACT_LINEAGE_REF_PATHS_PARAM]: merged,
+    };
+}
 export const flowRunNode = {
     kind: "flow-run",
     version: 1,
@@ -13,28 +32,228 @@ export const flowRunNode = {
             printInfo(String(labelText));
         }
         const flow = loadNamedDeclarativeFlow(fileName, context.cwd);
-        const executionState = {
+        let resolvedFlowParams = withCanonicalReviewLoopParams(flow.kind, flowParams);
+        if (flow.kind === "design-review-flow") {
+            const taskKey = String(flowParams["taskKey"] ?? "");
+            if (taskKey) {
+                const contract = resolveDesignReviewInputContract(taskKey);
+                resolvedFlowParams = withArtifactLineageRefPaths({
+                    ...flowParams,
+                    iteration: contract.planningIteration,
+                    planningIteration: contract.planningIteration,
+                    designFile: contract.designFile,
+                    designJsonFile: contract.designJsonFile,
+                    planFile: contract.planFile,
+                    planJsonFile: contract.planJsonFile,
+                    hasQaArtifacts: contract.hasQaArtifacts,
+                    qaFilePath: contract.qaFilePath,
+                    qaJsonFilePath: contract.qaJsonFilePath,
+                    qaFile: contract.qaFile,
+                    qaJsonFile: contract.qaJsonFile,
+                    hasTaskContextJsonFile: contract.hasTaskContextJsonFile,
+                    taskContextJsonFilePath: contract.taskContextJsonFilePath,
+                    taskContextJsonFile: contract.taskContextJsonFile,
+                    hasJiraTaskFile: contract.hasJiraTaskFile,
+                    jiraTaskFilePath: contract.jiraTaskFilePath,
+                    jiraTaskFile: contract.jiraTaskFile,
+                    hasJiraAttachmentsManifestFile: contract.hasJiraAttachmentsManifestFile,
+                    jiraAttachmentsManifestFilePath: contract.jiraAttachmentsManifestFilePath,
+                    jiraAttachmentsManifestFile: contract.jiraAttachmentsManifestFile,
+                    hasJiraAttachmentsContextFile: contract.hasJiraAttachmentsContextFile,
+                    jiraAttachmentsContextFilePath: contract.jiraAttachmentsContextFilePath,
+                    jiraAttachmentsContextFile: contract.jiraAttachmentsContextFile,
+                    hasPlanningAnswersJsonFile: contract.hasPlanningAnswersJsonFile,
+                    planningAnswersJsonFilePath: contract.planningAnswersJsonFilePath,
+                    planningAnswersJsonFile: contract.planningAnswersJsonFile,
+                    hasTaskInputJsonFile: contract.hasTaskInputJsonFile,
+                    taskInputJsonFilePath: contract.taskInputJsonFilePath,
+                    taskInputJsonFile: contract.taskInputJsonFile,
+                }, {
+                    "params.designFile": contract.designFile,
+                    "params.designJsonFile": contract.designJsonFile,
+                    "params.planFile": contract.planFile,
+                    "params.planJsonFile": contract.planJsonFile,
+                    ...(contract.qaFilePath ? { "params.qaFile": contract.qaFilePath } : {}),
+                    ...(contract.qaJsonFilePath ? { "params.qaJsonFile": contract.qaJsonFilePath } : {}),
+                    ...(contract.taskContextJsonFilePath
+                        ? { "params.taskContextJsonFile": contract.taskContextJsonFilePath }
+                        : {}),
+                    ...(contract.jiraTaskFilePath ? { "params.jiraTaskFile": contract.jiraTaskFilePath } : {}),
+                    ...(contract.jiraAttachmentsManifestFilePath
+                        ? { "params.jiraAttachmentsManifestFile": contract.jiraAttachmentsManifestFilePath }
+                        : {}),
+                    ...(contract.jiraAttachmentsContextFilePath
+                        ? { "params.jiraAttachmentsContextFile": contract.jiraAttachmentsContextFilePath }
+                        : {}),
+                    ...(contract.planningAnswersJsonFilePath
+                        ? { "params.planningAnswersJsonFile": contract.planningAnswersJsonFilePath }
+                        : {}),
+                    ...(contract.taskInputJsonFilePath
+                        ? { "params.taskInputJsonFile": contract.taskInputJsonFilePath }
+                        : {}),
+                });
+            }
+        }
+        else if (flow.kind === "plan-revise-flow") {
+            const taskKey = String(flowParams["taskKey"] ?? "");
+            if (taskKey) {
+                const contract = resolvePlanReviseInputContract(taskKey);
+                resolvedFlowParams = withArtifactLineageRefPaths({
+                    ...flowParams,
+                    reviewIteration: contract.reviewIteration,
+                    reviewFile: contract.reviewFile,
+                    reviewJsonFile: contract.reviewJsonFile,
+                    sourcePlanningIteration: contract.sourcePlanningIteration,
+                    outputIteration: contract.outputIteration,
+                    designFile: contract.designFile,
+                    designJsonFile: contract.designJsonFile,
+                    planFile: contract.planFile,
+                    planJsonFile: contract.planJsonFile,
+                    hasQaArtifacts: contract.hasQaArtifacts,
+                    qaFilePath: contract.qaFilePath,
+                    qaJsonFilePath: contract.qaJsonFilePath,
+                    qaFile: contract.qaFile,
+                    qaJsonFile: contract.qaJsonFile,
+                    revisedDesignFile: contract.revisedDesignFile,
+                    revisedDesignJsonFile: contract.revisedDesignJsonFile,
+                    revisedPlanFile: contract.revisedPlanFile,
+                    revisedPlanJsonFile: contract.revisedPlanJsonFile,
+                    revisedQaFile: contract.revisedQaFile,
+                    revisedQaJsonFile: contract.revisedQaJsonFile,
+                    hasTaskContextJsonFile: contract.hasTaskContextJsonFile,
+                    taskContextJsonFilePath: contract.taskContextJsonFilePath,
+                    taskContextJsonFile: contract.taskContextJsonFile,
+                    hasJiraTaskFile: contract.hasJiraTaskFile,
+                    jiraTaskFilePath: contract.jiraTaskFilePath,
+                    jiraTaskFile: contract.jiraTaskFile,
+                    hasJiraAttachmentsManifestFile: contract.hasJiraAttachmentsManifestFile,
+                    jiraAttachmentsManifestFilePath: contract.jiraAttachmentsManifestFilePath,
+                    jiraAttachmentsManifestFile: contract.jiraAttachmentsManifestFile,
+                    hasJiraAttachmentsContextFile: contract.hasJiraAttachmentsContextFile,
+                    jiraAttachmentsContextFilePath: contract.jiraAttachmentsContextFilePath,
+                    jiraAttachmentsContextFile: contract.jiraAttachmentsContextFile,
+                    hasPlanningAnswersJsonFile: contract.hasPlanningAnswersJsonFile,
+                    planningAnswersJsonFilePath: contract.planningAnswersJsonFilePath,
+                    planningAnswersJsonFile: contract.planningAnswersJsonFile,
+                    hasTaskInputJsonFile: contract.hasTaskInputJsonFile,
+                    taskInputJsonFilePath: contract.taskInputJsonFilePath,
+                    taskInputJsonFile: contract.taskInputJsonFile,
+                }, {
+                    "params.reviewFile": contract.reviewFile,
+                    "params.reviewJsonFile": contract.reviewJsonFile,
+                    "params.designFile": contract.designFile,
+                    "params.designJsonFile": contract.designJsonFile,
+                    "params.planFile": contract.planFile,
+                    "params.planJsonFile": contract.planJsonFile,
+                    ...(contract.qaFilePath ? { "params.qaFile": contract.qaFilePath } : {}),
+                    ...(contract.qaJsonFilePath ? { "params.qaJsonFile": contract.qaJsonFilePath } : {}),
+                    ...(contract.taskContextJsonFilePath
+                        ? { "params.taskContextJsonFile": contract.taskContextJsonFilePath }
+                        : {}),
+                    ...(contract.jiraTaskFilePath ? { "params.jiraTaskFile": contract.jiraTaskFilePath } : {}),
+                    ...(contract.jiraAttachmentsManifestFilePath
+                        ? { "params.jiraAttachmentsManifestFile": contract.jiraAttachmentsManifestFilePath }
+                        : {}),
+                    ...(contract.jiraAttachmentsContextFilePath
+                        ? { "params.jiraAttachmentsContextFile": contract.jiraAttachmentsContextFilePath }
+                        : {}),
+                    ...(contract.planningAnswersJsonFilePath
+                        ? { "params.planningAnswersJsonFile": contract.planningAnswersJsonFilePath }
+                        : {}),
+                    ...(contract.taskInputJsonFilePath
+                        ? { "params.taskInputJsonFile": contract.taskInputJsonFilePath }
+                        : {}),
+                });
+            }
+        }
+        else if (flow.kind === "review-flow") {
+            const taskKey = String(flowParams["taskKey"] ?? "");
+            if (taskKey) {
+                const inspection = inspectReviewInputContract(taskKey);
+                if (inspection.status === "ready") {
+                    const { contract } = inspection;
+                    resolvedFlowParams = withArtifactLineageRefPaths({
+                        ...flowParams,
+                        planningIteration: contract.planningIteration,
+                        designFile: contract.designFile,
+                        designJsonFile: contract.designJsonFile,
+                        planFile: contract.planFile,
+                        planJsonFile: contract.planJsonFile,
+                        hasTaskContextJsonFile: contract.hasTaskContextJsonFile,
+                        taskContextJsonFilePath: contract.taskContextJsonFilePath,
+                        taskContextJsonFile: contract.taskContextJsonFile,
+                        hasJiraTaskFile: contract.hasJiraTaskFile,
+                        jiraTaskFilePath: contract.jiraTaskFilePath,
+                        jiraTaskFile: contract.jiraTaskFile,
+                        hasTaskInputJsonFile: contract.hasTaskInputJsonFile,
+                        taskInputJsonFilePath: contract.taskInputJsonFilePath,
+                        taskInputJsonFile: contract.taskInputJsonFile,
+                    }, {
+                        "params.designFile": contract.designFile,
+                        "params.designJsonFile": contract.designJsonFile,
+                        "params.planFile": contract.planFile,
+                        "params.planJsonFile": contract.planJsonFile,
+                        ...(contract.taskContextJsonFilePath
+                            ? { "params.taskContextJsonFile": contract.taskContextJsonFilePath }
+                            : {}),
+                        ...(contract.jiraTaskFilePath ? { "params.jiraTaskFile": contract.jiraTaskFilePath } : {}),
+                        ...(contract.taskInputJsonFilePath
+                            ? { "params.taskInputJsonFile": contract.taskInputJsonFilePath }
+                            : {}),
+                    });
+                }
+            }
+        }
+        const resumeValue = isFlowRunResumeEnvelope(context.resumeStepValue)
+            && context.resumeStepValue.flowKind === flow.kind
+            && context.resumeStepValue.flowVersion === flow.version
+            ? context.resumeStepValue
+            : null;
+        const executionState = resumeValue?.executionState ?? {
             flowKind: flow.kind,
             flowVersion: flow.version,
             terminated: false,
+            terminationOutcome: "success",
             phases: [],
         };
+        const buildResumeEnvelope = (nextExecutionState) => ({
+            resumeKind: "flow-run",
+            flowKind: flow.kind,
+            flowVersion: flow.version,
+            executionState: nextExecutionState,
+            publishedArtifacts: collectPublishedArtifacts(nextExecutionState),
+        });
         for (const phase of flow.phases) {
-            await runExpandedPhase(phase, context, flowParams, flow.constants, {
+            await runExpandedPhase(phase, context, resolvedFlowParams, flow.constants, {
                 executionState,
                 flowKind: flow.kind,
                 flowVersion: flow.version,
+                onStateChange: async (nextExecutionState) => {
+                    await context.persistRunningStepValue?.(buildResumeEnvelope(nextExecutionState));
+                },
             });
             if (executionState.terminated) {
                 break;
             }
         }
         return {
-            value: {
-                flowKind: flow.kind,
-                flowVersion: flow.version,
-                executionState,
-            },
+            value: buildResumeEnvelope(executionState),
         };
     },
 };
+function collectPublishedArtifacts(executionState) {
+    const merged = [];
+    const seen = new Set();
+    for (const phase of executionState.phases) {
+        for (const step of phase.steps) {
+            for (const artifact of step.publishedArtifacts ?? []) {
+                if (seen.has(artifact.artifact_id)) {
+                    continue;
+                }
+                seen.add(artifact.artifact_id);
+                merged.push(artifact);
+            }
+        }
+    }
+    return merged;
+}

package/dist/pipeline/nodes/git-commit-form-node.js

@@ -1,5 +1,6 @@
 import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import path from "node:path";
+import { buildLogicalKeyForPayload } from "../../artifact-manifest.js";
 import { TaskRunnerError } from "../../errors.js";
 import { validateUserInputValues } from "../../user-input.js";
 function parseCommitMessage(content) {
@@ -131,6 +132,13 @@ export const gitCommitFormNode = {
                     kind: "artifact",
                     path: params.outputFile,
                     required: true,
+                    manifest: {
+                        publish: true,
+                        logicalKey: buildLogicalKeyForPayload(context.issueKey, params.outputFile),
+                        payloadFamily: "structured-json",
+                        schemaId: "user-input/v1",
+                        schemaVersion: 1,
+                    },
                 },
             ],
         };

package/dist/pipeline/nodes/gitlab-review-artifacts-node.js

@@ -1,5 +1,6 @@
 import { writeFileSync } from "node:fs";
 import { readFileSync } from "node:fs";
+import { buildLogicalKeyForPayload } from "../../artifact-manifest.js";
 import { TaskRunnerError } from "../../errors.js";
 function normalizeMarkdownLanguage(mdLang) {
     return mdLang === "en" ? "en" : "ru";
@@ -101,8 +102,24 @@ export const gitlabReviewArtifactsNode = {
                 readyToMerge: artifact.ready_to_merge,
             },
             outputs: [
-                { kind: "artifact", path: params.reviewFile, required: true },
-                { kind: "artifact", path: params.reviewJsonFile, required: true },
+                {
+                    kind: "artifact",
+                    path: params.reviewFile,
+                    required: true,
+                    manifest: {
+                        publish: true,
+                        logicalKey: buildLogicalKeyForPayload(context.issueKey, params.reviewFile),
+                    },
+                },
+                {
+                    kind: "artifact",
+                    path: params.reviewJsonFile,
+                    required: true,
+                    manifest: {
+                        publish: true,
+                        logicalKey: buildLogicalKeyForPayload(context.issueKey, params.reviewJsonFile),
+                    },
+                },
             ],
         };
     },

package/dist/pipeline/nodes/jira-fetch-node.js

@@ -10,15 +10,61 @@ export const jiraFetchNode = {
             ...(params.attachmentsManifestFile ? { attachmentsManifestFile: params.attachmentsManifestFile } : {}),
             ...(params.attachmentsContextFile ? { attachmentsContextFile: params.attachmentsContextFile } : {}),
         }, executor.defaultConfig);
-        const outputs = [{ kind: "file", path: params.outputFile, required: true }];
+        const outputs = [
+            {
+                kind: "file",
+                path: params.outputFile,
+                required: true,
+                manifest: {
+                    publish: true,
+                    logicalKey: "artifacts/jira-task.json",
+                    payloadFamily: "helper-json",
+                    schemaId: "helper-json/v1",
+                    schemaVersion: 1,
+                },
+            },
+        ];
         if (params.attachmentsManifestFile) {
-            outputs.push({ kind: "artifact", path: params.attachmentsManifestFile, required: true });
+            outputs.push({
+                kind: "artifact",
+                path: params.attachmentsManifestFile,
+                required: true,
+                manifest: {
+                    publish: true,
+                    logicalKey: "artifacts/jira-attachments.json",
+                    payloadFamily: "helper-json",
+                    schemaId: "helper-json/v1",
+                    schemaVersion: 1,
+                },
+            });
         }
         if (params.attachmentsContextFile) {
-            outputs.push({ kind: "artifact", path: params.attachmentsContextFile, required: true });
+            outputs.push({
+                kind: "artifact",
+                path: params.attachmentsContextFile,
+                required: true,
+                manifest: {
+                    publish: true,
+                    logicalKey: "jira-attachments-context.txt",
+                    payloadFamily: "plain-text",
+                    schemaId: "plain-text/v1",
+                    schemaVersion: 1,
+                },
+            });
         }
         if (value.enrichedFile) {
-            outputs.push({ kind: "artifact", path: value.enrichedFile, required: false });
+            outputs.push({
+                kind: "artifact",
+                path: value.enrichedFile,
+                required: false,
+                manifest: {
+                    publish: true,
+                    logicalKey: "artifacts/jira-task-enriched.json",
+                    payloadFamily: "helper-json",
+                    schemaId: "helper-json/v1",
+                    schemaVersion: 1,
+                },
+            });
         }
         return {
             value,

package/dist/pipeline/nodes/llm-prompt-node.js

@@ -2,24 +2,44 @@ import { TaskRunnerError } from "../../errors.js";
 import { printInfo, printPrompt } from "../../tui.js";
 import { isAllowedModelForExecutor, isLlmExecutorId, } from "../launch-profile-config.js";
 import { toExecutorContext } from "../types.js";
+function outputsForArtifacts(requiredArtifacts) {
+    return Array.from(new Set(requiredArtifacts ?? [])).map((outputPath) => ({
+        kind: "artifact",
+        path: outputPath,
+        required: true,
+        manifest: {
+            publish: true,
+        },
+    }));
+}
 export const llmPromptNode = {
     kind: "llm-prompt",
     version: 1,
     async run(context, params) {
-        if (!isLlmExecutorId(params.executor)) {
-            throw new TaskRunnerError(`Unsupported llm executor '${params.executor}'.`);
+        const routedProfile = params.routingGroup
+            ? context.executionRouting?.groups[params.routingGroup]
+            : undefined;
+        const fallbackProfile = context.executionRouting?.defaultRoute;
+        const executor = params.routingGroup
+            ? routedProfile?.executor ?? params.executor ?? fallbackProfile?.executor
+            : params.executor ?? fallbackProfile?.executor;
+        const model = params.routingGroup
+            ? routedProfile?.model ?? params.model ?? fallbackProfile?.model
+            : params.model ?? fallbackProfile?.model;
+        if (!executor || !isLlmExecutorId(executor)) {
+            throw new TaskRunnerError(`Unsupported llm executor '${String(executor ?? params.executor ?? "undefined")}'.`);
         }
-        if (params.model && !isAllowedModelForExecutor(params.executor, params.model)) {
-            throw new TaskRunnerError(`Model '${params.model}' is not allowed for executor '${params.executor}'.`);
+        if (model && !isAllowedModelForExecutor(executor, model)) {
+            throw new TaskRunnerError(`Model '${model}' is not allowed for executor '${executor}'.`);
         }
         printInfo(params.labelText);
-        printPrompt(`LLM:${params.executor}`, params.prompt);
+        printPrompt(`LLM:${executor}`, params.prompt);
         const executorContext = toExecutorContext(context);
-        if (params.executor === "codex") {
+        if (executor === "codex") {
             const executor = context.executors.get("codex");
             const value = await executor.execute(executorContext, {
                 prompt: params.prompt,
-                ...(params.model ? { model: params.model } : {}),
+                ...(model ? { model } : {}),
                 env: { ...context.env },
             }, executor.defaultConfig);
             return {
@@ -27,14 +47,14 @@ export const llmPromptNode = {
                     ...value,
                     executor: "codex",
                 },
-                outputs: (params.requiredArtifacts ?? []).map((path) => ({ kind: "artifact", path, required: true })),
+                outputs: outputsForArtifacts(params.requiredArtifacts),
             };
         }
-        if (params.executor === "opencode") {
+        if (executor === "opencode") {
             const executor = context.executors.get("opencode");
             const value = await executor.execute(executorContext, {
                 prompt: params.prompt,
-                ...(params.model ? { model: params.model } : {}),
+                ...(model ? { model } : {}),
                 env: { ...context.env },
             }, executor.defaultConfig);
             return {
@@ -42,10 +62,10 @@ export const llmPromptNode = {
                     ...value,
                     executor: "opencode",
                 },
-                outputs: (params.requiredArtifacts ?? []).map((path) => ({ kind: "artifact", path, required: true })),
+                outputs: outputsForArtifacts(params.requiredArtifacts),
             };
         }
-        throw new TaskRunnerError(`Unsupported llm executor '${params.executor}'.`);
+        throw new TaskRunnerError(`Unsupported llm executor '${executor}'.`);
     },
     checks(_context, params) {
         if (!params.requiredArtifacts || params.requiredArtifacts.length === 0) {

package/dist/pipeline/nodes/planning-bundle-node.js

@@ -0,0 +1,10 @@
+import { resolveLatestPlanningBundle } from "../../runtime/planning-bundle.js";
+export const planningBundleNode = {
+    kind: "planning-bundle",
+    version: 1,
+    async run(_context, params) {
+        return {
+            value: resolveLatestPlanningBundle(params.taskKey),
+        };
+    },
+};