agentweaver 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,17 +1,29 @@
 #!/usr/bin/env node
-import { accessSync, constants, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { appendFile, readFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
-import { spawn, spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { READY_TO_MERGE_FILE, REVIEW_FILE_RE, REVIEW_REPLY_FILE_RE, artifactFile, designFile, planArtifacts, planFile, qaFile, requireArtifacts, taskSummaryFile, } from "./artifacts.js";
+import { REVIEW_FILE_RE, REVIEW_REPLY_FILE_RE, designFile, planArtifacts, planFile, requireArtifacts, taskSummaryFile, } from "./artifacts.js";
 import { TaskRunnerError } from "./errors.js";
-import { buildJiraApiUrl, buildJiraBrowseUrl, extractIssueKey, fetchJiraIssue, requireJiraTaskFile } from "./jira.js";
-import { AUTO_REVIEW_FIX_EXTRA_PROMPT, IMPLEMENT_PROMPT_TEMPLATE, PLAN_PROMPT_TEMPLATE, REVIEW_FIX_PROMPT_TEMPLATE, REVIEW_PROMPT_TEMPLATE, REVIEW_REPLY_PROMPT_TEMPLATE, REVIEW_REPLY_SUMMARY_PROMPT_TEMPLATE, REVIEW_SUMMARY_PROMPT_TEMPLATE, TASK_SUMMARY_PROMPT_TEMPLATE, TEST_FIX_PROMPT_TEMPLATE, TEST_LINTER_FIX_PROMPT_TEMPLATE, formatPrompt, formatTemplate, } from "./prompts.js";
+import { buildJiraApiUrl, buildJiraBrowseUrl, extractIssueKey, requireJiraTaskFile } from "./jira.js";
+import { AUTO_REVIEW_FIX_EXTRA_PROMPT, IMPLEMENT_PROMPT_TEMPLATE, formatPrompt, formatTemplate, } from "./prompts.js";
+import { summarizeBuildFailure as summarizeBuildFailureViaPipeline } from "./pipeline/build-failure-summary.js";
+import { createPipelineContext } from "./pipeline/context.js";
+import { runFlow } from "./pipeline/flow-runner.js";
+import { implementFlowDefinition, runImplementFlow } from "./pipeline/flows/implement-flow.js";
+import { planFlowDefinition, runPlanFlow } from "./pipeline/flows/plan-flow.js";
+import { runPreflightFlow } from "./pipeline/flows/preflight-flow.js";
+import { createReviewFixFlowDefinition, runReviewFixFlow } from "./pipeline/flows/review-fix-flow.js";
+import { createReviewFlowDefinition, runReviewFlow } from "./pipeline/flows/review-flow.js";
+import { runTestFixFlow } from "./pipeline/flows/test-fix-flow.js";
+import { runTestFlow, testFlowDefinition } from "./pipeline/flows/test-flow.js";
+import { resolveCmd, resolveDockerComposeCmd } from "./runtime/command-resolution.js";
+import { defaultDockerComposeFile, dockerRuntimeEnv } from "./runtime/docker-runtime.js";
+import { runCommand } from "./runtime/process-runner.js";
 import { InteractiveUi } from "./interactive-ui.js";
-import { bye, dim, formatDone, getOutputAdapter, printError, printInfo, printPanel, printPrompt, printSummary } from "./tui.js";
+import { bye, printError, printInfo, printPanel, printSummary } from "./tui.js";
 const COMMANDS = [
     "plan",
     "implement",
@@ -26,12 +38,17 @@ const COMMANDS = [
 ];
 const DEFAULT_CODEX_MODEL = "gpt-5.4";
 const DEFAULT_CLAUDE_REVIEW_MODEL = "opus";
-const DEFAULT_CLAUDE_SUMMARY_MODEL = "haiku";
 const HISTORY_FILE = path.join(os.homedir(), ".codex", "memories", "agentweaver-history");
 const AUTO_STATE_SCHEMA_VERSION = 1;
 const AUTO_MAX_REVIEW_ITERATIONS = 3;
 const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 const PACKAGE_ROOT = path.resolve(MODULE_DIR, "..");
+const runtimeServices = {
+    resolveCmd,
+    resolveDockerComposeCmd,
+    dockerRuntimeEnv: () => dockerRuntimeEnv(PACKAGE_ROOT),
+    runCommand,
+};
 function usage() {
     return `Usage:
   agentweaver <jira-browse-url|jira-issue-key>
@@ -224,110 +241,6 @@ function loadEnvFile(envFilePath) {
         process.env[key] = value;
     }
 }
-function agentweaverHome() {
-    const configured = process.env.AGENTWEAVER_HOME?.trim();
-    if (configured) {
-        return path.resolve(configured);
-    }
-    return PACKAGE_ROOT;
-}
-function defaultDockerComposeFile() {
-    return path.join(agentweaverHome(), "docker-compose.yml");
-}
-function defaultCodexHomeDir() {
-    return path.join(agentweaverHome(), ".codex-home");
-}
-function ensureRuntimeBindPath(targetPath, isDir) {
-    mkdirSync(path.dirname(targetPath), { recursive: true });
-    if (isDir) {
-        mkdirSync(targetPath, { recursive: true });
-    }
-    else if (!existsSync(targetPath)) {
-        writeFileSync(targetPath, "", "utf8");
-    }
-    return targetPath;
-}
-function defaultHostSshDir() {
-    const candidate = path.join(os.homedir(), ".ssh");
-    if (existsSync(candidate)) {
-        return candidate;
-    }
-    return ensureRuntimeBindPath(path.join(agentweaverHome(), ".runtime", "ssh"), true);
-}
-function defaultHostGitconfig() {
-    const candidate = path.join(os.homedir(), ".gitconfig");
-    if (existsSync(candidate)) {
-        return candidate;
-    }
-    return ensureRuntimeBindPath(path.join(agentweaverHome(), ".runtime", "gitconfig"), false);
-}
-function dockerRuntimeEnv() {
-    const env = { ...process.env };
-    env.AGENTWEAVER_HOME ??= agentweaverHome();
-    env.PROJECT_DIR ??= process.cwd();
-    env.CODEX_HOME_DIR ??= ensureRuntimeBindPath(defaultCodexHomeDir(), true);
-    env.HOST_SSH_DIR ??= defaultHostSshDir();
-    env.HOST_GITCONFIG ??= defaultHostGitconfig();
-    env.LOCAL_UID ??= typeof process.getuid === "function" ? String(process.getuid()) : "1000";
-    env.LOCAL_GID ??= typeof process.getgid === "function" ? String(process.getgid()) : "1000";
-    return env;
-}
-function commandExists(commandName) {
-    const result = spawnSync("bash", ["-lc", `command -v ${shellQuote(commandName)}`], { stdio: "ignore" });
-    return result.status === 0;
-}
-function shellQuote(value) {
-    return `'${value.replaceAll("'", `'\\''`)}'`;
-}
-function resolveCmd(commandName, envVarName) {
-    const configuredPath = process.env[envVarName];
-    if (configuredPath) {
-        accessSync(configuredPath, constants.X_OK);
-        return configuredPath;
-    }
-    const result = spawnSync("bash", ["-lc", `command -v ${shellQuote(commandName)}`], { encoding: "utf8" });
-    if (result.status === 0 && result.stdout.trim()) {
-        return result.stdout.trim().split(/\r?\n/)[0] ?? commandName;
-    }
-    throw new TaskRunnerError(`Missing required command: ${commandName}`);
-}
-function requireDockerCompose() {
-    if (!commandExists("docker")) {
-        throw new TaskRunnerError("Missing required command: docker");
-    }
-    const result = spawnSync("docker", ["compose", "version"], { stdio: "ignore" });
-    if (result.status !== 0) {
-        throw new TaskRunnerError("Missing required docker compose plugin");
-    }
-}
-function resolveDockerComposeCmd() {
-    const configured = process.env.DOCKER_COMPOSE_BIN?.trim() ?? "";
-    if (configured) {
-        const parts = splitArgs(configured);
-        if (parts.length === 0) {
-            throw new TaskRunnerError("DOCKER_COMPOSE_BIN is set but empty.");
-        }
-        const executable = parts[0] ?? "";
-        try {
-            if (path.isAbsolute(executable)) {
-                accessSync(executable, constants.X_OK);
-                return parts;
-            }
-        }
-        catch {
-            throw new TaskRunnerError(`Configured docker compose command is not executable: ${configured}`);
-        }
-        if (commandExists(executable)) {
-            return parts;
-        }
-        throw new TaskRunnerError(`Configured docker compose command is not executable: ${configured}`);
-    }
-    if (commandExists("docker-compose")) {
-        return ["docker-compose"];
-    }
-    requireDockerCompose();
-    return ["docker", "compose"];
-}
 function nextReviewIterationForTask(taskKey) {
     let maxIndex = 0;
     for (const entry of readdirSync(process.cwd(), { withFileTypes: true })) {
@@ -355,110 +268,6 @@ function latestReviewReplyIteration(taskKey) {
     }
     return maxIndex;
 }
-function formatCommand(argv, env) {
-    const envParts = Object.entries(env ?? {})
-        .filter(([key, value]) => value !== undefined && process.env[key] !== value)
-        .map(([key, value]) => `${key}=${shellQuote(value ?? "")}`);
-    const command = argv.map(shellQuote).join(" ");
-    return envParts.length > 0 ? `${envParts.join(" ")} ${command}` : command;
-}
-function formatDuration(ms) {
-    const totalSeconds = Math.max(0, Math.floor(ms / 1000));
-    const minutes = String(Math.floor(totalSeconds / 60)).padStart(2, "0");
-    const seconds = String(totalSeconds % 60).padStart(2, "0");
-    return `${minutes}:${seconds}`;
-}
-async function runCommand(argv, options = {}) {
-    const { env, dryRun = false, verbose = false, label, printFailureOutput = true } = options;
-    const outputAdapter = getOutputAdapter();
-    if (dryRun) {
-        outputAdapter.writeStdout(`${formatCommand(argv, env)}\n`);
-        return "";
-    }
-    if (verbose && outputAdapter.supportsPassthrough) {
-        await new Promise((resolve, reject) => {
-            const child = spawn(argv[0] ?? "", argv.slice(1), {
-                stdio: "inherit",
-                env,
-            });
-            child.on("exit", (code) => (code === 0 ? resolve() : reject(new Error(String(code ?? 1)))));
-            child.on("error", reject);
-        }).catch((error) => {
-            const code = Number.parseInt(error.message, 10);
-            throw Object.assign(new Error(`Command failed with exit code ${Number.isNaN(code) ? 1 : code}`), {
-                returnCode: Number.isNaN(code) ? 1 : code,
-                output: "",
-            });
-        });
-        return "";
-    }
-    const startedAt = Date.now();
-    const statusLabel = label ?? path.basename(argv[0] ?? argv.join(" "));
-    const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-    let frameIndex = 0;
-    let output = "";
-    const child = spawn(argv[0] ?? "", argv.slice(1), {
-        env,
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    child.stdout?.on("data", (chunk) => {
-        const text = String(chunk);
-        output += text;
-        if (!outputAdapter.supportsTransientStatus || verbose) {
-            outputAdapter.writeStdout(text);
-        }
-    });
-    child.stderr?.on("data", (chunk) => {
-        const text = String(chunk);
-        output += text;
-        if (!outputAdapter.supportsTransientStatus || verbose) {
-            outputAdapter.writeStderr(text);
-        }
-    });
-    if (!outputAdapter.supportsTransientStatus) {
-        outputAdapter.writeStdout(`Running ${statusLabel}\n`);
-    }
-    const timer = outputAdapter.supportsTransientStatus
-        ? setInterval(() => {
-            const elapsed = formatDuration(Date.now() - startedAt);
-            process.stdout.write(`\r${frames[frameIndex]} ${statusLabel} ${dim(elapsed)}`);
-            frameIndex = (frameIndex + 1) % frames.length;
-        }, 200)
-        : null;
-    try {
-        const exitCode = await new Promise((resolve, reject) => {
-            child.on("error", reject);
-            child.on("exit", (code) => resolve(code ?? 1));
-        });
-        if (timer) {
-            clearInterval(timer);
-            process.stdout.write(`\r${" ".repeat(80)}\r${formatDone(formatDuration(Date.now() - startedAt))}\n`);
-        }
-        else {
-            outputAdapter.writeStdout(`Done ${formatDuration(Date.now() - startedAt)}\n`);
-        }
-        if (exitCode !== 0) {
-            if (output && printFailureOutput) {
-                if (outputAdapter.supportsTransientStatus) {
-                    process.stderr.write(output);
-                    if (!output.endsWith("\n")) {
-                        process.stderr.write("\n");
-                    }
-                }
-            }
-            throw Object.assign(new Error(`Command failed with exit code ${exitCode}`), {
-                returnCode: exitCode,
-                output,
-            });
-        }
-        return output;
-    }
-    finally {
-        if (timer) {
-            clearInterval(timer);
-        }
-    }
-}
 function buildConfig(command, jiraRef, options = {}) {
     const jiraIssueKey = extractIssueKey(jiraRef);
     return {
@@ -469,8 +278,7 @@ function buildConfig(command, jiraRef, options = {}) {
         autoFromPhase: options.autoFromPhase ? validateAutoPhaseId(options.autoFromPhase) : null,
         dryRun: options.dryRun ?? false,
         verbose: options.verbose ?? false,
-        dockerComposeFile: defaultDockerComposeFile(),
-        dockerComposeCmd: [],
+        dockerComposeFile: defaultDockerComposeFile(PACKAGE_ROOT),
         codexCmd: process.env.CODEX_BIN ?? "codex",
         claudeCmd: process.env.CLAUDE_BIN ?? "claude",
         jiraIssueKey,
@@ -483,7 +291,6 @@ function buildConfig(command, jiraRef, options = {}) {
 function checkPrerequisites(config) {
     let codexCmd = config.codexCmd;
     let claudeCmd = config.claudeCmd;
-    let dockerComposeCmd = config.dockerComposeCmd;
     if (config.command === "plan" || config.command === "review") {
         codexCmd = resolveCmd("codex", "CODEX_BIN");
     }
@@ -491,12 +298,12 @@ function checkPrerequisites(config) {
         claudeCmd = resolveCmd("claude", "CLAUDE_BIN");
     }
     if (["implement", "review-fix", "test", "test-fix", "test-linter-fix"].includes(config.command)) {
-        dockerComposeCmd = resolveDockerComposeCmd();
+        resolveDockerComposeCmd();
         if (!existsSync(config.dockerComposeFile)) {
             throw new TaskRunnerError(`docker-compose file not found: ${config.dockerComposeFile}`);
         }
     }
-    return { codexCmd, claudeCmd, dockerComposeCmd };
+    return { codexCmd, claudeCmd };
 }
 function buildPhaseConfig(baseConfig, command) {
     return { ...baseConfig, command };
@@ -516,6 +323,99 @@ function configForAutoStep(baseConfig, step) {
     }
     return buildPhaseConfig(baseConfig, step.command);
 }
+async function runAutoStepViaFlow(config, step, codexCmd, claudeCmd, state) {
+    const context = createPipelineContext({
+        issueKey: config.taskKey,
+        jiraRef: config.jiraRef,
+        dryRun: config.dryRun,
+        verbose: config.verbose,
+        runtime: runtimeServices,
+    });
+    const onStepStart = async (flowStep) => {
+        state.currentStep = `${step.id}:${flowStep.id}`;
+        saveAutoPipelineState(state);
+    };
+    if (step.command === "plan") {
+        await runFlow(planFlowDefinition, context, {
+            jiraApiUrl: config.jiraApiUrl,
+            jiraTaskFile: config.jiraTaskFile,
+            taskKey: config.taskKey,
+            codexCmd,
+            ...(config.extraPrompt !== undefined ? { extraPrompt: config.extraPrompt } : {}),
+        }, { onStepStart });
+        return false;
+    }
+    if (step.command === "implement") {
+        const implementPrompt = formatPrompt(formatTemplate(IMPLEMENT_PROMPT_TEMPLATE, {
+            design_file: designFile(config.taskKey),
+            plan_file: planFile(config.taskKey),
+        }), config.extraPrompt);
+        await runFlow(implementFlowDefinition, context, {
+            dockerComposeFile: config.dockerComposeFile,
+            prompt: implementPrompt,
+            runFollowupVerify: false,
+            ...(!config.dryRun
+                ? {
+                    onVerifyBuildFailure: async (output) => {
+                        printError("Build verification failed");
+                        printSummary("Build Failure Summary", await summarizeBuildFailure(output));
+                    },
+                }
+                : {}),
+        }, { onStepStart });
+        return false;
+    }
+    if (step.command === "test") {
+        await runFlow(testFlowDefinition, context, {
+            taskKey: config.taskKey,
+            dockerComposeFile: config.dockerComposeFile,
+            ...(!config.dryRun
+                ? {
+                    onVerifyBuildFailure: async (output) => {
+                        printError("Build verification failed");
+                        printSummary("Build Failure Summary", await summarizeBuildFailure(output));
+                    },
+                }
+                : {}),
+        }, { onStepStart });
+        return false;
+    }
+    if (step.command === "review") {
+        const iteration = step.reviewIteration ?? nextReviewIterationForTask(config.taskKey);
+        const result = await runFlow(createReviewFlowDefinition(iteration), context, {
+            jiraTaskFile: config.jiraTaskFile,
+            taskKey: config.taskKey,
+            claudeCmd,
+            codexCmd,
+            ...(config.extraPrompt !== undefined ? { extraPrompt: config.extraPrompt } : {}),
+        }, { onStepStart });
+        return result.steps.find((candidate) => candidate.id === "check_ready_to_merge")?.result.metadata?.readyToMerge === true;
+    }
+    if (step.command === "review-fix") {
+        const latestIteration = step.reviewIteration ?? latestReviewReplyIteration(config.taskKey);
+        if (latestIteration === null) {
+            throw new TaskRunnerError(`Review-fix mode requires at least one review-reply-${config.taskKey}-N.md artifact.`);
+        }
+        await runFlow(createReviewFixFlowDefinition(latestIteration), context, {
+            taskKey: config.taskKey,
+            dockerComposeFile: config.dockerComposeFile,
+            latestIteration,
+            ...(config.reviewFixPoints !== undefined ? { reviewFixPoints: config.reviewFixPoints } : {}),
+            ...(config.extraPrompt !== undefined ? { extraPrompt: config.extraPrompt } : {}),
+            runFollowupVerify: false,
+            ...(!config.dryRun
+                ? {
+                    onVerifyBuildFailure: async (output) => {
+                        printError("Build verification failed");
+                        printSummary("Build Failure Summary", await summarizeBuildFailure(output));
+                    },
+                }
+                : {}),
+        }, { onStepStart });
+        return false;
+    }
+    throw new TaskRunnerError(`Unsupported auto step command: ${step.command}`);
+}
 function rewindAutoPipelineState(state, phaseId) {
     const targetPhaseId = validateAutoPhaseId(phaseId);
     let phaseSeen = false;
@@ -540,120 +440,20 @@ function rewindAutoPipelineState(state, phaseId) {
     state.currentStep = null;
     state.lastError = null;
 }
-async function runCodexInDocker(config, dockerComposeCmd, prompt, labelText) {
-    const dockerEnv = dockerRuntimeEnv();
-    dockerEnv.CODEX_PROMPT = prompt;
-    dockerEnv.CODEX_EXEC_FLAGS = `--model ${codexModel()} --dangerously-bypass-approvals-and-sandbox`;
-    printInfo(labelText);
-    printPrompt("Codex", prompt);
-    await runCommand([...dockerComposeCmd, "-f", config.dockerComposeFile, "run", "--rm", "codex-exec"], {
-        env: dockerEnv,
-        dryRun: config.dryRun,
-        verbose: config.verbose,
-        label: `codex:${codexModel()}`,
-    });
-}
-async function runVerifyBuildInDocker(config, dockerComposeCmd, labelText) {
-    printInfo(labelText);
-    try {
-        await runCommand([...dockerComposeCmd, "-f", config.dockerComposeFile, "run", "--rm", "verify-build"], {
-            env: dockerRuntimeEnv(),
-            dryRun: config.dryRun,
-            verbose: false,
-            label: "verify-build",
-            printFailureOutput: false,
-        });
-    }
-    catch (error) {
-        const returnCode = Number(error.returnCode ?? 1);
-        printError(`Build verification failed with exit code ${returnCode}`);
-        if (!config.dryRun) {
-            printSummary("Build Failure Summary", await summarizeBuildFailure(String(error.output ?? "")));
-        }
-        throw error;
-    }
-}
 function codexModel() {
     return process.env.CODEX_MODEL?.trim() || DEFAULT_CODEX_MODEL;
 }
 function claudeReviewModel() {
     return process.env.CLAUDE_REVIEW_MODEL?.trim() || DEFAULT_CLAUDE_REVIEW_MODEL;
 }
-function claudeSummaryModel() {
-    return process.env.CLAUDE_SUMMARY_MODEL?.trim() || DEFAULT_CLAUDE_SUMMARY_MODEL;
-}
-function truncateText(text, maxChars = 12000) {
-    return text.length <= maxChars ? text.trim() : text.trim().slice(-maxChars);
-}
-function fallbackBuildFailureSummary(output) {
-    const lines = output
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter(Boolean);
-    const tail = lines.length > 0 ? lines.slice(-8) : ["No build output captured."];
-    return `Не удалось получить summary через Claude.\n\nПоследние строки лога:\n${tail.join("\n")}`;
-}
 async function summarizeBuildFailure(output) {
-    if (!output.trim()) {
-        return "Build verification failed, but no output was captured.";
-    }
-    let claudeCmd;
-    try {
-        claudeCmd = resolveCmd("claude", "CLAUDE_BIN");
-    }
-    catch {
-        return fallbackBuildFailureSummary(output);
-    }
-    const prompt = "Ниже лог упавшей build verification.\n" +
-        "Сделай краткое резюме на русском языке, без воды.\n" +
-        "Нужно обязательно выделить:\n" +
-        "1. Где именно упало.\n" +
-        "2. Главную причину падения.\n" +
-        "3. Что нужно исправить дальше, если это очевидно.\n" +
-        "Ответ дай максимум 5 короткими пунктами.\n\n" +
-        `Лог:\n${truncateText(output)}`;
-    printInfo(`Summarizing build failure with Claude (${claudeSummaryModel()})`);
-    try {
-        const summary = await runCommand([claudeCmd, "--model", claudeSummaryModel(), "-p", prompt], {
-            env: { ...process.env },
-            dryRun: false,
-            verbose: false,
-            label: `claude:${claudeSummaryModel()}`,
-        });
-        return summary.trim() || fallbackBuildFailureSummary(output);
-    }
-    catch {
-        return fallbackBuildFailureSummary(output);
-    }
-}
-async function runClaudeSummary(claudeCmd, outputFile, prompt, verbose = false) {
-    printInfo(`Preparing summary in ${outputFile}`);
-    printPrompt("Claude", prompt);
-    await runCommand([claudeCmd, "--model", claudeSummaryModel(), "-p", "--allowedTools=Read,Write,Edit", prompt], {
-        env: { ...process.env },
+    return summarizeBuildFailureViaPipeline(createPipelineContext({
+        issueKey: "build-failure-summary",
+        jiraRef: "build-failure-summary",
         dryRun: false,
-        verbose,
-        label: `claude:${claudeSummaryModel()}`,
-    });
-    requireArtifacts([outputFile], `Claude summary did not produce ${outputFile}.`);
-    return readFileSync(outputFile, "utf8").trim();
-}
-async function summarizeTask(jiraRef) {
-    const config = buildConfig("plan", jiraRef);
-    const claudeCmd = resolveCmd("claude", "CLAUDE_BIN");
-    await fetchJiraIssue(config.jiraApiUrl, config.jiraTaskFile);
-    const summaryPrompt = formatTemplate(TASK_SUMMARY_PROMPT_TEMPLATE, {
-        jira_task_file: config.jiraTaskFile,
-        task_summary_file: taskSummaryFile(config.taskKey),
-    });
-    const summaryText = await runClaudeSummary(claudeCmd, taskSummaryFile(config.taskKey), summaryPrompt);
-    return { issueKey: config.jiraIssueKey, summaryText };
-}
-function resolveTaskIdentity(jiraRef) {
-    const config = buildConfig("plan", jiraRef);
-    const summaryPath = taskSummaryFile(config.taskKey);
-    const summaryText = existsSync(summaryPath) ? readFileSync(summaryPath, "utf8").trim() : "";
-    return { issueKey: config.jiraIssueKey, summaryText };
+        verbose: false,
+        runtime: runtimeServices,
+    }), output);
 }
 async function executeCommand(config, runFollowupVerify = true) {
     if (config.command === "auto") {
@@ -674,16 +474,10 @@ async function executeCommand(config, runFollowupVerify = true) {
         printPanel("Auto Reset", removed ? `State file ${autoStateFile(config.taskKey)} removed.` : "No auto state file found.", "yellow");
         return false;
     }
-    const { codexCmd, claudeCmd, dockerComposeCmd } = checkPrerequisites(config);
+    const { codexCmd, claudeCmd } = checkPrerequisites(config);
     process.env.JIRA_BROWSE_URL = config.jiraBrowseUrl;
     process.env.JIRA_API_URL = config.jiraApiUrl;
     process.env.JIRA_TASK_FILE = config.jiraTaskFile;
-    const planPrompt = formatPrompt(formatTemplate(PLAN_PROMPT_TEMPLATE, {
-        jira_task_file: config.jiraTaskFile,
-        design_file: designFile(config.taskKey),
-        plan_file: planFile(config.taskKey),
-        qa_file: qaFile(config.taskKey),
-    }), config.extraPrompt);
     const implementPrompt = formatPrompt(formatTemplate(IMPLEMENT_PROMPT_TEMPLATE, {
         design_file: designFile(config.taskKey),
         plan_file: planFile(config.taskKey),
@@ -694,149 +488,149 @@ async function executeCommand(config, runFollowupVerify = true) {
             process.stdout.write(`Resolved Jira API URL: ${config.jiraApiUrl}\n`);
             process.stdout.write(`Saving Jira issue JSON to: ${config.jiraTaskFile}\n`);
         }
-        await fetchJiraIssue(config.jiraApiUrl, config.jiraTaskFile);
-        printInfo("Running Codex planning mode");
-        printPrompt("Codex", planPrompt);
-        await runCommand([codexCmd, "exec", "--model", codexModel(), "--full-auto", planPrompt], {
-            env: { ...process.env },
+        await runPlanFlow(createPipelineContext({
+            issueKey: config.taskKey,
+            jiraRef: config.jiraRef,
             dryRun: config.dryRun,
             verbose: config.verbose,
-            label: `codex:${codexModel()}`,
+            runtime: runtimeServices,
+        }), {
+            jiraApiUrl: config.jiraApiUrl,
+            jiraTaskFile: config.jiraTaskFile,
+            taskKey: config.taskKey,
+            codexCmd,
+            ...(config.extraPrompt !== undefined ? { extraPrompt: config.extraPrompt } : {}),
         });
-        requireArtifacts(planArtifacts(config.taskKey), "Plan mode did not produce the required artifacts.");
         return false;
     }
     if (config.command === "implement") {
         requireJiraTaskFile(config.jiraTaskFile);
         requireArtifacts(planArtifacts(config.taskKey), "Implement mode requires plan artifacts from the planning phase.");
-        await runCodexInDocker(config, dockerComposeCmd, implementPrompt, "Running Codex implementation mode in isolated Docker");
-        if (runFollowupVerify) {
-            await runVerifyBuildInDocker(config, dockerComposeCmd, "Running build verification in isolated Docker");
-        }
+        await runImplementFlow(createPipelineContext({
+            issueKey: config.taskKey,
+            jiraRef: config.jiraRef,
+            dryRun: config.dryRun,
+            verbose: config.verbose,
+            runtime: runtimeServices,
+        }), {
+            dockerComposeFile: config.dockerComposeFile,
+            prompt: implementPrompt,
+            runFollowupVerify,
+            ...(!config.dryRun
+                ? {
+                    onVerifyBuildFailure: async (output) => {
+                        printError("Build verification failed");
+                        printSummary("Build Failure Summary", await summarizeBuildFailure(output));
+                    },
+                }
+                : {}),
+        });
         return false;
     }
     if (config.command === "review") {
         requireJiraTaskFile(config.jiraTaskFile);
-        requireArtifacts(planArtifacts(config.taskKey), "Review mode requires plan artifacts from the planning phase.");
-        const iteration = nextReviewIterationForTask(config.taskKey);
-        const reviewFile = artifactFile("review", config.taskKey, iteration);
-        const reviewReplyFile = artifactFile("review-reply", config.taskKey, iteration);
-        const reviewSummaryFile = artifactFile("review-summary", config.taskKey, iteration);
-        const reviewReplySummaryFile = artifactFile("review-reply-summary", config.taskKey, iteration);
-        const claudePrompt = formatPrompt(formatTemplate(REVIEW_PROMPT_TEMPLATE, {
-            jira_task_file: config.jiraTaskFile,
-            design_file: designFile(config.taskKey),
-            plan_file: planFile(config.taskKey),
-            review_file: reviewFile,
-        }), config.extraPrompt);
-        const codexReplyPrompt = formatPrompt(formatTemplate(REVIEW_REPLY_PROMPT_TEMPLATE, {
-            review_file: reviewFile,
-            jira_task_file: config.jiraTaskFile,
-            design_file: designFile(config.taskKey),
-            plan_file: planFile(config.taskKey),
-            review_reply_file: reviewReplyFile,
-        }), config.extraPrompt);
-        printInfo(`Running Claude review mode (iteration ${iteration})`);
-        printPrompt("Claude", claudePrompt);
-        await runCommand([
-            claudeCmd,
-            "--model",
-            claudeReviewModel(),
-            "-p",
-            "--allowedTools=Read,Write,Edit",
-            "--output-format",
-            "stream-json",
-            "--verbose",
-            "--include-partial-messages",
-            claudePrompt,
-        ], {
-            env: { ...process.env },
-            dryRun: config.dryRun,
-            verbose: config.verbose,
-            label: `claude:${claudeReviewModel()}`,
-        });
-        if (!config.dryRun) {
-            requireArtifacts([reviewFile], "Claude review did not produce the required review artifact.");
-            const reviewSummaryText = await runClaudeSummary(claudeCmd, reviewSummaryFile, formatTemplate(REVIEW_SUMMARY_PROMPT_TEMPLATE, {
-                review_file: reviewFile,
-                review_summary_file: reviewSummaryFile,
-            }), config.verbose);
-            printSummary("Claude Comments", reviewSummaryText);
-        }
-        printInfo(`Running Codex review reply mode (iteration ${iteration})`);
-        printPrompt("Codex", codexReplyPrompt);
-        await runCommand([codexCmd, "exec", "--model", codexModel(), "--full-auto", codexReplyPrompt], {
-            env: { ...process.env },
+        const result = await runReviewFlow(createPipelineContext({
+            issueKey: config.taskKey,
+            jiraRef: config.jiraRef,
             dryRun: config.dryRun,
             verbose: config.verbose,
-            label: `codex:${codexModel()}`,
+            runtime: runtimeServices,
+        }), {
+            jiraTaskFile: config.jiraTaskFile,
+            taskKey: config.taskKey,
+            claudeCmd,
+            codexCmd,
+            ...(config.extraPrompt !== undefined ? { extraPrompt: config.extraPrompt } : {}),
         });
-        let readyToMerge = false;
-        if (!config.dryRun) {
-            requireArtifacts([reviewReplyFile], "Codex review reply did not produce the required review-reply artifact.");
-            const reviewReplySummaryText = await runClaudeSummary(claudeCmd, reviewReplySummaryFile, formatTemplate(REVIEW_REPLY_SUMMARY_PROMPT_TEMPLATE, {
-                review_reply_file: reviewReplyFile,
-                review_reply_summary_file: reviewReplySummaryFile,
-            }), config.verbose);
-            printSummary("Codex Reply Summary", reviewReplySummaryText);
-            if (existsSync(READY_TO_MERGE_FILE)) {
-                printPanel("Ready To Merge", "Изменения готовы к merge\nФайл ready-to-merge.md создан.", "green");
-                readyToMerge = true;
-            }
-        }
-        return readyToMerge;
+        return result.readyToMerge;
     }
     if (config.command === "review-fix") {
         requireJiraTaskFile(config.jiraTaskFile);
-        requireArtifacts(planArtifacts(config.taskKey), "Review-fix mode requires plan artifacts from the planning phase.");
-        const latestIteration = latestReviewReplyIteration(config.taskKey);
-        if (latestIteration === null) {
-            throw new TaskRunnerError(`Review-fix mode requires at least one review-reply-${config.taskKey}-N.md artifact.`);
-        }
-        const reviewReplyFile = artifactFile("review-reply", config.taskKey, latestIteration);
-        const reviewFixFile = artifactFile("review-fix", config.taskKey, latestIteration);
-        const reviewFixPrompt = formatPrompt(formatTemplate(REVIEW_FIX_PROMPT_TEMPLATE, {
-            review_reply_file: reviewReplyFile,
-            items: config.reviewFixPoints ?? "",
-            review_fix_file: reviewFixFile,
-        }), config.extraPrompt);
-        await runCodexInDocker(config, dockerComposeCmd, reviewFixPrompt, `Running Codex review-fix mode in isolated Docker (iteration ${latestIteration})`);
-        if (!config.dryRun) {
-            requireArtifacts([reviewFixFile], "Review-fix mode did not produce the required review-fix artifact.");
-        }
-        if (runFollowupVerify) {
-            await runVerifyBuildInDocker(config, dockerComposeCmd, "Running build verification in isolated Docker");
-        }
+        await runReviewFixFlow(createPipelineContext({
+            issueKey: config.taskKey,
+            jiraRef: config.jiraRef,
+            dryRun: config.dryRun,
+            verbose: config.verbose,
+            runtime: runtimeServices,
+        }), {
+            taskKey: config.taskKey,
+            dockerComposeFile: config.dockerComposeFile,
+            latestIteration: latestReviewReplyIteration(config.taskKey),
+            ...(config.extraPrompt !== undefined ? { extraPrompt: config.extraPrompt } : {}),
+            ...(config.reviewFixPoints !== undefined ? { reviewFixPoints: config.reviewFixPoints } : {}),
+            runFollowupVerify,
+            ...(!config.dryRun
+                ? {
+                    onVerifyBuildFailure: async (output) => {
+                        printError("Build verification failed");
+                        printSummary("Build Failure Summary", await summarizeBuildFailure(output));
+                    },
+                }
+                : {}),
+        });
         return false;
     }
     if (config.command === "test") {
         requireJiraTaskFile(config.jiraTaskFile);
-        requireArtifacts(planArtifacts(config.taskKey), "Test mode requires plan artifacts from the planning phase.");
-        await runVerifyBuildInDocker(config, dockerComposeCmd, "Running build verification in isolated Docker");
+        await runTestFlow(createPipelineContext({
+            issueKey: config.taskKey,
+            jiraRef: config.jiraRef,
+            dryRun: config.dryRun,
+            verbose: config.verbose,
+            runtime: runtimeServices,
+        }), {
+            taskKey: config.taskKey,
+            dockerComposeFile: config.dockerComposeFile,
+            ...(!config.dryRun
+                ? {
+                    onVerifyBuildFailure: async (output) => {
+                        printError("Build verification failed");
+                        printSummary("Build Failure Summary", await summarizeBuildFailure(output));
+                    },
+                }
+                : {}),
+        });
         return false;
     }
     if (config.command === "test-fix" || config.command === "test-linter-fix") {
         requireJiraTaskFile(config.jiraTaskFile);
-        requireArtifacts(planArtifacts(config.taskKey), `${config.command} mode requires plan artifacts from the planning phase.`);
-        const prompt = formatPrompt(config.command === "test-fix" ? TEST_FIX_PROMPT_TEMPLATE : TEST_LINTER_FIX_PROMPT_TEMPLATE, config.extraPrompt);
-        await runCodexInDocker(config, dockerComposeCmd, prompt, `Running Codex ${config.command} mode in isolated Docker`);
+        await runTestFixFlow(createPipelineContext({
+            issueKey: config.taskKey,
+            jiraRef: config.jiraRef,
+            dryRun: config.dryRun,
+            verbose: config.verbose,
+            runtime: runtimeServices,
+        }), {
+            command: config.command,
+            taskKey: config.taskKey,
+            dockerComposeFile: config.dockerComposeFile,
+            ...(config.extraPrompt !== undefined ? { extraPrompt: config.extraPrompt } : {}),
+        });
         return false;
     }
     throw new TaskRunnerError(`Unsupported command: ${config.command}`);
 }
 async function runAutoPipelineDryRun(config) {
+    const { codexCmd, claudeCmd } = checkPrerequisites(config);
     printInfo("Dry-run auto pipeline: plan -> implement -> test -> review/review-fix/test");
-    await executeCommand(buildPhaseConfig(config, "plan"));
-    await executeCommand(buildPhaseConfig(config, "implement"), false);
-    await executeCommand(buildPhaseConfig(config, "test"));
+    const dryState = createAutoPipelineState(config);
+    await runAutoStepViaFlow(buildPhaseConfig(config, "plan"), dryState.steps[0], codexCmd, claudeCmd, dryState);
+    await runAutoStepViaFlow(buildPhaseConfig(config, "implement"), dryState.steps[1], codexCmd, claudeCmd, dryState);
+    await runAutoStepViaFlow(buildPhaseConfig(config, "test"), dryState.steps[2], codexCmd, claudeCmd, dryState);
     for (let iteration = 1; iteration <= AUTO_MAX_REVIEW_ITERATIONS; iteration += 1) {
         printInfo(`Dry-run auto review iteration ${iteration}/${AUTO_MAX_REVIEW_ITERATIONS}`);
-        await executeCommand(buildPhaseConfig(config, "review"));
-        await executeCommand({
+        const reviewStep = dryState.steps.find((step) => step.id === `review_${iteration}`);
+        const reviewFixStep = dryState.steps.find((step) => step.id === `review_fix_${iteration}`);
+        const testStep = dryState.steps.find((step) => step.id === `test_after_review_fix_${iteration}`);
+        if (!reviewStep || !reviewFixStep || !testStep) {
+            throw new TaskRunnerError(`Missing auto dry-run steps for iteration ${iteration}`);
+        }
+        await runAutoStepViaFlow(buildPhaseConfig(config, "review"), reviewStep, codexCmd, claudeCmd, dryState);
+        await runAutoStepViaFlow({
             ...buildPhaseConfig(config, "review-fix"),
             extraPrompt: appendPromptText(config.extraPrompt, AUTO_REVIEW_FIX_EXTRA_PROMPT),
-        }, false);
-        await executeCommand(buildPhaseConfig(config, "test"));
+        }, reviewFixStep, codexCmd, claudeCmd, dryState);
+        await runAutoStepViaFlow(buildPhaseConfig(config, "test"), testStep, codexCmd, claudeCmd, dryState);
     }
 }
 async function runAutoPipeline(config) {
@@ -844,6 +638,7 @@ async function runAutoPipeline(config) {
         await runAutoPipelineDryRun(config);
         return;
     }
+    const { codexCmd, claudeCmd } = checkPrerequisites(config);
     let state = loadAutoPipelineState(config) ?? createAutoPipelineState(config);
     if (config.autoFromPhase) {
         rewindAutoPipelineState(state, config.autoFromPhase);
@@ -887,7 +682,7 @@ async function runAutoPipeline(config) {
         saveAutoPipelineState(state);
         try {
             printInfo(`Running auto step: ${step.id}`);
-            const readyToMerge = await executeCommand(configForAutoStep(config, step), !["implement", "review-fix"].includes(step.command));
+            const readyToMerge = await runAutoStepViaFlow(configForAutoStep(config, step), step, codexCmd, claudeCmd, state);
             step.status = "done";
             step.finishedAt = nowIso8601();
             step.returnCode = 0;
@@ -1098,7 +893,6 @@ async function ensureHistoryFile() {
 async function runInteractive(jiraRef, forceRefresh = false) {
     const config = buildConfig("plan", jiraRef);
     const jiraTaskPath = config.jiraTaskFile;
-    const taskIdentity = forceRefresh || !existsSync(jiraTaskPath) ? await summarizeTask(jiraRef) : resolveTaskIdentity(jiraRef);
     await ensureHistoryFile();
     const historyLines = (await readFile(HISTORY_FILE, "utf8"))
         .split(/\r?\n/)
@@ -1120,8 +914,8 @@ async function runInteractive(jiraRef, forceRefresh = false) {
         "/exit",
     ];
     const ui = new InteractiveUi({
-        issueKey: taskIdentity.issueKey,
-        summaryText: taskIdentity.summaryText || "Task summary is not available yet. Run /plan or refresh Jira data.",
+        issueKey: config.jiraIssueKey,
+        summaryText: "Starting interactive session...",
         cwd: process.cwd(),
         commands: commandList,
         onSubmit: async (line) => {
@@ -1159,14 +953,40 @@ async function runInteractive(jiraRef, forceRefresh = false) {
         },
     }, historyLines);
     ui.mount();
-    printInfo(`Interactive mode for ${taskIdentity.issueKey}`);
-    if (taskIdentity.summaryText) {
-        printInfo("Task summary loaded.");
+    printInfo(`Interactive mode for ${config.jiraIssueKey}`);
+    printInfo("Use /help to see commands.");
+    try {
+        ui.setBusy(true, "preflight");
+        await runPreflightFlow(createPipelineContext({
+            issueKey: config.taskKey,
+            jiraRef: config.jiraRef,
+            dryRun: false,
+            verbose: config.verbose,
+            runtime: runtimeServices,
+            setSummary: (markdown) => {
+                ui.setSummary(markdown);
+            },
+        }), {
+            jiraApiUrl: config.jiraApiUrl,
+            jiraTaskFile: config.jiraTaskFile,
+            taskKey: config.taskKey,
+            forceRefresh,
+        });
+        if (!existsSync(taskSummaryFile(config.taskKey))) {
+            ui.setSummary("Task summary is not available yet. Run `/plan` or refresh Jira data.");
+        }
     }
-    else {
-        printInfo("Task summary is not available yet.");
+    catch (error) {
+        if (error instanceof TaskRunnerError) {
+            printError(error.message);
+        }
+        else {
+            throw error;
+        }
+    }
+    finally {
+        ui.setBusy(false);
     }
-    printInfo("Use /help to see commands.");
     return await new Promise((resolve, reject) => {
         const interval = setInterval(() => {
             if (!exiting) {