prompt-language-shell 0.8.8 → 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 } 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,93 +7,155 @@ 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 { createMessage, markAsDone } from '../services/components.js';
-import { Message } from './Message.js';
+import { getCurrentTaskIndex } from '../execution/utils.js';
+import { createFeedback, createMessage } from '../services/components.js';
+import { FeedbackType } from '../types/types.js';
 import { Spinner } from './Spinner.js';
-import { Task } from './Task.js';
+import { TaskView } from './Task.js';
 const MINIMUM_PROCESSING_TIME = 400;
-export const ExecuteView = ({ state, status, onTaskComplete, onTaskAbort, onTaskError, }) => {
-    const isActive = status === ComponentStatus.Active;
-    const { error, taskInfos, message, completed, completionMessage } = state;
-    const hasProcessed = taskInfos.length > 0;
-    // Derive loading state from current conditions
-    const isLoading = isActive && taskInfos.length === 0 && !error && !hasProcessed;
-    const isExecuting = completed < taskInfos.length;
+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
+ */
+function createExecuteState(overrides = {}) {
+    return {
+        message: '',
+        summary: '',
+        tasks: [],
+        completionMessage: null,
+        error: null,
+        ...overrides,
+    };
+}
+/**
+ * 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 && taskInfos.length === 0 && !error) {
+    if (!isActive && tasks.length === 0 && !error) {
         return null;
     }
-    // Show completed steps when not active
-    const showTasks = !isActive && taskInfos.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, {})] })), taskInfos.map((taskInfo, index) => (_jsx(Box, { marginBottom: index < taskInfos.length - 1 ? 1 : 0, children: _jsx(Task, { label: taskInfo.label, command: taskInfo.command, isActive: isActive && index === completed, index: index, initialStatus: taskInfo.status, initialElapsed: taskInfo.elapsed, 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, status, service, requestHandlers, lifecycleHandlers, workflowHandlers, }) {
+export function Execute({ tasks: inputTasks, status, service, requestHandlers, lifecycleHandlers, workflowHandlers, }) {
     const isActive = status === ComponentStatus.Active;
     const [localState, dispatch] = useReducer(executeReducer, initialState);
-    const { error, taskInfos, message, completed, hasProcessed, taskExecutionTimes, completionMessage, summary, } = localState;
-    // Derive loading state from current conditions
-    const isLoading = isActive && taskInfos.length === 0 && !error && !hasProcessed;
-    const isExecuting = completed < taskInfos.length;
-    // Handle cancel with useCallback to ensure we capture latest state
+    // 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);
+    // 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 = 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
-        const updatedTaskInfos = taskInfos.map((task, taskIndex) => {
-            if (taskIndex < completed) {
-                return { ...task, status: ExecutionStatus.Success };
-            }
-            else if (taskIndex === completed) {
-                return { ...task, status: ExecutionStatus.Aborted };
+        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,
+                    status: ExecutionStatus.Aborted,
+                    stdout: liveOutput.stdout,
+                    stderr: liveOutput.stderr,
+                    error: liveOutput.error,
+                };
             }
-            else {
+            else if (task.status === ExecutionStatus.Pending) {
                 return { ...task, status: ExecutionStatus.Cancelled };
             }
+            return task;
         });
-        // Expose final state
-        const finalState = {
+        const finalState = createExecuteState({
             message,
             summary,
-            taskInfos: updatedTaskInfos,
-            completed,
-            taskExecutionTimes,
-            completionMessage: null,
-            error: null,
-        };
+            tasks: updatedTaskInfos,
+        });
         requestHandlers.onCompleted(finalState);
         requestHandlers.onAborted('execution');
-    }, [
-        message,
-        summary,
-        taskInfos,
-        completed,
-        taskExecutionTimes,
-        requestHandlers,
-    ]);
+    }, [message, summary, tasks, liveOutput, requestHandlers]);
     useInput((_, key) => {
-        if (key.escape && (isLoading || isExecuting) && isActive) {
+        if (key.escape && (isLoading || isExecuting)) {
             handleCancel();
         }
     }, { isActive: (isLoading || isExecuting) && isActive });
     // Process tasks to get commands from AI
     useEffect(() => {
-        if (!isActive || taskInfos.length > 0 || hasProcessed) {
+        if (!isActive || tasks.length > 0 || hasProcessed) {
             return;
         }
         let mounted = true;
         async function process(svc) {
             const startTime = Date.now();
             try {
-                const result = await processTasks(tasks, svc);
+                const result = await processTasks(inputTasks, svc);
                 await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
                 if (!mounted)
                     return;
@@ -102,67 +164,41 @@ export function Execute({ tasks, status, service, requestHandlers, lifecycleHand
                     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)
-                        const finalState = {
-                            message: result.message,
-                            summary: '',
-                            taskInfos: [],
-                            completed: 0,
-                            taskExecutionTimes: [],
-                            completionMessage: null,
-                            error: null,
-                        };
-                        requestHandlers.onCompleted(finalState);
+                        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 },
                     });
-                    const finalState = {
-                        message: result.message,
-                        summary: '',
-                        taskInfos: [],
-                        completed: 0,
-                        taskExecutionTimes: [],
-                        completionMessage: null,
-                        error: null,
-                    };
-                    requestHandlers.onCompleted(finalState);
+                    requestHandlers.onCompleted(createExecuteState({ message: result.message }));
                     lifecycleHandlers.completeActive();
                     return;
                 }
                 // Create task infos from commands
-                const infos = result.commands.map((cmd, index) => ({
-                    label: tasks[index]?.action,
+                const taskInfos = result.commands.map((cmd, index) => ({
+                    label: inputTasks[index]?.action ?? cmd.description,
                     command: cmd,
+                    status: ExecutionStatus.Pending,
+                    elapsed: 0,
                 }));
                 dispatch({
                     type: ExecuteActionType.CommandsReady,
                     payload: {
                         message: result.message,
                         summary: result.summary,
-                        taskInfos: infos,
+                        tasks: taskInfos,
                     },
                 });
-                // Update state after AI processing
-                const finalState = {
+                requestHandlers.onCompleted(createExecuteState({
                     message: result.message,
                     summary: result.summary,
-                    taskInfos: infos,
-                    completed: 0,
-                    taskExecutionTimes: [],
-                    completionMessage: null,
-                    error: null,
-                };
-                requestHandlers.onCompleted(finalState);
+                    tasks: taskInfos,
+                }));
             }
             catch (err) {
                 await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
@@ -172,16 +208,7 @@ export function Execute({ tasks, status, service, requestHandlers, lifecycleHand
                         type: ExecuteActionType.ProcessingError,
                         payload: { error: errorMessage },
                     });
-                    const finalState = {
-                        message: '',
-                        summary: '',
-                        taskInfos: [],
-                        completed: 0,
-                        taskExecutionTimes: [],
-                        completionMessage: null,
-                        error: errorMessage,
-                    };
-                    requestHandlers.onCompleted(finalState);
+                    requestHandlers.onCompleted(createExecuteState({ error: errorMessage }));
                     requestHandlers.onError(errorMessage);
                 }
             }
@@ -191,81 +218,140 @@ export function Execute({ tasks, status, service, requestHandlers, lifecycleHand
             mounted = false;
         };
     }, [
-        tasks,
+        inputTasks,
         isActive,
         service,
         requestHandlers,
         lifecycleHandlers,
         workflowHandlers,
-        taskInfos.length,
+        tasks.length,
         hasProcessed,
     ]);
-    // Handle task completion - move to next task
-    const handleTaskComplete = useCallback((index, _output, elapsed) => {
-        const result = handleTaskCompletion(index, elapsed, {
-            taskInfos,
-            message,
-            summary,
-            taskExecutionTimes,
-        });
-        dispatch(result.action);
-        requestHandlers.onCompleted(result.finalState);
-        if (result.shouldComplete) {
-            lifecycleHandlers.completeActive();
-        }
-    }, [
-        taskInfos,
-        message,
-        summary,
-        taskExecutionTimes,
-        requestHandlers,
-        lifecycleHandlers,
-    ]);
-    const handleTaskError = useCallback((index, error, elapsed) => {
-        const result = handleTaskFailure(index, error, elapsed, {
-            taskInfos,
-            message,
-            summary,
-            taskExecutionTimes,
-        });
-        dispatch(result.action);
-        requestHandlers.onCompleted(result.finalState);
-        if (result.shouldReportError) {
-            requestHandlers.onError(error);
+    // Execute current task
+    useEffect(() => {
+        if (!isActive ||
+            tasks.length === 0 ||
+            currentTaskIndex >= tasks.length ||
+            error) {
+            return;
         }
-        if (result.shouldComplete) {
-            lifecycleHandlers.completeActive();
+        const currentTask = tasks[currentTaskIndex];
+        if (currentTask.status !== ExecutionStatus.Pending) {
+            return;
         }
+        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();
+                }
+            },
+        });
     }, [
-        taskInfos,
+        isActive,
+        tasks,
+        currentTaskIndex,
         message,
         summary,
-        taskExecutionTimes,
+        error,
         requestHandlers,
         lifecycleHandlers,
+        workflowHandlers,
     ]);
-    const handleTaskAbort = useCallback((_index) => {
-        // Task was aborted - execution already stopped by Escape handler
-        // Just update state, don't call onAborted (already called at Execute level)
-        const finalState = buildAbortedState(taskInfos, message, summary, completed, taskExecutionTimes);
-        requestHandlers.onCompleted(finalState);
-    }, [
-        taskInfos,
-        message,
-        summary,
-        completed,
-        taskExecutionTimes,
-        requestHandlers,
-    ]);
-    // Controller always renders View with current state
-    const viewState = {
-        error,
-        taskInfos,
-        message,
-        summary,
-        completed,
-        taskExecutionTimes,
-        completionMessage,
-    };
-    return (_jsx(ExecuteView, { tasks: tasks, state: viewState, status: status, onTaskComplete: handleTaskComplete, onTaskAbort: handleTaskAbort, onTaskError: handleTaskError }));
+    // 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, { 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]);