agentweaver 0.1.0 → 0.1.3

package/dist/index.js

@@ -1,17 +1,22 @@
 #!/usr/bin/env node
-import { accessSync, constants, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { appendFile, readFile } from "node:fs/promises";
-import os from "node:os";
+import { existsSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 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, autoStateFile, ensureTaskWorkspaceDir, jiraTaskFile, planArtifacts, readyToMergeFile, requireArtifacts, taskWorkspaceDir, 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 { summarizeBuildFailure as summarizeBuildFailureViaPipeline } from "./pipeline/build-failure-summary.js";
+import { createPipelineContext } from "./pipeline/context.js";
+import { loadAutoFlow } from "./pipeline/auto-flow.js";
+import { loadDeclarativeFlow } from "./pipeline/declarative-flows.js";
+import { findPhaseById, runExpandedPhase } from "./pipeline/declarative-flow-runner.js";
+import { runPreflightFlow } from "./pipeline/flows/preflight-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, setFlowExecutionState } from "./tui.js";
 const COMMANDS = [
     "plan",
     "implement",
@@ -24,14 +29,15 @@ const COMMANDS = [
     "auto-status",
     "auto-reset",
 ];
-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 AUTO_STATE_SCHEMA_VERSION = 2;
 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>
@@ -50,10 +56,11 @@ function usage() {
   agentweaver auto-reset <jira-browse-url|jira-issue-key>
 
 Interactive Mode:
-  When started with only a Jira task, the script opens an interactive shell.
-  Available slash commands: /plan, /implement, /review, /review-fix, /test, /test-fix, /test-linter-fix, /auto, /auto-status, /auto-reset, /help, /exit
+  When started with only a Jira task, the script opens an interactive UI.
+  Use Up/Down to select a flow, Enter to confirm launch, h for help, q to exit.
 
 Flags:
+  --version       Show package version
   --force         In interactive mode, force refresh Jira task and task summary
   --dry           Fetch Jira task, but print docker/codex/claude commands instead of executing them
   --verbose       Show live stdout/stderr of launched commands
@@ -69,8 +76,15 @@ Optional environment variables:
   CODEX_BIN
   CODEX_MODEL
   CLAUDE_BIN
-  CLAUDE_REVIEW_MODEL
-  CLAUDE_SUMMARY_MODEL`;
+  CLAUDE_MODEL`;
+}
+function packageVersion() {
+    const packageJsonPath = path.join(PACKAGE_ROOT, "package.json");
+    const raw = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    if (typeof raw.version !== "string" || !raw.version.trim()) {
+        throw new TaskRunnerError(`Package version is missing in ${packageJsonPath}`);
+    }
+    return raw.version;
 }
 function nowIso8601() {
     return new Date().toISOString();
@@ -78,24 +92,14 @@ function nowIso8601() {
 function normalizeAutoPhaseId(phaseId) {
     return phaseId.trim().toLowerCase().replaceAll("-", "_");
 }
-function buildAutoSteps(maxReviewIterations = AUTO_MAX_REVIEW_ITERATIONS) {
-    const steps = [
-        { id: "plan", command: "plan", status: "pending" },
-        { id: "implement", command: "implement", status: "pending" },
-        { id: "test_after_implement", command: "test", status: "pending" },
-    ];
-    for (let iteration = 1; iteration <= maxReviewIterations; iteration += 1) {
-        steps.push({ id: `review_${iteration}`, command: "review", status: "pending", reviewIteration: iteration }, { id: `review_fix_${iteration}`, command: "review-fix", status: "pending", reviewIteration: iteration }, {
-            id: `test_after_review_fix_${iteration}`,
-            command: "test",
-            status: "pending",
-            reviewIteration: iteration,
-        });
-    }
-    return steps;
+function buildAutoSteps() {
+    return loadAutoFlow().phases.map((phase) => ({
+        id: phase.id,
+        status: "pending",
+    }));
 }
-function autoPhaseIds(maxReviewIterations = AUTO_MAX_REVIEW_ITERATIONS) {
-    return buildAutoSteps(maxReviewIterations).map((step) => step.id);
+function autoPhaseIds() {
+    return buildAutoSteps().map((step) => step.id);
 }
 function validateAutoPhaseId(phaseId) {
     const normalized = normalizeAutoPhaseId(phaseId);
@@ -104,19 +108,46 @@ function validateAutoPhaseId(phaseId) {
     }
     return normalized;
 }
-function autoStateFile(taskKey) {
-    return path.join(process.cwd(), `.agentweaver-state-${taskKey}.json`);
-}
 function createAutoPipelineState(config) {
+    const autoFlow = loadAutoFlow();
+    const maxReviewIterations = autoFlow.phases.filter((phase) => /^review_\d+$/.test(phase.id)).length;
     return {
         schemaVersion: AUTO_STATE_SCHEMA_VERSION,
         issueKey: config.taskKey,
         jiraRef: config.jiraRef,
         status: "pending",
         currentStep: null,
-        maxReviewIterations: AUTO_MAX_REVIEW_ITERATIONS,
+        maxReviewIterations,
         updatedAt: nowIso8601(),
         steps: buildAutoSteps(),
+        executionState: {
+            flowKind: autoFlow.kind,
+            flowVersion: autoFlow.version,
+            terminated: false,
+            phases: [],
+        },
+    };
+}
+function stripExecutionStatePayload(executionState) {
+    return {
+        flowKind: executionState.flowKind,
+        flowVersion: executionState.flowVersion,
+        terminated: executionState.terminated,
+        ...(executionState.terminationReason ? { terminationReason: executionState.terminationReason } : {}),
+        phases: executionState.phases.map((phase) => ({
+            id: phase.id,
+            status: phase.status,
+            repeatVars: { ...phase.repeatVars },
+            ...(phase.startedAt ? { startedAt: phase.startedAt } : {}),
+            ...(phase.finishedAt ? { finishedAt: phase.finishedAt } : {}),
+            steps: phase.steps.map((step) => ({
+                id: step.id,
+                status: step.status,
+                ...(step.startedAt ? { startedAt: step.startedAt } : {}),
+                ...(step.finishedAt ? { finishedAt: step.finishedAt } : {}),
+                ...(step.stopFlow !== undefined ? { stopFlow: step.stopFlow } : {}),
+            })),
+        })),
     };
 }
 function loadAutoPipelineState(config) {
@@ -138,11 +169,29 @@ function loadAutoPipelineState(config) {
     if (state.schemaVersion !== AUTO_STATE_SCHEMA_VERSION) {
         throw new TaskRunnerError(`Unsupported auto state schema in ${filePath}: ${state.schemaVersion}`);
     }
+    if (!state.executionState) {
+        const autoFlow = loadAutoFlow();
+        state.executionState = {
+            flowKind: autoFlow.kind,
+            flowVersion: autoFlow.version,
+            terminated: false,
+            phases: [],
+        };
+    }
+    syncAutoStepsFromExecutionState(state);
     return state;
 }
 function saveAutoPipelineState(state) {
     state.updatedAt = nowIso8601();
-    writeFileSync(autoStateFile(state.issueKey), `${JSON.stringify(state, null, 2)}\n`, "utf8");
+    ensureTaskWorkspaceDir(state.issueKey);
+    writeFileSync(autoStateFile(state.issueKey), `${JSON.stringify({
+        ...state,
+        executionState: stripExecutionStatePayload(state.executionState),
+    }, null, 2)}\n`, "utf8");
+}
+function syncAndSaveAutoPipelineState(state) {
+    syncAutoStepsFromExecutionState(state);
+    saveAutoPipelineState(state);
 }
 function resetAutoPipelineState(config) {
     const filePath = autoStateFile(config.taskKey);
@@ -155,28 +204,42 @@ function resetAutoPipelineState(config) {
 function nextAutoStep(state) {
     return state.steps.find((step) => ["running", "failed", "pending"].includes(step.status)) ?? null;
 }
-function markAutoStepSkipped(step, note) {
-    step.status = "skipped";
-    step.note = note;
-    step.finishedAt = nowIso8601();
-}
-function skipAutoStepsAfterReadyToMerge(state, currentStepId) {
-    let seenCurrent = false;
-    for (const step of state.steps) {
-        if (!seenCurrent) {
-            seenCurrent = step.id === currentStepId;
-            continue;
-        }
-        if (step.status === "pending") {
-            markAutoStepSkipped(step, "ready-to-merge detected");
+function findCurrentExecutionStep(state) {
+    for (const phase of state.executionState.phases) {
+        const runningStep = phase.steps.find((step) => step.status === "running");
+        if (runningStep) {
+            return `${phase.id}:${runningStep.id}`;
         }
     }
+    return null;
+}
+function deriveAutoPipelineStatus(state) {
+    if (state.lastError || state.steps.some((candidate) => candidate.status === "failed")) {
+        return "blocked";
+    }
+    if (state.executionState.terminated) {
+        return "completed";
+    }
+    if (state.steps.some((candidate) => candidate.status === "running")) {
+        return "running";
+    }
+    if (state.steps.some((candidate) => candidate.status === "pending")) {
+        return "pending";
+    }
+    if (state.steps.some((candidate) => candidate.status === "skipped")) {
+        return "completed";
+    }
+    if (state.steps.every((candidate) => candidate.status === "done")) {
+        return "completed";
+    }
+    return state.status;
 }
 function printAutoState(state) {
+    const currentStep = findCurrentExecutionStep(state) ?? state.currentStep ?? "-";
     const lines = [
         `Issue: ${state.issueKey}`,
-        `Status: ${state.status}`,
-        `Current step: ${state.currentStep ?? "-"}`,
+        `Status: ${deriveAutoPipelineStatus(state)}`,
+        `Current step: ${currentStep}`,
         `Updated: ${state.updatedAt}`,
     ];
     if (state.lastError) {
@@ -185,14 +248,42 @@ function printAutoState(state) {
     lines.push("");
     for (const step of state.steps) {
         lines.push(`[${step.status}] ${step.id}${step.note ? ` (${step.note})` : ""}`);
+        const phaseState = state.executionState.phases.find((candidate) => candidate.id === step.id);
+        for (const childStep of phaseState?.steps ?? []) {
+            lines.push(`  - [${childStep.status}] ${childStep.id}`);
+        }
+    }
+    if (state.executionState.terminated) {
+        lines.push("", `Execution terminated: ${state.executionState.terminationReason ?? "yes"}`);
     }
     printPanel("Auto Status", lines.join("\n"), "cyan");
 }
-function printAutoPhasesHelp() {
-    const phaseLines = ["Available auto phases:", "", "plan", "implement", "test_after_implement"];
-    for (let iteration = 1; iteration <= AUTO_MAX_REVIEW_ITERATIONS; iteration += 1) {
-        phaseLines.push(`review_${iteration}`, `review_fix_${iteration}`, `test_after_review_fix_${iteration}`);
+function syncAutoStepsFromExecutionState(state) {
+    for (const step of state.steps) {
+        const phaseState = state.executionState.phases.find((candidate) => candidate.id === step.id);
+        if (!phaseState) {
+            continue;
+        }
+        step.status = phaseState.status;
+        step.startedAt = phaseState.startedAt ?? null;
+        step.finishedAt = phaseState.finishedAt ?? null;
+        step.note = null;
+        if (phaseState.status === "skipped") {
+            step.note = "condition not met";
+            step.returnCode ??= 0;
+        }
+        else if (phaseState.status === "done") {
+            step.returnCode ??= 0;
+            if (state.executionState.terminated && state.executionState.terminationReason?.startsWith(`Stopped by ${step.id}:`)) {
+                step.note = "stop condition met";
+            }
+        }
     }
+    state.currentStep = findCurrentExecutionStep(state);
+    state.status = deriveAutoPipelineStatus(state);
+}
+function printAutoPhasesHelp() {
+    const phaseLines = ["Available auto phases:", "", ...autoPhaseIds()];
     phaseLines.push("", "You can resume auto from a phase with:", "agentweaver auto --from <phase> <jira>", "or in interactive mode:", "/auto --from <phase>");
     printPanel("Auto Phases", phaseLines.join("\n"), "magenta");
 }
@@ -224,113 +315,13 @@ 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 })) {
+    const workspaceDir = taskWorkspaceDir(taskKey);
+    if (!existsSync(workspaceDir)) {
+        return 1;
+    }
+    for (const entry of readdirSync(workspaceDir, { withFileTypes: true })) {
         if (!entry.isFile()) {
             continue;
         }
@@ -343,7 +334,11 @@ function nextReviewIterationForTask(taskKey) {
 }
 function latestReviewReplyIteration(taskKey) {
     let maxIndex = null;
-    for (const entry of readdirSync(process.cwd(), { withFileTypes: true })) {
+    const workspaceDir = taskWorkspaceDir(taskKey);
+    if (!existsSync(workspaceDir)) {
+        return null;
+    }
+    for (const entry of readdirSync(workspaceDir, { withFileTypes: true })) {
         if (!entry.isFile()) {
             continue;
         }
@@ -355,112 +350,9 @@ 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);
+    ensureTaskWorkspaceDir(jiraIssueKey);
     return {
         command,
         jiraRef,
@@ -469,52 +361,158 @@ function buildConfig(command, jiraRef, options = {}) {
         autoFromPhase: options.autoFromPhase ? validateAutoPhaseId(options.autoFromPhase) : null,
         dryRun: options.dryRun ?? false,
         verbose: options.verbose ?? false,
-        dockerComposeFile: defaultDockerComposeFile(),
-        dockerComposeCmd: [],
-        codexCmd: process.env.CODEX_BIN ?? "codex",
-        claudeCmd: process.env.CLAUDE_BIN ?? "claude",
+        dockerComposeFile: defaultDockerComposeFile(PACKAGE_ROOT),
         jiraIssueKey,
         taskKey: jiraIssueKey,
         jiraBrowseUrl: buildJiraBrowseUrl(jiraRef),
         jiraApiUrl: buildJiraApiUrl(jiraRef),
-        jiraTaskFile: `./${jiraIssueKey}.json`,
+        jiraTaskFile: jiraTaskFile(jiraIssueKey),
     };
 }
 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");
+        resolveCmd("codex", "CODEX_BIN");
     }
     if (config.command === "review") {
-        claudeCmd = resolveCmd("claude", "CLAUDE_BIN");
+        resolveCmd("claude", "CLAUDE_BIN");
     }
-    if (["implement", "review-fix", "test", "test-fix", "test-linter-fix"].includes(config.command)) {
-        dockerComposeCmd = resolveDockerComposeCmd();
+    if (["implement", "review-fix", "test"].includes(config.command)) {
+        resolveDockerComposeCmd();
         if (!existsSync(config.dockerComposeFile)) {
             throw new TaskRunnerError(`docker-compose file not found: ${config.dockerComposeFile}`);
         }
     }
-    return { codexCmd, claudeCmd, dockerComposeCmd };
 }
-function buildPhaseConfig(baseConfig, command) {
-    return { ...baseConfig, command };
+function checkAutoPrerequisites(config) {
+    resolveCmd("codex", "CODEX_BIN");
+    resolveCmd("claude", "CLAUDE_BIN");
+    resolveDockerComposeCmd();
+    if (!existsSync(config.dockerComposeFile)) {
+        throw new TaskRunnerError(`docker-compose file not found: ${config.dockerComposeFile}`);
+    }
+}
+function autoFlowParams(config) {
+    return {
+        jiraApiUrl: config.jiraApiUrl,
+        taskKey: config.taskKey,
+        dockerComposeFile: config.dockerComposeFile,
+        extraPrompt: config.extraPrompt,
+        reviewFixPoints: config.reviewFixPoints,
+    };
+}
+function declarativeFlowDefinition(id, label, fileName) {
+    const flow = loadDeclarativeFlow(fileName);
+    return {
+        id,
+        label,
+        phases: flow.phases.map((phase) => ({
+            id: phase.id,
+            repeatVars: Object.fromEntries(Object.entries(phase.repeatVars).map(([key, value]) => [key, value])),
+            steps: phase.steps.map((step) => ({
+                id: step.id,
+            })),
+        })),
+    };
+}
+function autoFlowDefinition() {
+    const flow = loadAutoFlow();
+    return {
+        id: "auto",
+        label: "auto",
+        phases: flow.phases.map((phase) => ({
+            id: phase.id,
+            repeatVars: Object.fromEntries(Object.entries(phase.repeatVars).map(([key, value]) => [key, value])),
+            steps: phase.steps.map((step) => ({
+                id: step.id,
+            })),
+        })),
+    };
+}
+function interactiveFlowDefinitions() {
+    return [
+        autoFlowDefinition(),
+        declarativeFlowDefinition("plan", "plan", "plan.json"),
+        declarativeFlowDefinition("implement", "implement", "implement.json"),
+        declarativeFlowDefinition("review", "review", "review.json"),
+        declarativeFlowDefinition("review-fix", "review-fix", "review-fix.json"),
+        declarativeFlowDefinition("test", "test", "test.json"),
+        declarativeFlowDefinition("test-fix", "test-fix", "test-fix.json"),
+        declarativeFlowDefinition("test-linter-fix", "test-linter-fix", "test-linter-fix.json"),
+    ];
+}
+function publishFlowState(flowId, executionState) {
+    setFlowExecutionState(flowId, stripExecutionStatePayload(executionState));
 }
-function appendPromptText(basePrompt, suffix) {
-    if (!basePrompt?.trim()) {
-        return suffix;
+async function runDeclarativeFlowBySpecFile(fileName, config, flowParams) {
+    const context = createPipelineContext({
+        issueKey: config.taskKey,
+        jiraRef: config.jiraRef,
+        dryRun: config.dryRun,
+        verbose: config.verbose,
+        runtime: runtimeServices,
+    });
+    const flow = loadDeclarativeFlow(fileName);
+    const executionState = {
+        flowKind: flow.kind,
+        flowVersion: flow.version,
+        terminated: false,
+        phases: [],
+    };
+    publishFlowState(config.command, executionState);
+    for (const phase of flow.phases) {
+        await runExpandedPhase(phase, context, flowParams, flow.constants, {
+            executionState,
+            flowKind: flow.kind,
+            flowVersion: flow.version,
+            onStateChange: async (state) => {
+                publishFlowState(config.command, state);
+            },
+        });
     }
-    return `${basePrompt.trim()}\n${suffix}`;
 }
-function configForAutoStep(baseConfig, step) {
-    if (step.command === "review-fix") {
-        return {
-            ...buildPhaseConfig(baseConfig, step.command),
-            extraPrompt: appendPromptText(baseConfig.extraPrompt, AUTO_REVIEW_FIX_EXTRA_PROMPT),
-        };
+async function runAutoPhaseViaSpec(config, phaseId, executionState, state) {
+    const context = createPipelineContext({
+        issueKey: config.taskKey,
+        jiraRef: config.jiraRef,
+        dryRun: config.dryRun,
+        verbose: config.verbose,
+        runtime: runtimeServices,
+    });
+    const autoFlow = loadAutoFlow();
+    const phase = findPhaseById(autoFlow.phases, phaseId);
+    publishFlowState("auto", executionState);
+    try {
+        const result = await runExpandedPhase(phase, context, autoFlowParams(config), autoFlow.constants, {
+            executionState,
+            flowKind: autoFlow.kind,
+            flowVersion: autoFlow.version,
+            onStateChange: async (state) => {
+                publishFlowState("auto", state);
+            },
+            onStepStart: async (_phase, step) => {
+                if (!state) {
+                    return;
+                }
+                state.currentStep = `${phaseId}:${step.id}`;
+                saveAutoPipelineState(state);
+            },
+        });
+        if (state) {
+            state.executionState = result.executionState;
+            syncAndSaveAutoPipelineState(state);
+        }
+        return result.status === "skipped" ? "skipped" : "done";
+    }
+    catch (error) {
+        if (!config.dryRun) {
+            const output = String(error.output ?? "");
+            if (output.trim()) {
+                printError("Build verification failed");
+                printSummary("Build Failure Summary", await summarizeBuildFailure(output));
+            }
+        }
+        throw error;
     }
-    return buildPhaseConfig(baseConfig, step.command);
 }
 function rewindAutoPipelineState(state, phaseId) {
     const targetPhaseId = validateAutoPhaseId(phaseId);
@@ -539,121 +537,21 @@ function rewindAutoPipelineState(state, phaseId) {
     state.status = "pending";
     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,
-        });
+    const targetIndex = state.executionState.phases.findIndex((phase) => phase.id === targetPhaseId);
+    if (targetIndex >= 0) {
+        state.executionState.phases = state.executionState.phases.slice(0, targetIndex);
     }
-    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")}`;
+    state.executionState.terminated = false;
+    delete state.executionState.terminationReason;
 }
 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,169 +572,127 @@ 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);
+    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),
-    }), config.extraPrompt);
     if (config.command === "plan") {
         if (config.verbose) {
             process.stdout.write(`Fetching Jira issue from browse URL: ${config.jiraBrowseUrl}\n`);
             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 },
-            dryRun: config.dryRun,
-            verbose: config.verbose,
-            label: `codex:${codexModel()}`,
+        await runDeclarativeFlowBySpecFile("plan.json", config, {
+            jiraApiUrl: config.jiraApiUrl,
+            taskKey: config.taskKey,
+            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");
+        try {
+            await runDeclarativeFlowBySpecFile("implement.json", config, {
+                taskKey: config.taskKey,
+                dockerComposeFile: config.dockerComposeFile,
+                extraPrompt: config.extraPrompt,
+                runFollowupVerify,
+            });
+        }
+        catch (error) {
+            if (!config.dryRun) {
+                const output = String(error.output ?? "");
+                if (output.trim()) {
+                    printError("Build verification failed");
+                    printSummary("Build Failure Summary", await summarizeBuildFailure(output));
+                }
+            }
+            throw error;
         }
         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 },
-            dryRun: config.dryRun,
-            verbose: config.verbose,
-            label: `codex:${codexModel()}`,
+        await runDeclarativeFlowBySpecFile("review.json", config, {
+            taskKey: config.taskKey,
+            iteration,
+            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 !config.dryRun && existsSync(readyToMergeFile(config.taskKey));
     }
     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.");
+        try {
+            await runDeclarativeFlowBySpecFile("review-fix.json", config, {
+                taskKey: config.taskKey,
+                dockerComposeFile: config.dockerComposeFile,
+                latestIteration: latestReviewReplyIteration(config.taskKey),
+                runFollowupVerify,
+                extraPrompt: config.extraPrompt,
+                reviewFixPoints: config.reviewFixPoints,
+            });
         }
-        if (runFollowupVerify) {
-            await runVerifyBuildInDocker(config, dockerComposeCmd, "Running build verification in isolated Docker");
+        catch (error) {
+            if (!config.dryRun) {
+                const output = String(error.output ?? "");
+                if (output.trim()) {
+                    printError("Build verification failed");
+                    printSummary("Build Failure Summary", await summarizeBuildFailure(output));
+                }
+            }
+            throw error;
         }
         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");
+        try {
+            await runDeclarativeFlowBySpecFile("test.json", config, {
+                taskKey: config.taskKey,
+                dockerComposeFile: config.dockerComposeFile,
+            });
+        }
+        catch (error) {
+            if (!config.dryRun) {
+                const output = String(error.output ?? "");
+                if (output.trim()) {
+                    printError("Build verification failed");
+                    printSummary("Build Failure Summary", await summarizeBuildFailure(output));
+                }
+            }
+            throw error;
+        }
         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 runDeclarativeFlowBySpecFile(config.command === "test-fix" ? "test-fix.json" : "test-linter-fix.json", config, {
+            taskKey: config.taskKey,
+            extraPrompt: config.extraPrompt,
+        });
         return false;
     }
     throw new TaskRunnerError(`Unsupported command: ${config.command}`);
 }
 async function runAutoPipelineDryRun(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"));
-    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({
-            ...buildPhaseConfig(config, "review-fix"),
-            extraPrompt: appendPromptText(config.extraPrompt, AUTO_REVIEW_FIX_EXTRA_PROMPT),
-        }, false);
-        await executeCommand(buildPhaseConfig(config, "test"));
+    checkAutoPrerequisites(config);
+    printInfo("Dry-run auto pipeline from declarative spec");
+    const autoFlow = loadAutoFlow();
+    const executionState = {
+        flowKind: autoFlow.kind,
+        flowVersion: autoFlow.version,
+        terminated: false,
+        phases: [],
+    };
+    publishFlowState("auto", executionState);
+    for (const phase of autoFlow.phases) {
+        printInfo(`Dry-run auto phase: ${phase.id}`);
+        await runAutoPhaseViaSpec(config, phase.id, executionState);
+        if (executionState.terminated) {
+            break;
+        }
     }
 }
 async function runAutoPipeline(config) {
@@ -844,6 +700,10 @@ async function runAutoPipeline(config) {
         await runAutoPipelineDryRun(config);
         return;
     }
+    checkAutoPrerequisites(config);
+    process.env.JIRA_BROWSE_URL = config.jiraBrowseUrl;
+    process.env.JIRA_API_URL = config.jiraApiUrl;
+    process.env.JIRA_TASK_FILE = config.jiraTaskFile;
     let state = loadAutoPipelineState(config) ?? createAutoPipelineState(config);
     if (config.autoFromPhase) {
         rewindAutoPipelineState(state, config.autoFromPhase);
@@ -857,17 +717,7 @@ async function runAutoPipeline(config) {
     while (true) {
         const step = nextAutoStep(state);
         if (!step) {
-            if (state.steps.some((candidate) => candidate.status === "failed")) {
-                state.status = "blocked";
-            }
-            else if (state.steps.some((candidate) => candidate.status === "skipped")) {
-                state.status = "completed";
-            }
-            else {
-                state.status = "max-iterations-reached";
-            }
-            state.currentStep = null;
-            saveAutoPipelineState(state);
+            syncAndSaveAutoPipelineState(state);
             if (state.status === "completed") {
                 printPanel("Auto", "Auto pipeline finished", "green");
             }
@@ -887,18 +737,14 @@ 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));
-            step.status = "done";
+            const status = await runAutoPhaseViaSpec(config, step.id, state.executionState, state);
+            step.status = status;
             step.finishedAt = nowIso8601();
             step.returnCode = 0;
-            if (step.command === "review" && readyToMerge) {
-                skipAutoStepsAfterReadyToMerge(state, step.id);
-                state.status = "completed";
-                state.currentStep = null;
-                saveAutoPipelineState(state);
-                printPanel("Auto", "Auto pipeline finished", "green");
-                return;
+            if (status === "skipped") {
+                step.note = "condition not met";
             }
+            syncAndSaveAutoPipelineState(state);
         }
         catch (error) {
             const returnCode = Number(error.returnCode ?? 1);
@@ -915,46 +761,18 @@ async function runAutoPipeline(config) {
             saveAutoPipelineState(state);
             throw error;
         }
-        saveAutoPipelineState(state);
-    }
-}
-function splitArgs(input) {
-    const result = [];
-    let current = "";
-    let quote = null;
-    for (let index = 0; index < input.length; index += 1) {
-        const char = input[index] ?? "";
-        if (quote) {
-            if (char === quote) {
-                quote = null;
-            }
-            else {
-                current += char;
-            }
-            continue;
-        }
-        if (char === "'" || char === '"') {
-            quote = char;
-            continue;
-        }
-        if (/\s/.test(char)) {
-            if (current) {
-                result.push(current);
-                current = "";
-            }
-            continue;
+        if (state.executionState.terminated) {
+            syncAndSaveAutoPipelineState(state);
+            printPanel("Auto", "Auto pipeline finished", "green");
+            return;
         }
-        current += char;
     }
-    if (quote) {
-        throw new TaskRunnerError("Cannot parse command: unterminated quote");
-    }
-    if (current) {
-        result.push(current);
-    }
-    return result;
 }
 function parseCliArgs(argv) {
+    if (argv.includes("--version") || argv.includes("-v")) {
+        process.stdout.write(`${packageVersion()}\n`);
+        process.exit(0);
+    }
     if (argv.includes("--help") || argv.includes("-h")) {
         process.stdout.write(`${usage()}\n`);
         process.exit(0);
@@ -1026,147 +844,86 @@ function buildConfigFromArgs(args) {
         verbose: args.verbose,
     });
 }
-function interactiveHelp() {
-    printPanel("Interactive Commands", [
-        "/plan [extra prompt]",
-        "/implement [extra prompt]",
-        "/review [extra prompt]",
-        "/review-fix [extra prompt]",
-        "/test",
-        "/test-fix [extra prompt]",
-        "/test-linter-fix [extra prompt]",
-        "/auto [extra prompt]",
-        "/auto --from <phase> [extra prompt]",
-        "/auto-status",
-        "/auto-reset",
-        "/help auto",
-        "/help",
-        "/exit",
-    ].join("\n"), "magenta");
-}
-function parseInteractiveCommand(line, jiraRef) {
-    const parts = splitArgs(line);
-    if (parts.length === 0) {
-        return null;
-    }
-    const command = parts[0] ?? "";
-    if (!command.startsWith("/")) {
-        throw new TaskRunnerError("Interactive mode expects slash commands. Use /help.");
-    }
-    const commandName = command.slice(1);
-    if (commandName === "help") {
-        if (parts[1] === "auto" || parts[1] === "phases") {
-            printAutoPhasesHelp();
-            return null;
-        }
-        interactiveHelp();
-        return null;
-    }
-    if (commandName === "exit" || commandName === "quit") {
-        throw new EOFError();
-    }
-    if (!COMMANDS.includes(commandName)) {
-        throw new TaskRunnerError(`Unknown command: ${command}`);
-    }
-    if (commandName === "auto") {
-        let autoFromPhase;
-        let extraParts = parts.slice(1);
-        if (extraParts[0] === "--from") {
-            if (!extraParts[1]) {
-                throw new TaskRunnerError("auto --from requires a phase name. Use /help auto.");
-            }
-            autoFromPhase = extraParts[1];
-            extraParts = extraParts.slice(2);
-        }
-        return buildConfig("auto", jiraRef, {
-            extraPrompt: extraParts.join(" ") || null,
-            ...(autoFromPhase !== undefined ? { autoFromPhase } : {}),
-        });
-    }
-    return buildConfig(commandName, jiraRef, {
-        extraPrompt: parts.slice(1).join(" ") || null,
-    });
-}
-class EOFError extends Error {
-}
-async function ensureHistoryFile() {
-    mkdirSync(path.dirname(HISTORY_FILE), { recursive: true });
-    if (!existsSync(HISTORY_FILE)) {
-        writeFileSync(HISTORY_FILE, "", "utf8");
-    }
-}
 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/)
-        .filter(Boolean)
-        .slice(-200);
     let exiting = false;
-    const commandList = [
-        "/plan",
-        "/implement",
-        "/review",
-        "/review-fix",
-        "/test",
-        "/test-fix",
-        "/test-linter-fix",
-        "/auto",
-        "/auto-status",
-        "/auto-reset",
-        "/help",
-        "/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) => {
+        flows: interactiveFlowDefinitions(),
+        onRun: async (flowId) => {
             try {
-                await appendFile(HISTORY_FILE, `${line.trim()}\n`, "utf8");
-                const command = parseInteractiveCommand(line, jiraRef);
-                if (!command) {
-                    return;
-                }
-                ui.setBusy(true, command.command);
+                const command = buildConfig(flowId, jiraRef);
                 await executeCommand(command);
             }
             catch (error) {
-                if (error instanceof EOFError) {
-                    exiting = true;
-                    return;
-                }
                 if (error instanceof TaskRunnerError) {
+                    ui.setFlowFailed(flowId);
                     printError(error.message);
                     return;
                 }
                 const returnCode = Number(error.returnCode);
                 if (!Number.isNaN(returnCode)) {
+                    ui.setFlowFailed(flowId);
                     printError(`Command failed with exit code ${returnCode}`);
                     return;
                 }
                 throw error;
             }
-            finally {
-                ui.setBusy(false);
-            }
         },
         onExit: () => {
             exiting = true;
         },
-    }, historyLines);
+    });
     ui.mount();
-    printInfo(`Interactive mode for ${taskIdentity.issueKey}`);
-    if (taskIdentity.summaryText) {
-        printInfo("Task summary loaded.");
+    printInfo(`Interactive mode for ${config.jiraIssueKey}`);
+    printInfo("Use h to see help.");
+    try {
+        ui.setBusy(true, "preflight");
+        const preflightState = 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,
+        });
+        const preflightPhase = preflightState.phases.find((phase) => phase.id === "preflight");
+        if (preflightPhase) {
+            ui.appendLog("[preflight] completed");
+            for (const step of preflightPhase.steps) {
+                ui.appendLog(`[preflight] ${step.id}: ${step.status}`);
+            }
+        }
+        if (!existsSync(jiraTaskPath)) {
+            throw new TaskRunnerError(`Preflight finished without Jira task file: ${jiraTaskPath}\n` +
+                "Jira fetch did not complete successfully. Check JIRA_API_KEY and Jira connectivity.");
+        }
+        if (!existsSync(taskSummaryFile(config.taskKey))) {
+            ui.appendLog("[preflight] task summary file was not created");
+            ui.setSummary("Task summary is not available yet. Select and 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) {