agentweaver 0.1.0 → 0.1.2

package/dist/interactive-ui.js

@@ -6,6 +6,7 @@ export class InteractiveUi {
     screen;
     header;
     summary;
+    status;
     sidebar;
     log;
     input;
@@ -15,7 +16,13 @@ export class InteractiveUi {
     historyIndex;
     busy = false;
     currentCommand = "idle";
+    summaryText = "";
     focusedPane = "input";
+    currentNode = null;
+    currentExecutor = null;
+    spinnerFrame = 0;
+    spinnerTimer = null;
+    runningStartedAt = null;
     constructor(options, history) {
         this.options = options;
         this.history = history;
@@ -49,7 +56,7 @@ export class InteractiveUi {
             top: 3,
             left: 0,
             width: "28%",
-            height: "100%-7",
+            bottom: 10,
             tags: true,
             label: " Commands ",
             padding: {
@@ -71,7 +78,7 @@ export class InteractiveUi {
             top: 3,
             left: "28%",
             width: "72%",
-            height: 9,
+            height: 8,
             tags: true,
             label: " Task Summary ",
             padding: {
@@ -88,12 +95,30 @@ export class InteractiveUi {
                 fg: "white",
             },
         });
+        this.status = blessed.box({
+            parent: this.screen,
+            bottom: 4,
+            left: 0,
+            width: "28%",
+            height: 6,
+            tags: true,
+            label: " Status ",
+            padding: {
+                left: 1,
+                right: 1,
+            },
+            border: "line",
+            style: {
+                border: { fg: "green" },
+                fg: "white",
+            },
+        });
         this.log = blessed.log({
             parent: this.screen,
-            top: 12,
+            top: 11,
+            bottom: 4,
             left: "28%",
             width: "72%",
-            height: "100%-16",
             tags: false,
             label: " Activity ",
             padding: {
@@ -347,12 +372,9 @@ export class InteractiveUi {
         this.screen.render();
     }
     renderStaticContent() {
-        this.header.setContent(`{bold}AgentWeaver{/bold}  {green-fg}${this.options.issueKey}{/green-fg}\n` +
-            `cwd: ${this.options.cwd}   current: ${this.currentCommand}`);
-        const summaryBody = this.options.summaryText.trim()
-            ? this.options.summaryText.trim()
-            : "Using existing Jira task file.\n\nUse /help to see commands.";
-        this.summary.setContent(renderMarkdownToTerminal(stripAnsi(summaryBody)));
+        this.summaryText = this.options.summaryText.trim();
+        this.updateHeader();
+        this.renderSummary();
         this.sidebar.setContent([
             this.options.commands.join("\n"),
             "",
@@ -378,6 +400,16 @@ export class InteractiveUi {
         ].join("\n")));
         this.footer.setContent(" Enter: run command | Tab: complete | Up/Down: history | ?: help | Ctrl+L: clear log | q: exit ");
     }
+    updateHeader() {
+        this.header.setContent(`{bold}AgentWeaver{/bold}  {green-fg}${this.options.issueKey}{/green-fg}\n` +
+            `cwd: ${this.options.cwd}   current: ${this.currentCommand}`);
+    }
+    renderSummary() {
+        const summaryBody = this.summaryText
+            ? this.summaryText
+            : "Task summary is not available yet.";
+        this.summary.setContent(renderMarkdownToTerminal(stripAnsi(summaryBody)));
+    }
     createAdapter() {
         return {
             writeStdout: (text) => {
@@ -388,6 +420,12 @@ export class InteractiveUi {
             },
             supportsTransientStatus: false,
             supportsPassthrough: false,
+            renderAuxiliaryOutput: false,
+            setExecutionState: (state) => {
+                this.currentNode = state.node;
+                this.currentExecutor = state.executor;
+                this.updateRunningPanel();
+            },
         };
     }
     mount() {
@@ -395,18 +433,39 @@ export class InteractiveUi {
         this.focusPane("input");
     }
     destroy() {
+        if (this.spinnerTimer) {
+            clearInterval(this.spinnerTimer);
+            this.spinnerTimer = null;
+        }
         setOutputAdapter(null);
         this.screen.destroy();
     }
     setBusy(busy, command) {
         this.busy = busy;
         this.currentCommand = command ?? (busy ? this.currentCommand : "idle");
+        if (busy && this.runningStartedAt === null) {
+            this.runningStartedAt = Date.now();
+        }
+        else if (!busy && this.currentNode === null && this.currentExecutor === null) {
+            this.runningStartedAt = null;
+        }
+        this.updateHeader();
         this.header.setContent(`{bold}AgentWeaver{/bold}  {green-fg}${this.options.issueKey}{/green-fg}\n` +
-            `cwd: ${this.options.cwd}\n` +
-            `current: ${this.currentCommand}${busy ? " {yellow-fg}[running]{/yellow-fg}" : ""}`);
+            `cwd: ${this.options.cwd}   current: ${this.currentCommand}${busy ? " {yellow-fg}[running]{/yellow-fg}" : ""}`);
+        this.updateRunningPanel();
         this.input.setLabel(busy ? " command [busy] " : " command ");
         this.screen.render();
     }
+    setStatus(status) {
+        this.currentCommand = status;
+        this.updateHeader();
+        this.screen.render();
+    }
+    setSummary(markdown) {
+        this.summaryText = markdown.trim();
+        this.renderSummary();
+        this.screen.render();
+    }
     appendLog(text) {
         const normalized = text
             .split("\n")
@@ -424,4 +483,42 @@ export class InteractiveUi {
         this.log.setScrollPerc(100);
         this.screen.render();
     }
+    updateRunningPanel() {
+        const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+        const running = this.busy || this.currentNode !== null || this.currentExecutor !== null;
+        if (running && this.spinnerTimer === null) {
+            if (this.runningStartedAt === null) {
+                this.runningStartedAt = Date.now();
+            }
+            this.spinnerTimer = setInterval(() => {
+                this.spinnerFrame = (this.spinnerFrame + 1) % frames.length;
+                this.updateRunningPanel();
+                this.screen.render();
+            }, 120);
+        }
+        else if (!running && this.spinnerTimer) {
+            clearInterval(this.spinnerTimer);
+            this.spinnerTimer = null;
+            this.spinnerFrame = 0;
+            this.runningStartedAt = null;
+        }
+        const spinner = running ? `{green-fg}${frames[this.spinnerFrame] ?? "•"}{/green-fg}` : "•";
+        const elapsed = this.formatElapsed(running ? Date.now() : null);
+        const nodeLine = `Node: ${this.currentNode ?? "-"}`;
+        const executorLine = `Executor: ${this.currentExecutor ?? "-"}`;
+        const stateLine = `State: ${running ? `${spinner} running` : "idle"}`;
+        const elapsedLine = `Time: ${elapsed}`;
+        this.status.setContent([stateLine, elapsedLine, nodeLine, executorLine].join("\n"));
+        this.screen.render();
+    }
+    formatElapsed(now) {
+        if (this.runningStartedAt === null || now === null) {
+            return "00:00:00";
+        }
+        const totalSeconds = Math.max(0, Math.floor((now - this.runningStartedAt) / 1000));
+        const hours = String(Math.floor(totalSeconds / 3600)).padStart(2, "0");
+        const minutes = String(Math.floor((totalSeconds % 3600) / 60)).padStart(2, "0");
+        const seconds = String(totalSeconds % 60).padStart(2, "0");
+        return `${hours}:${minutes}:${seconds}`;
+    }
 }

package/dist/pipeline/build-failure-summary.js

@@ -0,0 +1,6 @@
+import { runNode } from "./node-runner.js";
+import { buildFailureSummaryNode } from "./nodes/build-failure-summary-node.js";
+export async function summarizeBuildFailure(context, output) {
+    const result = await runNode(buildFailureSummaryNode, context, { output });
+    return result.value.summaryText;
+}

package/dist/pipeline/checks.js

@@ -0,0 +1,15 @@
+import { requireArtifacts } from "../artifacts.js";
+import { TaskRunnerError } from "../errors.js";
+export function runNodeChecks(checks) {
+    for (const check of checks) {
+        if (check.kind === "require-artifacts") {
+            requireArtifacts(check.paths, check.message);
+            continue;
+        }
+        if (check.kind === "require-file") {
+            requireArtifacts([check.path], check.message);
+            continue;
+        }
+        throw new TaskRunnerError(`Unsupported node check: ${check.kind ?? "unknown"}`);
+    }
+}

package/dist/pipeline/context.js

@@ -0,0 +1,17 @@
+import process from "node:process";
+import { getOutputAdapter } from "../tui.js";
+import { createExecutorRegistry } from "./registry.js";
+export function createPipelineContext(input) {
+    return {
+        issueKey: input.issueKey,
+        jiraRef: input.jiraRef,
+        cwd: process.cwd(),
+        env: { ...process.env },
+        ui: getOutputAdapter(),
+        dryRun: input.dryRun,
+        verbose: input.verbose,
+        runtime: input.runtime,
+        executors: createExecutorRegistry(),
+        ...(input.setSummary ? { setSummary: input.setSummary } : {}),
+    };
+}

package/dist/pipeline/flow-runner.js

@@ -0,0 +1,13 @@
+export async function runFlow(definition, context, params, options = {}) {
+    const steps = [];
+    for (const step of definition.steps) {
+        await options.onStepStart?.(step);
+        const result = await step.run(context, params);
+        await options.onStepComplete?.(step, result);
+        steps.push({
+            id: step.id,
+            result,
+        });
+    }
+    return { steps };
+}

package/dist/pipeline/flow-types.js

@@ -0,0 +1 @@
+export {};

package/dist/pipeline/flows/implement-flow.js

@@ -0,0 +1,48 @@
+import { runFlow } from "../flow-runner.js";
+import { runNode } from "../node-runner.js";
+import { codexDockerPromptNode } from "../nodes/codex-docker-prompt-node.js";
+import { verifyBuildNode } from "../nodes/verify-build-node.js";
+export const implementFlowDefinition = {
+    kind: "implement-flow",
+    version: 1,
+    steps: [
+        {
+            id: "run_codex_implement",
+            async run(context, params) {
+                await runNode(codexDockerPromptNode, context, {
+                    dockerComposeFile: params.dockerComposeFile,
+                    prompt: params.prompt,
+                    labelText: "Running Codex implementation mode in isolated Docker",
+                });
+                return { completed: true };
+            },
+        },
+        {
+            id: "verify_build_after_implement",
+            async run(context, params) {
+                if (!params.runFollowupVerify) {
+                    return {
+                        completed: true,
+                        metadata: { skipped: true },
+                    };
+                }
+                try {
+                    await runNode(verifyBuildNode, context, {
+                        dockerComposeFile: params.dockerComposeFile,
+                        labelText: "Running build verification in isolated Docker",
+                    });
+                }
+                catch (error) {
+                    if (params.onVerifyBuildFailure) {
+                        await params.onVerifyBuildFailure(String(error.output ?? ""));
+                    }
+                    throw error;
+                }
+                return { completed: true };
+            },
+        },
+    ],
+};
+export async function runImplementFlow(context, params) {
+    await runFlow(implementFlowDefinition, context, params);
+}

package/dist/pipeline/flows/plan-flow.js

@@ -0,0 +1,42 @@
+import { designFile, planArtifacts, planFile, qaFile } from "../../artifacts.js";
+import { PLAN_PROMPT_TEMPLATE, formatPrompt, formatTemplate } from "../../prompts.js";
+import { runFlow } from "../flow-runner.js";
+import { runNode } from "../node-runner.js";
+import { jiraFetchNode } from "../nodes/jira-fetch-node.js";
+import { planCodexNode } from "../nodes/plan-codex-node.js";
+export const planFlowDefinition = {
+    kind: "plan-flow",
+    version: 1,
+    steps: [
+        {
+            id: "fetch_jira",
+            async run(context, params) {
+                await runNode(jiraFetchNode, context, {
+                    jiraApiUrl: params.jiraApiUrl,
+                    outputFile: params.jiraTaskFile,
+                });
+                return { completed: true };
+            },
+        },
+        {
+            id: "run_codex_plan",
+            async run(context, params) {
+                const prompt = formatPrompt(formatTemplate(PLAN_PROMPT_TEMPLATE, {
+                    jira_task_file: params.jiraTaskFile,
+                    design_file: designFile(params.taskKey),
+                    plan_file: planFile(params.taskKey),
+                    qa_file: qaFile(params.taskKey),
+                }), params.extraPrompt);
+                await runNode(planCodexNode, context, {
+                    prompt,
+                    command: params.codexCmd,
+                    requiredArtifacts: planArtifacts(params.taskKey),
+                });
+                return { completed: true };
+            },
+        },
+    ],
+};
+export async function runPlanFlow(context, params) {
+    await runFlow(planFlowDefinition, context, params);
+}

package/dist/pipeline/flows/preflight-flow.js

@@ -0,0 +1,59 @@
+import { existsSync, readFileSync } from "node:fs";
+import { taskSummaryFile } from "../../artifacts.js";
+import { runFlow } from "../flow-runner.js";
+import { runNode } from "../node-runner.js";
+import { commandCheckNode } from "../nodes/command-check-node.js";
+import { jiraFetchNode } from "../nodes/jira-fetch-node.js";
+import { taskSummaryNode } from "../nodes/task-summary-node.js";
+export const preflightFlowDefinition = {
+    kind: "interactive-preflight-flow",
+    version: 1,
+    steps: [
+        {
+            id: "check_commands",
+            async run(context) {
+                const result = await runNode(commandCheckNode, context, {
+                    commands: [
+                        { commandName: "codex", envVarName: "CODEX_BIN" },
+                        { commandName: "claude", envVarName: "CLAUDE_BIN" },
+                    ],
+                });
+                return { completed: true, metadata: { resolved: result.value.resolved.length } };
+            },
+        },
+        {
+            id: "fetch_jira_if_needed",
+            async run(context, params) {
+                if (!params.forceRefresh && existsSync(params.jiraTaskFile)) {
+                    return { completed: true, metadata: { skipped: true } };
+                }
+                await runNode(jiraFetchNode, context, {
+                    jiraApiUrl: params.jiraApiUrl,
+                    outputFile: params.jiraTaskFile,
+                });
+                return { completed: true };
+            },
+        },
+        {
+            id: "load_or_generate_task_summary",
+            async run(context, params) {
+                const summaryPath = taskSummaryFile(params.taskKey);
+                if (!params.forceRefresh && existsSync(params.jiraTaskFile) && existsSync(summaryPath)) {
+                    context.setSummary?.(readFileSync(summaryPath, "utf8").trim());
+                    return { completed: true, metadata: { source: "existing" } };
+                }
+                const claudeCmd = context.runtime.resolveCmd("claude", "CLAUDE_BIN");
+                await runNode(taskSummaryNode, context, {
+                    jiraTaskFile: params.jiraTaskFile,
+                    taskKey: params.taskKey,
+                    claudeCmd,
+                    verbose: context.verbose,
+                });
+                return { completed: true, metadata: { source: "generated" } };
+            },
+        },
+    ],
+};
+export async function runPreflightFlow(context, params) {
+    await runFlow(preflightFlowDefinition, context, params);
+}

package/dist/pipeline/flows/review-fix-flow.js

@@ -0,0 +1,63 @@
+import { artifactFile, planArtifacts, requireArtifacts } from "../../artifacts.js";
+import { TaskRunnerError } from "../../errors.js";
+import { REVIEW_FIX_PROMPT_TEMPLATE, formatPrompt, formatTemplate } from "../../prompts.js";
+import { runFlow } from "../flow-runner.js";
+import { runNode } from "../node-runner.js";
+import { codexDockerPromptNode } from "../nodes/codex-docker-prompt-node.js";
+import { verifyBuildNode } from "../nodes/verify-build-node.js";
+export function createReviewFixFlowDefinition(iteration) {
+    return {
+        kind: "review-fix-flow",
+        version: 1,
+        steps: [
+            {
+                id: "run_codex_review_fix",
+                async run(stepContext, stepParams) {
+                    const reviewReplyFile = artifactFile("review-reply", stepParams.taskKey, iteration);
+                    const reviewFixFile = artifactFile("review-fix", stepParams.taskKey, iteration);
+                    const prompt = formatPrompt(formatTemplate(REVIEW_FIX_PROMPT_TEMPLATE, {
+                        review_reply_file: reviewReplyFile,
+                        items: stepParams.reviewFixPoints ?? "",
+                        review_fix_file: reviewFixFile,
+                    }), stepParams.extraPrompt);
+                    await runNode(codexDockerPromptNode, stepContext, {
+                        dockerComposeFile: stepParams.dockerComposeFile,
+                        prompt,
+                        labelText: `Running Codex review-fix mode in isolated Docker (iteration ${iteration})`,
+                        requiredArtifacts: stepContext.dryRun ? [] : [reviewFixFile],
+                        missingArtifactsMessage: "Review-fix mode did not produce the required review-fix artifact.",
+                    });
+                    return { completed: true, metadata: { iteration } };
+                },
+            },
+            {
+                id: "verify_build_after_review_fix",
+                async run(stepContext, stepParams) {
+                    if (!stepParams.runFollowupVerify) {
+                        return { completed: true, metadata: { skipped: true } };
+                    }
+                    try {
+                        await runNode(verifyBuildNode, stepContext, {
+                            dockerComposeFile: stepParams.dockerComposeFile,
+                            labelText: "Running build verification in isolated Docker",
+                        });
+                    }
+                    catch (error) {
+                        if (stepParams.onVerifyBuildFailure) {
+                            await stepParams.onVerifyBuildFailure(String(error.output ?? ""));
+                        }
+                        throw error;
+                    }
+                    return { completed: true };
+                },
+            },
+        ],
+    };
+}
+export async function runReviewFixFlow(context, params) {
+    requireArtifacts(planArtifacts(params.taskKey), "Review-fix mode requires plan artifacts from the planning phase.");
+    if (params.latestIteration === null) {
+        throw new TaskRunnerError(`Review-fix mode requires at least one review-reply-${params.taskKey}-N.md artifact.`);
+    }
+    await runFlow(createReviewFixFlowDefinition(params.latestIteration), context, params);
+}

package/dist/pipeline/flows/review-flow.js

@@ -0,0 +1,120 @@
+import { existsSync, readdirSync } from "node:fs";
+import { READY_TO_MERGE_FILE, REVIEW_REPLY_FILE_RE, artifactFile, planArtifacts, requireArtifacts, } from "../../artifacts.js";
+import { REVIEW_REPLY_SUMMARY_PROMPT_TEMPLATE, REVIEW_SUMMARY_PROMPT_TEMPLATE, formatTemplate } from "../../prompts.js";
+import { printPanel } from "../../tui.js";
+import { runFlow } from "../flow-runner.js";
+import { runNode } from "../node-runner.js";
+import { claudeSummaryNode } from "../nodes/claude-summary-node.js";
+import { reviewClaudeNode } from "../nodes/review-claude-node.js";
+import { reviewReplyCodexNode } from "../nodes/review-reply-codex-node.js";
+function nextReviewIterationForTask(taskKey) {
+    let maxIndex = 0;
+    for (const entry of readdirSync(process.cwd(), { withFileTypes: true })) {
+        if (!entry.isFile()) {
+            continue;
+        }
+        const match = REVIEW_REPLY_FILE_RE.exec(entry.name);
+        if (match && match[1] === taskKey) {
+            const current = Number.parseInt(match[2] ?? "0", 10);
+            maxIndex = Math.max(maxIndex, current);
+        }
+    }
+    return maxIndex + 1;
+}
+export function createReviewFlowDefinition(iteration) {
+    return {
+        kind: "review-flow",
+        version: 1,
+        steps: [
+            {
+                id: "run_claude_review",
+                async run(stepContext, stepParams) {
+                    await runNode(reviewClaudeNode, stepContext, {
+                        jiraTaskFile: stepParams.jiraTaskFile,
+                        taskKey: stepParams.taskKey,
+                        iteration,
+                        claudeCmd: stepParams.claudeCmd,
+                        ...(stepParams.extraPrompt !== undefined ? { extraPrompt: stepParams.extraPrompt } : {}),
+                    });
+                    return { completed: true, metadata: { iteration } };
+                },
+            },
+            {
+                id: "summarize_review",
+                async run(stepContext, stepParams) {
+                    const reviewFile = artifactFile("review", stepParams.taskKey, iteration);
+                    const reviewSummaryFile = artifactFile("review-summary", stepParams.taskKey, iteration);
+                    if (stepContext.dryRun) {
+                        return { completed: true, metadata: { skipped: true } };
+                    }
+                    await runNode(claudeSummaryNode, stepContext, {
+                        claudeCmd: stepParams.claudeCmd,
+                        outputFile: reviewSummaryFile,
+                        prompt: formatTemplate(REVIEW_SUMMARY_PROMPT_TEMPLATE, {
+                            review_file: reviewFile,
+                            review_summary_file: reviewSummaryFile,
+                        }),
+                        summaryTitle: "Claude Comments",
+                        verbose: stepContext.verbose,
+                    });
+                    return { completed: true };
+                },
+            },
+            {
+                id: "run_codex_review_reply",
+                async run(stepContext, stepParams) {
+                    await runNode(reviewReplyCodexNode, stepContext, {
+                        jiraTaskFile: stepParams.jiraTaskFile,
+                        taskKey: stepParams.taskKey,
+                        iteration,
+                        codexCmd: stepParams.codexCmd,
+                        ...(stepParams.extraPrompt !== undefined ? { extraPrompt: stepParams.extraPrompt } : {}),
+                    });
+                    return { completed: true };
+                },
+            },
+            {
+                id: "summarize_review_reply",
+                async run(stepContext, stepParams) {
+                    const reviewReplyFile = artifactFile("review-reply", stepParams.taskKey, iteration);
+                    const reviewReplySummaryFile = artifactFile("review-reply-summary", stepParams.taskKey, iteration);
+                    if (stepContext.dryRun) {
+                        return { completed: true, metadata: { skipped: true } };
+                    }
+                    await runNode(claudeSummaryNode, stepContext, {
+                        claudeCmd: stepParams.claudeCmd,
+                        outputFile: reviewReplySummaryFile,
+                        prompt: formatTemplate(REVIEW_REPLY_SUMMARY_PROMPT_TEMPLATE, {
+                            review_reply_file: reviewReplyFile,
+                            review_reply_summary_file: reviewReplySummaryFile,
+                        }),
+                        summaryTitle: "Codex Reply Summary",
+                        verbose: stepContext.verbose,
+                    });
+                    return { completed: true };
+                },
+            },
+            {
+                id: "check_ready_to_merge",
+                async run(stepContext) {
+                    const readyToMerge = !stepContext.dryRun && existsSync(READY_TO_MERGE_FILE);
+                    if (readyToMerge) {
+                        printPanel("Ready To Merge", "Изменения готовы к merge\nФайл ready-to-merge.md создан.", "green");
+                    }
+                    return { completed: true, metadata: { readyToMerge } };
+                },
+            },
+        ],
+    };
+}
+async function runReviewFlowInternal(context, params, iteration) {
+    requireArtifacts(planArtifacts(params.taskKey), "Review mode requires plan artifacts from the planning phase.");
+    const result = await runFlow(createReviewFlowDefinition(iteration), context, params);
+    const readyToMerge = result.steps.find((step) => step.id === "check_ready_to_merge")?.result.metadata?.readyToMerge === true;
+    return { readyToMerge };
+}
+export async function runReviewFlow(context, params) {
+    const iteration = nextReviewIterationForTask(params.taskKey);
+    const result = await runReviewFlowInternal(context, params, iteration);
+    return { readyToMerge: result.readyToMerge, iteration };
+}

package/dist/pipeline/flows/test-fix-flow.js

@@ -0,0 +1,13 @@
+import { planArtifacts, requireArtifacts } from "../../artifacts.js";
+import { TEST_FIX_PROMPT_TEMPLATE, TEST_LINTER_FIX_PROMPT_TEMPLATE, formatPrompt } from "../../prompts.js";
+import { runNode } from "../node-runner.js";
+import { codexDockerPromptNode } from "../nodes/codex-docker-prompt-node.js";
+export async function runTestFixFlow(context, params) {
+    requireArtifacts(planArtifacts(params.taskKey), `${params.command} mode requires plan artifacts from the planning phase.`);
+    const prompt = formatPrompt(params.command === "test-fix" ? TEST_FIX_PROMPT_TEMPLATE : TEST_LINTER_FIX_PROMPT_TEMPLATE, params.extraPrompt);
+    await runNode(codexDockerPromptNode, context, {
+        dockerComposeFile: params.dockerComposeFile,
+        prompt,
+        labelText: `Running Codex ${params.command} mode in isolated Docker`,
+    });
+}

package/dist/pipeline/flows/test-flow.js

@@ -0,0 +1,32 @@
+import { planArtifacts, requireArtifacts } from "../../artifacts.js";
+import { runFlow } from "../flow-runner.js";
+import { runNode } from "../node-runner.js";
+import { verifyBuildNode } from "../nodes/verify-build-node.js";
+export const testFlowDefinition = {
+    kind: "test-flow",
+    version: 1,
+    steps: [
+        {
+            id: "verify_build",
+            async run(context, params) {
+                try {
+                    await runNode(verifyBuildNode, context, {
+                        dockerComposeFile: params.dockerComposeFile,
+                        labelText: "Running build verification in isolated Docker",
+                    });
+                }
+                catch (error) {
+                    if (params.onVerifyBuildFailure) {
+                        await params.onVerifyBuildFailure(String(error.output ?? ""));
+                    }
+                    throw error;
+                }
+                return { completed: true };
+            },
+        },
+    ],
+};
+export async function runTestFlow(context, params) {
+    requireArtifacts(planArtifacts(params.taskKey), "Test mode requires plan artifacts from the planning phase.");
+    await runFlow(testFlowDefinition, context, params);
+}

package/dist/pipeline/node-runner.js

@@ -0,0 +1,14 @@
+import { setCurrentNode } from "../tui.js";
+import { runNodeChecks } from "./checks.js";
+export async function runNode(node, context, params) {
+    setCurrentNode(node.kind);
+    try {
+        const result = await node.run(context, params);
+        const checks = node.checks?.(context, params, result) ?? [];
+        runNodeChecks(checks);
+        return result;
+    }
+    finally {
+        setCurrentNode(null);
+    }
+}