prompt-language-shell 0.9.0 → 0.9.4

package/dist/components/controllers/Execute.js

@@ -0,0 +1,288 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useReducer, useRef } from 'react';
+import { ComponentStatus, } from '../../types/components.js';
+import { useInput } from '../../services/keyboard.js';
+import { formatErrorMessage, getExecutionErrorMessage, } from '../../services/messages.js';
+import { ExecutionStatus } from '../../services/shell.js';
+import { ELAPSED_UPDATE_INTERVAL, ensureMinimumTime, } from '../../services/timing.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 { getCurrentTaskIndex } from '../../execution/utils.js';
+import { createMessage } from '../../services/components.js';
+import { ExecuteView } from '../views/Execute.js';
+export { ExecuteView, mapStateToViewProps, } from '../views/Execute.js';
+const MINIMUM_PROCESSING_TIME = 400;
+/**
+ * Create an ExecuteState with defaults
+ */
+function createExecuteState(overrides = {}) {
+    return {
+        message: '',
+        summary: '',
+        tasks: [],
+        completionMessage: null,
+        error: null,
+        ...overrides,
+    };
+}
+/**
+ * Execute controller: Runs tasks sequentially and manages all execution state
+ */
+export function Execute({ tasks: inputTasks, status, service, upcoming, label, requestHandlers, lifecycleHandlers, workflowHandlers, }) {
+    const isActive = status === ComponentStatus.Active;
+    const [localState, dispatch] = useReducer(executeReducer, initialState);
+    // Track working directory across commands (persists cd changes)
+    const workdirRef = useRef(undefined);
+    // Ref to collect live output during execution (dispatched every second)
+    const outputRef = useRef({ stdout: '', stderr: '' });
+    // 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;
+    // Get current running task for progress updates
+    const runningTask = tasks.find((t) => t.status === ExecutionStatus.Running);
+    // Update reducer with progress every second while task is running
+    useEffect(() => {
+        if (!runningTask?.startTime || !isExecuting)
+            return;
+        const taskStartTime = runningTask.startTime;
+        const interval = setInterval(() => {
+            const elapsed = Date.now() - taskStartTime;
+            dispatch({
+                type: ExecuteActionType.TaskProgress,
+                payload: {
+                    index: currentTaskIndex,
+                    elapsed,
+                    output: {
+                        stdout: outputRef.current.stdout,
+                        stderr: outputRef.current.stderr,
+                    },
+                },
+            });
+        }, ELAPSED_UPDATE_INTERVAL);
+        return () => {
+            clearInterval(interval);
+        };
+    }, [runningTask?.startTime, isExecuting, currentTaskIndex]);
+    // Handle cancel - state already in reducer, just need to update final output
+    const handleCancel = useCallback(() => {
+        cancelledRef.current = true;
+        dispatch({ type: ExecuteActionType.CancelExecution });
+        // Build final state with current output for the running task
+        const updatedTasks = tasks.map((task) => {
+            if (task.status === ExecutionStatus.Running) {
+                return {
+                    ...task,
+                    status: ExecutionStatus.Aborted,
+                    output: {
+                        stdout: outputRef.current.stdout,
+                        stderr: outputRef.current.stderr,
+                    },
+                };
+            }
+            else if (task.status === ExecutionStatus.Pending) {
+                return { ...task, status: ExecutionStatus.Cancelled };
+            }
+            return task;
+        });
+        const finalState = createExecuteState({
+            message,
+            summary,
+            tasks: updatedTasks,
+        });
+        requestHandlers.onCompleted(finalState);
+        requestHandlers.onAborted('execution');
+    }, [message, summary, tasks, requestHandlers]);
+    useInput((_, key) => {
+        if (key.escape && (isLoading || isExecuting)) {
+            handleCancel();
+        }
+    }, { isActive: (isLoading || isExecuting) && isActive });
+    // Process tasks to get commands from AI
+    useEffect(() => {
+        if (!isActive || tasks.length > 0 || hasProcessed) {
+            return;
+        }
+        let mounted = true;
+        async function process(svc) {
+            const startTime = Date.now();
+            try {
+                const result = await processTasks(inputTasks, svc);
+                await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
+                if (!mounted)
+                    return;
+                // Add debug components to timeline if present
+                if (result.debug?.length) {
+                    workflowHandlers.addToTimeline(...result.debug);
+                }
+                if (result.commands.length === 0) {
+                    if (result.error) {
+                        const errorMessage = getExecutionErrorMessage(result.error);
+                        workflowHandlers.addToTimeline(createMessage({ text: errorMessage }, ComponentStatus.Done));
+                        requestHandlers.onCompleted(createExecuteState({ message: result.message }));
+                        lifecycleHandlers.completeActive();
+                        return;
+                    }
+                    dispatch({
+                        type: ExecuteActionType.ProcessingComplete,
+                        payload: { message: result.message },
+                    });
+                    requestHandlers.onCompleted(createExecuteState({ message: result.message }));
+                    lifecycleHandlers.completeActive();
+                    return;
+                }
+                // Create task data from commands
+                const tasks = result.commands.map((cmd, index) => ({
+                    label: inputTasks[index]?.action ?? cmd.description,
+                    command: cmd,
+                    status: ExecutionStatus.Pending,
+                    elapsed: 0,
+                    output: null,
+                }));
+                dispatch({
+                    type: ExecuteActionType.CommandsReady,
+                    payload: {
+                        message: result.message,
+                        summary: result.summary,
+                        tasks,
+                    },
+                });
+                requestHandlers.onCompleted(createExecuteState({
+                    message: result.message,
+                    summary: result.summary,
+                    tasks,
+                }));
+            }
+            catch (err) {
+                await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
+                if (mounted) {
+                    const errorMessage = formatErrorMessage(err);
+                    dispatch({
+                        type: ExecuteActionType.ProcessingError,
+                        payload: { error: errorMessage },
+                    });
+                    requestHandlers.onCompleted(createExecuteState({ error: errorMessage }));
+                    requestHandlers.onError(errorMessage);
+                }
+            }
+        }
+        void process(service);
+        return () => {
+            mounted = false;
+        };
+    }, [
+        inputTasks,
+        isActive,
+        service,
+        requestHandlers,
+        lifecycleHandlers,
+        workflowHandlers,
+        tasks.length,
+        hasProcessed,
+    ]);
+    // Execute current task
+    useEffect(() => {
+        if (!isActive ||
+            tasks.length === 0 ||
+            currentTaskIndex >= tasks.length ||
+            error) {
+            return;
+        }
+        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, startTime: Date.now() },
+        });
+        // Reset output ref for new task
+        outputRef.current = { stdout: '', stderr: '' };
+        // Merge workdir into command
+        const command = workdirRef.current
+            ? { ...currentTask.command, workdir: workdirRef.current }
+            : currentTask.command;
+        void executeTask(command, currentTaskIndex, {
+            onUpdate: (output) => {
+                if (!cancelledRef.current) {
+                    outputRef.current = { stdout: output.stdout, stderr: output.stderr };
+                }
+            },
+            onComplete: (elapsed, execOutput) => {
+                if (cancelledRef.current)
+                    return;
+                // Track working directory
+                if (execOutput.workdir) {
+                    workdirRef.current = execOutput.workdir;
+                }
+                const tasksWithOutput = tasks.map((task, i) => i === currentTaskIndex
+                    ? {
+                        ...task,
+                        output: {
+                            stdout: execOutput.stdout,
+                            stderr: execOutput.stderr,
+                        },
+                    }
+                    : task);
+                const result = handleTaskCompletion(currentTaskIndex, elapsed, {
+                    tasks: tasksWithOutput,
+                    message,
+                    summary,
+                });
+                dispatch(result.action);
+                requestHandlers.onCompleted(result.finalState);
+                if (result.shouldComplete) {
+                    lifecycleHandlers.completeActive();
+                }
+            },
+            onError: (errorMsg, execOutput) => {
+                if (cancelledRef.current)
+                    return;
+                // Track working directory
+                if (execOutput.workdir) {
+                    workdirRef.current = execOutput.workdir;
+                }
+                const tasksWithOutput = tasks.map((task, i) => i === currentTaskIndex
+                    ? {
+                        ...task,
+                        output: {
+                            stdout: execOutput.stdout,
+                            stderr: execOutput.stderr,
+                        },
+                        error: execOutput.error || undefined,
+                    }
+                    : task);
+                const result = handleTaskFailure(currentTaskIndex, errorMsg, {
+                    tasks: tasksWithOutput,
+                    message,
+                    summary,
+                });
+                dispatch(result.action);
+                requestHandlers.onCompleted(result.finalState);
+                const errorMessage = getExecutionErrorMessage(errorMsg);
+                requestHandlers.onError(errorMessage);
+            },
+        });
+    }, [
+        isActive,
+        tasks,
+        currentTaskIndex,
+        message,
+        summary,
+        error,
+        requestHandlers,
+        lifecycleHandlers,
+        workflowHandlers,
+    ]);
+    return (_jsx(ExecuteView, { isLoading: isLoading, isExecuting: isExecuting, isActive: isActive, error: error, message: message, tasks: tasks, completionMessage: completionMessage, showTasks: showTasks, upcoming: upcoming, label: label }));
+}

package/dist/{ui → components/controllers}/Introspect.js

@@ -1,24 +1,15 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
-import { Box, Text } from 'ink';
-import { ComponentStatus, } from '../types/components.js';
-import { Colors, getTextColor } from '../services/colors.js';
-import { createReportDefinition } from '../services/components.js';
-import { DebugLevel } from '../configuration/types.js';
-import { useInput } from '../services/keyboard.js';
-import { formatErrorMessage } from '../services/messages.js';
-import { ensureMinimumTime } from '../services/timing.js';
-import { Spinner } from './Spinner.js';
+import { ComponentStatus, } from '../../types/components.js';
+import { Origin } from '../../types/types.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';
+import { ensureMinimumTime } from '../../services/timing.js';
+import { IntrospectView } from '../views/Introspect.js';
+export { IntrospectView } from '../views/Introspect.js';
 const MIN_PROCESSING_TIME = 1000;
-export const IntrospectView = ({ state, status, children, }) => {
-    const isActive = status === ComponentStatus.Active;
-    const { error } = state;
-    // Don't render wrapper when done and nothing to show
-    if (!isActive && !error && !children) {
-        return null;
-    }
-    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isActive && (_jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: "Listing capabilities. " }), _jsx(Spinner, {})] })), error && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) })), children] }));
-};
 /**
  * Introspect controller: Lists capabilities via LLM
  */
@@ -26,7 +17,6 @@ export function Introspect({ tasks, status, service, children, debug = DebugLeve
     const isActive = status === ComponentStatus.Active;
     const [error, setError] = useState(null);
     const [capabilities, setCapabilities] = useState(null);
-    const [message, setMessage] = useState(null);
     useInput((input, key) => {
         if (key.escape && isActive) {
             requestHandlers.onAborted('introspection');
@@ -51,24 +41,21 @@ 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);
                     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();
                 }
@@ -101,10 +88,6 @@ export function Introspect({ tasks, status, service, children, debug = DebugLeve
         lifecycleHandlers,
         workflowHandlers,
     ]);
-    const state = {
-        error,
-        capabilities: capabilities || [],
-        message,
-    };
-    return (_jsx(IntrospectView, { state: state, status: status, children: children }));
+    const hasCapabilities = capabilities !== null && capabilities.length > 0;
+    return (_jsx(IntrospectView, { status: status, hasCapabilities: hasCapabilities, error: error, children: children }));
 }

package/dist/components/controllers/Refinement.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ComponentStatus } from '../../types/components.js';
+import { useInput } from '../../services/keyboard.js';
+import { RefinementView } from '../views/Refinement.js';
+export { RefinementView } from '../views/Refinement.js';
+/**
+ * Refinement controller: Handles abort input
+ */
+export const Refinement = ({ text, status, onAborted }) => {
+    const isActive = status === ComponentStatus.Active;
+    useInput((_, key) => {
+        if (key.escape && isActive) {
+            onAborted('plan refinement');
+            return;
+        }
+    }, { isActive });
+    return _jsx(RefinementView, { text: text, status: status });
+};

package/dist/{ui → components/controllers}/Schedule.js

@@ -1,121 +1,11 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
-import { Box } from 'ink';
-import { ComponentStatus, } from '../types/components.js';
-import { TaskType } from '../types/types.js';
-import { getTaskColors, getTaskTypeLabel, Palette, } from '../services/colors.js';
-import { DebugLevel } from '../configuration/types.js';
-import { useInput } from '../services/keyboard.js';
-import { Label } from './Label.js';
-import { List } from './List.js';
-export function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutSelection = false, status = ComponentStatus.Done, debug = DebugLevel.None) {
-    const taskColors = getTaskColors(task.type, status);
-    // Determine description color based on status
-    let descriptionColor = taskColors.description;
-    if (status === ComponentStatus.Pending) {
-        descriptionColor = Palette.SoftWhite;
-    }
-    const item = {
-        description: {
-            text: task.action,
-            color: descriptionColor,
-        },
-        type: { text: getTaskTypeLabel(task.type, debug), color: taskColors.type },
-        children: [],
-    };
-    // Mark define tasks with right arrow when no selection has been made
-    if (isDefineTaskWithoutSelection) {
-        item.marker = '  → ';
-        item.markerColor = getTaskColors(TaskType.Schedule, status).type;
-    }
-    // Add children for Define tasks with options
-    if (task.type === TaskType.Define && Array.isArray(task.params?.options)) {
-        item.children = task.params.options.map((option, index) => {
-            // Determine the type based on selection state
-            let childType = TaskType.Select;
-            if (highlightedChildIndex !== null) {
-                // A selection was made - mark others as discarded
-                childType =
-                    index === highlightedChildIndex ? TaskType.Execute : TaskType.Discard;
-            }
-            const colors = getTaskColors(childType, status);
-            const planColors = getTaskColors(TaskType.Schedule, status);
-            return {
-                description: {
-                    text: option,
-                    color: colors.description,
-                    highlightedColor: planColors.description,
-                },
-                type: {
-                    text: getTaskTypeLabel(childType, debug),
-                    color: colors.type,
-                    highlightedColor: planColors.type,
-                },
-            };
-        });
-    }
-    // Add children for Group tasks with subtasks
-    const scheduledTask = task;
-    if (task.type === TaskType.Group &&
-        scheduledTask.subtasks &&
-        Array.isArray(scheduledTask.subtasks) &&
-        scheduledTask.subtasks.length > 0) {
-        item.children = scheduledTask.subtasks.map((subtask) => {
-            const subtaskColors = getTaskColors(subtask.type, status);
-            return {
-                description: {
-                    text: subtask.action,
-                    color: Palette.AshGray,
-                },
-                type: {
-                    text: getTaskTypeLabel(subtask.type, debug),
-                    color: subtaskColors.type,
-                },
-            };
-        });
-    }
-    return item;
-}
-export const ScheduleView = ({ message, tasks, state, status, debug = DebugLevel.None, }) => {
-    const isActive = status === ComponentStatus.Active;
-    const { highlightedIndex, currentDefineGroupIndex, completedSelections } = state;
-    // Find all Define tasks
-    const defineTaskIndices = tasks
-        .map((t, idx) => (t.type === TaskType.Define ? idx : -1))
-        .filter((idx) => idx !== -1);
-    // Get the current active define task
-    const currentDefineTaskIndex = defineTaskIndices[currentDefineGroupIndex] ?? -1;
-    const listItems = tasks.map((task, idx) => {
-        // Find which define group this task belongs to (if any)
-        const defineGroupIndex = defineTaskIndices.indexOf(idx);
-        const isDefineTask = defineGroupIndex !== -1;
-        // Determine child selection state
-        let childIndex = null;
-        if (isDefineTask) {
-            if (defineGroupIndex < currentDefineGroupIndex) {
-                // Previously completed group - show the selection
-                childIndex = completedSelections[defineGroupIndex] ?? null;
-            }
-            else if (defineGroupIndex === currentDefineGroupIndex) {
-                // Current active group - show live navigation unless not active
-                if (!isActive) {
-                    // If not active, show the completed selection for this group too
-                    childIndex = completedSelections[defineGroupIndex] ?? null;
-                }
-                else {
-                    childIndex = null;
-                }
-            }
-        }
-        // Show arrow on current active define task when no child is highlighted and is active
-        const isDefineWithoutSelection = isDefineTask &&
-            defineGroupIndex === currentDefineGroupIndex &&
-            highlightedIndex === null &&
-            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 }) })] }));
-};
+import { ComponentStatus, } from '../../types/components.js';
+import { TaskType } from '../../types/types.js';
+import { DebugLevel } from '../../configuration/types.js';
+import { useInput } from '../../services/keyboard.js';
+import { ScheduleView } from '../views/Schedule.js';
+export { ScheduleView, taskToListItem, } from '../views/Schedule.js';
 /**
  * Schedule controller: Manages task selection and navigation
  */
@@ -245,11 +135,5 @@ export function Schedule({ message, tasks, status, debug = DebugLevel.None, requ
             }
         }
     }, { isActive: isActive && defineTask !== null });
-    // Controller always renders View, passing current state
-    const state = {
-        highlightedIndex,
-        currentDefineGroupIndex,
-        completedSelections,
-    };
-    return (_jsx(ScheduleView, { message: message, tasks: tasks, state: state, status: status, debug: debug }));
+    return (_jsx(ScheduleView, { status: status, message: message, tasks: tasks, highlightedIndex: highlightedIndex, currentDefineGroupIndex: currentDefineGroupIndex, completedSelections: completedSelections, debug: debug }));
 }

package/dist/{ui → components/controllers}/Validate.js

@@ -1,27 +1,18 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
-import { Box, Text } from 'ink';
-import { ComponentStatus, } from '../types/components.js';
-import { TaskType } from '../types/types.js';
-import { saveConfig } from '../configuration/io.js';
-import { unflattenConfig } from '../configuration/transformation.js';
-import { Colors, getTextColor } from '../services/colors.js';
-import { createConfigDefinitionWithKeys, createMessage, } from '../services/components.js';
-import { saveConfigLabels } from '../services/config-labels.js';
-import { useInput } from '../services/keyboard.js';
-import { formatErrorMessage, getUnresolvedPlaceholdersMessage, } from '../services/messages.js';
-import { ensureMinimumTime } from '../services/timing.js';
-import { Spinner } from './Spinner.js';
+import { ComponentStatus, } from '../../types/components.js';
+import { TaskType } from '../../types/types.js';
+import { saveConfig } from '../../configuration/io.js';
+import { createConfigStepsFromSchema } from '../../configuration/steps.js';
+import { unflattenConfig } from '../../configuration/transformation.js';
+import { createConfig, createMessage } from '../../services/components.js';
+import { saveConfigLabels } from '../../configuration/labels.js';
+import { useInput } from '../../services/keyboard.js';
+import { formatErrorMessage, getUnresolvedPlaceholdersMessage, } from '../../services/messages.js';
+import { ensureMinimumTime } from '../../services/timing.js';
+import { ValidateView } from '../views/Validate.js';
+export { ValidateView } from '../views/Validate.js';
 const MIN_PROCESSING_TIME = 1000;
-export const ValidateView = ({ state, status }) => {
-    const isActive = status === ComponentStatus.Active;
-    const { error, completionMessage } = state;
-    // Don't render when not active and nothing to show
-    if (!isActive && !completionMessage && !error) {
-        return null;
-    }
-    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isActive && !completionMessage && !error && (_jsxs(Box, { marginLeft: 1, children: [_jsxs(Text, { color: getTextColor(isActive), children: ["Validating configuration requirements.", ' '] }), _jsx(Spinner, {})] })), completionMessage && (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { color: getTextColor(isActive), children: completionMessage }) })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) }))] }));
-};
 /**
  * Validate controller: Validates missing config
  */
@@ -29,7 +20,6 @@ export function Validate({ missingConfig, userRequest, status, service, onError,
     const isActive = status === ComponentStatus.Active;
     const [error, setError] = useState(null);
     const [completionMessage, setCompletionMessage] = useState(null);
-    const [configRequirements, setConfigRequirements] = useState([]);
     useInput((_, key) => {
         if (key.escape && isActive) {
             onAborted('validation');
@@ -71,30 +61,33 @@ export function Validate({ missingConfig, userRequest, status, service, onError,
                     // Build completion message showing which config properties are needed
                     const message = getUnresolvedPlaceholdersMessage(withDescriptions.length);
                     setCompletionMessage(message);
-                    setConfigRequirements(withDescriptions);
                     // Add validation message to timeline before Config component
-                    workflowHandlers.addToTimeline(createMessage(message));
+                    workflowHandlers.addToTimeline(createMessage({ text: message }));
                     // Create Config component and add to queue
                     const keys = withDescriptions.map((req) => req.path);
-                    const configDef = createConfigDefinitionWithKeys(keys, (config) => {
-                        // Convert flat dotted keys to nested structure grouped by section
-                        const configBySection = unflattenConfig(config);
-                        // Extract and save labels to cache
-                        const labels = {};
-                        for (const req of withDescriptions) {
-                            if (req.description) {
-                                labels[req.path] = req.description;
+                    const configDef = createConfig({
+                        steps: createConfigStepsFromSchema(keys),
+                        onFinished: (config) => {
+                            // Convert flat dotted keys to nested structure grouped by section
+                            const configBySection = unflattenConfig(config);
+                            // Extract and save labels to cache
+                            const labels = {};
+                            for (const req of withDescriptions) {
+                                if (req.description) {
+                                    labels[req.path] = req.description;
+                                }
+                            }
+                            saveConfigLabels(labels);
+                            // Save each section
+                            for (const [section, sectionConfig] of Object.entries(configBySection)) {
+                                saveConfig(section, sectionConfig);
                             }
-                        }
-                        saveConfigLabels(labels);
-                        // Save each section
-                        for (const [section, sectionConfig] of Object.entries(configBySection)) {
-                            saveConfig(section, sectionConfig);
-                        }
-                        // After config is saved, invoke callback to add Execute component to queue
-                        onValidationComplete(withDescriptions);
-                    }, (operation) => {
-                        onAborted(operation);
+                            // After config is saved, invoke callback to add Execute component to queue
+                            onValidationComplete(withDescriptions);
+                        },
+                        onAborted: (operation) => {
+                            onAborted(operation);
+                        },
                     });
                     // Override descriptions with LLM-generated ones
                     if ('props' in configDef && 'steps' in configDef.props) {
@@ -147,13 +140,7 @@ export function Validate({ missingConfig, userRequest, status, service, onError,
         lifecycleHandlers,
         workflowHandlers,
     ]);
-    const state = {
-        error,
-        completionMessage,
-        configRequirements,
-        validated: error === null && completionMessage !== null,
-    };
-    return _jsx(ValidateView, { state: state, status: status });
+    return (_jsx(ValidateView, { status: status, completionMessage: completionMessage, error: error }));
 }
 /**
  * Build prompt for VALIDATE tool