agentweaver 0.1.8 → 0.1.10

package/dist/index.js

@@ -3,8 +3,8 @@ import { existsSync, readdirSync, readFileSync, rmSync, writeFileSync } from "no
 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, ensureScopeWorkspaceDir, gitlabReviewFile, gitlabReviewJsonFile, planJsonFile, planArtifacts, qaJsonFile, readyToMergeFile, requireArtifacts, reviewReplyJsonFile, reviewFixSelectionJsonFile, reviewJsonFile, scopeWorkspaceDir, taskSummaryFile, } from "./artifacts.js";
-import { TaskRunnerError } from "./errors.js";
+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 { FlowInterruptedError, TaskRunnerError } from "./errors.js";
 import { createFlowRunState, hasResumableFlowState, loadFlowRunState, prepareFlowStateForResume, resetFlowRunState, saveFlowRunState, stripExecutionStatePayload, } from "./flow-state.js";
 import { requireJiraTaskFile } from "./jira.js";
 import { validateStructuredArtifacts } from "./structured-artifacts.js";
@@ -13,16 +13,18 @@ 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 { 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 { 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 { detectGitBranchName, requestTaskScope, resolveProjectScope, resolveTaskScope, } from "./scope.js";
+import { attachJiraContext, detectGitBranchName, requestJiraContext, resolveProjectScope, } from "./scope.js";
 const COMMANDS = [
     "bug-analyze",
     "bug-fix",
+    "gitlab-diff-review",
     "gitlab-review",
     "mr-description",
     "plan",
@@ -39,12 +41,15 @@ const COMMANDS = [
 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,
+        resolveDockerComposeCmd,
+        dockerRuntimeEnv: () => dockerRuntimeEnv(PACKAGE_ROOT),
+        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) {
@@ -81,7 +86,8 @@ function usage() {
   agentweaver
   agentweaver <jira-browse-url|jira-issue-key>
   agentweaver --force <jira-browse-url|jira-issue-key>
-  agentweaver gitlab-review [--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>
@@ -100,8 +106,8 @@ function usage() {
 
 Interactive Mode:
   When started without a command, the script opens an interactive UI.
-  If a Jira task is provided, interactive mode starts in task scope; otherwise it starts in project scope.
-  Use Up/Down to select a flow, Enter to confirm launch, h for help, q to exit.
+  If a Jira task is provided, interactive mode starts in the current project scope with Jira context attached.
+  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
@@ -121,12 +127,15 @@ Optional environment variables:
   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.
-  - Scope-flexible flows use the current git branch by default when Jira task is not provided.`;
+  - 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.`;
 }
 function packageVersion() {
     const packageJsonPath = path.join(PACKAGE_ROOT, "package.json");
@@ -334,6 +343,20 @@ function buildFlowResumeDetails(state) {
     }
     return lines.join("\n");
 }
+function lookupInteractiveFlowResume(flowEntry, currentScope) {
+    const directState = loadFlowRunState(currentScope.scopeKey, flowEntry.id);
+    if (directState && hasResumableFlowState(directState)) {
+        return {
+            resumeAvailable: true,
+            hasExistingState: true,
+            details: buildFlowResumeDetails(directState),
+        };
+    }
+    return {
+        resumeAvailable: false,
+        hasExistingState: Boolean(directState),
+    };
+}
 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>");
@@ -423,7 +446,6 @@ function commandRequiresTask(command) {
     return (command === "plan" ||
         command === "bug-analyze" ||
         command === "bug-fix" ||
-        command === "gitlab-review" ||
         command === "mr-description" ||
         command === "task-describe" ||
         command === "auto" ||
@@ -431,7 +453,9 @@ function commandRequiresTask(command) {
         command === "auto-reset");
 }
 function commandSupportsProjectScope(command) {
-    return (command === "implement" ||
+    return (command === "gitlab-diff-review" ||
+        command === "gitlab-review" ||
+        command === "implement" ||
         command === "review" ||
         command === "review-fix" ||
         command === "run-go-tests-loop" ||
@@ -439,12 +463,12 @@ function commandSupportsProjectScope(command) {
 }
 async function resolveScopeForCommand(config, requestUserInput) {
     if (config.jiraRef?.trim()) {
-        return resolveTaskScope(config.jiraRef, config.scopeName);
+        return resolveProjectScope(config.scopeName, config.jiraRef);
     }
     if (commandRequiresTask(config.command)) {
         try {
-            const taskScope = await requestTaskScope(requestUserInput);
-            return config.scopeName ? resolveTaskScope(taskScope.jiraRef, config.scopeName) : taskScope;
+            const jiraContext = await requestJiraContext(requestUserInput);
+            return resolveProjectScope(config.scopeName, jiraContext.jiraRef);
         }
         catch (error) {
             if (error instanceof TaskRunnerError && error.message.includes("no TTY is available")) {
@@ -461,22 +485,14 @@ async function resolveScopeForCommand(config, requestUserInput) {
 }
 function buildRuntimeConfig(baseConfig, scope) {
     ensureScopeWorkspaceDir(scope.scopeKey);
-    if (scope.scopeType === "task") {
-        return {
-            ...baseConfig,
-            scope,
-            taskKey: scope.scopeKey,
-            jiraRef: scope.jiraRef,
-            jiraBrowseUrl: scope.jiraBrowseUrl,
-            jiraApiUrl: scope.jiraApiUrl,
-            jiraTaskFile: scope.jiraTaskFile,
-        };
-    }
     return {
         ...baseConfig,
         scope,
         taskKey: scope.scopeKey,
-        jiraRef: scope.scopeKey,
+        jiraRef: scope.jiraRef ?? scope.scopeKey,
+        ...(scope.jiraBrowseUrl ? { jiraBrowseUrl: scope.jiraBrowseUrl } : {}),
+        ...(scope.jiraApiUrl ? { jiraApiUrl: scope.jiraApiUrl } : {}),
+        ...(scope.jiraTaskFile ? { jiraTaskFile: scope.jiraTaskFile } : {}),
     };
 }
 function checkPrerequisites(config) {
@@ -490,7 +506,7 @@ function checkPrerequisites(config) {
         config.command === "run-go-linter-loop") {
         resolveCmd("codex", "CODEX_BIN");
     }
-    if (config.command === "review") {
+    if (config.command === "review" || config.command === "gitlab-diff-review") {
         resolveCmd("claude", "CLAUDE_BIN");
     }
 }
@@ -514,6 +530,7 @@ function autoFlowParams(config, forceRefreshSummary = false) {
 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 на основе задачи и текущих изменений.",
@@ -528,12 +545,15 @@ const FLOW_DESCRIPTIONS = {
 function flowDescription(id) {
     return FLOW_DESCRIPTIONS[id] ?? "Описание для этого flow пока не задано.";
 }
-function declarativeFlowDefinition(id, label, fileName) {
-    const flow = loadDeclarativeFlow(fileName);
+function interactiveFlowDefinition(entry) {
+    const flow = entry.flow;
     return {
-        id,
-        label,
-        description: flowDescription(id),
+        id: entry.id,
+        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,
             repeatVars: Object.fromEntries(Object.entries(phase.repeatVars).map(([key, value]) => [key, value])),
@@ -543,36 +563,8 @@ function declarativeFlowDefinition(id, label, fileName) {
         })),
     };
 }
-function autoFlowDefinition() {
-    const flow = loadAutoFlow();
-    return {
-        id: "auto",
-        label: "auto",
-        description: flowDescription("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("bug-analyze", "bug-analyze", "bug-analyze.json"),
-        declarativeFlowDefinition("bug-fix", "bug-fix", "bug-fix.json"),
-        declarativeFlowDefinition("gitlab-review", "gitlab-review", "gitlab-review.json"),
-        declarativeFlowDefinition("mr-description", "mr-description", "mr-description.json"),
-        declarativeFlowDefinition("plan", "plan", "plan.json"),
-        declarativeFlowDefinition("task-describe", "task-describe", "task-describe.json"),
-        declarativeFlowDefinition("implement", "implement", "implement.json"),
-        declarativeFlowDefinition("review", "review", "review.json"),
-        declarativeFlowDefinition("review-fix", "review-fix", "review-fix.json"),
-        declarativeFlowDefinition("run-go-tests-loop", "run-go-tests-loop", "run-go-tests-loop.json"),
-        declarativeFlowDefinition("run-go-linter-loop", "run-go-linter-loop", "run-go-linter-loop.json"),
-    ];
+function interactiveFlowDefinitions(catalog) {
+    return catalog.map((entry) => interactiveFlowDefinition(entry));
 }
 function publishFlowState(flowId, executionState) {
     setFlowExecutionState(flowId, stripExecutionStatePayload(executionState));
@@ -586,7 +578,7 @@ function loadTaskSummaryMarkdown(taskKey) {
     return markdown.length > 0 ? markdown : null;
 }
 function syncInteractiveTaskSummary(ui, scope, forceRefresh = false) {
-    if (scope.scopeType !== "task" || forceRefresh) {
+    if (forceRefresh) {
         ui.clearSummary();
         return;
     }
@@ -610,38 +602,38 @@ function findCurrentFlowExecutionStep(state) {
     }
     return null;
 }
-async function runDeclarativeFlowBySpecFile(fileName, config, flowParams, requestUserInput = requestUserInputInTerminal, setSummary, launchMode = "restart") {
+async function runDeclarativeFlowByRef(flowId, flowRef, config, flowParams, requestUserInput = requestUserInputInTerminal, setSummary, launchMode = "restart", runtime = runtimeServices) {
     const context = createPipelineContext({
         issueKey: config.taskKey,
         jiraRef: config.jiraRef,
         dryRun: config.dryRun,
         verbose: config.verbose,
-        runtime: runtimeServices,
+        runtime,
         ...(setSummary ? { setSummary } : {}),
         requestUserInput,
     });
-    const flow = loadDeclarativeFlow(fileName);
+    const flow = loadDeclarativeFlow(flowRef);
     const initialExecutionState = {
         flowKind: flow.kind,
         flowVersion: flow.version,
         terminated: false,
         phases: [],
     };
-    let persistedState = launchMode === "resume" ? loadFlowRunState(config.scope.scopeKey, config.command) : null;
+    let persistedState = launchMode === "resume" ? loadFlowRunState(config.scope.scopeKey, flowId) : null;
     if (persistedState && launchMode === "resume") {
         persistedState = prepareFlowStateForResume(persistedState);
     }
     else if (launchMode === "restart") {
-        resetFlowRunState(config.scope.scopeKey, config.command);
+        resetFlowRunState(config.scope.scopeKey, flowId);
     }
     const executionState = persistedState?.executionState ?? initialExecutionState;
-    const state = persistedState ?? createFlowRunState(config.scope.scopeKey, config.command, executionState);
+    const state = persistedState ?? createFlowRunState(config.scope.scopeKey, flowId, executionState);
     state.status = "running";
     state.lastError = null;
     state.currentStep = findCurrentFlowExecutionStep(state);
     state.executionState = executionState;
     saveFlowRunState(state);
-    publishFlowState(config.command, executionState);
+    publishFlowState(flowId, executionState);
     try {
         for (const phase of flow.phases) {
             await runExpandedPhase(phase, context, flowParams, flow.constants, {
@@ -652,7 +644,7 @@ async function runDeclarativeFlowBySpecFile(fileName, config, flowParams, reques
                     state.executionState = nextExecutionState;
                     state.currentStep = findCurrentFlowExecutionStep(state);
                     saveFlowRunState(state);
-                    publishFlowState(config.command, nextExecutionState);
+                    publishFlowState(flowId, nextExecutionState);
                 },
                 onStepStart: async (currentPhase, step) => {
                     state.currentStep = `${currentPhase.id}:${step.id}`;
@@ -681,13 +673,59 @@ async function runDeclarativeFlowBySpecFile(fileName, config, flowParams, reques
         throw error;
     }
 }
-async function runAutoPhaseViaSpec(config, phaseId, executionState, state, setSummary, forceRefreshSummary = false) {
+async function runDeclarativeFlowBySpecFile(fileName, config, flowParams, requestUserInput = requestUserInputInTerminal, setSummary, launchMode = "restart", runtime = runtimeServices) {
+    await runDeclarativeFlowByRef(config.command, { source: "built-in", fileName }, config, flowParams, requestUserInput, setSummary, launchMode, runtime);
+}
+function defaultDeclarativeFlowParams(config, forceRefreshSummary = false) {
+    const iteration = nextReviewIterationForTask(config.taskKey);
+    const latestIteration = latestReviewReplyIteration(config.taskKey);
+    return {
+        taskKey: config.taskKey,
+        jiraRef: config.jiraRef,
+        jiraBrowseUrl: config.jiraBrowseUrl,
+        jiraApiUrl: config.jiraApiUrl,
+        jiraTaskFile: config.jiraTaskFile,
+        scopeKey: config.scope.scopeKey,
+        dockerComposeFile: config.dockerComposeFile,
+        runGoTestsScript: config.runGoTestsScript,
+        runGoLinterScript: config.runGoLinterScript,
+        runGoCoverageScript: config.runGoCoverageScript,
+        extraPrompt: config.extraPrompt,
+        reviewFixPoints: config.reviewFixPoints,
+        iteration,
+        latestIteration,
+        ...(latestIteration !== null ? { reviewFixSelectionJsonFile: reviewFixSelectionJsonFile(config.taskKey, latestIteration) } : {}),
+        forceRefresh: forceRefreshSummary,
+    };
+}
+const TASK_SCOPE_PARAM_REFS = new Set(["params.jiraApiUrl", "params.jiraBrowseUrl", "params.jiraTaskFile"]);
+function valueReferencesTaskScopeParams(value) {
+    if (Array.isArray(value)) {
+        return value.some((item) => valueReferencesTaskScopeParams(item));
+    }
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    if ("ref" in value &&
+        typeof value.ref === "string" &&
+        TASK_SCOPE_PARAM_REFS.has(value.ref)) {
+        return true;
+    }
+    return Object.values(value).some((item) => valueReferencesTaskScopeParams(item));
+}
+function flowRequiresTaskScope(entry) {
+    if (entry.source === "built-in" && isBuiltInCommandFlowId(entry.id)) {
+        return commandRequiresTask(entry.id);
+    }
+    return valueReferencesTaskScopeParams(entry.flow.phases);
+}
+async function runAutoPhaseViaSpec(config, phaseId, executionState, state, setSummary, forceRefreshSummary = false, runtime = runtimeServices) {
     const context = createPipelineContext({
         issueKey: config.taskKey,
         jiraRef: config.jiraRef,
         dryRun: config.dryRun,
         verbose: config.verbose,
-        runtime: runtimeServices,
+        runtime,
         ...(setSummary ? { setSummary } : {}),
         requestUserInput: requestUserInputInTerminal,
     });
@@ -767,18 +805,18 @@ async function summarizeBuildFailure(output) {
         requestUserInput: requestUserInputInTerminal,
     }), output);
 }
-function requireTaskScopeConfig(config) {
-    if (config.scope.scopeType !== "task" || !config.jiraBrowseUrl || !config.jiraApiUrl || !config.jiraTaskFile) {
-        throw new TaskRunnerError(`Command '${config.command}' requires Jira task scope.`);
+function requireJiraConfig(config) {
+    if (!config.jiraBrowseUrl || !config.jiraApiUrl || !config.jiraTaskFile) {
+        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", runtime = runtimeServices) {
     const config = buildRuntimeConfig(baseConfig, resolvedScope ?? (await resolveScopeForCommand(baseConfig, requestUserInput)));
     if (config.command === "auto") {
         if (launchMode === "restart") {
             resetAutoPipelineState(config);
         }
-        await runAutoPipeline(config, setSummary, forceRefreshSummary);
+        await runAutoPipeline(config, setSummary, forceRefreshSummary, runtime);
         return false;
     }
     if (config.command === "auto-status") {
@@ -796,7 +834,7 @@ async function executeCommand(baseConfig, runFollowupVerify = true, requestUserI
         return false;
     }
     checkPrerequisites(config);
-    if (config.scope.scopeType === "task") {
+    if (config.jiraBrowseUrl && config.jiraApiUrl && config.jiraTaskFile) {
         process.env.JIRA_BROWSE_URL = config.jiraBrowseUrl ?? "";
         process.env.JIRA_API_URL = config.jiraApiUrl ?? "";
         process.env.JIRA_TASK_FILE = config.jiraTaskFile ?? "";
@@ -807,7 +845,7 @@ async function executeCommand(baseConfig, runFollowupVerify = true, requestUserI
         delete process.env.JIRA_TASK_FILE;
     }
     if (config.command === "plan") {
-        requireTaskScopeConfig(config);
+        requireJiraConfig(config);
         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`);
@@ -818,11 +856,11 @@ async function executeCommand(baseConfig, runFollowupVerify = true, requestUserI
             taskKey: config.taskKey,
             extraPrompt: config.extraPrompt,
             forceRefresh: forceRefreshSummary,
-        }, requestUserInput, setSummary, launchMode);
+        }, requestUserInput, setSummary, launchMode, runtime);
         return false;
     }
     if (config.command === "bug-analyze") {
-        requireTaskScopeConfig(config);
+        requireJiraConfig(config);
         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`);
@@ -833,29 +871,35 @@ async function executeCommand(baseConfig, runFollowupVerify = true, requestUserI
             taskKey: config.taskKey,
             extraPrompt: config.extraPrompt,
             forceRefresh: forceRefreshSummary,
-        }, requestUserInput, setSummary, launchMode);
+        }, requestUserInput, setSummary, launchMode, runtime);
         return false;
     }
     if (config.command === "gitlab-review") {
-        requireTaskScopeConfig(config);
-        requireJiraTaskFile(config.jiraTaskFile);
-        validateStructuredArtifacts([
-            { path: designJsonFile(config.taskKey), schemaId: "implementation-design/v1" },
-            { path: planJsonFile(config.taskKey), schemaId: "implementation-plan/v1" },
-        ], "GitLab-review mode requires valid structured plan artifacts from the planning phase.");
         const iteration = nextReviewIterationForTask(config.taskKey);
         await runDeclarativeFlowBySpecFile("gitlab-review.json", config, {
             taskKey: config.taskKey,
             iteration,
             extraPrompt: config.extraPrompt,
-        }, requestUserInput, undefined, launchMode);
+        }, requestUserInput, undefined, launchMode, runtime);
         if (!config.dryRun) {
             printSummary("GitLab Review", `Artifacts:\n${gitlabReviewFile(config.taskKey)}\n${gitlabReviewJsonFile(config.taskKey)}`);
         }
         return false;
     }
+    if (config.command === "gitlab-diff-review") {
+        const iteration = nextReviewIterationForTask(config.taskKey);
+        await runDeclarativeFlowBySpecFile("gitlab-diff-review.json", config, {
+            taskKey: config.taskKey,
+            iteration,
+            extraPrompt: config.extraPrompt,
+        }, 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)}`);
+        }
+        return false;
+    }
     if (config.command === "bug-fix") {
-        requireTaskScopeConfig(config);
+        requireJiraConfig(config);
         requireJiraTaskFile(config.jiraTaskFile);
         requireArtifacts(bugAnalyzeArtifacts(config.taskKey), "Bug-fix mode requires bug-analyze artifacts from the bug analysis phase.");
         validateStructuredArtifacts([
@@ -866,25 +910,25 @@ async function executeCommand(baseConfig, runFollowupVerify = true, requestUserI
         await runDeclarativeFlowBySpecFile("bug-fix.json", config, {
             taskKey: config.taskKey,
             extraPrompt: config.extraPrompt,
-        }, requestUserInput, undefined, launchMode);
+        }, requestUserInput, undefined, launchMode, runtime);
         return false;
     }
     if (config.command === "mr-description") {
-        requireTaskScopeConfig(config);
+        requireJiraConfig(config);
         requireJiraTaskFile(config.jiraTaskFile);
         await runDeclarativeFlowBySpecFile("mr-description.json", config, {
             taskKey: config.taskKey,
             extraPrompt: config.extraPrompt,
-        }, requestUserInput, undefined, launchMode);
+        }, requestUserInput, undefined, launchMode, runtime);
         return false;
     }
     if (config.command === "task-describe") {
-        requireTaskScopeConfig(config);
+        requireJiraConfig(config);
         await runDeclarativeFlowBySpecFile("task-describe.json", config, {
             jiraApiUrl: config.jiraApiUrl,
             taskKey: config.taskKey,
             extraPrompt: config.extraPrompt,
-        }, requestUserInput, undefined, launchMode);
+        }, requestUserInput, undefined, launchMode, runtime);
         return false;
     }
     if (config.command === "implement") {
@@ -902,8 +946,8 @@ async function executeCommand(baseConfig, runFollowupVerify = true, requestUserI
     }
     if (config.command === "review") {
         const iteration = nextReviewIterationForTask(config.taskKey);
-        if (config.scope.scopeType === "task") {
-            requireTaskScopeConfig(config);
+        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" },
@@ -912,14 +956,14 @@ async function executeCommand(baseConfig, runFollowupVerify = true, requestUserI
                 taskKey: config.taskKey,
                 iteration,
                 extraPrompt: config.extraPrompt,
-            }, requestUserInput, undefined, launchMode);
+            }, requestUserInput, undefined, launchMode, runtime);
         }
         else {
             await runDeclarativeFlowBySpecFile("review-project.json", config, {
                 taskKey: config.taskKey,
                 iteration,
                 extraPrompt: config.extraPrompt,
-            }, requestUserInput, undefined, launchMode);
+            }, requestUserInput, undefined, launchMode, runtime);
         }
         return !config.dryRun && existsSync(readyToMergeFile(config.taskKey));
     }
@@ -938,7 +982,7 @@ async function executeCommand(baseConfig, runFollowupVerify = true, requestUserI
             reviewFixSelectionJsonFile: reviewFixSelectionJsonFile(config.taskKey, latestIteration),
             extraPrompt: config.extraPrompt,
             reviewFixPoints: config.reviewFixPoints,
-        }, requestUserInput, undefined, launchMode);
+        }, requestUserInput, undefined, launchMode, runtime);
         return false;
     }
     if (config.command === "run-go-tests-loop" || config.command === "run-go-linter-loop") {
@@ -947,12 +991,12 @@ async function executeCommand(baseConfig, runFollowupVerify = true, requestUserI
             runGoTestsScript: config.runGoTestsScript,
             runGoLinterScript: config.runGoLinterScript,
             extraPrompt: config.extraPrompt,
-        }, requestUserInput, undefined, launchMode);
+        }, requestUserInput, undefined, launchMode, runtime);
         return false;
     }
     throw new TaskRunnerError(`Unsupported command: ${config.command}`);
 }
-async function runAutoPipelineDryRun(config, setSummary, forceRefreshSummary = false) {
+async function runAutoPipelineDryRun(config, setSummary, forceRefreshSummary = false, runtime = runtimeServices) {
     checkAutoPrerequisites(config);
     printInfo("Dry-run auto pipeline from declarative spec");
     const autoFlow = loadAutoFlow();
@@ -965,16 +1009,16 @@ async function runAutoPipelineDryRun(config, setSummary, forceRefreshSummary = f
     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);
+        await runAutoPhaseViaSpec(config, phase.id, executionState, undefined, setSummary, forceRefreshSummary, runtime);
         if (executionState.terminated) {
             break;
         }
     }
 }
-async function runAutoPipeline(config, setSummary, forceRefreshSummary = false) {
-    requireTaskScopeConfig(config);
+async function runAutoPipeline(config, setSummary, forceRefreshSummary = false, runtime = runtimeServices) {
+    requireJiraConfig(config);
     if (config.dryRun) {
-        await runAutoPipelineDryRun(config, setSummary, forceRefreshSummary);
+        await runAutoPipelineDryRun(config, setSummary, forceRefreshSummary, runtime);
         return;
     }
     checkAutoPrerequisites(config);
@@ -1014,7 +1058,7 @@ async function runAutoPipeline(config, setSummary, forceRefreshSummary = false)
         saveAutoPipelineState(state);
         try {
             printInfo(`Running auto step: ${step.id}`);
-            const status = await runAutoPhaseViaSpec(config, step.id, state.executionState, state, setSummary, forceRefreshSummary);
+            const status = await runAutoPhaseViaSpec(config, step.id, state.executionState, state, setSummary, forceRefreshSummary, runtime);
             step.status = status;
             step.finishedAt = nowIso8601();
             step.returnCode = 0;
@@ -1127,24 +1171,31 @@ function buildConfigFromArgs(args) {
     });
 }
 async function runInteractive(jiraRef, forceRefresh = false, scopeName) {
-    let currentScope = jiraRef?.trim() ? resolveTaskScope(jiraRef, scopeName) : resolveProjectScope(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,
-        jiraIssueKey: currentScope.scopeType === "task" ? currentScope.jiraIssueKey : null,
+        jiraIssueKey: currentScope.jiraIssueKey ?? null,
         summaryText: "",
         cwd: process.cwd(),
         gitBranchName,
-        flows: interactiveFlowDefinitions(),
+        flows: interactiveFlowDefinitions(flowCatalog),
         getRunConfirmation: async (flowId) => {
+            const flowEntry = findCatalogEntry(flowId, flowCatalog);
+            if (!flowEntry) {
+                throw new TaskRunnerError(`Unknown flow: ${flowId}`);
+            }
             if (flowId === "auto") {
-                if (currentScope.scopeType !== "task") {
+                if (!currentScope.jiraRef) {
                     return { resumeAvailable: false, hasExistingState: false };
                 }
                 const baseConfig = buildBaseConfig("auto", {
                     jiraRef: currentScope.jiraRef,
-                    scopeName: currentScope.scopeKey !== currentScope.jiraIssueKey ? currentScope.scopeKey : null,
+                    scopeName: currentScope.scopeKey,
                 });
                 const state = loadAutoPipelineState(buildRuntimeConfig(baseConfig, currentScope));
                 if (!state) {
@@ -1160,39 +1211,48 @@ async function runInteractive(jiraRef, forceRefresh = false, scopeName) {
                     details: buildAutoResumeDetails(state),
                 };
             }
-            if (commandRequiresTask(flowId) && currentScope.scopeType !== "task") {
-                return { resumeAvailable: false, hasExistingState: false };
-            }
-            const state = loadFlowRunState(currentScope.scopeKey, flowId);
-            if (!state || !hasResumableFlowState(state)) {
-                return { resumeAvailable: false, hasExistingState: Boolean(state) };
-            }
-            return {
-                resumeAvailable: true,
-                hasExistingState: true,
-                details: buildFlowResumeDetails(state),
-            };
+            const resumeLookup = lookupInteractiveFlowResume(flowEntry, currentScope);
+            return resumeLookup;
         },
         onRun: async (flowId, launchMode) => {
+            const abortController = new AbortController();
+            activeAbortController = abortController;
+            activeFlowId = flowId;
             try {
-                const previousScopeType = currentScope.scopeType;
+                const flowEntry = findCatalogEntry(flowId, flowCatalog);
+                if (!flowEntry) {
+                    throw new TaskRunnerError(`Unknown flow: ${flowId}`);
+                }
                 const previousScopeKey = currentScope.scopeKey;
                 const baseConfig = buildBaseConfig(flowId, {
-                    ...(currentScope.scopeType === "task" ? { jiraRef: currentScope.jiraRef } : {}),
-                    ...(currentScope.scopeType === "task" && currentScope.scopeKey !== currentScope.jiraIssueKey
-                        ? { scopeName: currentScope.scopeKey }
-                        : {}),
-                    ...(currentScope.scopeType === "project" ? { scopeName: currentScope.scopeKey } : {}),
+                    ...(currentScope.jiraRef ? { jiraRef: currentScope.jiraRef } : {}),
+                    scopeName: currentScope.scopeKey,
                 });
-                const nextScope = await resolveScopeForCommand(baseConfig, (form) => ui.requestUserInput(form));
-                currentScope = nextScope;
-                ui.setScope(currentScope.scopeKey, currentScope.scopeType === "task" ? currentScope.jiraIssueKey : null);
-                if (currentScope.scopeType === "task" && (previousScopeType !== "task" || previousScopeKey !== currentScope.scopeKey)) {
+                if (flowEntry.source === "built-in" && isBuiltInCommandFlowId(flowId)) {
+                    const nextScope = await resolveScopeForCommand(baseConfig, (form) => ui.requestUserInput(form));
+                    currentScope = nextScope;
+                }
+                else if (flowRequiresTaskScope(flowEntry) && !currentScope.jiraRef) {
+                    const jiraContext = await requestJiraContext((form) => ui.requestUserInput(form));
+                    currentScope = attachJiraContext(currentScope, jiraContext.jiraRef);
+                }
+                ui.setScope(currentScope.scopeKey, currentScope.jiraIssueKey ?? null);
+                if (previousScopeKey !== currentScope.scopeKey || currentScope.jiraIssueKey) {
                     syncInteractiveTaskSummary(ui, currentScope, forceRefresh);
                 }
-                await executeCommand(baseConfig, true, (form) => ui.requestUserInput(form), currentScope, (markdown) => ui.setSummary(markdown), forceRefresh, launchMode);
+                if (flowEntry.source === "built-in" && isBuiltInCommandFlowId(flowId)) {
+                    await executeCommand(baseConfig, true, (form) => ui.requestUserInput(form), currentScope, (markdown) => ui.setSummary(markdown), forceRefresh, launchMode, 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, 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);
@@ -1206,6 +1266,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;
@@ -1214,12 +1287,10 @@ async function runInteractive(jiraRef, forceRefresh = false, scopeName) {
     ui.mount();
     printInfo(`Interactive mode for ${currentScope.scopeKey}`);
     printInfo("Use h to see help.");
-    if (currentScope.scopeType !== "task") {
+    if (!currentScope.jiraIssueKey) {
         ui.appendLog("[scope] project scope active; task summary will appear after a Jira-backed flow runs");
     }
-    if (currentScope.scopeType === "task") {
-        syncInteractiveTaskSummary(ui, currentScope, forceRefresh);
-    }
+    syncInteractiveTaskSummary(ui, currentScope, forceRefresh);
     return await new Promise((resolve, reject) => {
         const interval = setInterval(() => {
             if (!exiting) {