agentweaver 0.1.5 → 0.1.7

package/dist/index.js

@@ -3,36 +3,35 @@ 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, ensureTaskWorkspaceDir, jiraTaskFile, planJsonFile, planArtifacts, qaJsonFile, readyToMergeFile, requireArtifacts, reviewReplyJsonFile, reviewFixSelectionJsonFile, reviewJsonFile, taskWorkspaceDir, taskSummaryFile, } from "./artifacts.js";
+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 { buildJiraApiUrl, buildJiraBrowseUrl, extractIssueKey, requireJiraTaskFile } from "./jira.js";
+import { createFlowRunState, hasResumableFlowState, loadFlowRunState, prepareFlowStateForResume, resetFlowRunState, 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 { createPipelineContext } from "./pipeline/context.js";
 import { loadAutoFlow } from "./pipeline/auto-flow.js";
 import { loadDeclarativeFlow } from "./pipeline/declarative-flows.js";
 import { findPhaseById, runExpandedPhase } from "./pipeline/declarative-flow-runner.js";
-import { runPreflightFlow } from "./pipeline/flows/preflight-flow.js";
 import { resolveCmd, resolveDockerComposeCmd } from "./runtime/command-resolution.js";
-import { defaultDockerComposeFile, dockerRuntimeEnv } from "./runtime/docker-runtime.js";
+import { 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";
 const COMMANDS = [
     "bug-analyze",
     "bug-fix",
+    "gitlab-review",
     "mr-description",
     "plan",
     "task-describe",
     "implement",
     "review",
     "review-fix",
-    "test",
-    "test-fix",
-    "test-linter-fix",
-    "run-tests-loop",
-    "run-linter-loop",
+    "run-go-tests-loop",
+    "run-go-linter-loop",
     "auto",
     "auto-status",
     "auto-reset",
@@ -79,36 +78,37 @@ function formatProcessFailure(error) {
 }
 function usage() {
     return `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 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 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 implement [--dry] [--verbose] [--prompt <text>] <jira-browse-url|jira-issue-key>
-  agentweaver review [--dry] [--verbose] [--prompt <text>] <jira-browse-url|jira-issue-key>
-  agentweaver review-fix [--dry] [--verbose] [--prompt <text>] <jira-browse-url|jira-issue-key>
-  agentweaver test [--dry] [--verbose] <jira-browse-url|jira-issue-key>
-  agentweaver test-fix [--dry] [--verbose] [--prompt <text>] <jira-browse-url|jira-issue-key>
-  agentweaver test-linter-fix [--dry] [--verbose] [--prompt <text>] <jira-browse-url|jira-issue-key>
-  agentweaver run-tests-loop [--dry] [--verbose] [--prompt <text>] <jira-browse-url|jira-issue-key>
-  agentweaver run-linter-loop [--dry] [--verbose] [--prompt <text>] <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 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 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-status <jira-browse-url|jira-issue-key>
-  agentweaver auto-reset <jira-browse-url|jira-issue-key>
+  agentweaver auto-status [<jira-browse-url|jira-issue-key>]
+  agentweaver auto-reset [<jira-browse-url|jira-issue-key>]
 
 Interactive Mode:
-  When started with only a Jira task, the script opens an interactive UI.
+  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.
 
 Flags:
   --version       Show package version
-  --force         In interactive mode, force refresh Jira task and task summary
+  --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
   --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
 
 Required environment variables:
@@ -116,12 +116,17 @@ Required environment variables:
 
 Optional environment variables:
   JIRA_BASE_URL
+  GITLAB_TOKEN
   AGENTWEAVER_HOME
   DOCKER_COMPOSE_BIN
   CODEX_BIN
   CODEX_MODEL
   CLAUDE_BIN
-  CLAUDE_MODEL`;
+  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.`;
 }
 function packageVersion() {
     const packageJsonPath = path.join(PACKAGE_ROOT, "package.json");
@@ -173,28 +178,6 @@ function createAutoPipelineState(config) {
         },
     };
 }
-function stripExecutionStatePayload(executionState) {
-    return {
-        flowKind: executionState.flowKind,
-        flowVersion: executionState.flowVersion,
-        terminated: executionState.terminated,
-        ...(executionState.terminationReason ? { terminationReason: executionState.terminationReason } : {}),
-        phases: executionState.phases.map((phase) => ({
-            id: phase.id,
-            status: phase.status,
-            repeatVars: { ...phase.repeatVars },
-            ...(phase.startedAt ? { startedAt: phase.startedAt } : {}),
-            ...(phase.finishedAt ? { finishedAt: phase.finishedAt } : {}),
-            steps: phase.steps.map((step) => ({
-                id: step.id,
-                status: step.status,
-                ...(step.startedAt ? { startedAt: step.startedAt } : {}),
-                ...(step.finishedAt ? { finishedAt: step.finishedAt } : {}),
-                ...(step.stopFlow !== undefined ? { stopFlow: step.stopFlow } : {}),
-            })),
-        })),
-    };
-}
 function loadAutoPipelineState(config) {
     const filePath = autoStateFile(config.taskKey);
     if (!existsSync(filePath)) {
@@ -228,7 +211,7 @@ function loadAutoPipelineState(config) {
 }
 function saveAutoPipelineState(state) {
     state.updatedAt = nowIso8601();
-    ensureTaskWorkspaceDir(state.issueKey);
+    ensureScopeWorkspaceDir(state.issueKey);
     writeFileSync(autoStateFile(state.issueKey), `${JSON.stringify({
         ...state,
         executionState: stripExecutionStatePayload(state.executionState),
@@ -327,6 +310,30 @@ function syncAutoStepsFromExecutionState(state) {
     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 ?? "-"})`);
+    }
+    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 ?? "-"})`);
+    }
+    return lines.join("\n");
+}
 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>");
@@ -362,7 +369,7 @@ function loadEnvFile(envFilePath) {
 }
 function nextReviewIterationForTask(taskKey) {
     let maxIndex = 0;
-    const workspaceDir = taskWorkspaceDir(taskKey);
+    const workspaceDir = scopeWorkspaceDir(taskKey);
     if (!existsSync(workspaceDir)) {
         return 1;
     }
@@ -379,7 +386,7 @@ function nextReviewIterationForTask(taskKey) {
 }
 function latestReviewReplyIteration(taskKey) {
     let maxIndex = null;
-    const workspaceDir = taskWorkspaceDir(taskKey);
+    const workspaceDir = scopeWorkspaceDir(taskKey);
     if (!existsSync(workspaceDir)) {
         return null;
     }
@@ -395,23 +402,81 @@ function latestReviewReplyIteration(taskKey) {
     }
     return maxIndex;
 }
-function buildConfig(command, jiraRef, options = {}) {
-    const jiraIssueKey = extractIssueKey(jiraRef);
-    ensureTaskWorkspaceDir(jiraIssueKey);
+function buildBaseConfig(command, options = {}) {
+    const homeDir = agentweaverHome(PACKAGE_ROOT);
     return {
         command,
-        jiraRef,
+        jiraRef: options.jiraRef ?? null,
+        scopeName: options.scopeName ?? null,
         reviewFixPoints: options.reviewFixPoints ?? null,
         extraPrompt: options.extraPrompt ?? null,
         autoFromPhase: options.autoFromPhase ? validateAutoPhaseId(options.autoFromPhase) : null,
         dryRun: options.dryRun ?? false,
         verbose: options.verbose ?? false,
         dockerComposeFile: defaultDockerComposeFile(PACKAGE_ROOT),
-        jiraIssueKey,
-        taskKey: jiraIssueKey,
-        jiraBrowseUrl: buildJiraBrowseUrl(jiraRef),
-        jiraApiUrl: buildJiraApiUrl(jiraRef),
-        jiraTaskFile: jiraTaskFile(jiraIssueKey),
+        runGoTestsScript: path.join(homeDir, "run_go_tests.sh"),
+        runGoLinterScript: path.join(homeDir, "run_go_linter.sh"),
+        runGoCoverageScript: path.join(homeDir, "run_go_coverage.sh"),
+    };
+}
+function commandRequiresTask(command) {
+    return (command === "plan" ||
+        command === "bug-analyze" ||
+        command === "bug-fix" ||
+        command === "gitlab-review" ||
+        command === "mr-description" ||
+        command === "task-describe" ||
+        command === "auto" ||
+        command === "auto-status" ||
+        command === "auto-reset");
+}
+function commandSupportsProjectScope(command) {
+    return (command === "implement" ||
+        command === "review" ||
+        command === "review-fix" ||
+        command === "run-go-tests-loop" ||
+        command === "run-go-linter-loop");
+}
+async function resolveScopeForCommand(config, requestUserInput) {
+    if (config.jiraRef?.trim()) {
+        return resolveTaskScope(config.jiraRef, config.scopeName);
+    }
+    if (commandRequiresTask(config.command)) {
+        try {
+            const taskScope = await requestTaskScope(requestUserInput);
+            return config.scopeName ? resolveTaskScope(taskScope.jiraRef, config.scopeName) : taskScope;
+        }
+        catch (error) {
+            if (error instanceof TaskRunnerError && error.message.includes("no TTY is available")) {
+                throw new TaskRunnerError(`Command '${config.command}' requires a Jira task.\n` +
+                    "Pass Jira issue key / browse URL as an argument, or run the command in an interactive terminal.");
+            }
+            throw error;
+        }
+    }
+    if (commandSupportsProjectScope(config.command)) {
+        return resolveProjectScope(config.scopeName);
+    }
+    throw new TaskRunnerError(`Unsupported scope policy for command: ${config.command}`);
+}
+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,
     };
 }
 function checkPrerequisites(config) {
@@ -421,40 +486,35 @@ function checkPrerequisites(config) {
         config.command === "plan" ||
         config.command === "task-describe" ||
         config.command === "review" ||
-        config.command === "run-tests-loop" ||
-        config.command === "run-linter-loop") {
+        config.command === "run-go-tests-loop" ||
+        config.command === "run-go-linter-loop") {
         resolveCmd("codex", "CODEX_BIN");
     }
     if (config.command === "review") {
         resolveCmd("claude", "CLAUDE_BIN");
     }
-    if (["implement", "review-fix", "test", "run-tests-loop", "run-linter-loop"].includes(config.command)) {
-        resolveDockerComposeCmd();
-        if (!existsSync(config.dockerComposeFile)) {
-            throw new TaskRunnerError(`docker-compose file not found: ${config.dockerComposeFile}`);
-        }
-    }
 }
 function checkAutoPrerequisites(config) {
     resolveCmd("codex", "CODEX_BIN");
     resolveCmd("claude", "CLAUDE_BIN");
-    resolveDockerComposeCmd();
-    if (!existsSync(config.dockerComposeFile)) {
-        throw new TaskRunnerError(`docker-compose file not found: ${config.dockerComposeFile}`);
-    }
 }
-function autoFlowParams(config) {
+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,
     };
 }
 const FLOW_DESCRIPTIONS = {
     auto: "Полный пайплайн задачи: планирование, реализация, проверки, ревью, ответы на ревью и повторные итерации до готовности к merge.",
     "bug-analyze": "Анализирует баг по Jira и создаёт структурированные артефакты: гипотезу причины, дизайн исправления и план работ.",
+    "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.",
@@ -462,11 +522,8 @@ const FLOW_DESCRIPTIONS = {
     implement: "Реализует задачу по утверждённым design/plan артефактам и при необходимости запускает post-verify сборки.",
     review: "Запускает Claude-код-ревью текущих изменений, валидирует structured findings, затем готовит ответ на замечания через Codex.",
     "review-fix": "Исправляет замечания после review-reply, обновляет код и прогоняет обязательные проверки после правок.",
-    test: "Запускает verify/build-проверку в контейнере и показывает результат с краткой сводкой при падении.",
-    "test-fix": "Прогоняет тесты, исправляет найденные проблемы и готовит код к следующей успешной проверке.",
-    "test-linter-fix": "Прогоняет линтер и генерацию, затем исправляет замечания для чистого прогона.",
-    "run-tests-loop": "Циклически запускает `./run_tests.sh`, анализирует последнюю ошибку и правит код до успешного прохождения или исчерпания попыток.",
-    "run-linter-loop": "Циклически запускает `./run_linter.sh`, исправляет проблемы линтера или генерации и повторяет попытки до успеха.",
+    "run-go-tests-loop": "Циклически запускает `./run_go_tests.sh` локально, анализирует последнюю ошибку и правит код до успешного прохождения или исчерпания попыток.",
+    "run-go-linter-loop": "Циклически запускает `./run_go_linter.sh` локально, исправляет проблемы линтера или генерации и повторяет попытки до успеха.",
 };
 function flowDescription(id) {
     return FLOW_DESCRIPTIONS[id] ?? "Описание для этого flow пока не задано.";
@@ -506,64 +563,139 @@ function interactiveFlowDefinitions() {
         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("test", "test", "test.json"),
-        declarativeFlowDefinition("test-fix", "test-fix", "test-fix.json"),
-        declarativeFlowDefinition("test-linter-fix", "test-linter-fix", "test-linter-fix.json"),
-        declarativeFlowDefinition("run-tests-loop", "run-tests-loop", "run-tests-loop.json"),
-        declarativeFlowDefinition("run-linter-loop", "run-linter-loop", "run-linter-loop.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 publishFlowState(flowId, executionState) {
     setFlowExecutionState(flowId, stripExecutionStatePayload(executionState));
 }
-async function runDeclarativeFlowBySpecFile(fileName, config, flowParams, requestUserInput = requestUserInputInTerminal) {
+function loadTaskSummaryMarkdown(taskKey) {
+    const summaryPath = taskSummaryFile(taskKey);
+    if (!existsSync(summaryPath)) {
+        return null;
+    }
+    const markdown = readFileSync(summaryPath, "utf8").trim();
+    return markdown.length > 0 ? markdown : null;
+}
+function syncInteractiveTaskSummary(ui, scope, forceRefresh = false) {
+    if (scope.scopeType !== "task" || forceRefresh) {
+        ui.clearSummary();
+        return;
+    }
+    const summaryMarkdown = loadTaskSummaryMarkdown(scope.scopeKey);
+    if (summaryMarkdown) {
+        ui.setSummary(summaryMarkdown);
+        return;
+    }
+    ui.clearSummary();
+}
+function findCurrentFlowExecutionStep(state) {
+    for (const phase of state.executionState.phases) {
+        const runningStep = phase.steps.find((step) => step.status === "running");
+        if (runningStep) {
+            return `${phase.id}:${runningStep.id}`;
+        }
+        const pendingStep = phase.steps.find((step) => step.status === "pending");
+        if (pendingStep && phase.steps.some((step) => step.status === "done" || step.status === "skipped")) {
+            return `${phase.id}:${pendingStep.id}`;
+        }
+    }
+    return null;
+}
+async function runDeclarativeFlowBySpecFile(fileName, config, flowParams, requestUserInput = requestUserInputInTerminal, setSummary, launchMode = "restart") {
     const context = createPipelineContext({
         issueKey: config.taskKey,
         jiraRef: config.jiraRef,
         dryRun: config.dryRun,
         verbose: config.verbose,
         runtime: runtimeServices,
+        ...(setSummary ? { setSummary } : {}),
         requestUserInput,
     });
     const flow = loadDeclarativeFlow(fileName);
-    const executionState = {
+    const initialExecutionState = {
         flowKind: flow.kind,
         flowVersion: flow.version,
         terminated: false,
         phases: [],
     };
+    let persistedState = launchMode === "resume" ? loadFlowRunState(config.scope.scopeKey, config.command) : null;
+    if (persistedState && launchMode === "resume") {
+        persistedState = prepareFlowStateForResume(persistedState);
+    }
+    else if (launchMode === "restart") {
+        resetFlowRunState(config.scope.scopeKey, config.command);
+    }
+    const executionState = persistedState?.executionState ?? initialExecutionState;
+    const state = persistedState ?? createFlowRunState(config.scope.scopeKey, config.command, executionState);
+    state.status = "running";
+    state.lastError = null;
+    state.currentStep = findCurrentFlowExecutionStep(state);
+    state.executionState = executionState;
+    saveFlowRunState(state);
     publishFlowState(config.command, executionState);
-    for (const phase of flow.phases) {
-        await runExpandedPhase(phase, context, flowParams, flow.constants, {
-            executionState,
-            flowKind: flow.kind,
-            flowVersion: flow.version,
-            onStateChange: async (state) => {
-                publishFlowState(config.command, state);
-            },
-        });
+    try {
+        for (const phase of flow.phases) {
+            await runExpandedPhase(phase, context, flowParams, flow.constants, {
+                executionState,
+                flowKind: flow.kind,
+                flowVersion: flow.version,
+                onStateChange: async (nextExecutionState) => {
+                    state.executionState = nextExecutionState;
+                    state.currentStep = findCurrentFlowExecutionStep(state);
+                    saveFlowRunState(state);
+                    publishFlowState(config.command, nextExecutionState);
+                },
+                onStepStart: async (currentPhase, step) => {
+                    state.currentStep = `${currentPhase.id}:${step.id}`;
+                    saveFlowRunState(state);
+                },
+            });
+        }
+        state.status = "completed";
+        state.currentStep = null;
+        state.lastError = null;
+        state.executionState = executionState;
+        saveFlowRunState(state);
+    }
+    catch (error) {
+        state.status = "blocked";
+        state.currentStep = findCurrentFlowExecutionStep(state);
+        state.lastError = {
+            returnCode: Number(error.returnCode ?? 1),
+            message: error.message || "command failed",
+        };
+        if (state.currentStep) {
+            state.lastError.step = state.currentStep;
+        }
+        state.executionState = executionState;
+        saveFlowRunState(state);
+        throw error;
     }
 }
-async function runAutoPhaseViaSpec(config, phaseId, executionState, state) {
+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), autoFlow.constants, {
+        const result = await runExpandedPhase(phase, context, autoFlowParams(config, forceRefreshSummary), autoFlow.constants, {
             executionState,
             flowKind: autoFlow.kind,
             flowVersion: autoFlow.version,
@@ -635,9 +767,18 @@ async function summarizeBuildFailure(output) {
         requestUserInput: requestUserInputInTerminal,
     }), output);
 }
-async function executeCommand(config, runFollowupVerify = true, requestUserInput = requestUserInputInTerminal) {
+function requireTaskScopeConfig(config) {
+    if (config.scope.scopeType !== "task" || !config.jiraBrowseUrl || !config.jiraApiUrl || !config.jiraTaskFile) {
+        throw new TaskRunnerError(`Command '${config.command}' requires Jira task scope.`);
+    }
+}
+async function executeCommand(baseConfig, runFollowupVerify = true, requestUserInput = requestUserInputInTerminal, resolvedScope, setSummary, forceRefreshSummary = false, launchMode = "restart") {
+    const config = buildRuntimeConfig(baseConfig, resolvedScope ?? (await resolveScopeForCommand(baseConfig, requestUserInput)));
     if (config.command === "auto") {
-        await runAutoPipeline(config);
+        if (launchMode === "restart") {
+            resetAutoPipelineState(config);
+        }
+        await runAutoPipeline(config, setSummary, forceRefreshSummary);
         return false;
     }
     if (config.command === "auto-status") {
@@ -655,10 +796,18 @@ async function executeCommand(config, runFollowupVerify = true, requestUserInput
         return false;
     }
     checkPrerequisites(config);
-    process.env.JIRA_BROWSE_URL = config.jiraBrowseUrl;
-    process.env.JIRA_API_URL = config.jiraApiUrl;
-    process.env.JIRA_TASK_FILE = config.jiraTaskFile;
+    if (config.scope.scopeType === "task") {
+        process.env.JIRA_BROWSE_URL = config.jiraBrowseUrl ?? "";
+        process.env.JIRA_API_URL = config.jiraApiUrl ?? "";
+        process.env.JIRA_TASK_FILE = config.jiraTaskFile ?? "";
+    }
+    else {
+        delete process.env.JIRA_BROWSE_URL;
+        delete process.env.JIRA_API_URL;
+        delete process.env.JIRA_TASK_FILE;
+    }
     if (config.command === "plan") {
+        requireTaskScopeConfig(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`);
@@ -668,10 +817,12 @@ async function executeCommand(config, runFollowupVerify = true, requestUserInput
             jiraApiUrl: config.jiraApiUrl,
             taskKey: config.taskKey,
             extraPrompt: config.extraPrompt,
-        }, requestUserInput);
+            forceRefresh: forceRefreshSummary,
+        }, requestUserInput, setSummary, launchMode);
         return false;
     }
     if (config.command === "bug-analyze") {
+        requireTaskScopeConfig(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`);
@@ -681,10 +832,30 @@ async function executeCommand(config, runFollowupVerify = true, requestUserInput
             jiraApiUrl: config.jiraApiUrl,
             taskKey: config.taskKey,
             extraPrompt: config.extraPrompt,
-        }, requestUserInput);
+            forceRefresh: forceRefreshSummary,
+        }, requestUserInput, setSummary, launchMode);
+        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);
+        if (!config.dryRun) {
+            printSummary("GitLab Review", `Artifacts:\n${gitlabReviewFile(config.taskKey)}\n${gitlabReviewJsonFile(config.taskKey)}`);
+        }
         return false;
     }
     if (config.command === "bug-fix") {
+        requireTaskScopeConfig(config);
         requireJiraTaskFile(config.jiraTaskFile);
         requireArtifacts(bugAnalyzeArtifacts(config.taskKey), "Bug-fix mode requires bug-analyze artifacts from the bug analysis phase.");
         validateStructuredArtifacts([
@@ -695,69 +866,64 @@ async function executeCommand(config, runFollowupVerify = true, requestUserInput
         await runDeclarativeFlowBySpecFile("bug-fix.json", config, {
             taskKey: config.taskKey,
             extraPrompt: config.extraPrompt,
-        }, requestUserInput);
+        }, requestUserInput, undefined, launchMode);
         return false;
     }
     if (config.command === "mr-description") {
+        requireTaskScopeConfig(config);
         requireJiraTaskFile(config.jiraTaskFile);
         await runDeclarativeFlowBySpecFile("mr-description.json", config, {
             taskKey: config.taskKey,
             extraPrompt: config.extraPrompt,
-        }, requestUserInput);
+        }, requestUserInput, undefined, launchMode);
         return false;
     }
     if (config.command === "task-describe") {
-        requireJiraTaskFile(config.jiraTaskFile);
+        requireTaskScopeConfig(config);
         await runDeclarativeFlowBySpecFile("task-describe.json", config, {
+            jiraApiUrl: config.jiraApiUrl,
             taskKey: config.taskKey,
             extraPrompt: config.extraPrompt,
-        }, requestUserInput);
+        }, requestUserInput, undefined, launchMode);
         return false;
     }
     if (config.command === "implement") {
-        requireJiraTaskFile(config.jiraTaskFile);
         requireArtifacts(planArtifacts(config.taskKey), "Implement mode requires plan artifacts from the planning phase.");
         validateStructuredArtifacts([
             { path: designJsonFile(config.taskKey), schemaId: "implementation-design/v1" },
             { path: planJsonFile(config.taskKey), schemaId: "implementation-plan/v1" },
             { path: qaJsonFile(config.taskKey), schemaId: "qa-plan/v1" },
         ], "Implement mode requires valid structured plan artifacts from the planning phase.");
-        try {
-            await runDeclarativeFlowBySpecFile("implement.json", config, {
-                taskKey: config.taskKey,
-                dockerComposeFile: config.dockerComposeFile,
-                extraPrompt: config.extraPrompt,
-                runFollowupVerify,
-            }, requestUserInput);
-        }
-        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;
-        }
+        await runDeclarativeFlowBySpecFile("implement.json", config, {
+            taskKey: config.taskKey,
+            extraPrompt: config.extraPrompt,
+        }, requestUserInput, undefined, launchMode);
         return false;
     }
     if (config.command === "review") {
-        requireJiraTaskFile(config.jiraTaskFile);
-        validateStructuredArtifacts([
-            { 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.");
         const iteration = nextReviewIterationForTask(config.taskKey);
-        await runDeclarativeFlowBySpecFile("review.json", config, {
-            taskKey: config.taskKey,
-            iteration,
-            extraPrompt: config.extraPrompt,
-        }, requestUserInput);
+        if (config.scope.scopeType === "task") {
+            requireTaskScopeConfig(config);
+            validateStructuredArtifacts([
+                { 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, {
+                taskKey: config.taskKey,
+                iteration,
+                extraPrompt: config.extraPrompt,
+            }, requestUserInput, undefined, launchMode);
+        }
+        else {
+            await runDeclarativeFlowBySpecFile("review-project.json", config, {
+                taskKey: config.taskKey,
+                iteration,
+                extraPrompt: config.extraPrompt,
+            }, requestUserInput, undefined, launchMode);
+        }
         return !config.dryRun && existsSync(readyToMergeFile(config.taskKey));
     }
     if (config.command === "review-fix") {
-        requireJiraTaskFile(config.jiraTaskFile);
         const latestIteration = latestReviewReplyIteration(config.taskKey);
         if (latestIteration === null) {
             throw new TaskRunnerError("Review-fix mode requires at least one review-reply artifact.");
@@ -766,68 +932,27 @@ async function executeCommand(config, runFollowupVerify = true, requestUserInput
             { 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.");
-        try {
-            await runDeclarativeFlowBySpecFile("review-fix.json", config, {
-                taskKey: config.taskKey,
-                dockerComposeFile: config.dockerComposeFile,
-                latestIteration,
-                reviewFixSelectionJsonFile: reviewFixSelectionJsonFile(config.taskKey, latestIteration),
-                runFollowupVerify,
-                extraPrompt: config.extraPrompt,
-                reviewFixPoints: config.reviewFixPoints,
-            }, requestUserInput);
-        }
-        catch (error) {
-            if (!config.dryRun) {
-                const output = String(error.output ?? "");
-                if (output.trim()) {
-                    printError("Build verification failed");
-                    printSummary("Build Failure Summary", await summarizeBuildFailure(output));
-                }
-            }
-            throw error;
-        }
-        return false;
-    }
-    if (config.command === "test") {
-        requireJiraTaskFile(config.jiraTaskFile);
-        try {
-            await runDeclarativeFlowBySpecFile("test.json", config, {
-                taskKey: config.taskKey,
-                dockerComposeFile: config.dockerComposeFile,
-            }, requestUserInput);
-        }
-        catch (error) {
-            if (!config.dryRun) {
-                const output = String(error.output ?? "");
-                if (output.trim()) {
-                    printError("Build verification failed");
-                    printSummary("Build Failure Summary", await summarizeBuildFailure(output));
-                }
-            }
-            throw error;
-        }
-        return false;
-    }
-    if (config.command === "test-fix" || config.command === "test-linter-fix") {
-        requireJiraTaskFile(config.jiraTaskFile);
-        await runDeclarativeFlowBySpecFile(config.command === "test-fix" ? "test-fix.json" : "test-linter-fix.json", config, {
+        await runDeclarativeFlowBySpecFile("review-fix.json", config, {
             taskKey: config.taskKey,
+            latestIteration,
+            reviewFixSelectionJsonFile: reviewFixSelectionJsonFile(config.taskKey, latestIteration),
             extraPrompt: config.extraPrompt,
-        }, requestUserInput);
+            reviewFixPoints: config.reviewFixPoints,
+        }, requestUserInput, undefined, launchMode);
         return false;
     }
-    if (config.command === "run-tests-loop" || config.command === "run-linter-loop") {
-        await runDeclarativeFlowBySpecFile(config.command === "run-tests-loop" ? "run-tests-loop.json" : "run-linter-loop.json", config, {
+    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, {
             taskKey: config.taskKey,
-            dockerComposeFile: config.dockerComposeFile,
+            runGoTestsScript: config.runGoTestsScript,
+            runGoLinterScript: config.runGoLinterScript,
             extraPrompt: config.extraPrompt,
-        }, requestUserInput);
+        }, requestUserInput, undefined, launchMode);
         return false;
     }
     throw new TaskRunnerError(`Unsupported command: ${config.command}`);
 }
-async function runAutoPipelineDryRun(config) {
+async function runAutoPipelineDryRun(config, setSummary, forceRefreshSummary = false) {
     checkAutoPrerequisites(config);
     printInfo("Dry-run auto pipeline from declarative spec");
     const autoFlow = loadAutoFlow();
@@ -840,15 +965,16 @@ async function runAutoPipelineDryRun(config) {
     publishFlowState("auto", executionState);
     for (const phase of autoFlow.phases) {
         printInfo(`Dry-run auto phase: ${phase.id}`);
-        await runAutoPhaseViaSpec(config, phase.id, executionState);
+        await runAutoPhaseViaSpec(config, phase.id, executionState, undefined, setSummary, forceRefreshSummary);
         if (executionState.terminated) {
             break;
         }
     }
 }
-async function runAutoPipeline(config) {
+async function runAutoPipeline(config, setSummary, forceRefreshSummary = false) {
+    requireTaskScopeConfig(config);
     if (config.dryRun) {
-        await runAutoPipelineDryRun(config);
+        await runAutoPipelineDryRun(config, setSummary, forceRefreshSummary);
         return;
     }
     checkAutoPrerequisites(config);
@@ -888,7 +1014,7 @@ async function runAutoPipeline(config) {
         saveAutoPipelineState(state);
         try {
             printInfo(`Running auto step: ${step.id}`);
-            const status = await runAutoPhaseViaSpec(config, step.id, state.executionState, state);
+            const status = await runAutoPhaseViaSpec(config, step.id, state.executionState, state, setSummary, forceRefreshSummary);
             step.status = status;
             step.finishedAt = nowIso8601();
             step.returnCode = 0;
@@ -941,6 +1067,7 @@ function parseCliArgs(argv) {
     let verbose = false;
     let prompt;
     let autoFromPhase;
+    let scopeName;
     let helpPhases = false;
     let jiraRef;
     for (let index = 1; index < argv.length; index += 1) {
@@ -962,6 +1089,11 @@ function parseCliArgs(argv) {
             index += 1;
             continue;
         }
+        if (token === "--scope") {
+            scopeName = argv[index + 1];
+            index += 1;
+            continue;
+        }
         if (token === "--from") {
             autoFromPhase = argv[index + 1];
             index += 1;
@@ -973,41 +1105,92 @@ function parseCliArgs(argv) {
         printAutoPhasesHelp();
         process.exit(0);
     }
-    if (!jiraRef) {
-        process.stderr.write(`${usage()}\n`);
-        process.exit(1);
-    }
     return {
         command: command,
-        jiraRef,
         dry,
         verbose,
         helpPhases,
+        ...(jiraRef !== undefined ? { jiraRef } : {}),
+        ...(scopeName !== undefined ? { scopeName } : {}),
         ...(prompt !== undefined ? { prompt } : {}),
         ...(autoFromPhase !== undefined ? { autoFromPhase } : {}),
     };
 }
 function buildConfigFromArgs(args) {
-    return buildConfig(args.command, args.jiraRef, {
+    return buildBaseConfig(args.command, {
+        ...(args.jiraRef !== undefined ? { jiraRef: args.jiraRef } : {}),
+        ...(args.scopeName !== undefined ? { scopeName: args.scopeName } : {}),
         ...(args.prompt !== undefined ? { extraPrompt: args.prompt } : {}),
         ...(args.autoFromPhase !== undefined ? { autoFromPhase: args.autoFromPhase } : {}),
         dryRun: args.dry,
         verbose: args.verbose,
     });
 }
-async function runInteractive(jiraRef, forceRefresh = false) {
-    const config = buildConfig("plan", jiraRef);
-    const jiraTaskPath = config.jiraTaskFile;
+async function runInteractive(jiraRef, forceRefresh = false, scopeName) {
+    let currentScope = jiraRef?.trim() ? resolveTaskScope(jiraRef, scopeName) : resolveProjectScope(scopeName);
+    const currentIssueKey = currentScope.scopeKey;
+    const gitBranchName = detectGitBranchName();
     let exiting = false;
     const ui = new InteractiveUi({
-        issueKey: config.jiraIssueKey,
-        summaryText: "Starting interactive session...",
+        issueKey: currentIssueKey,
+        summaryText: "",
         cwd: process.cwd(),
+        gitBranchName,
         flows: interactiveFlowDefinitions(),
-        onRun: async (flowId) => {
+        getRunConfirmation: async (flowId) => {
+            if (flowId === "auto") {
+                if (currentScope.scopeType !== "task") {
+                    return { resumeAvailable: false, hasExistingState: false };
+                }
+                const baseConfig = buildBaseConfig("auto", {
+                    jiraRef: currentScope.jiraRef,
+                    scopeName: currentScope.scopeKey !== currentScope.jiraIssueKey ? currentScope.scopeKey : null,
+                });
+                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),
+                };
+            }
+            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),
+            };
+        },
+        onRun: async (flowId, launchMode) => {
             try {
-                const command = buildConfig(flowId, jiraRef);
-                await executeCommand(command, true, (form) => ui.requestUserInput(form));
+                const previousScopeType = currentScope.scopeType;
+                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 } : {}),
+                });
+                const nextScope = await resolveScopeForCommand(baseConfig, (form) => ui.requestUserInput(form));
+                currentScope = nextScope;
+                ui.setIssueKey(currentScope.scopeKey);
+                if (currentScope.scopeType === "task" && (previousScopeType !== "task" || previousScopeKey !== currentScope.scopeKey)) {
+                    syncInteractiveTaskSummary(ui, currentScope, forceRefresh);
+                }
+                await executeCommand(baseConfig, true, (form) => ui.requestUserInput(form), currentScope, (markdown) => ui.setSummary(markdown), forceRefresh, launchMode);
             }
             catch (error) {
                 if (error instanceof TaskRunnerError) {
@@ -1029,52 +1212,13 @@ async function runInteractive(jiraRef, forceRefresh = false) {
         },
     });
     ui.mount();
-    printInfo(`Interactive mode for ${config.jiraIssueKey}`);
+    printInfo(`Interactive mode for ${currentScope.scopeKey}`);
     printInfo("Use h to see help.");
-    try {
-        ui.setBusy(true, "preflight");
-        const preflightState = await runPreflightFlow(createPipelineContext({
-            issueKey: config.taskKey,
-            jiraRef: config.jiraRef,
-            dryRun: false,
-            verbose: config.verbose,
-            runtime: runtimeServices,
-            setSummary: (markdown) => {
-                ui.setSummary(markdown);
-            },
-            requestUserInput: (form) => ui.requestUserInput(form),
-        }), {
-            jiraApiUrl: config.jiraApiUrl,
-            jiraTaskFile: config.jiraTaskFile,
-            taskKey: config.taskKey,
-            forceRefresh,
-        });
-        const preflightPhase = preflightState.phases.find((phase) => phase.id === "preflight");
-        if (preflightPhase) {
-            ui.appendLog("[preflight] completed");
-            for (const step of preflightPhase.steps) {
-                ui.appendLog(`[preflight] ${step.id}: ${step.status}`);
-            }
-        }
-        if (!existsSync(jiraTaskPath)) {
-            throw new TaskRunnerError(`Preflight finished without Jira task file: ${jiraTaskPath}\n` +
-                "Jira fetch did not complete successfully. Check JIRA_API_KEY and Jira connectivity.");
-        }
-        if (!existsSync(taskSummaryFile(config.taskKey))) {
-            ui.appendLog("[preflight] task summary file was not created");
-            ui.setSummary("Task summary is not available yet. Select and run `plan` or refresh Jira data.");
-        }
+    if (currentScope.scopeType !== "task") {
+        ui.appendLog("[scope] project scope active; task summary will appear after a Jira-backed flow runs");
     }
-    catch (error) {
-        if (error instanceof TaskRunnerError) {
-            printError(error.message);
-        }
-        else {
-            throw error;
-        }
-    }
-    finally {
-        ui.setBusy(false);
+    if (currentScope.scopeType === "task") {
+        syncInteractiveTaskSummary(ui, currentScope, forceRefresh);
     }
     return await new Promise((resolve, reject) => {
         const interval = setInterval(() => {
@@ -1102,6 +1246,9 @@ export async function main(argv = process.argv.slice(2)) {
         args.shift();
     }
     try {
+        if (args.length === 0) {
+            return await runInteractive(undefined, forceRefresh);
+        }
         if (args.length === 1 && !args[0]?.startsWith("-") && !COMMANDS.includes(args[0])) {
             return await runInteractive(args[0] ?? "", forceRefresh);
         }