agentweaver 0.1.18 → 0.1.20

package/dist/interactive/controller.js

@@ -1,8 +1,13 @@
 import path from "node:path";
 import { FlowInterruptedError, TaskRunnerError } from "../errors.js";
+import { createGitService } from "../git/git-service.js";
+import { needsGitFileStage } from "../git/git-stage-selection.js";
 import { renderMarkdownToTerminal } from "../markdown.js";
+import { loadAutoFlowConfigByName, saveAutoFlowConfig, } from "../pipeline/auto-flow-config.js";
+import { runCommand } from "../runtime/process-runner.js";
 import { setOutputAdapter, stripAnsi } from "../tui.js";
 import { buildInitialUserInputValues, normalizeUserInputFieldValue, resolveFieldDefinition, validateUserInputValues, } from "../user-input.js";
+import { buildAutoFlowEditorViewModel, createConfigAutoFlowDefinition, insertAutoFlowBlock, removeAutoFlowBlock, setAutoFlowBlockEnabled, updateAutoFlowBlockParameter, } from "./auto-flow.js";
 import { buildProgressViewModel } from "./progress.js";
 import { selectHeaderLabel } from "./selectors.js";
 import { createInitialInteractiveState } from "./state.js";
@@ -28,6 +33,9 @@ const LOG_FLUSH_INTERVAL_MS = 120;
 function clamp(value, min, max) {
     return Math.min(max, Math.max(min, value));
 }
+function cloneSavedAutoFlowConfig(config) {
+    return JSON.parse(JSON.stringify(config));
+}
 function isPrintableCharacter(ch, key) {
     return Boolean(ch) && !key.ctrl && !key.meta && !/^[\x00-\x1f\x7f]$/.test(ch);
 }
@@ -93,12 +101,16 @@ function normalizeLogText(text) {
     }
     return normalized.split("\n");
 }
+function isGitFileStaged(file) {
+    return file.indexStatus !== " " && file.indexStatus !== "?";
+}
 export class InteractiveSessionController {
     options;
     listeners = new Set();
     flowMap;
     flowTree;
     expandedFlowFolders = new Set();
+    autoFlowEditors = new Map();
     visibleFlowItems;
     state;
     logLines = [];
@@ -110,6 +122,7 @@ export class InteractiveSessionController {
     activeFormSession = null;
     spinnerTimer = null;
     mounted = false;
+    gitService;
     constructor(options) {
         this.options = options;
         if (options.flows.length === 0) {
@@ -117,9 +130,24 @@ export class InteractiveSessionController {
         }
         this.state = createInitialInteractiveState(options);
         this.flowMap = new Map(options.flows.map((flow) => [flow.id, flow]));
+        for (const flow of options.flows) {
+            if (!flow.autoFlow) {
+                continue;
+            }
+            this.autoFlowEditors.set(flow.id, {
+                definition: flow.autoFlow,
+                config: cloneSavedAutoFlowConfig(flow.autoFlow.config),
+                diagnostics: [],
+                saveTarget: "project",
+            });
+        }
         this.flowTree = buildFlowTree(options.flows);
         collectInitiallyExpandedFolderKeys(this.flowTree).forEach((key) => this.expandedFlowFolders.add(key));
         this.visibleFlowItems = computeVisibleFlowItems(this.flowTree, this.expandedFlowFolders);
+        this.gitService = options.gitService ?? createGitService({
+            cwd: options.cwd,
+            runCommand,
+        });
     }
     subscribe(listener) {
         this.listeners.add(listener);
@@ -522,17 +550,343 @@ export class InteractiveSessionController {
     setScrollOffset(panel, offset) {
         this.applyScrollOffset(panel, offset, this.panelMaxScroll(panel));
     }
+    getCurrentFlowExecutionState() {
+        return this.state.flowState.executionState;
+    }
+    getGitService() {
+        return this.gitService;
+    }
+    getGitWorkspaceSnapshot() {
+        return this.state.gitWorkspace;
+    }
+    getAutoFlowEditor(flowId = this.state.selectedFlowId) {
+        return this.autoFlowViewForFlow(flowId);
+    }
+    selectAutoFlowPreset(preset) {
+        const flowId = preset === "simple" ? "auto-simple" : "auto-common";
+        this.selectFlowId(flowId);
+    }
+    loadAutoFlowConfig(name, flowId = this.state.selectedFlowId) {
+        const loaded = loadAutoFlowConfigByName(name, this.options.cwd);
+        const source = {
+            type: loaded.source.type === "project" ? "project-config" : "user-config",
+            configName: loaded.config.name,
+            path: loaded.source.path,
+            ...(loaded.source.shadowedUserPath ? { shadowedUserPath: loaded.source.shadowedUserPath } : {}),
+        };
+        const definition = createConfigAutoFlowDefinition({
+            config: loaded.config,
+            source,
+        });
+        const targetFlowId = this.flowMap.has(`auto-config:${loaded.config.name}`)
+            ? `auto-config:${loaded.config.name}`
+            : flowId;
+        if (!this.autoFlowEditors.has(targetFlowId)) {
+            throw new Error(`Flow '${targetFlowId}' is not a configurable auto-flow entry.`);
+        }
+        this.autoFlowEditors.set(targetFlowId, {
+            definition,
+            config: cloneSavedAutoFlowConfig(loaded.config),
+            diagnostics: [],
+            saveTarget: loaded.source.type,
+            lastMessage: `Loaded auto-flow config '${loaded.config.name}'.`,
+        });
+        this.selectFlowId(targetFlowId);
+        this.emitChange();
+    }
+    toggleAutoFlowBlock(flowId, blockId, enabled, slotId) {
+        const targetFlowId = flowId ?? this.state.selectedFlowId;
+        const editor = this.requireAutoFlowEditor(targetFlowId);
+        const view = this.autoFlowViewForFlow(targetFlowId);
+        const currentBlock = view?.slots.flatMap((slot) => slot.blocks).find((block) => (block.blockId === blockId && (slotId === undefined || block.slotId === slotId)));
+        const nextEnabled = enabled ?? !(currentBlock?.enabled ?? true);
+        const result = setAutoFlowBlockEnabled(editor.config, blockId, nextEnabled, slotId);
+        this.autoFlowEditors.set(targetFlowId, {
+            ...editor,
+            config: result.config,
+            diagnostics: result.diagnostics,
+            lastMessage: result.diagnostics.length > 0
+                ? result.diagnostics[0]?.message ?? `Auto-flow block '${blockId}' could not be updated.`
+                : `${nextEnabled ? "Enabled" : "Disabled"} auto-flow block '${blockId}'${slotId ? ` in '${slotId}'` : ""}.`,
+        });
+        this.emitChange();
+        if (result.diagnostics.length > 0) {
+            throw new TaskRunnerError(result.diagnostics[0]?.message ?? `Auto-flow block '${blockId}' could not be updated.`);
+        }
+    }
+    updateAutoFlowParameter(flowId, blockId, paramName, value, slotId) {
+        const targetFlowId = flowId ?? this.state.selectedFlowId;
+        const editor = this.requireAutoFlowEditor(targetFlowId);
+        const result = updateAutoFlowBlockParameter(editor.config, blockId, paramName, value, slotId);
+        this.autoFlowEditors.set(targetFlowId, {
+            ...editor,
+            config: result.config,
+            diagnostics: result.diagnostics,
+            lastMessage: result.diagnostics.length > 0
+                ? result.diagnostics[0]?.message ?? `Auto-flow block '${blockId}' parameter '${paramName}' is invalid.`
+                : `Updated '${blockId}.${paramName}'${slotId ? ` in '${slotId}'` : ""} to ${value}.`,
+        });
+        this.emitChange();
+    }
+    insertAutoFlowBlock(flowId, slotId, blockId) {
+        const targetFlowId = flowId ?? this.state.selectedFlowId;
+        const editor = this.requireAutoFlowEditor(targetFlowId);
+        const result = insertAutoFlowBlock(editor.config, slotId, blockId);
+        this.autoFlowEditors.set(targetFlowId, {
+            ...editor,
+            config: result.config,
+            diagnostics: result.diagnostics,
+            lastMessage: result.diagnostics.length > 0
+                ? result.diagnostics[0]?.message ?? `Auto-flow block '${blockId}' could not be inserted into '${slotId}'.`
+                : `Inserted auto-flow block '${blockId}' into '${slotId}'.`,
+        });
+        this.emitChange();
+        if (!result.inserted || result.diagnostics.length > 0) {
+            throw new TaskRunnerError(result.diagnostics[0]?.message ?? `Auto-flow block '${blockId}' could not be inserted into '${slotId}'.`);
+        }
+    }
+    removeAutoFlowBlock(flowId, slotId, blockId) {
+        const targetFlowId = flowId ?? this.state.selectedFlowId;
+        const editor = this.requireAutoFlowEditor(targetFlowId);
+        const result = removeAutoFlowBlock(editor.config, slotId, blockId);
+        this.autoFlowEditors.set(targetFlowId, {
+            ...editor,
+            config: result.config,
+            diagnostics: result.diagnostics,
+            lastMessage: result.diagnostics.length > 0
+                ? result.diagnostics[0]?.message ?? `Auto-flow block '${blockId}' could not be removed from '${slotId}'.`
+                : `Removed auto-flow block '${blockId}' from '${slotId}'.`,
+        });
+        this.emitChange();
+        if (!result.removed || result.diagnostics.length > 0) {
+            throw new TaskRunnerError(result.diagnostics[0]?.message ?? `Auto-flow block '${blockId}' could not be removed from '${slotId}'.`);
+        }
+    }
+    resetAutoFlowConfig(flowId) {
+        const targetFlowId = flowId ?? this.state.selectedFlowId;
+        const editor = this.requireAutoFlowEditor(targetFlowId);
+        this.autoFlowEditors.set(targetFlowId, {
+            ...editor,
+            config: cloneSavedAutoFlowConfig(editor.definition.config),
+            diagnostics: [],
+            lastMessage: "Reset auto-flow changes.",
+        });
+        this.emitChange();
+    }
+    saveAutoFlowConfig(flowId, name, location) {
+        const targetFlowId = flowId ?? this.state.selectedFlowId;
+        const editor = this.requireAutoFlowEditor(targetFlowId);
+        const view = this.autoFlowViewForFlow(targetFlowId);
+        if (view && !view.status.canSave) {
+            const message = view.diagnostics[0]?.message ?? "Auto-flow config has validation errors and cannot be saved.";
+            this.autoFlowEditors.set(targetFlowId, {
+                ...editor,
+                lastMessage: message,
+            });
+            this.emitChange();
+            throw new TaskRunnerError(message);
+        }
+        const config = {
+            ...editor.config,
+            ...(name ? { name } : {}),
+        };
+        const result = saveAutoFlowConfig(config, {
+            cwd: this.options.cwd,
+            location: location ?? editor.saveTarget,
+        });
+        this.autoFlowEditors.set(targetFlowId, {
+            ...editor,
+            definition: {
+                ...editor.definition,
+                config: cloneSavedAutoFlowConfig(result.config),
+            },
+            config: result.config,
+            diagnostics: [],
+            saveTarget: result.source.type,
+            lastMessage: `Saved auto-flow config '${result.config.name}' to ${result.source.path}.`,
+        });
+        this.appendLog(`Saved auto-flow config '${result.config.name}' to ${result.source.path}.`);
+        this.emitChange();
+    }
+    hasActiveInput() {
+        return this.confirmSession !== null || this.activeFormSession !== null;
+    }
+    setArtifactExplorerAvailability(input) {
+        const count = input.artifactCount;
+        const hasCount = typeof count === "number";
+        const failed = input.status === "failed";
+        const label = input.label
+            ?? (failed
+                ? hasCount && count > 0 ? "Run failed; artifacts available" : "Run failed"
+                : hasCount && count === 0 ? "Run completed; no artifacts found" : "Artifacts ready");
+        const message = input.message
+            ?? (failed
+                ? hasCount && count > 0
+                    ? "The workflow failed, but artifacts are available for review."
+                    : "The workflow failed. The explorer can check for any artifacts written before failure."
+                : hasCount && count === 0
+                    ? "The workflow completed, but no artifacts were found for this scope yet."
+                    : "The workflow completed and scope artifacts are available for review.");
+        this.state.artifactExplorer = {
+            available: true,
+            open: Boolean(input.open) && !this.hasActiveInput(),
+            scopeKey: input.scopeKey,
+            runId: input.runId ?? null,
+            ...(input.runIds && input.runIds.length > 1 ? { runIds: input.runIds } : {}),
+            status: input.status,
+            label,
+            ...(hasCount ? { artifactCount: count } : {}),
+            message,
+        };
+        this.emitChange();
+    }
+    setArtifactExplorerUnavailable(message = "Artifacts are available after a Web UI workflow run completes.") {
+        if (!this.state.artifactExplorer.available && !this.state.artifactExplorer.open) {
+            return;
+        }
+        this.state.artifactExplorer = {
+            available: false,
+            open: false,
+            scopeKey: null,
+            runId: null,
+            status: "unavailable",
+            label: "Artifact Explorer",
+            message,
+        };
+        this.emitChange();
+    }
+    closeArtifactExplorer() {
+        if (!this.state.artifactExplorer.open) {
+            return;
+        }
+        this.state.artifactExplorer = {
+            ...this.state.artifactExplorer,
+            open: false,
+        };
+        this.emitChange();
+    }
+    openArtifactExplorer() {
+        if (!this.state.artifactExplorer.available || this.hasActiveInput()) {
+            return;
+        }
+        if (this.state.artifactExplorer.open) {
+            return;
+        }
+        this.state.artifactExplorer = {
+            ...this.state.artifactExplorer,
+            open: true,
+        };
+        this.emitChange();
+    }
+    async refreshGitWorkspace(operation) {
+        const previous = this.state.gitWorkspace;
+        const snapshot = await this.gitService.status();
+        const validPaths = new Set(snapshot.changedFiles.map((file) => file.path));
+        this.state.gitWorkspace = {
+            ...snapshot,
+            selectedPaths: previous.selectedPaths.filter((filePath) => validPaths.has(filePath)),
+            commitMessage: previous.commitMessage,
+            operation: operation ?? previous.operation,
+        };
+        this.emitChange();
+    }
+    updateGitCommitMessage(message) {
+        this.state.gitWorkspace = {
+            ...this.state.gitWorkspace,
+            commitMessage: message,
+        };
+        this.emitChange();
+    }
+    updateGitSelectedPaths(paths) {
+        const changed = new Set(this.state.gitWorkspace.changedFiles.map((file) => file.path));
+        const selectedPaths = paths.filter((filePath, index, allPaths) => changed.has(filePath) && allPaths.indexOf(filePath) === index);
+        this.state.gitWorkspace = {
+            ...this.state.gitWorkspace,
+            selectedPaths,
+        };
+        this.emitChange();
+    }
+    async createGitBranch(branchName) {
+        await this.runGitOperation("create branch", () => this.gitService.createBranch(branchName));
+    }
+    async checkoutGitBranch(branchName) {
+        await this.runGitOperation("checkout", () => this.gitService.checkout(branchName));
+    }
+    async fetchGitWorkspace() {
+        await this.runGitOperation("fetch", () => this.gitService.fetch());
+    }
+    async pullGitWorkspaceFfOnly() {
+        await this.runGitOperation("pull --ff-only", () => this.gitService.pullFfOnly());
+    }
+    async stageGitPaths(paths) {
+        if (paths.length === 0) {
+            this.setGitOperationError("No files were selected for staging.");
+            return;
+        }
+        const snapshot = this.state.gitWorkspace;
+        this.updateGitSelectedPaths(paths);
+        const stagePaths = this.filterGitPaths(paths, snapshot, needsGitFileStage);
+        if (stagePaths.length === 0) {
+            this.setGitOperationError("Selected files are already staged.");
+            return;
+        }
+        await this.runGitOperation("stage", () => this.gitService.stage(stagePaths, snapshot));
+    }
+    async unstageGitPaths(paths) {
+        if (paths.length === 0) {
+            this.setGitOperationError("No files were selected for unstaging.");
+            return;
+        }
+        const snapshot = this.state.gitWorkspace;
+        this.updateGitSelectedPaths(paths);
+        const unstagePaths = this.filterGitPaths(paths, snapshot, isGitFileStaged);
+        if (unstagePaths.length === 0) {
+            this.setGitOperationError("Selected files are not staged.");
+            return;
+        }
+        await this.runGitOperation("unstage", () => this.gitService.unstage(unstagePaths, snapshot));
+    }
+    filterGitPaths(paths, snapshot, predicate) {
+        const selected = new Set(paths);
+        return snapshot.changedFiles
+            .filter((file) => selected.has(file.path) && predicate(file))
+            .map((file) => file.path);
+    }
+    async commitGitChanges(paths, message) {
+        if (message.trim().length === 0) {
+            this.setGitOperationError("Commit message must not be empty.");
+            return;
+        }
+        const snapshot = this.state.gitWorkspace;
+        const commitPaths = paths ?? snapshot.selectedPaths;
+        if (paths) {
+            this.updateGitSelectedPaths(paths);
+        }
+        this.updateGitCommitMessage(message);
+        await this.runGitOperation("commit", () => this.gitService.commit(commitPaths, message, snapshot));
+    }
+    async pushGitWorkspace() {
+        const snapshot = this.state.gitWorkspace;
+        if (!snapshot.canPush) {
+            this.setGitOperationError(snapshot.pushDisabledReason ?? "Push is not available.");
+            return;
+        }
+        await this.runGitOperation("push", () => this.gitService.push(snapshot));
+    }
     getViewModel(layout) {
         const selectedItem = this.selectedFlowTreeItem();
         const activeFlowId = this.activeFlowId();
-        const selectedFlow = selectedItem?.kind === "flow" ? selectedItem.flow : null;
-        const progressFlow = this.state.busy ? this.flowMap.get(activeFlowId) ?? null : selectedFlow;
+        const selectedFlow = this.flowWithAutoFlowEditor(selectedItem?.kind === "flow" ? selectedItem.flow : null);
+        const progressFlow = this.flowWithAutoFlowEditor(this.state.busy ? this.flowMap.get(activeFlowId) ?? null : selectedFlow);
         const progressState = progressFlow && this.state.flowState.flowId === progressFlow.id
             ? this.state.flowState.executionState
             : progressFlow && this.state.currentFlowId === progressFlow.id
                 ? this.state.flowState.executionState
                 : null;
-        const progressViewModel = buildProgressViewModel(progressFlow, progressState);
+        const progressViewModel = buildProgressViewModel(progressFlow, progressState, {
+            failedFlowId: this.state.failedFlowId,
+            waitingForUserInput: this.activeFormSession !== null,
+        });
         const helpText = `${HELP_TEXT}\n\nAvailable flows:\n${this.options.flows.map((flow) => `- ${flow.treePath.join("/")}`).join("\n")}`;
         return {
             header: this.buildHeaderText(),
@@ -552,6 +906,8 @@ export class InteractiveSessionController {
             })),
             selectedFlowIndex: Math.max(0, this.visibleFlowItems.findIndex((item) => item.key === this.state.selectedFlowItemKey)),
             progressTitle: this.panelTitle("Current Flow", "progress"),
+            progress: progressViewModel,
+            autoFlow: selectedFlow?.autoFlow ? this.autoFlowViewForFlow(selectedFlow.id) : null,
             progressText: this.renderProgress(progressViewModel),
             progressScrollOffset: this.state.progressScrollOffset,
             descriptionText: this.renderDescription(selectedItem),
@@ -566,13 +922,84 @@ export class InteractiveSessionController {
             confirmText: this.renderConfirmText(),
             confirmation: this.renderConfirmationView(),
             form: this.renderFormView(layout),
+            artifactExplorer: { ...this.state.artifactExplorer },
+            gitWorkspace: {
+                ...this.state.gitWorkspace,
+                changedFiles: this.state.gitWorkspace.changedFiles.map((file) => ({ ...file })),
+                branches: this.state.gitWorkspace.branches.map((branch) => ({ ...branch })),
+                remotes: this.state.gitWorkspace.remotes.map((remote) => ({ ...remote })),
+                warnings: [...this.state.gitWorkspace.warnings],
+                selectedPaths: [...this.state.gitWorkspace.selectedPaths],
+                operation: { ...this.state.gitWorkspace.operation },
+            },
         };
     }
+    setGitOperationError(message) {
+        this.state.gitWorkspace = {
+            ...this.state.gitWorkspace,
+            operation: { status: "error", message },
+        };
+        this.appendLog(`Git operation failed: ${message}`);
+        this.emitChange();
+    }
+    async runGitOperation(action, operation) {
+        this.state.gitWorkspace = {
+            ...this.state.gitWorkspace,
+            operation: { status: "running", action, message: `Running git ${action}...` },
+        };
+        this.emitChange();
+        const result = await operation();
+        if (result.status === "success") {
+            this.appendLog(`Git ${action}: ${result.message ?? "completed."}`);
+        }
+        else {
+            this.appendLog(`Git ${action} failed: ${result.message ?? "Git operation failed."}`);
+        }
+        await this.refreshGitWorkspace({ ...result, action });
+    }
     emitChange(event = { type: "render" }) {
         for (const listener of this.listeners) {
             listener(event);
         }
     }
+    requireAutoFlowEditor(flowId) {
+        const editor = this.autoFlowEditors.get(flowId);
+        if (!editor) {
+            throw new Error(`Flow '${flowId}' is not a configurable auto-flow entry.`);
+        }
+        return editor;
+    }
+    flowWithAutoFlowEditor(flow) {
+        if (!flow?.autoFlow) {
+            return flow;
+        }
+        const editor = this.autoFlowEditors.get(flow.id);
+        if (!editor) {
+            return flow;
+        }
+        return {
+            ...flow,
+            autoFlow: {
+                ...editor.definition,
+                config: cloneSavedAutoFlowConfig(editor.config),
+                ...(editor.diagnostics.length > 0 ? { diagnostics: editor.diagnostics } : {}),
+                ...(editor.lastMessage ? { lastMessage: editor.lastMessage } : {}),
+            },
+        };
+    }
+    autoFlowViewForFlow(flowId) {
+        const flow = this.flowMap.get(flowId);
+        const editor = this.autoFlowEditors.get(flowId);
+        if (!flow?.autoFlow || !editor) {
+            return null;
+        }
+        return buildAutoFlowEditorViewModel(editor.definition, {
+            config: editor.config,
+            ...(editor.diagnostics.length > 0 ? { diagnostics: editor.diagnostics } : {}),
+            saveTarget: editor.saveTarget,
+            ...(editor.lastMessage ? { lastMessage: editor.lastMessage } : {}),
+        });
+    }
     createAdapter() {
         return {
             writeStdout: (text) => {
@@ -652,8 +1079,34 @@ export class InteractiveSessionController {
                 `State: ${this.expandedFlowFolders.has(selectedItem.key) ? "expanded" : "collapsed"}`,
             ].join("\n");
         }
-        const { flow } = selectedItem;
+        const flow = this.flowWithAutoFlowEditor(selectedItem.flow) ?? selectedItem.flow;
         const description = flow.description?.trim() || "No description available for this flow.";
+        if (flow.autoFlow) {
+            const autoFlow = this.autoFlowViewForFlow(flow.id);
+            const diagnostics = autoFlow?.diagnostics ?? [];
+            const slotLines = autoFlow?.slots.map((slot) => {
+                const blockText = slot.blocks.length === 0
+                    ? "empty"
+                    : slot.blocks.map((block) => `${block.title} [${block.status}]`).join(", ");
+                return `- ${slot.title}: ${blockText}`;
+            }) ?? [];
+            const diagnosticLines = diagnostics.length > 0
+                ? ["", "Validation:", ...diagnostics.map((diagnostic) => `- ${diagnostic.message}`)]
+                : [];
+            const statusLine = autoFlow
+                ? `Config status: ${autoFlow.status.valid ? "valid" : "invalid"} (${autoFlow.status.sourceLabel})`
+                : "Config status: unavailable";
+            return renderMarkdownToTerminal(stripAnsi([
+                description,
+                "",
+                statusLine,
+                autoFlow?.status.lastMessage ? `Last action: ${autoFlow.status.lastMessage}` : "",
+                "",
+                "Slots:",
+                ...slotLines,
+                ...diagnosticLines,
+            ].filter((line) => line.length > 0).join("\n")));
+        }
         const details = [
             `Path: ${flow.treePath.join("/")}`,
             `Source: ${flow.source === "project-local" ? "project-local" : flow.source === "global" ? "global" : "built-in"}`,
@@ -670,13 +1123,16 @@ export class InteractiveSessionController {
         const lines = [progressViewModel.flow.label, ""];
         for (const item of progressViewModel.items) {
             if (item.kind === "termination") {
-                const symbol = item.status === "done" ? "✓" : "■";
+                const symbol = item.status === "done" || item.status === "success" ? "✓" : item.status === "failed" ? "×" : "■";
                 lines.push(`${symbol} ${item.label}`);
                 lines.push(item.detail);
                 continue;
             }
             const indent = "  ".repeat(item.depth);
             lines.push(`${indent}${this.symbolForStatus(progressViewModel.flow.id, item.status)} ${item.label}`);
+            if ((item.kind === "slot" || item.kind === "block") && item.detail && item.status !== "pending" && item.status !== "success") {
+                lines.push(`${indent}  ${item.detail}`);
+            }
         }
         return lines.join("\n").trimEnd();
     }
@@ -990,6 +1446,20 @@ export class InteractiveSessionController {
         if (!selectedItem || selectedItem.kind !== "flow") {
             return;
         }
+        const autoFlow = this.autoFlowViewForFlow(selectedItem.flow.id);
+        if (autoFlow && !autoFlow.status.canRun) {
+            const message = autoFlow.diagnostics[0]?.message ?? "Auto-flow config has validation errors and cannot be run.";
+            const editor = this.autoFlowEditors.get(selectedItem.flow.id);
+            if (editor) {
+                this.autoFlowEditors.set(selectedItem.flow.id, {
+                    ...editor,
+                    lastMessage: message,
+                });
+            }
+            this.appendLog(message);
+            this.emitChange();
+            return;
+        }
         const confirmation = await this.options.getRunConfirmation(selectedItem.flow.id);
         if (this.state.busy || this.confirmSession) {
             return;
@@ -1175,13 +1645,22 @@ export class InteractiveSessionController {
         return this.state.currentFlowId ?? this.state.selectedFlowId;
     }
     symbolForStatus(flowId, status) {
-        if (status === "done") {
+        if (status === "done" || status === "success") {
             return "✓";
         }
+        if (status === "failed" || status === "invalid") {
+            return "×";
+        }
+        if (status === "stopped" || status === "blocked") {
+            return "■";
+        }
+        if (status === "disabled" || status === "empty") {
+            return "·";
+        }
         if (status === "skipped") {
             return "·";
         }
-        if (status === "running") {
+        if (status === "running" || status === "waiting-user") {
             if (this.state.failedFlowId === flowId && !this.state.busy) {
                 return "×";
             }
@@ -1213,6 +1692,9 @@ export class InteractiveSessionController {
     }
     applyScrollOffset(panel, value, maxOffset) {
         const next = clamp(value, 0, maxOffset);
+        if (this.scrollOffsetFor(panel) === next) {
+            return;
+        }
         if (panel === "progress") {
             this.state.progressScrollOffset = next;
         }