prompt-language-shell 0.9.0 → 0.9.2

package/dist/ui/Execute.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useCallback, useEffect, useReducer, useRef } from 'react';
+import { useCallback, useEffect, useReducer, useRef, useState } from 'react';
 import { Box, Text } from 'ink';
 import { ComponentStatus, } from '../types/components.js';
 import { getTextColor } from '../services/colors.js';
@@ -7,16 +7,53 @@ import { useInput } from '../services/keyboard.js';
 import { formatErrorMessage, getExecutionErrorMessage, } from '../services/messages.js';
 import { ExecutionStatus } from '../services/shell.js';
 import { ensureMinimumTime } from '../services/timing.js';
-import { buildAbortedState, handleTaskCompletion, handleTaskFailure, } from '../execution/handlers.js';
+import { handleTaskCompletion, handleTaskFailure, } from '../execution/handlers.js';
 import { processTasks } from '../execution/processing.js';
 import { executeReducer, initialState } from '../execution/reducer.js';
+import { executeTask } from '../execution/runner.js';
 import { ExecuteActionType } from '../execution/types.js';
-import { createFeedback, createMessage, markAsDone, } from '../services/components.js';
+import { getCurrentTaskIndex } from '../execution/utils.js';
+import { createFeedback, createMessage } from '../services/components.js';
 import { FeedbackType } from '../types/types.js';
-import { Message } from './Message.js';
 import { Spinner } from './Spinner.js';
-import { Task } from './Task.js';
+import { TaskView } from './Task.js';
 const MINIMUM_PROCESSING_TIME = 400;
+const ELAPSED_UPDATE_INTERVAL = 1000;
+/**
+ * Check if a task is finished (success, failed, or aborted)
+ */
+function isTaskFinished(task) {
+    return (task.status === ExecutionStatus.Success ||
+        task.status === ExecutionStatus.Failed ||
+        task.status === ExecutionStatus.Aborted);
+}
+/**
+ * Map ExecuteState to view props for rendering in timeline
+ */
+export function mapStateToViewProps(state, isActive) {
+    const taskViewData = state.tasks.map((task) => {
+        return {
+            label: task.label,
+            command: task.command,
+            status: task.status,
+            elapsed: task.elapsed,
+            stdout: task.stdout ?? '',
+            stderr: task.stderr ?? '',
+            isActive: false, // In timeline, no task is active
+            isFinished: isTaskFinished(task),
+        };
+    });
+    return {
+        isLoading: false,
+        isExecuting: false,
+        isActive,
+        error: state.error,
+        message: state.message,
+        tasks: taskViewData,
+        completionMessage: state.completionMessage,
+        showTasks: state.tasks.length > 0,
+    };
+}
 /**
  * Create an ExecuteState with defaults
  */
@@ -25,96 +62,87 @@ function createExecuteState(overrides = {}) {
         message: '',
         summary: '',
         tasks: [],
-        completed: 0,
         completionMessage: null,
         error: null,
         ...overrides,
     };
 }
-export const ExecuteView = ({ state, status, workdir, onOutputChange, onTaskComplete, onTaskAbort, onTaskError, }) => {
-    const isActive = status === ComponentStatus.Active;
-    const { error, tasks, message, completed, completionMessage } = state;
-    const hasProcessed = tasks.length > 0;
-    // Derive loading state from current conditions
-    const isLoading = isActive && tasks.length === 0 && !error && !hasProcessed;
-    const isExecuting = completed < tasks.length;
+/**
+ * Execute view: Pure display component for task execution progress
+ */
+export const ExecuteView = ({ isLoading, isExecuting, isActive, error, message, tasks, completionMessage, showTasks, }) => {
     // Return null only when loading completes with no commands
     if (!isActive && tasks.length === 0 && !error) {
         return null;
     }
-    // Show completed steps when not active
-    const showTasks = !isActive && tasks.length > 0;
-    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isLoading && (_jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: "Preparing commands. " }), _jsx(Spinner, {})] })), (isExecuting || showTasks) && (_jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [message && (_jsxs(Box, { marginBottom: 1, gap: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: message }), isExecuting && _jsx(Spinner, {})] })), tasks.map((taskInfo, index) => {
-                        // Merge workdir into active task's command
-                        const taskCommand = isActive && index === completed && workdir
-                            ? { ...taskInfo.command, workdir }
-                            : taskInfo.command;
-                        return (_jsx(Box, { marginBottom: index < tasks.length - 1 ? 1 : 0, children: _jsx(Task, { label: taskInfo.label, command: taskCommand, isActive: isActive && index === completed, isFinished: index < completed, index: index, initialStatus: taskInfo.status, initialElapsed: taskInfo.elapsed, initialOutput: taskInfo.stdout || taskInfo.stderr || taskInfo.error
-                                    ? {
-                                        stdout: taskInfo.stdout ?? '',
-                                        stderr: taskInfo.stderr ?? '',
-                                        error: taskInfo.error ?? '',
-                                    }
-                                    : undefined, onOutputChange: onOutputChange, onComplete: onTaskComplete, onAbort: onTaskAbort, onError: onTaskError }) }, index));
-                    })] })), completionMessage && !isActive && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsx(Text, { color: getTextColor(false), children: completionMessage }) })), error && _jsx(Message, { text: error, status: status })] }));
+    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isLoading && (_jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: "Preparing commands. " }), _jsx(Spinner, {})] })), (isExecuting || showTasks) && (_jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [message && (_jsxs(Box, { marginBottom: 1, gap: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: message }), isExecuting && _jsx(Spinner, {})] })), tasks.map((task, index) => (_jsx(Box, { marginBottom: index < tasks.length - 1 ? 1 : 0, children: _jsx(TaskView, { label: task.label, command: task.command, status: task.status, elapsed: task.elapsed, stdout: task.stdout, stderr: task.stderr, isFinished: task.isFinished }) }, index)))] })), completionMessage && !isActive && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsx(Text, { color: getTextColor(false), children: completionMessage }) })), error && (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { children: error }) }))] }));
 };
 /**
- * Execute controller: Runs tasks sequentially
+ * Execute controller: Runs tasks sequentially and manages all execution state
  */
 export function Execute({ tasks: inputTasks, status, service, requestHandlers, lifecycleHandlers, workflowHandlers, }) {
     const isActive = status === ComponentStatus.Active;
     const [localState, dispatch] = useReducer(executeReducer, initialState);
-    // Ref to store current output for each task (avoids re-renders)
-    const taskOutputRef = useRef(new Map());
+    // Live output state for currently executing task
+    const [liveOutput, setLiveOutput] = useState({
+        stdout: '',
+        stderr: '',
+        error: '',
+    });
+    const [liveElapsed, setLiveElapsed] = useState(0);
+    const [taskStartTime, setTaskStartTime] = useState(null);
     // Track working directory across commands (persists cd changes)
     const workdirRef = useRef(undefined);
-    const { error, tasks, message, completed, hasProcessed, completionMessage, summary, } = localState;
-    // Derive loading state from current conditions
+    // Ref to track if current task execution is cancelled
+    const cancelledRef = useRef(false);
+    const { error, tasks, message, hasProcessed, completionMessage, summary } = localState;
+    // Derive current task index from tasks
+    const currentTaskIndex = getCurrentTaskIndex(tasks);
+    // Derive states
     const isLoading = isActive && tasks.length === 0 && !error && !hasProcessed;
-    const isExecuting = completed < tasks.length;
-    // Handle output changes from Task - store in ref (no re-render)
-    const handleOutputChange = useCallback((index, taskOutput) => {
-        taskOutputRef.current.set(index, taskOutput);
-    }, []);
-    // Handle cancel with useCallback to ensure we capture latest state
+    const isExecuting = isActive && currentTaskIndex < tasks.length;
+    const showTasks = !isActive && tasks.length > 0;
+    // Update elapsed time while task is running
+    useEffect(() => {
+        if (!taskStartTime || !isExecuting)
+            return;
+        const interval = setInterval(() => {
+            setLiveElapsed(Date.now() - taskStartTime);
+        }, ELAPSED_UPDATE_INTERVAL);
+        return () => {
+            clearInterval(interval);
+        };
+    }, [taskStartTime, isExecuting]);
+    // Handle cancel
     const handleCancel = useCallback(() => {
-        dispatch({
-            type: ExecuteActionType.CancelExecution,
-            payload: { completed },
-        });
-        // Get updated task infos after cancel, merging output from ref
-        const updatedTaskInfos = tasks.map((task, taskIndex) => {
-            const output = taskOutputRef.current.get(taskIndex);
-            const baseTask = output
-                ? {
+        cancelledRef.current = true;
+        dispatch({ type: ExecuteActionType.CancelExecution });
+        // Build updated task infos with current output for the running task
+        const updatedTaskInfos = tasks.map((task) => {
+            if (task.status === ExecutionStatus.Running) {
+                return {
                     ...task,
-                    stdout: output.stdout,
-                    stderr: output.stderr,
-                    error: output.error,
-                }
-                : task;
-            if (taskIndex < completed) {
-                return { ...baseTask, status: ExecutionStatus.Success };
-            }
-            else if (taskIndex === completed) {
-                return { ...baseTask, status: ExecutionStatus.Aborted };
+                    status: ExecutionStatus.Aborted,
+                    stdout: liveOutput.stdout,
+                    stderr: liveOutput.stderr,
+                    error: liveOutput.error,
+                };
             }
-            else {
-                return { ...baseTask, status: ExecutionStatus.Cancelled };
+            else if (task.status === ExecutionStatus.Pending) {
+                return { ...task, status: ExecutionStatus.Cancelled };
             }
+            return task;
         });
-        // Expose final state
         const finalState = createExecuteState({
             message,
             summary,
             tasks: updatedTaskInfos,
-            completed,
         });
         requestHandlers.onCompleted(finalState);
         requestHandlers.onAborted('execution');
-    }, [message, summary, tasks, completed, requestHandlers]);
+    }, [message, summary, tasks, liveOutput, requestHandlers]);
     useInput((_, key) => {
-        if (key.escape && (isLoading || isExecuting) && isActive) {
+        if (key.escape && (isLoading || isExecuting)) {
             handleCancel();
         }
     }, { isActive: (isLoading || isExecuting) && isActive });
@@ -136,17 +164,13 @@ export function Execute({ tasks: inputTasks, status, service, requestHandlers, l
                     workflowHandlers.addToTimeline(...result.debug);
                 }
                 if (result.commands.length === 0) {
-                    // Check if this is an error response (has error field)
                     if (result.error) {
-                        // Add error message to timeline
                         const errorMessage = getExecutionErrorMessage(result.error);
-                        workflowHandlers.addToTimeline(markAsDone(createMessage(errorMessage)));
-                        // Complete without error in state (message already in timeline)
+                        workflowHandlers.addToTimeline(createMessage({ text: errorMessage }, ComponentStatus.Done));
                         requestHandlers.onCompleted(createExecuteState({ message: result.message }));
                         lifecycleHandlers.completeActive();
                         return;
                     }
-                    // No commands and no error - just complete
                     dispatch({
                         type: ExecuteActionType.ProcessingComplete,
                         payload: { message: result.message },
@@ -156,7 +180,7 @@ export function Execute({ tasks: inputTasks, status, service, requestHandlers, l
                     return;
                 }
                 // Create task infos from commands
-                const tasks = result.commands.map((cmd, index) => ({
+                const taskInfos = result.commands.map((cmd, index) => ({
                     label: inputTasks[index]?.action ?? cmd.description,
                     command: cmd,
                     status: ExecutionStatus.Pending,
@@ -167,14 +191,13 @@ export function Execute({ tasks: inputTasks, status, service, requestHandlers, l
                     payload: {
                         message: result.message,
                         summary: result.summary,
-                        tasks,
+                        tasks: taskInfos,
                     },
                 });
-                // Update state after AI processing
                 requestHandlers.onCompleted(createExecuteState({
                     message: result.message,
                     summary: result.summary,
-                    tasks,
+                    tasks: taskInfos,
                 }));
             }
             catch (err) {
@@ -204,91 +227,131 @@ export function Execute({ tasks: inputTasks, status, service, requestHandlers, l
         tasks.length,
         hasProcessed,
     ]);
-    // Handle task completion - move to next task
-    const handleTaskComplete = useCallback((index, elapsed, taskOutput) => {
-        // Track working directory for subsequent commands
-        if (taskOutput.workdir) {
-            workdirRef.current = taskOutput.workdir;
-        }
-        // Update tasks with output before calling handler
-        const tasksWithOutput = tasks.map((task, i) => i === index
-            ? {
-                ...task,
-                stdout: taskOutput.stdout,
-                stderr: taskOutput.stderr,
-                error: taskOutput.error,
-            }
-            : task);
-        const result = handleTaskCompletion(index, elapsed, {
-            tasks: tasksWithOutput,
-            message,
-            summary,
-        });
-        dispatch(result.action);
-        requestHandlers.onCompleted(result.finalState);
-        if (result.shouldComplete) {
-            lifecycleHandlers.completeActive();
+    // Execute current task
+    useEffect(() => {
+        if (!isActive ||
+            tasks.length === 0 ||
+            currentTaskIndex >= tasks.length ||
+            error) {
+            return;
         }
-    }, [tasks, message, summary, requestHandlers, lifecycleHandlers]);
-    const handleTaskError = useCallback((index, error, elapsed, taskOutput) => {
-        // Track working directory for subsequent commands (even on error)
-        if (taskOutput.workdir) {
-            workdirRef.current = taskOutput.workdir;
+        const currentTask = tasks[currentTaskIndex];
+        if (currentTask.status !== ExecutionStatus.Pending) {
+            return;
         }
-        // Update tasks with output before calling handler
-        const tasksWithOutput = tasks.map((task, i) => i === index
-            ? {
-                ...task,
-                stdout: taskOutput.stdout,
-                stderr: taskOutput.stderr,
-                error: taskOutput.error,
-            }
-            : task);
-        const result = handleTaskFailure(index, error, elapsed, {
-            tasks: tasksWithOutput,
-            message,
-            summary,
+        cancelledRef.current = false;
+        // Mark task as started (running)
+        dispatch({
+            type: ExecuteActionType.TaskStarted,
+            payload: { index: currentTaskIndex },
+        });
+        // Reset live state for new task
+        setLiveOutput({ stdout: '', stderr: '', error: '' });
+        setLiveElapsed(0);
+        setTaskStartTime(Date.now());
+        // Merge workdir into command
+        const command = workdirRef.current
+            ? { ...currentTask.command, workdir: workdirRef.current }
+            : currentTask.command;
+        void executeTask(command, currentTaskIndex, {
+            onOutputChange: (output) => {
+                if (!cancelledRef.current) {
+                    setLiveOutput(output);
+                }
+            },
+            onComplete: (elapsed, output) => {
+                if (cancelledRef.current)
+                    return;
+                setTaskStartTime(null);
+                // Track working directory
+                if (output.workdir) {
+                    workdirRef.current = output.workdir;
+                }
+                const tasksWithOutput = tasks.map((task, i) => i === currentTaskIndex
+                    ? {
+                        ...task,
+                        stdout: output.stdout,
+                        stderr: output.stderr,
+                        error: output.error,
+                    }
+                    : task);
+                const result = handleTaskCompletion(currentTaskIndex, elapsed, {
+                    tasks: tasksWithOutput,
+                    message,
+                    summary,
+                });
+                dispatch(result.action);
+                requestHandlers.onCompleted(result.finalState);
+                if (result.shouldComplete) {
+                    lifecycleHandlers.completeActive();
+                }
+            },
+            onError: (errorMsg, elapsed, output) => {
+                if (cancelledRef.current)
+                    return;
+                setTaskStartTime(null);
+                // Track working directory
+                if (output.workdir) {
+                    workdirRef.current = output.workdir;
+                }
+                const tasksWithOutput = tasks.map((task, i) => i === currentTaskIndex
+                    ? {
+                        ...task,
+                        stdout: output.stdout,
+                        stderr: output.stderr,
+                        error: output.error,
+                    }
+                    : task);
+                const result = handleTaskFailure(currentTaskIndex, errorMsg, elapsed, {
+                    tasks: tasksWithOutput,
+                    message,
+                    summary,
+                });
+                dispatch(result.action);
+                requestHandlers.onCompleted(result.finalState);
+                if (result.action.type === ExecuteActionType.TaskErrorCritical) {
+                    const errorMessage = getExecutionErrorMessage(errorMsg);
+                    workflowHandlers.addToQueue(createFeedback({ type: FeedbackType.Failed, message: errorMessage }));
+                }
+                if (result.shouldComplete) {
+                    lifecycleHandlers.completeActive();
+                }
+            },
         });
-        dispatch(result.action);
-        requestHandlers.onCompleted(result.finalState);
-        // Add error feedback to queue for critical failures
-        if (result.action.type === ExecuteActionType.TaskErrorCritical) {
-            const errorMessage = getExecutionErrorMessage(error);
-            workflowHandlers.addToQueue(createFeedback(FeedbackType.Failed, errorMessage));
-        }
-        if (result.shouldComplete) {
-            lifecycleHandlers.completeActive();
-        }
     }, [
+        isActive,
         tasks,
+        currentTaskIndex,
         message,
         summary,
+        error,
         requestHandlers,
         lifecycleHandlers,
         workflowHandlers,
     ]);
-    const handleTaskAbort = useCallback((index, taskOutput) => {
-        // Task was aborted - execution already stopped by Escape handler
-        // Update tasks with output before building state
-        const tasksWithOutput = tasks.map((task, i) => i === index
-            ? {
-                ...task,
-                stdout: taskOutput.stdout,
-                stderr: taskOutput.stderr,
-                error: taskOutput.error,
-            }
-            : task);
-        const finalState = buildAbortedState(tasksWithOutput, message, summary, completed);
-        requestHandlers.onCompleted(finalState);
-    }, [tasks, message, summary, completed, requestHandlers]);
-    // Controller always renders View with current state
-    const viewState = createExecuteState({
-        error,
-        tasks,
-        message,
-        summary,
-        completed,
-        completionMessage,
+    // Build view data for each task
+    const taskViewData = tasks.map((task) => {
+        const isTaskActive = isActive && task.status === ExecutionStatus.Running;
+        const finished = isTaskFinished(task);
+        // Use live output for active task, stored output for finished tasks
+        const stdout = isTaskActive ? liveOutput.stdout : (task.stdout ?? '');
+        const stderr = isTaskActive ? liveOutput.stderr : (task.stderr ?? '');
+        // Use live elapsed for active running task
+        const elapsed = isTaskActive ? liveElapsed : task.elapsed;
+        // Merge workdir for active task
+        const command = isTaskActive && workdirRef.current
+            ? { ...task.command, workdir: workdirRef.current }
+            : task.command;
+        return {
+            label: task.label,
+            command,
+            status: task.status,
+            elapsed,
+            stdout,
+            stderr,
+            isActive: isTaskActive,
+            isFinished: finished,
+        };
     });
-    return (_jsx(ExecuteView, { state: viewState, status: status, workdir: workdirRef.current, onOutputChange: handleOutputChange, onTaskComplete: handleTaskComplete, onTaskAbort: handleTaskAbort, onTaskError: handleTaskError }));
+    return (_jsx(ExecuteView, { isLoading: isLoading, isExecuting: isExecuting, isActive: isActive, error: error, message: message, tasks: taskViewData, completionMessage: completionMessage, showTasks: showTasks }));
 }

package/dist/ui/Introspect.js

@@ -2,8 +2,9 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import { Box, Text } from 'ink';
 import { ComponentStatus, } from '../types/components.js';
+import { Origin } from '../types/types.js';
 import { Colors, getTextColor } from '../services/colors.js';
-import { createReportDefinition } from '../services/components.js';
+import { createReport } from '../services/components.js';
 import { DebugLevel } from '../configuration/types.js';
 import { useInput } from '../services/keyboard.js';
 import { formatErrorMessage } from '../services/messages.js';
@@ -51,24 +52,22 @@ export function Introspect({ tasks, status, service, children, debug = DebugLeve
                     if (result.debug?.length) {
                         workflowHandlers.addToTimeline(...result.debug);
                     }
-                    // Capabilities come directly from result - no parsing needed
-                    let caps = result.capabilities;
-                    // Filter out internal capabilities when not in debug mode
-                    if (debug === DebugLevel.None) {
-                        caps = caps.filter((cap) => cap.name.toUpperCase() !== 'SCHEDULE' &&
-                            cap.name.toUpperCase() !== 'VALIDATE' &&
-                            cap.name.toUpperCase() !== 'REPORT');
-                    }
-                    setCapabilities(caps);
-                    setMessage(result.message);
+                    // Destructure message from result
+                    const { message } = result;
+                    // Filter out meta workflow capabilities when not in debug mode
+                    const capabilities = debug === DebugLevel.None
+                        ? result.capabilities.filter((cap) => cap.origin !== Origin.Indirect)
+                        : result.capabilities;
+                    setCapabilities(capabilities);
+                    setMessage(message);
                     const finalState = {
                         error: null,
-                        capabilities: caps,
-                        message: result.message,
+                        capabilities,
+                        message,
                     };
                     requestHandlers.onCompleted(finalState);
                     // Add Report component to queue
-                    workflowHandlers.addToQueue(createReportDefinition(result.message, caps));
+                    workflowHandlers.addToQueue(createReport({ message, capabilities }));
                     // Signal completion
                     lifecycleHandlers.completeActive();
                 }

package/dist/ui/List.js

@@ -2,9 +2,9 @@ import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-run
 import { Box, Text } from 'ink';
 import { Palette } from '../services/colors.js';
 import { Separator } from './Separator.js';
-export const List = ({ items, level = 0, highlightedIndex = null, highlightedParentIndex = null, showType = false, }) => {
+export const List = ({ items, level = 0, highlightedIndex = null, highlightedParentIndex = null, showType = false, compact = false, }) => {
     const marginLeft = level > 0 ? 2 : 0;
-    const gap = level === 0 ? 1 : 0;
+    const gap = level === 0 && !compact ? 1 : 0;
     return (_jsx(Box, { flexDirection: "column", marginLeft: marginLeft, gap: gap, children: items.map((item, index) => {
             // At level 0, track which parent is active for child highlighting
             // At level > 0, only highlight if this parent is the active one

package/dist/ui/Main.js

@@ -5,9 +5,10 @@ import { FeedbackType } from '../types/types.js';
 import { loadConfig, loadDebugSetting, saveConfig, saveDebugSetting, } from '../configuration/io.js';
 import { getConfigurationRequiredMessage } from '../configuration/messages.js';
 import { getMissingConfigKeys } from '../configuration/schema.js';
+import { createConfigStepsFromSchema } from '../configuration/steps.js';
 import { unflattenConfig } from '../configuration/transformation.js';
 import { createAnthropicService } from '../services/anthropic.js';
-import { createCommandDefinition, createConfigDefinitionWithKeys, createFeedback, createMessage, createWelcomeDefinition, } from '../services/components.js';
+import { createCommand, createConfig, createFeedback, createMessage, createWelcome, } from '../services/components.js';
 import { registerGlobalShortcut } from '../services/keyboard.js';
 import { initializeLogger, setDebugLevel } from '../services/logger.js';
 import { Workflow } from './Workflow.js';
@@ -56,7 +57,9 @@ export const Main = ({ app, command, serviceFactory = createAnthropicService, })
                 const errorMessage = error instanceof Error
                     ? error.message
                     : 'Failed to initialize service';
-                setInitialQueue([createFeedback(FeedbackType.Failed, errorMessage)]);
+                setInitialQueue([
+                    createFeedback({ type: FeedbackType.Failed, message: errorMessage }),
+                ]);
             }
         }
         // If config is missing, service will be created after config completes
@@ -94,18 +97,22 @@ export const Main = ({ app, command, serviceFactory = createAnthropicService, })
                 // Config was cancelled
             };
             setInitialQueue([
-                createWelcomeDefinition(app),
-                createMessage(getConfigurationRequiredMessage()),
-                createConfigDefinitionWithKeys(missingKeys, handleConfigFinished, handleConfigAborted),
+                createWelcome({ app }),
+                createMessage({ text: getConfigurationRequiredMessage() }),
+                createConfig({
+                    steps: createConfigStepsFromSchema(missingKeys),
+                    onFinished: handleConfigFinished,
+                    onAborted: handleConfigAborted,
+                }),
             ]);
         }
         else if (service && command) {
             // Valid service exists and command provided - execute command
-            setInitialQueue([createCommandDefinition(command, service)]);
+            setInitialQueue([createCommand({ command, service })]);
         }
         else if (service && !command) {
             // Valid service exists, no command - show welcome
-            setInitialQueue([createWelcomeDefinition(app)]);
+            setInitialQueue([createWelcome({ app })]);
         }
         // Wait for service to be initialized before setting queue
     }, [app, command, service, initialQueue]);

package/dist/ui/Schedule.js

@@ -79,6 +79,8 @@ export function taskToListItem(task, highlightedChildIndex = null, isDefineTaskW
 export const ScheduleView = ({ message, tasks, state, status, debug = DebugLevel.None, }) => {
     const isActive = status === ComponentStatus.Active;
     const { highlightedIndex, currentDefineGroupIndex, completedSelections } = state;
+    // Use compact mode when all tasks are Config type
+    const isCompact = tasks.every((task) => task.type === TaskType.Config);
     // Find all Define tasks
     const defineTaskIndices = tasks
         .map((t, idx) => (t.type === TaskType.Define ? idx : -1))
@@ -114,7 +116,7 @@ export const ScheduleView = ({ message, tasks, state, status, debug = DebugLevel
             isActive;
         return taskToListItem(task, childIndex, isDefineWithoutSelection, status, debug);
     });
-    return (_jsxs(Box, { flexDirection: "column", children: [message && (_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Label, { description: message, taskType: TaskType.Schedule, showType: debug !== DebugLevel.None, status: status, debug: debug }) })), _jsx(Box, { marginLeft: 1, children: _jsx(List, { items: listItems, highlightedIndex: currentDefineTaskIndex >= 0 ? highlightedIndex : null, highlightedParentIndex: currentDefineTaskIndex, showType: debug !== DebugLevel.None }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [message && (_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Label, { description: message, taskType: TaskType.Schedule, showType: debug !== DebugLevel.None, status: status, debug: debug }) })), _jsx(Box, { marginLeft: 1, children: _jsx(List, { items: listItems, highlightedIndex: currentDefineTaskIndex >= 0 ? highlightedIndex : null, highlightedParentIndex: currentDefineTaskIndex, showType: debug !== DebugLevel.None, compact: isCompact }) })] }));
 };
 /**
  * Schedule controller: Manages task selection and navigation

package/dist/ui/Subtask.js

@@ -4,7 +4,11 @@ import { getStatusColors, Palette, STATUS_ICONS } from '../services/colors.js';
 import { ExecutionStatus } from '../services/shell.js';
 import { formatDuration } from '../services/utils.js';
 import { Spinner } from './Spinner.js';
-export function Subtask({ label, command, status, isActive: _isActive, startTime, endTime, elapsed, }) {
+/**
+ * Pure display component for a single subtask.
+ * Shows label, command, status icon, and elapsed time.
+ */
+export function SubtaskView({ label, command, status, elapsed, }) {
     const colors = getStatusColors(status);
     const isCancelled = status === ExecutionStatus.Cancelled;
     const isAborted = status === ExecutionStatus.Aborted;
@@ -12,11 +16,10 @@ export function Subtask({ label, command, status, isActive: _isActive, startTime
     const isFinished = status === ExecutionStatus.Success ||
         status === ExecutionStatus.Failed ||
         status === ExecutionStatus.Aborted;
-    const elapsedTime = elapsed ?? (startTime && endTime ? endTime - startTime : undefined);
     // Apply strikethrough for cancelled and aborted tasks
     const formatText = (text) => shouldStrikethrough ? text.split('').join('\u0336') + '\u0336' : text;
     return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { paddingLeft: 2, gap: 1, children: [_jsx(Text, { color: colors.icon, children: STATUS_ICONS[status] }), _jsx(Text, { color: colors.description, children: shouldStrikethrough
                             ? formatText(label || command.description)
                             : label || command.description }), (isFinished || status === ExecutionStatus.Running) &&
-                        elapsedTime !== undefined && (_jsxs(Text, { color: Palette.DarkGray, children: ["(", formatDuration(elapsedTime), ")"] }))] }), _jsxs(Box, { paddingLeft: 5, flexDirection: "row", children: [_jsx(Box, { children: _jsx(Text, { color: colors.symbol, children: "\u221F " }) }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { color: colors.command, children: command.command }), status === ExecutionStatus.Running && _jsx(Spinner, {})] })] })] }));
+                        elapsed !== undefined && (_jsxs(Text, { color: Palette.DarkGray, children: ["(", formatDuration(elapsed), ")"] }))] }), _jsxs(Box, { paddingLeft: 5, flexDirection: "row", children: [_jsx(Box, { children: _jsx(Text, { color: colors.symbol, children: "\u221F " }) }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { color: colors.command, children: command.command }), status === ExecutionStatus.Running && _jsx(Spinner, {})] })] })] }));
 }