agentweaver 0.1.2 → 0.1.3

package/dist/index.js

@@ -1,29 +1,22 @@
 #!/usr/bin/env node
-import { 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 { fileURLToPath } from "node:url";
-import { REVIEW_FILE_RE, REVIEW_REPLY_FILE_RE, designFile, planArtifacts, planFile, 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, 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 { 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 { 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, printError, printInfo, printPanel, printSummary } from "./tui.js";
+import { bye, printError, printInfo, printPanel, printSummary, setFlowExecutionState } from "./tui.js";
 const COMMANDS = [
     "plan",
     "implement",
@@ -36,11 +29,7 @@ const COMMANDS = [
     "auto-status",
     "auto-reset",
 ];
-const DEFAULT_CODEX_MODEL = "gpt-5.4";
-const DEFAULT_CLAUDE_REVIEW_MODEL = "opus";
-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 = {
@@ -67,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
@@ -86,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();
@@ -95,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);
@@ -121,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) {
@@ -155,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);
@@ -172,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) {
@@ -202,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");
 }
@@ -243,7 +317,11 @@ function loadEnvFile(envFilePath) {
 }
 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;
         }
@@ -256,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;
         }
@@ -270,6 +352,7 @@ function latestReviewReplyIteration(taskKey) {
 }
 function buildConfig(command, jiraRef, options = {}) {
     const jiraIssueKey = extractIssueKey(jiraRef);
+    ensureTaskWorkspaceDir(jiraIssueKey);
     return {
         command,
         jiraRef,
@@ -279,51 +362,88 @@ function buildConfig(command, jiraRef, options = {}) {
         dryRun: options.dryRun ?? false,
         verbose: options.verbose ?? false,
         dockerComposeFile: defaultDockerComposeFile(PACKAGE_ROOT),
-        codexCmd: process.env.CODEX_BIN ?? "codex",
-        claudeCmd: process.env.CLAUDE_BIN ?? "claude",
         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;
     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)) {
+    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 };
 }
-function buildPhaseConfig(baseConfig, command) {
-    return { ...baseConfig, command };
-}
-function appendPromptText(basePrompt, suffix) {
-    if (!basePrompt?.trim()) {
-        return suffix;
+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}`);
     }
-    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),
-        };
-    }
-    return buildPhaseConfig(baseConfig, step.command);
+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"),
+    ];
 }
-async function runAutoStepViaFlow(config, step, codexCmd, claudeCmd, state) {
+function publishFlowState(flowId, executionState) {
+    setFlowExecutionState(flowId, stripExecutionStatePayload(executionState));
+}
+async function runDeclarativeFlowBySpecFile(fileName, config, flowParams) {
     const context = createPipelineContext({
         issueKey: config.taskKey,
         jiraRef: config.jiraRef,
@@ -331,90 +451,68 @@ async function runAutoStepViaFlow(config, step, codexCmd, claudeCmd, state) {
         verbose: config.verbose,
         runtime: runtimeServices,
     });
-    const onStepStart = async (flowStep) => {
-        state.currentStep = `${step.id}:${flowStep.id}`;
-        saveAutoPipelineState(state);
+    const flow = loadDeclarativeFlow(fileName);
+    const executionState = {
+        flowKind: flow.kind,
+        flowVersion: flow.version,
+        terminated: false,
+        phases: [],
     };
-    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;
+    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);
+            },
+        });
     }
-    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));
-                    },
+}
+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;
                 }
-                : {}),
-        }, { 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;
+                state.currentStep = `${phaseId}:${step.id}`;
+                saveAutoPipelineState(state);
+            },
+        });
+        if (state) {
+            state.executionState = result.executionState;
+            syncAndSaveAutoPipelineState(state);
+        }
+        return result.status === "skipped" ? "skipped" : "done";
     }
-    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.`);
+    catch (error) {
+        if (!config.dryRun) {
+            const output = String(error.output ?? "");
+            if (output.trim()) {
+                printError("Build verification failed");
+                printSummary("Build Failure Summary", await summarizeBuildFailure(output));
+            }
         }
-        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 error;
     }
-    throw new TaskRunnerError(`Unsupported auto step command: ${step.command}`);
 }
 function rewindAutoPipelineState(state, phaseId) {
     const targetPhaseId = validateAutoPhaseId(phaseId);
@@ -439,12 +537,12 @@ function rewindAutoPipelineState(state, phaseId) {
     state.status = "pending";
     state.currentStep = null;
     state.lastError = null;
-}
-function codexModel() {
-    return process.env.CODEX_MODEL?.trim() || DEFAULT_CODEX_MODEL;
-}
-function claudeReviewModel() {
-    return process.env.CLAUDE_REVIEW_MODEL?.trim() || DEFAULT_CLAUDE_REVIEW_MODEL;
+    const targetIndex = state.executionState.phases.findIndex((phase) => phase.id === targetPhaseId);
+    if (targetIndex >= 0) {
+        state.executionState.phases = state.executionState.phases.slice(0, targetIndex);
+    }
+    state.executionState.terminated = false;
+    delete state.executionState.terminationReason;
 }
 async function summarizeBuildFailure(output) {
     return summarizeBuildFailureViaPipeline(createPipelineContext({
@@ -474,163 +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 } = 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 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 runPlanFlow(createPipelineContext({
-            issueKey: config.taskKey,
-            jiraRef: config.jiraRef,
-            dryRun: config.dryRun,
-            verbose: config.verbose,
-            runtime: runtimeServices,
-        }), {
+        await runDeclarativeFlowBySpecFile("plan.json", config, {
             jiraApiUrl: config.jiraApiUrl,
-            jiraTaskFile: config.jiraTaskFile,
             taskKey: config.taskKey,
-            codexCmd,
-            ...(config.extraPrompt !== undefined ? { extraPrompt: config.extraPrompt } : {}),
+            extraPrompt: config.extraPrompt,
         });
         return false;
     }
     if (config.command === "implement") {
         requireJiraTaskFile(config.jiraTaskFile);
         requireArtifacts(planArtifacts(config.taskKey), "Implement mode requires plan artifacts from the planning phase.");
-        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));
-                    },
+        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);
-        const result = await runReviewFlow(createPipelineContext({
-            issueKey: config.taskKey,
-            jiraRef: config.jiraRef,
-            dryRun: config.dryRun,
-            verbose: config.verbose,
-            runtime: runtimeServices,
-        }), {
-            jiraTaskFile: config.jiraTaskFile,
+        const iteration = nextReviewIterationForTask(config.taskKey);
+        await runDeclarativeFlowBySpecFile("review.json", config, {
             taskKey: config.taskKey,
-            claudeCmd,
-            codexCmd,
-            ...(config.extraPrompt !== undefined ? { extraPrompt: config.extraPrompt } : {}),
+            iteration,
+            extraPrompt: config.extraPrompt,
         });
-        return result.readyToMerge;
+        return !config.dryRun && existsSync(readyToMergeFile(config.taskKey));
     }
     if (config.command === "review-fix") {
         requireJiraTaskFile(config.jiraTaskFile);
-        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));
-                    },
+        try {
+            await runDeclarativeFlowBySpecFile("review-fix.json", config, {
+                taskKey: config.taskKey,
+                dockerComposeFile: config.dockerComposeFile,
+                latestIteration: latestReviewReplyIteration(config.taskKey),
+                runFollowupVerify,
+                extraPrompt: config.extraPrompt,
+                reviewFixPoints: config.reviewFixPoints,
+            });
+        }
+        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);
-        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));
-                    },
+        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);
-        await runTestFixFlow(createPipelineContext({
-            issueKey: config.taskKey,
-            jiraRef: config.jiraRef,
-            dryRun: config.dryRun,
-            verbose: config.verbose,
-            runtime: runtimeServices,
-        }), {
-            command: config.command,
+        await runDeclarativeFlowBySpecFile(config.command === "test-fix" ? "test-fix.json" : "test-linter-fix.json", config, {
             taskKey: config.taskKey,
-            dockerComposeFile: config.dockerComposeFile,
-            ...(config.extraPrompt !== undefined ? { extraPrompt: config.extraPrompt } : {}),
+            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");
-    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}`);
-        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}`);
+    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;
         }
-        await runAutoStepViaFlow(buildPhaseConfig(config, "review"), reviewStep, codexCmd, claudeCmd, dryState);
-        await runAutoStepViaFlow({
-            ...buildPhaseConfig(config, "review-fix"),
-            extraPrompt: appendPromptText(config.extraPrompt, AUTO_REVIEW_FIX_EXTRA_PROMPT),
-        }, reviewFixStep, codexCmd, claudeCmd, dryState);
-        await runAutoStepViaFlow(buildPhaseConfig(config, "test"), testStep, codexCmd, claudeCmd, dryState);
     }
 }
 async function runAutoPipeline(config) {
@@ -638,7 +700,10 @@ async function runAutoPipeline(config) {
         await runAutoPipelineDryRun(config);
         return;
     }
-    const { codexCmd, claudeCmd } = checkPrerequisites(config);
+    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);
@@ -652,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");
             }
@@ -682,18 +737,14 @@ async function runAutoPipeline(config) {
         saveAutoPipelineState(state);
         try {
             printInfo(`Running auto step: ${step.id}`);
-            const readyToMerge = await runAutoStepViaFlow(configForAutoStep(config, step), step, codexCmd, claudeCmd, state);
-            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);
@@ -710,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);
@@ -821,143 +844,45 @@ 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;
-    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: 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 ${config.jiraIssueKey}`);
-    printInfo("Use /help to see commands.");
+    printInfo("Use h to see help.");
     try {
         ui.setBusy(true, "preflight");
-        await runPreflightFlow(createPipelineContext({
+        const preflightState = await runPreflightFlow(createPipelineContext({
             issueKey: config.taskKey,
             jiraRef: config.jiraRef,
             dryRun: false,
@@ -972,8 +897,20 @@ async function runInteractive(jiraRef, forceRefresh = false) {
             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.setSummary("Task summary is not available yet. Run `/plan` or refresh Jira data.");
+            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.");
         }
     }
     catch (error) {