agentweaver 0.1.9 → 0.1.11

package/dist/index.js

@@ -1,29 +1,37 @@
 #!/usr/bin/env node
-import { existsSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync } 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, autoStateFile, bugAnalyzeArtifacts, bugAnalyzeJsonFile, bugFixDesignJsonFile, bugFixPlanJsonFile, designJsonFile, gitlabDiffFile, gitlabDiffJsonFile, ensureScopeWorkspaceDir, gitlabReviewFile, gitlabReviewJsonFile, planJsonFile, planArtifacts, qaJsonFile, readyToMergeFile, requireArtifacts, reviewFile, reviewReplyJsonFile, reviewFixSelectionJsonFile, reviewJsonFile, scopeWorkspaceDir, taskSummaryFile, } from "./artifacts.js";
-import { TaskRunnerError } from "./errors.js";
-import { createFlowRunState, hasResumableFlowState, loadFlowRunState, prepareFlowStateForResume, resetFlowRunState, saveFlowRunState, stripExecutionStatePayload, } from "./flow-state.js";
+import { REVIEW_FILE_RE, bugAnalyzeArtifacts, bugAnalyzeJsonFile, bugFixDesignJsonFile, bugFixPlanJsonFile, designJsonFile, gitlabDiffFile, gitlabDiffJsonFile, ensureScopeWorkspaceDir, gitlabReviewFile, gitlabReviewJsonFile, latestArtifactIteration, nextArtifactIteration, planJsonFile, planArtifacts, qaJsonFile, readyToMergeFile, requireArtifacts, reviewFile, reviewFixSelectionJsonFile, reviewJsonFile, scopeWorkspaceDir, flowStateFile, taskSummaryFile, } from "./artifacts.js";
+import { FlowInterruptedError, TaskRunnerError } from "./errors.js";
+import { createFlowRunState, hasResumableFlowState, loadFlowRunState, prepareFlowStateForResume, resetFlowRunState, rewindFlowRunStateToPhase, saveFlowRunState, stripExecutionStatePayload, } from "./flow-state.js";
 import { requireJiraTaskFile } from "./jira.js";
 import { validateStructuredArtifacts } from "./structured-artifacts.js";
 import { summarizeBuildFailure as summarizeBuildFailureViaPipeline } from "./pipeline/build-failure-summary.js";
+import { runNodeChecks } from "./pipeline/checks.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 { runExpandedPhase } from "./pipeline/declarative-flow-runner.js";
 import { findCatalogEntry, isBuiltInCommandFlowId, loadInteractiveFlowCatalog, toDeclarativeFlowRef } from "./pipeline/flow-catalog.js";
-import { resolveCmd, resolveDockerComposeCmd } from "./runtime/command-resolution.js";
-import { agentweaverHome, defaultDockerComposeFile, dockerRuntimeEnv } from "./runtime/docker-runtime.js";
+import { ALLOWED_MODELS_BY_EXECUTOR, defaultModelForExecutor, DEFAULT_LAUNCH_PROFILE, LLM_EXECUTOR_IDS, resolveLaunchProfile, } from "./pipeline/launch-profile-config.js";
+import { evaluateCondition, resolveValue } from "./pipeline/value-resolver.js";
+import { resolveCmd } from "./runtime/command-resolution.js";
+import { loadTieredEnv } from "./runtime/env-loader.js";
+import { agentweaverHome } from "./runtime/agentweaver-home.js";
 import { runCommand } from "./runtime/process-runner.js";
 import { InteractiveUi } from "./interactive-ui.js";
 import { bye, printError, printInfo, printPanel, printSummary, setFlowExecutionState, stripAnsi, } from "./tui.js";
 import { requestUserInputInTerminal } from "./user-input.js";
 import { attachJiraContext, detectGitBranchName, requestJiraContext, resolveProjectScope, } from "./scope.js";
 const COMMANDS = [
+    "auto-golang",
+    "auto-common",
+    "auto-status",
+    "auto-reset",
     "bug-analyze",
     "bug-fix",
+    "git-commit",
     "gitlab-diff-review",
     "gitlab-review",
     "mr-description",
@@ -32,21 +40,19 @@ const COMMANDS = [
     "implement",
     "review",
     "review-fix",
+    "review-loop",
     "run-go-tests-loop",
     "run-go-linter-loop",
-    "auto",
-    "auto-status",
-    "auto-reset",
 ];
-const AUTO_STATE_SCHEMA_VERSION = 3;
 const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 const PACKAGE_ROOT = path.resolve(MODULE_DIR, "..");
-const runtimeServices = {
-    resolveCmd,
-    resolveDockerComposeCmd,
-    dockerRuntimeEnv: () => dockerRuntimeEnv(PACKAGE_ROOT),
-    runCommand,
-};
+function createRuntimeServices(signal) {
+    return {
+        resolveCmd,
+        runCommand: (argv, options = {}) => runCommand(argv, { ...options, ...(signal ? { signal } : {}) }),
+    };
+}
+const runtimeServices = createRuntimeServices();
 function buildFailureOutputPreview(output) {
     const normalized = stripAnsi(output).replace(/\r\n/g, "\n").trim();
     if (!normalized) {
@@ -78,59 +84,64 @@ function formatProcessFailure(error) {
     }
     return `${baseMessage}\nПричина:\n${preview}`;
 }
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function usage() {
     return `Usage:
   agentweaver
   agentweaver <jira-browse-url|jira-issue-key>
   agentweaver --force <jira-browse-url|jira-issue-key>
+  agentweaver git-commit [--dry] [--verbose] [--prompt <text>] [--scope <name>] [<jira-browse-url|jira-issue-key>]
   agentweaver gitlab-diff-review [--dry] [--verbose] [--prompt <text>] [--scope <name>]
   agentweaver gitlab-review [--dry] [--verbose] [--prompt <text>] [--scope <name>]
   agentweaver bug-analyze [--dry] [--verbose] [--prompt <text>] <jira-browse-url|jira-issue-key>
   agentweaver bug-fix [--dry] [--verbose] [--prompt <text>] <jira-browse-url|jira-issue-key>
   agentweaver mr-description [--dry] [--verbose] [--prompt <text>] <jira-browse-url|jira-issue-key>
-  agentweaver plan [--dry] [--verbose] [--prompt <text>] [<jira-browse-url|jira-issue-key>]
-  agentweaver task-describe [--dry] [--verbose] [--prompt <text>] <jira-browse-url|jira-issue-key>
+  agentweaver plan [--dry] [--verbose] [--prompt <text>] [--md-lang <en|ru>] [<jira-browse-url|jira-issue-key>]
+  agentweaver task-describe [--dry] [--verbose] [--prompt <text>] [<jira-browse-url|jira-issue-key>]
   agentweaver implement [--dry] [--verbose] [--prompt <text>] [--scope <name>] [<jira-browse-url|jira-issue-key>]
   agentweaver review [--dry] [--verbose] [--prompt <text>] [--scope <name>] [<jira-browse-url|jira-issue-key>]
   agentweaver review-fix [--dry] [--verbose] [--prompt <text>] [--scope <name>] [<jira-browse-url|jira-issue-key>]
+  agentweaver review-loop [--dry] [--verbose] [--prompt <text>] [--scope <name>] [<jira-browse-url|jira-issue-key>]
   agentweaver run-go-tests-loop [--dry] [--verbose] [--prompt <text>] [--scope <name>] [<jira-browse-url|jira-issue-key>]
   agentweaver run-go-linter-loop [--dry] [--verbose] [--prompt <text>] [--scope <name>] [<jira-browse-url|jira-issue-key>]
-  agentweaver auto [--dry] [--verbose] [--prompt <text>] [<jira-browse-url|jira-issue-key>]
-  agentweaver auto [--dry] [--verbose] [--prompt <text>] --from <phase> [<jira-browse-url|jira-issue-key>]
-  agentweaver auto --help-phases
+  agentweaver auto-golang [--dry] [--verbose] [--prompt <text>] [<jira-browse-url|jira-issue-key>]
+  agentweaver auto-golang [--dry] [--verbose] [--prompt <text>] --from <phase> [<jira-browse-url|jira-issue-key>]
+  agentweaver auto-golang --help-phases
   agentweaver auto-status [<jira-browse-url|jira-issue-key>]
   agentweaver auto-reset [<jira-browse-url|jira-issue-key>]
 
 Interactive Mode:
   When started without a command, the script opens an interactive UI.
   If a Jira task is provided, interactive mode starts in the current project scope with Jira context attached.
-  Use Up/Down to select a flow, Enter to confirm launch, h for help, q to exit.
+  Use Up/Down to move in the flow tree, Left/Right to collapse or expand folders, Enter to toggle a folder or run a flow, h for help, q to exit.
 
 Flags:
   --version       Show package version
   --force         In interactive mode, regenerate task summary in Jira-backed flows
-  --dry           Fetch Jira task, but print docker/codex/claude commands instead of executing them
+  --dry           Fetch Jira task, but print codex/opencode commands instead of executing them
   --verbose       Show live stdout/stderr of launched commands
   --scope         Explicit workflow scope name for non-Jira runs
   --prompt        Extra prompt text appended to the base prompt
+  --md-lang       Language for markdown output files: en (English) or ru (Russian, default)
 
 Required environment variables:
-  JIRA_API_KEY    Jira API key used in Authorization: Bearer <token> for Jira-backed flows
+  JIRA_API_KEY    Jira API token used for Jira-backed flows (Bearer by default, or Basic with Jira Cloud)
 
 Optional environment variables:
+  JIRA_USERNAME   Required for Jira Cloud Basic auth (usually Atlassian account email)
+  JIRA_AUTH_MODE  Override Jira auth mode: auto | basic | bearer
   JIRA_BASE_URL
   GITLAB_TOKEN
   AGENTWEAVER_HOME
-  DOCKER_COMPOSE_BIN
   CODEX_BIN
   CODEX_MODEL
   OPENCODE_BIN
   OPENCODE_MODEL
-  CLAUDE_BIN
-  CLAUDE_MODEL
 
 Notes:
-  - Task-only flows will ask for Jira task via user-input when it is not passed as an argument.
+  - Jira-backed task flows will ask for Jira task via user-input when it is not passed as an argument. task-describe can also work from a manual task description without Jira.
   - All flow state and artifacts are stored in the current project scope by default.
   - gitlab-review and gitlab-diff-review ask for GitLab merge request URL via user-input.`;
 }
@@ -142,212 +153,235 @@ function packageVersion() {
     }
     return raw.version;
 }
-function nowIso8601() {
-    return new Date().toISOString();
-}
 function normalizeAutoPhaseId(phaseId) {
     return phaseId.trim().toLowerCase().replaceAll("-", "_");
 }
-function buildAutoSteps() {
-    return loadAutoFlow().phases.map((phase) => ({
-        id: phase.id,
-        status: "pending",
-    }));
-}
 function autoPhaseIds() {
-    return buildAutoSteps().map((step) => step.id);
+    return loadDeclarativeFlow({ source: "built-in", fileName: "auto-golang.json" }).phases.map((phase) => phase.id);
 }
 function validateAutoPhaseId(phaseId) {
     const normalized = normalizeAutoPhaseId(phaseId);
     if (!autoPhaseIds().includes(normalized)) {
-        throw new TaskRunnerError(`Unknown auto phase: ${phaseId}\nUse 'agentweaver auto --help-phases' or '/help auto' to list valid phases.`);
+        throw new TaskRunnerError(`Unknown auto-golang phase: ${phaseId}\nUse 'agentweaver auto-golang --help-phases' or '/help auto-golang' to list valid phases.`);
     }
     return normalized;
 }
-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,
-        updatedAt: nowIso8601(),
-        steps: buildAutoSteps(),
-        executionState: {
-            flowKind: autoFlow.kind,
-            flowVersion: autoFlow.version,
-            terminated: false,
-            phases: [],
-        },
-    };
-}
-function loadAutoPipelineState(config) {
-    const filePath = autoStateFile(config.taskKey);
-    if (!existsSync(filePath)) {
-        return null;
-    }
-    let raw;
-    try {
-        raw = JSON.parse(readFileSync(filePath, "utf8"));
+function buildFlowResumeDetails(state) {
+    const currentStep = findCurrentFlowExecutionStep(state) ?? state.currentStep ?? "-";
+    const lines = [
+        "Interrupted run found.",
+        `Current step: ${currentStep}`,
+        `Updated: ${state.updatedAt}`,
+    ];
+    if (state.launchProfile) {
+        lines.push(`Launch profile: ${state.launchProfile.executor} / ${state.launchProfile.model}`);
     }
-    catch (error) {
-        throw new TaskRunnerError(`Failed to parse auto state file ${filePath}: ${error.message}`);
-    }
-    if (!raw || typeof raw !== "object") {
-        throw new TaskRunnerError(`Invalid auto state file format: ${filePath}`);
-    }
-    const state = raw;
-    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: [],
-        };
+    if (state.lastError) {
+        lines.push(`Last error: ${state.lastError.message ?? "-"} (exit ${state.lastError.returnCode ?? "-"})`);
     }
-    syncAutoStepsFromExecutionState(state);
-    return state;
+    return lines.join("\n");
 }
-function saveAutoPipelineState(state) {
-    state.updatedAt = nowIso8601();
-    ensureScopeWorkspaceDir(state.issueKey);
-    writeFileSync(autoStateFile(state.issueKey), `${JSON.stringify({
-        ...state,
-        executionState: stripExecutionStatePayload(state.executionState),
-    }, null, 2)}\n`, "utf8");
+function launchProfileSelectionForm() {
+    const defaultExecutor = DEFAULT_LAUNCH_PROFILE.executor;
+    return {
+        formId: "flow-launch-profile",
+        title: "Настройки запуска LLM",
+        description: `Выберите executor для запуска flow. Текущий default: ${defaultExecutor}.`,
+        submitLabel: "Continue",
+        fields: [
+            {
+                id: "executor",
+                type: "single-select",
+                label: "Executor",
+                required: true,
+                default: "default",
+                options: [
+                    { value: "default", label: `default (${defaultExecutor})` },
+                    ...LLM_EXECUTOR_IDS.map((id) => ({
+                        value: id,
+                        label: id === defaultExecutor ? `${id} [default]` : id,
+                    })),
+                ],
+            },
+        ],
+    };
 }
-function syncAndSaveAutoPipelineState(state) {
-    syncAutoStepsFromExecutionState(state);
-    saveAutoPipelineState(state);
+function launchModelSelectionForm(executor) {
+    const resolvedExecutor = executor === "default" ? DEFAULT_LAUNCH_PROFILE.executor : executor;
+    const defaultModel = defaultModelForExecutor(resolvedExecutor);
+    const options = executor === "default"
+        ? [{ value: "default", label: `default (${DEFAULT_LAUNCH_PROFILE.model})` }]
+        : [
+            { value: "default", label: `default (${defaultModel})` },
+            ...ALLOWED_MODELS_BY_EXECUTOR[executor].map((model) => ({
+                value: model,
+                label: model === defaultModel ? `${model} [default]` : model,
+            })),
+        ];
+    return {
+        formId: "flow-launch-model",
+        title: "Настройки запуска LLM",
+        description: `Выберите модель для запуска flow. Текущий default для ${resolvedExecutor}: ${defaultModel}.`,
+        submitLabel: "Start",
+        fields: [
+            {
+                id: "model",
+                type: "single-select",
+                label: "Model",
+                required: true,
+                default: "default",
+                options,
+            },
+        ],
+    };
 }
-function resetAutoPipelineState(config) {
-    const filePath = autoStateFile(config.taskKey);
-    if (!existsSync(filePath)) {
-        return false;
-    }
-    rmSync(filePath);
-    return true;
+async function requestInteractiveLaunchProfile(requestUserInput) {
+    const executorFormResult = await requestUserInput(launchProfileSelectionForm());
+    const rawExecutor = String(executorFormResult.values.executor ?? "default");
+    const executor = rawExecutor === "default" ? "default" : LLM_EXECUTOR_IDS.find((id) => id === rawExecutor);
+    if (!executor) {
+        throw new TaskRunnerError(`Unsupported launch executor '${rawExecutor}'.`);
+    }
+    const modelFormResult = await requestUserInput(launchModelSelectionForm(executor));
+    const rawModel = String(modelFormResult.values.model ?? "default").trim();
+    return resolveLaunchProfile({
+        executor,
+        model: rawModel.length > 0 ? rawModel : "default",
+    }, DEFAULT_LAUNCH_PROFILE);
 }
-function nextAutoStep(state) {
-    return state.steps.find((step) => ["running", "failed", "pending"].includes(step.status)) ?? null;
+function buildResolverContext(pipelineContext, flowParams, flowConstants, repeatVars, executionState) {
+    return {
+        flowParams,
+        flowConstants,
+        pipelineContext,
+        repeatVars,
+        executionState,
+    };
 }
-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}`;
+function resolveResumeChecks(step, context) {
+    return (step.expect ?? [])
+        .filter((expectation) => evaluateCondition(expectation.when, context))
+        .flatMap((expectation) => {
+        if (expectation.kind === "step-output") {
+            const value = resolveValue(expectation.value, context);
+            if (expectation.equals !== undefined) {
+                const expected = resolveValue(expectation.equals, context);
+                if (value !== expected) {
+                    throw new TaskRunnerError(expectation.message);
+                }
+                return [];
+            }
+            if (!value) {
+                throw new TaskRunnerError(expectation.message);
+            }
+            return [];
         }
-    }
-    return null;
+        if (expectation.kind === "require-artifacts") {
+            const value = resolveValue(expectation.paths, context);
+            if (!Array.isArray(value) || value.some((candidate) => typeof candidate !== "string")) {
+                throw new TaskRunnerError("Expectation 'require-artifacts' must resolve to string[]");
+            }
+            return [{ kind: "require-artifacts", paths: value, message: expectation.message }];
+        }
+        if (expectation.kind === "require-file") {
+            const value = resolveValue(expectation.path, context);
+            if (typeof value !== "string") {
+                throw new TaskRunnerError("Expectation 'require-file' must resolve to string");
+            }
+            return [{ kind: "require-file", path: value, message: expectation.message }];
+        }
+        const items = expectation.items.map((item) => {
+            const value = resolveValue(item.path, context);
+            if (typeof value !== "string") {
+                throw new TaskRunnerError("Expectation 'require-structured-artifacts' item path must resolve to string");
+            }
+            return {
+                path: value,
+                schemaId: item.schemaId,
+            };
+        });
+        return [{ kind: "require-structured-artifacts", items, message: expectation.message }];
+    });
 }
-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";
+function validateDeclarativePhaseResumeState(phase, phaseState, pipelineContext, flowParams, flowConstants, executionState) {
+    if (phaseState.status === "done") {
+        return;
     }
-    if (state.steps.every((candidate) => candidate.status === "done")) {
-        return "completed";
+    for (const [stepIndex, step] of phase.steps.entries()) {
+        const stepState = phaseState.steps[stepIndex];
+        if (!stepState || stepState.status !== "done") {
+            continue;
+        }
+        const context = buildResolverContext(pipelineContext, flowParams, flowConstants, step.repeatVars, executionState);
+        const checks = resolveResumeChecks(step, context);
+        try {
+            runNodeChecks(checks);
+        }
+        catch (error) {
+            throw new TaskRunnerError(`Resume is impossible for '${phase.id}:${step.id}' because required artifacts are missing or invalid. Use restart.\n${error.message}`);
+        }
     }
-    return state.status;
 }
-function printAutoState(state) {
-    const currentStep = findCurrentExecutionStep(state) ?? state.currentStep ?? "-";
-    const lines = [
-        `Issue: ${state.issueKey}`,
-        `Status: ${deriveAutoPipelineStatus(state)}`,
-        `Current step: ${currentStep}`,
-        `Updated: ${state.updatedAt}`,
-    ];
-    if (state.lastError) {
-        lines.push(`Last error: ${state.lastError.step ?? "-"} (exit ${state.lastError.returnCode ?? "-"}, ${state.lastError.message ?? "-"})`);
-    }
-    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}`);
+function validateDeclarativeFlowResumeState(flowEntry, config, state, launchProfile, runtime = runtimeServices) {
+    if (state.launchProfile) {
+        if (!launchProfile) {
+            throw new TaskRunnerError("Resume is impossible because launch profile is missing. Use restart.");
+        }
+        if (state.launchProfile.fingerprint !== launchProfile.fingerprint) {
+            throw new TaskRunnerError(`Resume is impossible because launch profile changed (${state.launchProfile.executor}/${state.launchProfile.model} -> ${launchProfile.executor}/${launchProfile.model}). Use restart.`);
         }
     }
-    if (state.executionState.terminated) {
-        lines.push("", `Execution terminated: ${state.executionState.terminationReason ?? "yes"}`);
+    if (flowRequiresTaskScope(flowEntry) && !config.jiraRef) {
+        throw new TaskRunnerError("Resume is impossible because Jira context is missing for this flow state. Use restart.");
     }
-    printPanel("Auto Status", lines.join("\n"), "cyan");
-}
-function syncAutoStepsFromExecutionState(state) {
-    for (const step of state.steps) {
-        const phaseState = state.executionState.phases.find((candidate) => candidate.id === step.id);
+    const pipelineContext = createPipelineContext({
+        issueKey: config.taskKey,
+        jiraRef: config.jiraRef,
+        dryRun: config.dryRun,
+        verbose: config.verbose,
+        ...(config.mdLang !== undefined ? { mdLang: config.mdLang } : {}),
+        runtime,
+        requestUserInput: requestUserInputInTerminal,
+    });
+    const flowParams = defaultDeclarativeFlowParams(config, false, launchProfile ? { launchProfile } : {});
+    for (const phase of flowEntry.flow.phases) {
+        const phaseState = state.executionState.phases.find((candidate) => candidate.id === phase.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 buildAutoResumeDetails(state) {
-    const currentStep = findCurrentExecutionStep(state) ?? state.currentStep ?? "-";
-    const lines = [
-        "Interrupted auto run found.",
-        `Current step: ${currentStep}`,
-        `Updated: ${state.updatedAt}`,
-    ];
-    if (state.lastError) {
-        lines.push(`Last error: ${state.lastError.message ?? "-"} (exit ${state.lastError.returnCode ?? "-"})`);
+        validateDeclarativePhaseResumeState(phase, phaseState, pipelineContext, flowParams, flowEntry.flow.constants, state.executionState);
     }
-    return lines.join("\n");
 }
-function buildFlowResumeDetails(state) {
-    const currentStep = findCurrentFlowExecutionStep(state) ?? state.currentStep ?? "-";
-    const lines = [
-        "Interrupted run found.",
-        `Current step: ${currentStep}`,
-        `Updated: ${state.updatedAt}`,
-    ];
-    if (state.lastError) {
-        lines.push(`Last error: ${state.lastError.message ?? "-"} (exit ${state.lastError.returnCode ?? "-"})`);
+function scopeWithRestoredJiraContext(scope, state) {
+    if (scope.jiraRef || !state?.jiraRef?.trim()) {
+        return scope;
     }
-    return lines.join("\n");
+    return attachJiraContext(scope, state.jiraRef);
 }
 function lookupInteractiveFlowResume(flowEntry, currentScope) {
     const directState = loadFlowRunState(currentScope.scopeKey, flowEntry.id);
     if (directState && hasResumableFlowState(directState)) {
-        return {
-            resumeAvailable: true,
-            hasExistingState: true,
-            details: buildFlowResumeDetails(directState),
-        };
+        try {
+            const effectiveScope = scopeWithRestoredJiraContext(currentScope, directState);
+            const baseConfig = buildBaseConfig(flowEntry.id, {
+                ...(effectiveScope.jiraRef ? { jiraRef: effectiveScope.jiraRef } : {}),
+                scopeName: effectiveScope.scopeKey,
+            });
+            const config = buildRuntimeConfig(baseConfig, effectiveScope);
+            validateDeclarativeFlowResumeState(flowEntry, config, directState, directState.launchProfile);
+            return {
+                resumeAvailable: true,
+                hasExistingState: true,
+                details: buildFlowResumeDetails(directState),
+            };
+        }
+        catch (error) {
+            return {
+                resumeAvailable: false,
+                hasExistingState: true,
+                details: `Interrupted run found, but resume is unavailable.\n${error.message}`,
+            };
+        }
     }
     return {
         resumeAvailable: false,
@@ -355,37 +389,17 @@ function lookupInteractiveFlowResume(flowEntry, currentScope) {
     };
 }
 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");
+    const phaseLines = ["Available auto-golang phases:", "", ...autoPhaseIds()];
+    phaseLines.push("", "You can resume auto-golang from a phase with:", "agentweaver auto-golang --from <phase> <jira>", "or in interactive mode:", "/auto-golang --from <phase>");
+    printPanel("Auto-Golang Phases", phaseLines.join("\n"), "magenta");
 }
-function loadEnvFile(envFilePath) {
-    if (!existsSync(envFilePath)) {
-        return;
-    }
-    const lines = readFileSync(envFilePath, "utf8").split(/\r?\n/);
-    for (const rawLine of lines) {
-        let line = rawLine.trim();
-        if (!line || line.startsWith("#")) {
-            continue;
-        }
-        if (line.startsWith("export ")) {
-            line = line.slice(7).trim();
-        }
-        const separatorIndex = line.indexOf("=");
-        if (separatorIndex < 0) {
-            continue;
-        }
-        const key = line.slice(0, separatorIndex).trim();
-        if (!key || process.env[key] !== undefined) {
-            continue;
-        }
-        let value = line.slice(separatorIndex + 1).trim();
-        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
-            value = value.slice(1, -1);
-        }
-        process.env[key] = value;
-    }
+function autoCommonPhaseIds() {
+    return loadDeclarativeFlow({ source: "built-in", fileName: "auto-common.json" }).phases.map((phase) => phase.id);
+}
+function printAutoCommonPhasesHelp() {
+    const phaseLines = ["Available auto-common phases:", "", ...autoCommonPhaseIds()];
+    phaseLines.push("", "You can run auto-common with:", "agentweaver auto-common <jira>");
+    printPanel("Auto-Common Phases", phaseLines.join("\n"), "magenta");
 }
 function nextReviewIterationForTask(taskKey) {
     let maxIndex = 0;
@@ -397,33 +411,14 @@ function nextReviewIterationForTask(taskKey) {
         if (!entry.isFile()) {
             continue;
         }
-        const match = REVIEW_FILE_RE.exec(entry.name) ?? REVIEW_REPLY_FILE_RE.exec(entry.name);
+        const match = REVIEW_FILE_RE.exec(entry.name);
         if (match && match[1] === taskKey) {
             maxIndex = Math.max(maxIndex, Number.parseInt(match[2] ?? "0", 10));
         }
     }
     return maxIndex + 1;
 }
-function latestReviewReplyIteration(taskKey) {
-    let maxIndex = null;
-    const workspaceDir = scopeWorkspaceDir(taskKey);
-    if (!existsSync(workspaceDir)) {
-        return null;
-    }
-    for (const entry of readdirSync(workspaceDir, { withFileTypes: true })) {
-        if (!entry.isFile()) {
-            continue;
-        }
-        const match = REVIEW_REPLY_FILE_RE.exec(entry.name);
-        if (match && match[1] === taskKey) {
-            const current = Number.parseInt(match[2] ?? "0", 10);
-            maxIndex = maxIndex === null ? current : Math.max(maxIndex, current);
-        }
-    }
-    return maxIndex;
-}
 function buildBaseConfig(command, options = {}) {
-    const homeDir = agentweaverHome(PACKAGE_ROOT);
     return {
         command,
         jiraRef: options.jiraRef ?? null,
@@ -431,12 +426,9 @@ function buildBaseConfig(command, options = {}) {
         reviewFixPoints: options.reviewFixPoints ?? null,
         extraPrompt: options.extraPrompt ?? null,
         autoFromPhase: options.autoFromPhase ? validateAutoPhaseId(options.autoFromPhase) : null,
+        mdLang: options.mdLang ?? null,
         dryRun: options.dryRun ?? false,
         verbose: options.verbose ?? false,
-        dockerComposeFile: defaultDockerComposeFile(PACKAGE_ROOT),
-        runGoTestsScript: path.join(homeDir, "run_go_tests.py"),
-        runGoLinterScript: path.join(homeDir, "run_go_linter.py"),
-        runGoCoverageScript: path.join(homeDir, "run_go_coverage.sh"),
     };
 }
 function commandRequiresTask(command) {
@@ -444,17 +436,20 @@ function commandRequiresTask(command) {
         command === "bug-analyze" ||
         command === "bug-fix" ||
         command === "mr-description" ||
-        command === "task-describe" ||
-        command === "auto" ||
+        command === "auto-golang" ||
+        command === "auto-common" ||
         command === "auto-status" ||
         command === "auto-reset");
 }
 function commandSupportsProjectScope(command) {
-    return (command === "gitlab-diff-review" ||
+    return (command === "git-commit" ||
+        command === "gitlab-diff-review" ||
         command === "gitlab-review" ||
+        command === "task-describe" ||
         command === "implement" ||
         command === "review" ||
         command === "review-fix" ||
+        command === "review-loop" ||
         command === "run-go-tests-loop" ||
         command === "run-go-linter-loop");
 }
@@ -503,41 +498,40 @@ function checkPrerequisites(config) {
         config.command === "run-go-linter-loop") {
         resolveCmd("codex", "CODEX_BIN");
     }
-    if (config.command === "review" || config.command === "gitlab-diff-review") {
-        resolveCmd("claude", "CLAUDE_BIN");
-    }
 }
 function checkAutoPrerequisites(config) {
     resolveCmd("codex", "CODEX_BIN");
-    resolveCmd("claude", "CLAUDE_BIN");
 }
 function autoFlowParams(config, forceRefreshSummary = false) {
     return {
         jiraApiUrl: config.jiraApiUrl,
         taskKey: config.taskKey,
-        dockerComposeFile: config.dockerComposeFile,
-        runGoTestsScript: config.runGoTestsScript,
-        runGoLinterScript: config.runGoLinterScript,
-        runGoCoverageScript: config.runGoCoverageScript,
         extraPrompt: config.extraPrompt,
         reviewFixPoints: config.reviewFixPoints,
         forceRefresh: forceRefreshSummary,
+        mdLang: config.mdLang,
+        runGoTestsScript: path.join(agentweaverHome(PACKAGE_ROOT), "run_go_tests.py"),
+        runGoLinterScript: path.join(agentweaverHome(PACKAGE_ROOT), "run_go_linter.py"),
+        runGoTestsIteration: nextArtifactIteration(config.taskKey, "run-go-tests-result", "json"),
+        runGoLinterIteration: nextArtifactIteration(config.taskKey, "run-go-linter-result", "json"),
     };
 }
 const FLOW_DESCRIPTIONS = {
-    auto: "Полный пайплайн задачи: планирование, реализация, проверки, ревью, ответы на ревью и повторные итерации до готовности к merge.",
-    "bug-analyze": "Анализирует баг по Jira и создаёт структурированные артефакты: гипотезу причины, дизайн исправления и план работ.",
-    "gitlab-diff-review": "Запрашивает GitLab MR URL через user-input, загружает diff merge request по API и запускает код-ревью через Claude Opus с сохранением markdown и structured JSON artifacts.",
-    "gitlab-review": "Запрашивает GitLab MR URL через user-input, загружает комментарии код-ревью по API и сохраняет markdown плюс structured JSON artifact.",
-    "bug-fix": "Берёт результаты bug-analyze как source of truth и реализует исправление бага в коде.",
-    "mr-description": "Готовит краткое intent-описание для merge request на основе задачи и текущих изменений.",
-    plan: "Загружает задачу из Jira и создаёт дизайн, план реализации и QA-план в structured JSON и markdown.",
-    "task-describe": "Строит короткое резюме задачи на основе Jira-артефакта для быстрого ознакомления.",
-    implement: "Реализует задачу по утверждённым design/plan артефактам и при необходимости запускает post-verify сборки.",
-    review: "Запускает Claude-код-ревью текущих изменений, валидирует structured findings, затем готовит ответ на замечания через Codex.",
-    "review-fix": "Исправляет замечания после review-reply, обновляет код и прогоняет обязательные проверки после правок.",
-    "run-go-tests-loop": "Циклически запускает `./run_go_tests.py` локально, анализирует последнюю ошибку и правит код до успешного прохождения или исчерпания попыток.",
-    "run-go-linter-loop": "Циклически запускает `./run_go_linter.py` локально, исправляет проблемы линтера или генерации и повторяет попытки до успеха.",
+    "auto-golang": "Full task pipeline: planning, implementation, checks, review, review replies, and repeated iterations until ready to merge.",
+    "bug-analyze": "Analyzes bug from Jira and creates structured artifacts: root cause hypothesis, fix design, and implementation plan.",
+    "git-commit": "Collects git status/diff, generates commit message via LLM, allows file selection and commit confirmation.",
+    "gitlab-diff-review": "Requests GitLab MR URL via user-input, downloads merge request diff via API, and runs code review with markdown and structured JSON artifacts.",
+    "gitlab-review": "Requests GitLab MR URL via user-input, downloads code review comments via API, and saves markdown plus structured JSON artifact.",
+    "bug-fix": "Takes bug-analyze results as source of truth and implements the bug fix in code.",
+    "mr-description": "Prepares a brief intent description for a merge request based on the task and current changes.",
+    plan: "Loads task from Jira and creates design, implementation plan, and QA plan in structured JSON and markdown.",
+    "task-describe": "Builds a brief task description either from Jira or from quick user-input without Jira.",
+    implement: "Implements the task from approved design/plan artifacts and runs post-verify builds if needed.",
+    review: "Runs code review of current changes, validates structured findings, then prepares a reply to comments.",
+    "review-fix": "Fixes issues after review-reply, updates code, and runs mandatory checks after modifications.",
+    "review-loop": "Iteratively runs review and review-fix cycles up to 5 times until ready-to-merge is achieved.",
+    "run-go-tests-loop": "Cycles through `./run_go_tests.py` locally, analyzes the last error, and fixes code until successful or attempts exhausted.",
+    "run-go-linter-loop": "Cycles through `./run_go_linter.py` locally, fixes linter or generation issues, and retries until success.",
 };
 function flowDescription(id) {
     return FLOW_DESCRIPTIONS[id] ?? "Описание для этого flow пока не задано.";
@@ -549,6 +543,7 @@ function interactiveFlowDefinition(entry) {
         label: entry.id,
         description: flowDescription(entry.id),
         source: entry.source,
+        treePath: [...entry.treePath],
         ...(entry.source === "project-local" ? { sourcePath: entry.absolutePath } : {}),
         phases: flow.phases.map((phase) => ({
             id: phase.id,
@@ -598,13 +593,14 @@ function findCurrentFlowExecutionStep(state) {
     }
     return null;
 }
-async function runDeclarativeFlowByRef(flowId, flowRef, config, flowParams, requestUserInput = requestUserInputInTerminal, setSummary, launchMode = "restart") {
+async function runDeclarativeFlowByRef(flowId, flowRef, config, flowParams, overrides = {}, requestUserInput = requestUserInputInTerminal, setSummary, launchMode = "restart", runtime = runtimeServices) {
     const context = createPipelineContext({
         issueKey: config.taskKey,
         jiraRef: config.jiraRef,
         dryRun: config.dryRun,
         verbose: config.verbose,
-        runtime: runtimeServices,
+        ...(config.mdLang !== undefined ? { mdLang: config.mdLang } : {}),
+        runtime,
         ...(setSummary ? { setSummary } : {}),
         requestUserInput,
     });
@@ -617,13 +613,25 @@ async function runDeclarativeFlowByRef(flowId, flowRef, config, flowParams, requ
     };
     let persistedState = launchMode === "resume" ? loadFlowRunState(config.scope.scopeKey, flowId) : null;
     if (persistedState && launchMode === "resume") {
+        validateDeclarativeFlowResumeState({
+            id: flowId,
+            source: flow.source,
+            fileName: flow.fileName,
+            absolutePath: flow.absolutePath,
+            treePath: [],
+            flow,
+        }, config, persistedState, overrides.launchProfile, runtime);
         persistedState = prepareFlowStateForResume(persistedState);
     }
     else if (launchMode === "restart") {
         resetFlowRunState(config.scope.scopeKey, flowId);
     }
     const executionState = persistedState?.executionState ?? initialExecutionState;
-    const state = persistedState ?? createFlowRunState(config.scope.scopeKey, flowId, executionState);
+    const state = persistedState
+        ?? createFlowRunState(config.scope.scopeKey, flowId, executionState, config.jiraRef, overrides.launchProfile);
+    if (overrides.launchProfile) {
+        state.launchProfile = overrides.launchProfile;
+    }
     state.status = "running";
     state.lastError = null;
     state.currentStep = findCurrentFlowExecutionStep(state);
@@ -669,10 +677,17 @@ async function runDeclarativeFlowByRef(flowId, flowRef, config, flowParams, requ
         throw error;
     }
 }
-async function runDeclarativeFlowBySpecFile(fileName, config, flowParams, requestUserInput = requestUserInputInTerminal, setSummary, launchMode = "restart") {
-    await runDeclarativeFlowByRef(config.command, { source: "built-in", fileName }, config, flowParams, requestUserInput, setSummary, launchMode);
+async function runDeclarativeFlowBySpecFile(fileName, config, flowParams, overrides = {}, requestUserInput = requestUserInputInTerminal, setSummary, launchMode = "restart", runtime = runtimeServices) {
+    const mergedFlowParams = {
+        ...defaultDeclarativeFlowParams(config, false, overrides),
+        ...flowParams,
+    };
+    await runDeclarativeFlowByRef(config.command, { source: "built-in", fileName }, config, mergedFlowParams, overrides, requestUserInput, setSummary, launchMode, runtime);
 }
-function defaultDeclarativeFlowParams(config, forceRefreshSummary = false) {
+function defaultDeclarativeFlowParams(config, forceRefreshSummary = false, overrides = {}) {
+    const iteration = nextReviewIterationForTask(config.taskKey);
+    const latestIteration = latestArtifactIteration(config.taskKey, "review");
+    const launchProfile = overrides.launchProfile ?? resolveLaunchProfile({ executor: "default", model: "default" }, DEFAULT_LAUNCH_PROFILE);
     return {
         taskKey: config.taskKey,
         jiraRef: config.jiraRef,
@@ -680,12 +695,20 @@ function defaultDeclarativeFlowParams(config, forceRefreshSummary = false) {
         jiraApiUrl: config.jiraApiUrl,
         jiraTaskFile: config.jiraTaskFile,
         scopeKey: config.scope.scopeKey,
-        dockerComposeFile: config.dockerComposeFile,
-        runGoTestsScript: config.runGoTestsScript,
-        runGoLinterScript: config.runGoLinterScript,
-        runGoCoverageScript: config.runGoCoverageScript,
+        workspaceDir: scopeWorkspaceDir(config.taskKey),
         extraPrompt: config.extraPrompt,
         reviewFixPoints: config.reviewFixPoints,
+        mdLang: config.mdLang,
+        llmExecutor: launchProfile.executor,
+        llmModel: launchProfile.model,
+        launchProfile,
+        iteration,
+        latestIteration,
+        taskSummaryIteration: nextArtifactIteration(config.taskKey, "task"),
+        designIteration: nextArtifactIteration(config.taskKey, "design"),
+        planIteration: nextArtifactIteration(config.taskKey, "plan"),
+        qaIteration: nextArtifactIteration(config.taskKey, "qa"),
+        ...(latestIteration !== null ? { reviewFixSelectionJsonFile: reviewFixSelectionJsonFile(config.taskKey, latestIteration) } : {}),
         forceRefresh: forceRefreshSummary,
     };
 }
@@ -710,88 +733,13 @@ function flowRequiresTaskScope(entry) {
     }
     return valueReferencesTaskScopeParams(entry.flow.phases);
 }
-async function runAutoPhaseViaSpec(config, phaseId, executionState, state, setSummary, forceRefreshSummary = false) {
-    const context = createPipelineContext({
-        issueKey: config.taskKey,
-        jiraRef: config.jiraRef,
-        dryRun: config.dryRun,
-        verbose: config.verbose,
-        runtime: runtimeServices,
-        ...(setSummary ? { setSummary } : {}),
-        requestUserInput: requestUserInputInTerminal,
-    });
-    const autoFlow = loadAutoFlow();
-    const phase = findPhaseById(autoFlow.phases, phaseId);
-    publishFlowState("auto", executionState);
-    try {
-        const result = await runExpandedPhase(phase, context, autoFlowParams(config, forceRefreshSummary), 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;
-    }
-}
-function rewindAutoPipelineState(state, phaseId) {
-    const targetPhaseId = validateAutoPhaseId(phaseId);
-    let phaseSeen = false;
-    for (const step of state.steps) {
-        if (step.id === targetPhaseId) {
-            phaseSeen = true;
-        }
-        if (phaseSeen) {
-            step.status = "pending";
-            step.startedAt = null;
-            step.finishedAt = null;
-            step.returnCode = null;
-            step.note = null;
-        }
-        else {
-            step.status = "done";
-            step.returnCode = 0;
-            step.finishedAt ??= nowIso8601();
-        }
-    }
-    state.status = "pending";
-    state.currentStep = null;
-    state.lastError = null;
-    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({
         issueKey: "build-failure-summary",
         jiraRef: "build-failure-summary",
         dryRun: false,
         verbose: false,
+        mdLang: null,
         runtime: runtimeServices,
         requestUserInput: requestUserInputInTerminal,
     }), output);
@@ -801,27 +749,78 @@ function requireJiraConfig(config) {
         throw new TaskRunnerError(`Command '${config.command}' requires Jira context in the current project scope.`);
     }
 }
-async function executeCommand(baseConfig, runFollowupVerify = true, requestUserInput = requestUserInputInTerminal, resolvedScope, setSummary, forceRefreshSummary = false, launchMode = "restart") {
+async function executeCommand(baseConfig, runFollowupVerify = true, requestUserInput = requestUserInputInTerminal, resolvedScope, setSummary, forceRefreshSummary = false, launchMode = "restart", launchProfile, runtime = runtimeServices) {
     const config = buildRuntimeConfig(baseConfig, resolvedScope ?? (await resolveScopeForCommand(baseConfig, requestUserInput)));
-    if (config.command === "auto") {
-        if (launchMode === "restart") {
-            resetAutoPipelineState(config);
+    if (config.command === "auto-golang") {
+        requireJiraConfig(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 effectiveLaunchMode = launchMode;
+        let effectiveLaunchProfile = launchProfile;
+        if (config.autoFromPhase) {
+            const flow = loadDeclarativeFlow({ source: "built-in", fileName: "auto-golang.json" });
+            const persistedState = loadFlowRunState(config.scope.scopeKey, "auto-golang");
+            if (!persistedState) {
+                throw new TaskRunnerError(`Cannot restart auto-golang from phase '${config.autoFromPhase}' because persisted flow state was not found.`);
+            }
+            rewindFlowRunStateToPhase(persistedState, flow.phases, config.autoFromPhase);
+            saveFlowRunState(persistedState);
+            effectiveLaunchMode = "resume";
+            effectiveLaunchProfile ??= persistedState.launchProfile;
+            printPanel("Auto-Golang Resume", `Auto-golang pipeline will continue from phase: ${config.autoFromPhase}`, "yellow");
         }
-        await runAutoPipeline(config, setSummary, forceRefreshSummary);
+        await runDeclarativeFlowBySpecFile("auto-golang.json", config, autoFlowParams(config, forceRefreshSummary), effectiveLaunchProfile ? { launchProfile: effectiveLaunchProfile } : {}, requestUserInput, setSummary, effectiveLaunchMode, runtime);
+        return false;
+    }
+    if (config.command === "auto-common") {
+        requireJiraConfig(config);
+        checkAutoPrerequisites(config);
+        process.env.JIRA_BROWSE_URL = config.jiraBrowseUrl;
+        process.env.JIRA_API_URL = config.jiraApiUrl;
+        process.env.JIRA_TASK_FILE = config.jiraTaskFile;
+        await runDeclarativeFlowBySpecFile("auto-common.json", config, autoFlowParams(config, forceRefreshSummary), launchProfile ? { launchProfile } : {}, requestUserInput, setSummary, launchMode, runtime);
         return false;
     }
     if (config.command === "auto-status") {
-        const state = loadAutoPipelineState(config);
+        const state = loadFlowRunState(config.scope.scopeKey, "auto-golang");
         if (!state) {
-            printPanel("Auto Status", `No auto state file found for ${config.taskKey}.`, "yellow");
+            printPanel("Auto-Golang Status", `No flow state file found for ${config.taskKey}.`, "yellow");
             return false;
         }
-        printAutoState(state);
+        const currentStep = findCurrentFlowExecutionStep(state) ?? state.currentStep ?? "-";
+        const phaseOrder = loadDeclarativeFlow({ source: "built-in", fileName: "auto-golang.json" }).phases;
+        const lines = [
+            `Issue: ${config.taskKey}`,
+            `Status: ${state.status}`,
+            `Current step: ${currentStep}`,
+            `Updated: ${state.updatedAt}`,
+        ];
+        if (state.launchProfile) {
+            lines.push(`Launch profile: ${state.launchProfile.executor} / ${state.launchProfile.model}`);
+        }
+        if (state.lastError) {
+            lines.push(`Last error: ${state.lastError.step ?? "-"} (exit ${state.lastError.returnCode ?? "-"}, ${state.lastError.message ?? "-"})`);
+        }
+        lines.push("");
+        for (const phase of phaseOrder) {
+            const phaseState = state.executionState.phases.find((candidate) => candidate.id === phase.id);
+            lines.push(`[${phaseState?.status ?? "pending"}] ${phase.id}`);
+            for (const step of phase.steps) {
+                const stepState = phaseState?.steps.find((candidate) => candidate.id === step.id);
+                lines.push(`  - [${stepState?.status ?? "pending"}] ${step.id}`);
+            }
+        }
+        if (state.executionState.terminated) {
+            lines.push("", `Execution terminated: ${state.executionState.terminationReason ?? "yes"}`);
+        }
+        printPanel("Auto-Golang Status", lines.join("\n"), "cyan");
         return false;
     }
     if (config.command === "auto-reset") {
-        const removed = resetAutoPipelineState(config);
-        printPanel("Auto Reset", removed ? `State file ${autoStateFile(config.taskKey)} removed.` : "No auto state file found.", "yellow");
+        const removed = resetFlowRunState(config.scope.scopeKey, "auto-golang");
+        printPanel("Auto-Golang Reset", removed ? `State file ${flowStateFile(config.scope.scopeKey, "auto-golang")} removed.` : "No flow state file found.", "yellow");
         return false;
     }
     checkPrerequisites(config);
@@ -845,9 +844,13 @@ async function executeCommand(baseConfig, runFollowupVerify = true, requestUserI
         await runDeclarativeFlowBySpecFile("plan.json", config, {
             jiraApiUrl: config.jiraApiUrl,
             taskKey: config.taskKey,
+            taskSummaryIteration: nextArtifactIteration(config.taskKey, "task"),
+            designIteration: nextArtifactIteration(config.taskKey, "design"),
+            planIteration: nextArtifactIteration(config.taskKey, "plan"),
+            qaIteration: nextArtifactIteration(config.taskKey, "qa"),
             extraPrompt: config.extraPrompt,
             forceRefresh: forceRefreshSummary,
-        }, requestUserInput, setSummary, launchMode);
+        }, launchProfile ? { launchProfile } : {}, requestUserInput, setSummary, launchMode, runtime);
         return false;
     }
     if (config.command === "bug-analyze") {
@@ -857,21 +860,27 @@ async function executeCommand(baseConfig, runFollowupVerify = true, requestUserI
             process.stdout.write(`Resolved Jira API URL: ${config.jiraApiUrl}\n`);
             process.stdout.write(`Saving Jira issue JSON to: ${config.jiraTaskFile}\n`);
         }
-        await runDeclarativeFlowBySpecFile("bug-analyze.json", config, {
+        await runDeclarativeFlowBySpecFile("bugz/bug-analyze.json", config, {
             jiraApiUrl: config.jiraApiUrl,
             taskKey: config.taskKey,
+            taskSummaryIteration: nextArtifactIteration(config.taskKey, "task"),
+            bugAnalyzeIteration: nextArtifactIteration(config.taskKey, "bug-analyze"),
+            bugFixDesignIteration: nextArtifactIteration(config.taskKey, "bug-fix-design"),
+            bugFixPlanIteration: nextArtifactIteration(config.taskKey, "bug-fix-plan"),
             extraPrompt: config.extraPrompt,
             forceRefresh: forceRefreshSummary,
-        }, requestUserInput, setSummary, launchMode);
+        }, launchProfile ? { launchProfile } : {}, requestUserInput, setSummary, launchMode, runtime);
         return false;
     }
     if (config.command === "gitlab-review") {
         const iteration = nextReviewIterationForTask(config.taskKey);
-        await runDeclarativeFlowBySpecFile("gitlab-review.json", config, {
+        const gitlabReviewIteration = nextArtifactIteration(config.taskKey, "gitlab-review");
+        await runDeclarativeFlowBySpecFile("gitlab/gitlab-review.json", config, {
             taskKey: config.taskKey,
             iteration,
+            gitlabReviewIteration,
             extraPrompt: config.extraPrompt,
-        }, requestUserInput, undefined, launchMode);
+        }, launchProfile ? { launchProfile } : {}, requestUserInput, undefined, launchMode, runtime);
         if (!config.dryRun) {
             printSummary("GitLab Review", `Artifacts:\n${gitlabReviewFile(config.taskKey)}\n${gitlabReviewJsonFile(config.taskKey)}`);
         }
@@ -879,11 +888,13 @@ async function executeCommand(baseConfig, runFollowupVerify = true, requestUserI
     }
     if (config.command === "gitlab-diff-review") {
         const iteration = nextReviewIterationForTask(config.taskKey);
-        await runDeclarativeFlowBySpecFile("gitlab-diff-review.json", config, {
+        const gitlabDiffIteration = nextArtifactIteration(config.taskKey, "gitlab-diff");
+        await runDeclarativeFlowBySpecFile("gitlab/gitlab-diff-review.json", config, {
             taskKey: config.taskKey,
             iteration,
+            gitlabDiffIteration,
             extraPrompt: config.extraPrompt,
-        }, requestUserInput, undefined, launchMode);
+        }, launchProfile ? { launchProfile } : {}, requestUserInput, undefined, launchMode, runtime);
         if (!config.dryRun) {
             printSummary("GitLab Diff Review", `Artifacts:\n${gitlabDiffFile(config.taskKey)}\n${gitlabDiffJsonFile(config.taskKey)}\n${reviewFile(config.taskKey, iteration)}\n${reviewJsonFile(config.taskKey, iteration)}`);
         }
@@ -898,28 +909,30 @@ async function executeCommand(baseConfig, runFollowupVerify = true, requestUserI
             { path: bugFixDesignJsonFile(config.taskKey), schemaId: "bug-fix-design/v1" },
             { path: bugFixPlanJsonFile(config.taskKey), schemaId: "bug-fix-plan/v1" },
         ], "Bug-fix mode requires valid structured artifacts from the bug analysis phase.");
-        await runDeclarativeFlowBySpecFile("bug-fix.json", config, {
+        await runDeclarativeFlowBySpecFile("bugz/bug-fix.json", config, {
             taskKey: config.taskKey,
             extraPrompt: config.extraPrompt,
-        }, requestUserInput, undefined, launchMode);
+        }, launchProfile ? { launchProfile } : {}, requestUserInput, undefined, launchMode, runtime);
         return false;
     }
     if (config.command === "mr-description") {
         requireJiraConfig(config);
         requireJiraTaskFile(config.jiraTaskFile);
-        await runDeclarativeFlowBySpecFile("mr-description.json", config, {
+        await runDeclarativeFlowBySpecFile("gitlab/mr-description.json", config, {
             taskKey: config.taskKey,
+            iteration: nextArtifactIteration(config.taskKey, "mr-description"),
             extraPrompt: config.extraPrompt,
-        }, requestUserInput, undefined, launchMode);
+        }, launchProfile ? { launchProfile } : {}, requestUserInput, undefined, launchMode, runtime);
         return false;
     }
     if (config.command === "task-describe") {
-        requireJiraConfig(config);
+        const iteration = nextArtifactIteration(config.taskKey, "jira-description");
         await runDeclarativeFlowBySpecFile("task-describe.json", config, {
             jiraApiUrl: config.jiraApiUrl,
             taskKey: config.taskKey,
+            iteration,
             extraPrompt: config.extraPrompt,
-        }, requestUserInput, undefined, launchMode);
+        }, launchProfile ? { launchProfile } : {}, requestUserInput, undefined, launchMode, runtime);
         return false;
     }
     if (config.command === "implement") {
@@ -932,7 +945,7 @@ async function executeCommand(baseConfig, runFollowupVerify = true, requestUserI
         await runDeclarativeFlowBySpecFile("implement.json", config, {
             taskKey: config.taskKey,
             extraPrompt: config.extraPrompt,
-        }, requestUserInput, undefined, launchMode);
+        }, launchProfile ? { launchProfile } : {}, requestUserInput, undefined, launchMode);
         return false;
     }
     if (config.command === "review") {
@@ -943,142 +956,73 @@ async function executeCommand(baseConfig, runFollowupVerify = true, requestUserI
                 { path: designJsonFile(config.taskKey), schemaId: "implementation-design/v1" },
                 { path: planJsonFile(config.taskKey), schemaId: "implementation-plan/v1" },
             ], "Review mode requires valid structured plan artifacts from the planning phase.");
-            await runDeclarativeFlowBySpecFile("review.json", config, {
+            await runDeclarativeFlowBySpecFile("review/review.json", config, {
                 taskKey: config.taskKey,
                 iteration,
                 extraPrompt: config.extraPrompt,
-            }, requestUserInput, undefined, launchMode);
+            }, launchProfile ? { launchProfile } : {}, requestUserInput, undefined, launchMode, runtime);
         }
         else {
-            await runDeclarativeFlowBySpecFile("review-project.json", config, {
+            await runDeclarativeFlowBySpecFile("review/review-project.json", config, {
                 taskKey: config.taskKey,
                 iteration,
                 extraPrompt: config.extraPrompt,
-            }, requestUserInput, undefined, launchMode);
+            }, launchProfile ? { launchProfile } : {}, requestUserInput, undefined, launchMode, runtime);
         }
         return !config.dryRun && existsSync(readyToMergeFile(config.taskKey));
     }
     if (config.command === "review-fix") {
-        const latestIteration = latestReviewReplyIteration(config.taskKey);
+        const latestIteration = latestArtifactIteration(config.taskKey, "review");
         if (latestIteration === null) {
-            throw new TaskRunnerError("Review-fix mode requires at least one review-reply artifact.");
+            throw new TaskRunnerError("Review-fix mode requires at least one review artifact.");
         }
         validateStructuredArtifacts([
             { path: reviewJsonFile(config.taskKey, latestIteration), schemaId: "review-findings/v1" },
-            { path: reviewReplyJsonFile(config.taskKey, latestIteration), schemaId: "review-reply/v1" },
         ], "Review-fix mode requires valid structured review artifacts.");
-        await runDeclarativeFlowBySpecFile("review-fix.json", config, {
+        await runDeclarativeFlowBySpecFile("review/review-fix.json", config, {
             taskKey: config.taskKey,
             latestIteration,
             reviewFixSelectionJsonFile: reviewFixSelectionJsonFile(config.taskKey, latestIteration),
             extraPrompt: config.extraPrompt,
             reviewFixPoints: config.reviewFixPoints,
-        }, requestUserInput, undefined, launchMode);
+        }, launchProfile ? { launchProfile } : {}, requestUserInput, undefined, launchMode, runtime);
         return false;
     }
+    if (config.command === "review-loop") {
+        const iteration = nextReviewIterationForTask(config.taskKey);
+        if (config.jiraBrowseUrl && config.jiraApiUrl && config.jiraTaskFile) {
+            requireJiraConfig(config);
+            validateStructuredArtifacts([
+                { path: designJsonFile(config.taskKey), schemaId: "implementation-design/v1" },
+                { path: planJsonFile(config.taskKey), schemaId: "implementation-plan/v1" },
+            ], "Review-loop mode requires valid structured plan artifacts from the planning phase.");
+        }
+        await runDeclarativeFlowBySpecFile("review/review-loop.json", config, {
+            taskKey: config.taskKey,
+            iteration,
+            extraPrompt: config.extraPrompt,
+        }, launchProfile ? { launchProfile } : {}, requestUserInput, undefined, launchMode, runtime);
+        return !config.dryRun && existsSync(readyToMergeFile(config.taskKey));
+    }
     if (config.command === "run-go-tests-loop" || config.command === "run-go-linter-loop") {
-        await runDeclarativeFlowBySpecFile(config.command === "run-go-tests-loop" ? "run-go-tests-loop.json" : "run-go-linter-loop.json", config, {
+        await runDeclarativeFlowBySpecFile(config.command === "run-go-tests-loop" ? "go/run-go-tests-loop.json" : "go/run-go-linter-loop.json", config, {
             taskKey: config.taskKey,
-            runGoTestsScript: config.runGoTestsScript,
-            runGoLinterScript: config.runGoLinterScript,
+            runGoTestsScript: path.join(agentweaverHome(PACKAGE_ROOT), "run_go_tests.py"),
+            runGoLinterScript: path.join(agentweaverHome(PACKAGE_ROOT), "run_go_linter.py"),
+            runGoTestsIteration: nextArtifactIteration(config.taskKey, "run-go-tests-result", "json"),
+            runGoLinterIteration: nextArtifactIteration(config.taskKey, "run-go-linter-result", "json"),
             extraPrompt: config.extraPrompt,
-        }, requestUserInput, undefined, launchMode);
+        }, launchProfile ? { launchProfile } : {}, requestUserInput, undefined, launchMode, runtime);
         return false;
     }
-    throw new TaskRunnerError(`Unsupported command: ${config.command}`);
-}
-async function runAutoPipelineDryRun(config, setSummary, forceRefreshSummary = false) {
-    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, undefined, setSummary, forceRefreshSummary);
-        if (executionState.terminated) {
-            break;
-        }
-    }
-}
-async function runAutoPipeline(config, setSummary, forceRefreshSummary = false) {
-    requireJiraConfig(config);
-    if (config.dryRun) {
-        await runAutoPipelineDryRun(config, setSummary, forceRefreshSummary);
-        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);
-        printPanel("Auto Resume", `Auto pipeline will continue from phase: ${config.autoFromPhase}`, "yellow");
-        saveAutoPipelineState(state);
-    }
-    else if (!existsSync(autoStateFile(config.taskKey))) {
-        saveAutoPipelineState(state);
-    }
-    printInfo("Running auto pipeline with persisted state");
-    while (true) {
-        const step = nextAutoStep(state);
-        if (!step) {
-            syncAndSaveAutoPipelineState(state);
-            if (state.status === "completed") {
-                printPanel("Auto", "Auto pipeline finished", "green");
-            }
-            else {
-                printInfo(`Auto pipeline finished with status: ${state.status}`);
-            }
-            return;
-        }
-        state.status = "running";
-        state.currentStep = step.id;
-        step.status = "running";
-        step.startedAt = nowIso8601();
-        step.finishedAt = null;
-        step.returnCode = null;
-        step.note = null;
-        state.lastError = null;
-        saveAutoPipelineState(state);
-        try {
-            printInfo(`Running auto step: ${step.id}`);
-            const status = await runAutoPhaseViaSpec(config, step.id, state.executionState, state, setSummary, forceRefreshSummary);
-            step.status = status;
-            step.finishedAt = nowIso8601();
-            step.returnCode = 0;
-            if (status === "skipped") {
-                step.note = "condition not met";
-            }
-            syncAndSaveAutoPipelineState(state);
-        }
-        catch (error) {
-            const returnCode = Number(error.returnCode ?? 1);
-            step.status = "failed";
-            step.finishedAt = nowIso8601();
-            step.returnCode = returnCode;
-            state.status = "blocked";
-            state.currentStep = step.id;
-            state.lastError = {
-                step: step.id,
-                returnCode,
-                message: "command failed",
-            };
-            saveAutoPipelineState(state);
-            throw error;
-        }
-        if (state.executionState.terminated) {
-            syncAndSaveAutoPipelineState(state);
-            printPanel("Auto", "Auto pipeline finished", "green");
-            return;
-        }
+    if (config.command === "git-commit") {
+        await runDeclarativeFlowBySpecFile("git-commit.json", config, {
+            taskKey: config.taskKey,
+            extraPrompt: config.extraPrompt,
+        }, launchProfile ? { launchProfile } : {}, requestUserInput, undefined, launchMode, runtime);
+        return false;
     }
+    throw new TaskRunnerError(`Unsupported command: ${config.command}`);
 }
 function parseCliArgs(argv) {
     if (argv.includes("--version") || argv.includes("-v")) {
@@ -1105,6 +1049,7 @@ function parseCliArgs(argv) {
     let scopeName;
     let helpPhases = false;
     let jiraRef;
+    let mdLang;
     for (let index = 1; index < argv.length; index += 1) {
         const token = argv[index] ?? "";
         if (token === "--dry") {
@@ -1134,12 +1079,39 @@ function parseCliArgs(argv) {
             index += 1;
             continue;
         }
+        if (token === "--md-lang") {
+            const langValue = argv[index + 1];
+            if (langValue === "en" || langValue === "ru") {
+                mdLang = langValue;
+            }
+            else {
+                process.stderr.write("Error: --md-lang accepts only 'en' or 'ru' as values.\n");
+                process.exit(1);
+            }
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("--md-lang=")) {
+            const langValue = token.slice("--md-lang=".length);
+            if (langValue === "en" || langValue === "ru") {
+                mdLang = langValue;
+            }
+            else {
+                process.stderr.write("Error: --md-lang accepts only 'en' or 'ru' as values.\n");
+                process.exit(1);
+            }
+            continue;
+        }
         jiraRef = token;
     }
-    if (command === "auto" && helpPhases) {
+    if (command === "auto-golang" && helpPhases) {
         printAutoPhasesHelp();
         process.exit(0);
     }
+    if (command === "auto-common" && helpPhases) {
+        printAutoCommonPhasesHelp();
+        process.exit(0);
+    }
     return {
         command: command,
         dry,
@@ -1149,6 +1121,7 @@ function parseCliArgs(argv) {
         ...(scopeName !== undefined ? { scopeName } : {}),
         ...(prompt !== undefined ? { prompt } : {}),
         ...(autoFromPhase !== undefined ? { autoFromPhase } : {}),
+        ...(mdLang !== undefined ? { mdLang } : {}),
     };
 }
 function buildConfigFromArgs(args) {
@@ -1157,6 +1130,7 @@ function buildConfigFromArgs(args) {
         ...(args.scopeName !== undefined ? { scopeName: args.scopeName } : {}),
         ...(args.prompt !== undefined ? { extraPrompt: args.prompt } : {}),
         ...(args.autoFromPhase !== undefined ? { autoFromPhase: args.autoFromPhase } : {}),
+        ...(args.mdLang !== undefined ? { mdLang: args.mdLang } : {}),
         dryRun: args.dry,
         verbose: args.verbose,
     });
@@ -1165,6 +1139,8 @@ async function runInteractive(jiraRef, forceRefresh = false, scopeName) {
     let currentScope = resolveProjectScope(scopeName, jiraRef);
     const gitBranchName = detectGitBranchName();
     const flowCatalog = loadInteractiveFlowCatalog(process.cwd());
+    let activeAbortController = null;
+    let activeFlowId = null;
     let exiting = false;
     const ui = new InteractiveUi({
         scopeKey: currentScope.scopeKey,
@@ -1172,43 +1148,35 @@ async function runInteractive(jiraRef, forceRefresh = false, scopeName) {
         summaryText: "",
         cwd: process.cwd(),
         gitBranchName,
+        version: packageVersion(),
         flows: interactiveFlowDefinitions(flowCatalog),
         getRunConfirmation: async (flowId) => {
             const flowEntry = findCatalogEntry(flowId, flowCatalog);
             if (!flowEntry) {
                 throw new TaskRunnerError(`Unknown flow: ${flowId}`);
             }
-            if (flowId === "auto") {
-                if (!currentScope.jiraRef) {
-                    return { resumeAvailable: false, hasExistingState: false };
-                }
-                const baseConfig = buildBaseConfig("auto", {
-                    jiraRef: currentScope.jiraRef,
-                    scopeName: currentScope.scopeKey,
-                });
-                const state = loadAutoPipelineState(buildRuntimeConfig(baseConfig, currentScope));
-                if (!state) {
-                    return { resumeAvailable: false, hasExistingState: false };
-                }
-                const status = deriveAutoPipelineStatus(state);
-                if (status === "completed") {
-                    return { resumeAvailable: false, hasExistingState: true };
-                }
-                return {
-                    resumeAvailable: true,
-                    hasExistingState: true,
-                    details: buildAutoResumeDetails(state),
-                };
-            }
             const resumeLookup = lookupInteractiveFlowResume(flowEntry, currentScope);
             return resumeLookup;
         },
         onRun: async (flowId, launchMode) => {
+            const abortController = new AbortController();
+            activeAbortController = abortController;
+            activeFlowId = flowId;
             try {
                 const flowEntry = findCatalogEntry(flowId, flowCatalog);
                 if (!flowEntry) {
                     throw new TaskRunnerError(`Unknown flow: ${flowId}`);
                 }
+                const resumeState = launchMode === "resume" ? loadFlowRunState(currentScope.scopeKey, flowId) : null;
+                if (resumeState) {
+                    currentScope = scopeWithRestoredJiraContext(currentScope, resumeState);
+                }
+                const launchProfile = launchMode === "resume"
+                    ? resumeState?.launchProfile
+                    : await requestInteractiveLaunchProfile((form) => ui.requestUserInput(form));
+                if (!launchProfile) {
+                    throw new TaskRunnerError("Resume is impossible because launch profile was not saved. Use restart.");
+                }
                 const previousScopeKey = currentScope.scopeKey;
                 const baseConfig = buildBaseConfig(flowId, {
                     ...(currentScope.jiraRef ? { jiraRef: currentScope.jiraRef } : {}),
@@ -1226,14 +1194,20 @@ async function runInteractive(jiraRef, forceRefresh = false, scopeName) {
                 if (previousScopeKey !== currentScope.scopeKey || currentScope.jiraIssueKey) {
                     syncInteractiveTaskSummary(ui, currentScope, forceRefresh);
                 }
+                printPanel("Effective Launch Config", `executor: ${launchProfile.executor}\nmodel: ${launchProfile.model}\nmode: ${launchMode}`, "cyan");
                 if (flowEntry.source === "built-in" && isBuiltInCommandFlowId(flowId)) {
-                    await executeCommand(baseConfig, true, (form) => ui.requestUserInput(form), currentScope, (markdown) => ui.setSummary(markdown), forceRefresh, launchMode);
+                    await executeCommand(baseConfig, true, (form) => ui.requestUserInput(form), currentScope, (markdown) => ui.setSummary(markdown), forceRefresh, launchMode, launchProfile, createRuntimeServices(abortController.signal));
                     return;
                 }
                 const runtimeConfig = buildRuntimeConfig(baseConfig, currentScope);
-                await runDeclarativeFlowByRef(flowId, toDeclarativeFlowRef(flowEntry), runtimeConfig, defaultDeclarativeFlowParams(runtimeConfig, forceRefresh), (form) => ui.requestUserInput(form), (markdown) => ui.setSummary(markdown), launchMode);
+                await runDeclarativeFlowByRef(flowId, toDeclarativeFlowRef(flowEntry), runtimeConfig, defaultDeclarativeFlowParams(runtimeConfig, forceRefresh, { launchProfile }), { launchProfile }, (form) => ui.requestUserInput(form), (markdown) => ui.setSummary(markdown), launchMode, createRuntimeServices(abortController.signal));
             }
             catch (error) {
+                if (error instanceof FlowInterruptedError) {
+                    ui.appendLog(`[interrupt] ${error.message}`);
+                    printInfo(error.message);
+                    return;
+                }
                 if (error instanceof TaskRunnerError) {
                     ui.setFlowFailed(flowId);
                     printError(error.message);
@@ -1247,6 +1221,19 @@ async function runInteractive(jiraRef, forceRefresh = false, scopeName) {
                 }
                 throw error;
             }
+            finally {
+                if (activeAbortController === abortController) {
+                    activeAbortController = null;
+                    activeFlowId = null;
+                }
+            }
+        },
+        onInterrupt: async (flowId) => {
+            if (!activeAbortController || activeFlowId !== flowId) {
+                return;
+            }
+            ui.interruptActiveForm();
+            activeAbortController.abort();
         },
         onExit: () => {
             exiting = true;
@@ -1277,7 +1264,7 @@ async function runInteractive(jiraRef, forceRefresh = false, scopeName) {
     });
 }
 export async function main(argv = process.argv.slice(2)) {
-    loadEnvFile(path.join(process.cwd(), ".env"));
+    loadTieredEnv(process.cwd());
     let forceRefresh = false;
     const args = [...argv];
     if (args[0] === "--force") {