prompt-language-shell 0.7.8 → 0.8.0

package/dist/services/colors.js

@@ -8,7 +8,6 @@ import { ExecutionStatus } from './shell.js';
 export const Palette = {
     White: '#ffffff',
     AshGray: '#d0d0d0',
-    PaleGreen: '#a8dcbc',
     Gray: '#888888',
     DarkGray: '#666666',
     CharcoalGray: '#282828',
@@ -16,8 +15,8 @@ export const Palette = {
     LightGreen: '#65b595',
     BrightGreen: '#3e9a3e',
     Yellow: '#cccc5c',
-    LightYellow: '#d4d47a',
     Orange: '#f48c80',
+    MediumOrange: '#d07560',
     DarkOrange: '#ab5e40',
     BurntOrange: '#cc7a5c',
     Red: '#cc5c5c',
@@ -47,7 +46,7 @@ export const Colors = {
     Status: {
         Success: Palette.BrightGreen,
         Error: Palette.Red,
-        Warning: Palette.Orange,
+        Warning: Palette.MediumOrange,
         Info: Palette.Cyan,
     },
     Label: {
@@ -130,7 +129,7 @@ const taskColors = {
 const feedbackColors = {
     [FeedbackType.Info]: Colors.Status.Info,
     [FeedbackType.Succeeded]: Colors.Status.Success,
-    [FeedbackType.Aborted]: Colors.Status.Warning,
+    [FeedbackType.Aborted]: Palette.MediumOrange,
     [FeedbackType.Failed]: Colors.Status.Error,
 };
 /**
@@ -220,6 +219,7 @@ export const STATUS_ICONS = {
     [ExecutionStatus.Success]: '✓ ',
     [ExecutionStatus.Failed]: '✗ ',
     [ExecutionStatus.Aborted]: '⊘ ',
+    [ExecutionStatus.Cancelled]: '⊘ ',
 };
 /**
  * Get colors for different execution status states.
@@ -249,7 +249,7 @@ export function getStatusColors(status) {
         case ExecutionStatus.Success:
             return {
                 icon: Colors.Status.Success,
-                description: getTextColor(true),
+                description: Palette.AshGray,
                 command: Palette.Gray,
                 symbol: Palette.Gray,
             };
@@ -262,10 +262,17 @@ export function getStatusColors(status) {
             };
         case ExecutionStatus.Aborted:
             return {
-                icon: Palette.DarkOrange,
-                description: getTextColor(true),
-                command: Palette.DarkOrange,
+                icon: Palette.MediumOrange,
+                description: Palette.Gray,
+                command: Palette.MediumOrange,
                 symbol: Palette.Gray,
             };
+        case ExecutionStatus.Cancelled:
+            return {
+                icon: Palette.DarkGray,
+                description: Palette.DarkGray,
+                command: Palette.DarkGray,
+                symbol: Palette.DarkGray,
+            };
     }
 }

package/dist/services/components.js

@@ -1,8 +1,8 @@
 import { randomUUID } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
-import { ComponentName } from '../types/types.js';
-import { ComponentStatus, } from '../types/components.js';
 import { parse as parseYaml } from 'yaml';
+import { ComponentStatus, } from '../types/components.js';
+import { ComponentName } from '../types/types.js';
 import { ConfigDefinitionType, getConfigPath, getConfigSchema, loadConfig, } from './configuration.js';
 import { getConfirmationMessage } from './messages.js';
 import { StepType } from '../ui/Config.js';
@@ -180,7 +180,11 @@ export function createConfigDefinition(onFinished, onAborted) {
         id: randomUUID(),
         name: ComponentName.Config,
         status: ComponentStatus.Awaiting,
-        state: {},
+        state: {
+            values: {},
+            completedStep: 0,
+            selectedIndex: 0,
+        },
         props: {
             steps: createConfigSteps(),
             onFinished,
@@ -196,7 +200,11 @@ export function createConfigDefinitionWithKeys(keys, onFinished, onAborted) {
         id: randomUUID(),
         name: ComponentName.Config,
         status: ComponentStatus.Awaiting,
-        state: {},
+        state: {
+            values: {},
+            completedStep: 0,
+            selectedIndex: 0,
+        },
         props: {
             steps: createConfigStepsFromSchema(keys),
             onFinished,
@@ -338,7 +346,15 @@ export function createExecuteDefinition(tasks, service) {
         id: randomUUID(),
         name: ComponentName.Execute,
         status: ComponentStatus.Awaiting,
-        state: {},
+        state: {
+            error: null,
+            message: '',
+            summary: '',
+            taskInfos: [],
+            completed: 0,
+            taskExecutionTimes: [],
+            completionMessage: null,
+        },
         props: {
             tasks,
             service,
@@ -350,7 +366,12 @@ export function createValidateDefinition(missingConfig, userRequest, service, on
         id: randomUUID(),
         name: ComponentName.Validate,
         status: ComponentStatus.Awaiting,
-        state: {},
+        state: {
+            error: null,
+            completionMessage: null,
+            configRequirements: null,
+            validated: false,
+        },
         props: {
             missingConfig,
             userRequest,

package/dist/services/router.js

@@ -1,9 +1,8 @@
-import { TaskType } from '../types/types.js';
+import { FeedbackType, TaskType } from '../types/types.js';
 import { createAnswerDefinition, createConfigDefinitionWithKeys, createConfirmDefinition, createExecuteDefinition, createFeedback, createIntrospectDefinition, createMessage, createScheduleDefinition, createValidateDefinition, } from './components.js';
 import { saveConfig, unflattenConfig } from './configuration.js';
-import { FeedbackType } from '../types/types.js';
-import { validateExecuteTasks } from './validator.js';
 import { getCancellationMessage, getMixedTaskTypesError, getUnknownRequestMessage, } from './messages.js';
+import { validateExecuteTasks } from './validator.js';
 /**
  * Determine the operation name based on task types
  */

package/dist/services/shell.js

@@ -5,6 +5,7 @@ export var ExecutionStatus;
     ExecutionStatus["Success"] = "success";
     ExecutionStatus["Failed"] = "failed";
     ExecutionStatus["Aborted"] = "aborted";
+    ExecutionStatus["Cancelled"] = "cancelled";
 })(ExecutionStatus || (ExecutionStatus = {}));
 export var ExecutionResult;
 (function (ExecutionResult) {

package/dist/ui/Answer.js

@@ -40,7 +40,9 @@ export function Answer({ question, state, status, service, handlers, }) {
                     const answerText = result.answer || '';
                     setAnswer(answerText);
                     // Update component state so answer persists in timeline
-                    handlers?.updateState({ answer: answerText });
+                    handlers?.updateState({
+                        answer: answerText,
+                    });
                     // Signal completion
                     handlers?.completeActive();
                 }
@@ -49,6 +51,9 @@ export function Answer({ question, state, status, service, handlers, }) {
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
                     setError(errorMessage);
+                    handlers?.updateState({
+                        error: errorMessage,
+                    });
                     handlers?.onError(errorMessage);
                 }
             }

package/dist/ui/Command.js

@@ -5,8 +5,8 @@ import { ComponentStatus, } from '../types/components.js';
 import { TaskType } from '../types/types.js';
 import { Colors } from '../services/colors.js';
 import { addDebugToTimeline, createScheduleDefinition, } from '../services/components.js';
-import { formatErrorMessage } from '../services/messages.js';
 import { useInput } from '../services/keyboard.js';
+import { formatErrorMessage } from '../services/messages.js';
 import { handleRefinement } from '../services/refinement.js';
 import { routeTasksWithConfirm } from '../services/router.js';
 import { ensureMinimumTime } from '../services/timing.js';
@@ -88,6 +88,9 @@ export function Command({ command, state, status, service, handlers, onAborted,
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
                     setError(errorMessage);
+                    handlers?.updateState({
+                        error: errorMessage,
+                    });
                     handlers?.onError(errorMessage);
                 }
             }

package/dist/ui/Component.js

@@ -3,16 +3,16 @@ import { memo } from 'react';
 import { ComponentName } from '../types/types.js';
 import { Answer } from './Answer.js';
 import { Command } from './Command.js';
-import { Confirm } from './Confirm.js';
 import { Config } from './Config.js';
+import { Confirm } from './Confirm.js';
 import { Debug } from './Debug.js';
 import { Execute } from './Execute.js';
 import { Feedback } from './Feedback.js';
 import { Introspect } from './Introspect.js';
 import { Message } from './Message.js';
-import { Schedule } from './Schedule.js';
 import { Refinement } from './Refinement.js';
 import { Report } from './Report.js';
+import { Schedule } from './Schedule.js';
 import { Validate } from './Validate.js';
 import { Welcome } from './Welcome.js';
 export const Component = memo(function Component({ def, debug, }) {

package/dist/ui/Config.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState } from 'react';
+import { useEffect, useState } from 'react';
 import { Box, Text, useFocus } from 'ink';
 import TextInput from 'ink-text-input';
 import { ComponentStatus } from '../types/components.js';
@@ -17,6 +17,10 @@ function TextStep({ value, placeholder, validate, onChange, onSubmit, }) {
     const [inputValue, setInputValue] = useState(value);
     const [validationFailed, setValidationFailed] = useState(false);
     const { isFocused } = useFocus({ autoFocus: true });
+    // Sync internal state with prop changes
+    useEffect(() => {
+        setInputValue(value);
+    }, [value]);
     const handleChange = (newValue) => {
         setInputValue(newValue);
         onChange(newValue);
@@ -92,8 +96,20 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
         });
         return initial;
     });
-    const [inputValue, setInputValue] = useState('');
+    const [inputValue, setInputValue] = useState(() => {
+        // Initialize with the current step's value if available
+        if (isActive && step < steps.length) {
+            const stepConfig = steps[step];
+            const configKey = stepConfig.path || stepConfig.key;
+            return values[configKey] || '';
+        }
+        return '';
+    });
     const [selectedIndex, setSelectedIndex] = useState(() => {
+        // If not active, use saved state
+        if (!isActive && state?.selectedIndex !== undefined) {
+            return state.selectedIndex;
+        }
         // Initialize selectedIndex based on current step's defaultIndex
         if (isActive &&
             step < steps.length &&
@@ -108,6 +124,16 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
         }
         return value.replace(/\n/g, '').trim();
     };
+    // Update inputValue when step changes
+    useEffect(() => {
+        if (isActive && step < steps.length) {
+            const stepConfig = steps[step];
+            const configKey = stepConfig.path || stepConfig.key;
+            const value = values[configKey] || '';
+            setInputValue(value);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [step, isActive, steps]);
     useInput((_, key) => {
         if (!isActive || step >= steps.length)
             return;
@@ -137,6 +163,7 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
             handlers?.updateState({
                 values,
                 completedStep: step,
+                selectedIndex,
             });
             if (onAborted) {
                 onAborted('configuration');
@@ -197,6 +224,7 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
             const stateUpdate = {
                 values: newValues,
                 completedStep: steps.length,
+                selectedIndex,
             };
             handlers?.updateState(stateUpdate);
             // Call onFinished callback and handle result
@@ -219,6 +247,7 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
             const stateUpdate = {
                 values: newValues,
                 completedStep: step + 1,
+                selectedIndex,
             };
             handlers?.updateState(stateUpdate);
             const nextStep = step + 1;

package/dist/ui/Confirm.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from 'react';
 import { Box, Text } from 'ink';
-import { ComponentStatus, } from '../types/components.js';
+import { ComponentStatus } from '../types/components.js';
 import { Colors, Palette } from '../services/colors.js';
 import { useInput } from '../services/keyboard.js';
 import { UserQuery } from './UserQuery.js';

package/dist/ui/Execute.js

@@ -1,13 +1,14 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useCallback, useEffect, useState } from 'react';
 import { Box, Text } from 'ink';
-import { ComponentStatus } from '../types/components.js';
+import { ComponentStatus, } from '../types/components.js';
 import { Colors, getTextColor } from '../services/colors.js';
 import { addDebugToTimeline } from '../services/components.js';
 import { useInput } from '../services/keyboard.js';
+import { loadUserConfig } from '../services/loader.js';
 import { formatErrorMessage } from '../services/messages.js';
 import { replacePlaceholders } from '../services/resolver.js';
-import { loadUserConfig } from '../services/loader.js';
+import { ExecutionStatus } from '../services/shell.js';
 import { ensureMinimumTime } from '../services/timing.js';
 import { formatDuration } from '../services/utils.js';
 import { Spinner } from './Spinner.js';
@@ -18,19 +19,49 @@ export function Execute({ tasks, state, status, service, handlers, }) {
     const [error, setError] = useState(state?.error ?? null);
     const [taskInfos, setTaskInfos] = useState(state?.taskInfos ?? []);
     const [message, setMessage] = useState(state?.message ?? '');
-    const [activeTaskIndex, setActiveTaskIndex] = useState(state?.activeTaskIndex ?? -1);
+    const [completed, setCompleted] = useState(state?.completed ?? 0);
     const [hasProcessed, setHasProcessed] = useState(false);
     const [taskExecutionTimes, setTaskExecutionTimes] = useState(state?.taskExecutionTimes ?? []);
     const [completionMessage, setCompletionMessage] = useState(state?.completionMessage ?? null);
     const [summary, setSummary] = useState(state?.summary ?? '');
     // Derive loading state from current conditions
     const isLoading = isActive && taskInfos.length === 0 && !error && !hasProcessed;
-    const isExecuting = activeTaskIndex >= 0 && activeTaskIndex < taskInfos.length;
+    const isExecuting = completed < taskInfos.length;
+    // Handle cancel with useCallback to ensure we capture latest state
+    const handleCancel = useCallback(() => {
+        // Mark tasks based on their status relative to completed:
+        // - Before completed: finished (Success)
+        // - At completed: interrupted (Aborted)
+        // - After completed: never started (Cancelled)
+        const updatedTaskInfos = taskInfos.map((task, taskIndex) => {
+            if (taskIndex < completed) {
+                // Tasks that completed before interruption
+                return { ...task, status: ExecutionStatus.Success };
+            }
+            else if (taskIndex === completed) {
+                // Task that was running when interrupted
+                return { ...task, status: ExecutionStatus.Aborted };
+            }
+            else {
+                // Tasks that haven't started yet
+                return { ...task, status: ExecutionStatus.Cancelled };
+            }
+        });
+        setTaskInfos(updatedTaskInfos);
+        handlers?.updateState({
+            message,
+            summary,
+            taskInfos: updatedTaskInfos,
+            completed,
+            taskExecutionTimes,
+            completionMessage: null,
+            error: null,
+        });
+        handlers?.onAborted('execution');
+    }, [message, summary, taskInfos, completed, taskExecutionTimes, handlers]);
     useInput((_, key) => {
         if (key.escape && (isLoading || isExecuting) && isActive) {
-            // Cancel execution
-            setActiveTaskIndex(-1);
-            handlers?.onAborted('execution');
+            handleCancel();
         }
     }, { isActive: (isLoading || isExecuting) && isActive });
     // Process tasks to get commands from AI
@@ -69,7 +100,12 @@ export function Execute({ tasks, state, status, service, handlers, }) {
                     setHasProcessed(true);
                     handlers?.updateState({
                         message: result.message,
+                        summary: '',
                         taskInfos: [],
+                        completed: 0,
+                        taskExecutionTimes: [],
+                        completionMessage: null,
+                        error: null,
                     });
                     handlers?.completeActive();
                     return;
@@ -80,14 +116,26 @@ export function Execute({ tasks, state, status, service, handlers, }) {
                     command: replacePlaceholders(cmd.command, userConfig),
                 }));
                 // Set message, summary, and create task infos
-                setMessage(result.message);
-                setSummary(result.summary || '');
+                const newMessage = result.message;
+                const newSummary = result.summary || '';
                 const infos = resolvedCommands.map((cmd, index) => ({
                     label: tasks[index]?.action,
                     command: cmd,
                 }));
+                setMessage(newMessage);
+                setSummary(newSummary);
                 setTaskInfos(infos);
-                setActiveTaskIndex(0); // Start with first task
+                setCompleted(0); // Start with first task
+                // Update state after AI processing
+                handlers?.updateState({
+                    message: newMessage,
+                    summary: newSummary,
+                    taskInfos: infos,
+                    completed: 0,
+                    taskExecutionTimes: [],
+                    completionMessage: null,
+                    error: null,
+                });
             }
             catch (err) {
                 await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
@@ -95,7 +143,15 @@ export function Execute({ tasks, state, status, service, handlers, }) {
                     const errorMessage = formatErrorMessage(err);
                     setError(errorMessage);
                     setHasProcessed(true);
-                    handlers?.updateState({ error: errorMessage });
+                    handlers?.updateState({
+                        message: '',
+                        summary: '',
+                        taskInfos: [],
+                        completed: 0,
+                        taskExecutionTimes: [],
+                        completionMessage: null,
+                        error: errorMessage,
+                    });
                     handlers?.onError(errorMessage);
                 }
             }
@@ -109,13 +165,26 @@ export function Execute({ tasks, state, status, service, handlers, }) {
     const handleTaskComplete = useCallback((index, _output, elapsed) => {
         const updatedTimes = [...taskExecutionTimes, elapsed];
         setTaskExecutionTimes(updatedTimes);
+        // Update task with elapsed time and success status
+        const updatedTaskInfos = taskInfos.map((task, i) => i === index
+            ? { ...task, status: ExecutionStatus.Success, elapsed }
+            : task);
+        setTaskInfos(updatedTaskInfos);
         if (index < taskInfos.length - 1) {
             // More tasks to execute
-            setActiveTaskIndex(index + 1);
+            setCompleted(index + 1);
+            handlers?.updateState({
+                message,
+                summary,
+                taskInfos: updatedTaskInfos,
+                completed: index + 1,
+                taskExecutionTimes: updatedTimes,
+                completionMessage: null,
+                error: null,
+            });
         }
         else {
             // All tasks complete
-            setActiveTaskIndex(-1);
             const totalElapsed = updatedTimes.reduce((sum, time) => sum + time, 0);
             const summaryText = summary?.trim() || 'Execution completed';
             const completion = `${summaryText} in ${formatDuration(totalElapsed)}.`;
@@ -123,48 +192,67 @@ export function Execute({ tasks, state, status, service, handlers, }) {
             handlers?.updateState({
                 message,
                 summary,
-                taskInfos,
-                activeTaskIndex: -1,
+                taskInfos: updatedTaskInfos,
+                completed: index + 1,
                 taskExecutionTimes: updatedTimes,
                 completionMessage: completion,
+                error: null,
             });
             handlers?.completeActive();
         }
     }, [taskInfos, message, handlers, taskExecutionTimes, summary]);
-    const handleTaskError = useCallback((index, error) => {
+    const handleTaskError = useCallback((index, error, elapsed) => {
         const task = taskInfos[index];
         const isCritical = task?.command.critical !== false; // Default to true
+        // Update task with elapsed time and failed status
+        const updatedTaskInfos = taskInfos.map((task, i) => i === index
+            ? { ...task, status: ExecutionStatus.Failed, elapsed }
+            : task);
+        setTaskInfos(updatedTaskInfos);
         if (isCritical) {
             // Critical failure - stop execution
-            setActiveTaskIndex(-1);
             setError(error);
             handlers?.updateState({
                 message,
-                taskInfos,
-                activeTaskIndex: -1,
+                summary,
+                taskInfos: updatedTaskInfos,
+                completed: index + 1,
+                taskExecutionTimes,
+                completionMessage: null,
                 error,
             });
             handlers?.onError(error);
         }
         else {
             // Non-critical failure - continue to next task
+            const updatedTimes = [...taskExecutionTimes, elapsed];
+            setTaskExecutionTimes(updatedTimes);
             if (index < taskInfos.length - 1) {
-                setActiveTaskIndex(index + 1);
+                setCompleted(index + 1);
+                handlers?.updateState({
+                    message,
+                    summary,
+                    taskInfos: updatedTaskInfos,
+                    completed: index + 1,
+                    taskExecutionTimes: updatedTimes,
+                    completionMessage: null,
+                    error: null,
+                });
             }
             else {
                 // Last task, complete execution
-                setActiveTaskIndex(-1);
-                const totalElapsed = taskExecutionTimes.reduce((sum, time) => sum + time, 0);
+                const totalElapsed = updatedTimes.reduce((sum, time) => sum + time, 0);
                 const summaryText = summary?.trim() || 'Execution completed';
                 const completion = `${summaryText} in ${formatDuration(totalElapsed)}.`;
                 setCompletionMessage(completion);
                 handlers?.updateState({
                     message,
                     summary,
-                    taskInfos,
-                    activeTaskIndex: -1,
-                    taskExecutionTimes,
+                    taskInfos: updatedTaskInfos,
+                    completed: index + 1,
+                    taskExecutionTimes: updatedTimes,
                     completionMessage: completion,
+                    error: null,
                 });
                 handlers?.completeActive();
             }
@@ -175,15 +263,19 @@ export function Execute({ tasks, state, status, service, handlers, }) {
         // Just update state, don't call onAborted (already called at Execute level)
         handlers?.updateState({
             message,
+            summary,
             taskInfos,
-            activeTaskIndex: -1,
+            completed,
+            taskExecutionTimes,
+            completionMessage: null,
+            error: null,
         });
-    }, [taskInfos, message, handlers]);
+    }, [taskInfos, message, summary, completed, taskExecutionTimes, handlers]);
     // Return null only when loading completes with no commands
     if (!isActive && taskInfos.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 === activeTaskIndex, index: index, onComplete: handleTaskComplete, onAbort: handleTaskAbort, onError: handleTaskError }) }, index)))] })), completionMessage && !isActive && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsx(Text, { color: getTextColor(false), children: completionMessage }) })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) }))] }));
+    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: handleTaskComplete, onAbort: handleTaskAbort, onError: handleTaskError }) }, index)))] })), completionMessage && !isActive && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsx(Text, { color: getTextColor(false), children: completionMessage }) })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) }))] }));
 }

package/dist/ui/Feedback.js

@@ -1,7 +1,7 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
-import { getFeedbackColor } from '../services/colors.js';
 import { FeedbackType } from '../types/types.js';
+import { getFeedbackColor } from '../services/colors.js';
 function getSymbol(type) {
     return {
         [FeedbackType.Info]: 'ℹ',

package/dist/ui/Label.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
-import { DebugLevel } from '../services/configuration.js';
 import { getTaskColors, getTaskTypeLabel } from '../services/colors.js';
+import { DebugLevel } from '../services/configuration.js';
 import { Separator } from './Separator.js';
 export function Label({ description, taskType, showType = false, isCurrent = false, debug = DebugLevel.None, }) {
     const colors = getTaskColors(taskType, isCurrent);

package/dist/ui/List.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 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, }) => {
     const marginLeft = level > 0 ? 2 : 0;
@@ -21,7 +22,7 @@ export const List = ({ items, level = 0, highlightedIndex = null, highlightedPar
             const markerColor = item.markerColor ||
                 (isHighlighted && item.type.highlightedColor
                     ? item.type.highlightedColor
-                    : 'whiteBright');
+                    : Palette.White);
             return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: markerColor, children: marker }), _jsx(Text, { color: descriptionColor, children: item.description.text }), showType && (_jsxs(_Fragment, { children: [_jsx(Separator, {}), _jsx(Text, { color: typeColor, children: item.type.text })] }))] }), item.children && item.children.length > 0 && (_jsx(List, { items: item.children, level: level + 1, highlightedIndex: shouldHighlightChildren ? highlightedIndex : null, showType: showType }))] }, index));
         }) }));
 };

package/dist/ui/Schedule.js

@@ -3,8 +3,8 @@ import { useEffect, useState } from 'react';
 import { Box } from 'ink';
 import { ComponentStatus } from '../types/components.js';
 import { TaskType } from '../types/types.js';
-import { DebugLevel } from '../services/configuration.js';
 import { getTaskColors, getTaskTypeLabel } from '../services/colors.js';
+import { DebugLevel } from '../services/configuration.js';
 import { useInput } from '../services/keyboard.js';
 import { Label } from './Label.js';
 import { List } from './List.js';

package/dist/ui/Spinner.js

@@ -1,6 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import { Text } from 'ink';
+import { Palette } from '../services/colors.js';
 const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 const INTERVAL = 80;
 const CYCLE = FRAMES.length * INTERVAL;
@@ -18,5 +19,5 @@ export function Spinner() {
         }, INTERVAL);
         return () => clearInterval(timer);
     }, []);
-    return _jsx(Text, { color: "blueBright", children: FRAMES[frame] });
+    return _jsx(Text, { color: Palette.Cyan, children: FRAMES[frame] });
 }

package/dist/ui/Subtask.js

@@ -1,11 +1,22 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { getStatusColors, Palette, STATUS_ICONS } from '../services/colors.js';
-import { formatDuration } from '../services/utils.js';
 import { ExecutionStatus } from '../services/shell.js';
+import { formatDuration } from '../services/utils.js';
 import { Spinner } from './Spinner.js';
-export function Subtask({ label, command, status, startTime, endTime, elapsed, }) {
+export function Subtask({ label, command, status, isActive, startTime, endTime, elapsed, }) {
     const colors = getStatusColors(status);
+    const isCancelled = status === ExecutionStatus.Cancelled;
+    const isAborted = status === ExecutionStatus.Aborted;
+    const shouldStrikethrough = isCancelled || isAborted;
+    const isFinished = status === ExecutionStatus.Success ||
+        status === ExecutionStatus.Failed ||
+        status === ExecutionStatus.Aborted;
     const elapsedTime = elapsed ?? (startTime && endTime ? endTime - startTime : undefined);
-    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: label || command.description }), elapsedTime !== undefined && (_jsxs(Text, { color: Palette.DarkGray, children: ["(", formatDuration(elapsedTime), ")"] }))] }), _jsxs(Box, { paddingLeft: 5, gap: 1, children: [_jsx(Text, { color: colors.symbol, children: "\u221F" }), _jsx(Text, { color: colors.command, children: command.command }), status === ExecutionStatus.Running && _jsx(Spinner, {})] })] }));
+    // 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, {})] })] })] }));
 }

package/dist/ui/Task.js

@@ -3,11 +3,11 @@ import { useEffect, useState } from 'react';
 import { ExecutionStatus, executeCommand, } from '../services/shell.js';
 import { calculateElapsed } from '../services/utils.js';
 import { Subtask } from './Subtask.js';
-export function Task({ label, command, isActive, index, onComplete, onAbort, onError, }) {
-    const [status, setStatus] = useState(ExecutionStatus.Pending);
+export function Task({ label, command, isActive, index, initialStatus, initialElapsed, onComplete, onAbort, onError, }) {
+    const [status, setStatus] = useState(initialStatus ?? ExecutionStatus.Pending);
     const [startTime, setStartTime] = useState();
     const [endTime, setEndTime] = useState();
-    const [elapsed, setElapsed] = useState();
+    const [elapsed, setElapsed] = useState(initialElapsed);
     const [currentElapsed, setCurrentElapsed] = useState(0);
     // Update elapsed time while running
     useEffect(() => {
@@ -23,7 +23,10 @@ export function Task({ label, command, isActive, index, onComplete, onAbort, onE
     }, [status, startTime]);
     // Execute command when becoming active
     useEffect(() => {
-        if (!isActive || status !== ExecutionStatus.Pending) {
+        // Don't execute if task is cancelled or if not active
+        if (!isActive ||
+            status === ExecutionStatus.Cancelled ||
+            status !== ExecutionStatus.Pending) {
             return;
         }
         let mounted = true;
@@ -47,7 +50,7 @@ export function Task({ label, command, isActive, index, onComplete, onAbort, onE
                     onComplete?.(index, output, taskDuration);
                 }
                 else {
-                    onError?.(index, output.errors || 'Command failed');
+                    onError?.(index, output.errors || 'Command failed', taskDuration);
                 }
             }
             catch (err) {
@@ -55,9 +58,10 @@ export function Task({ label, command, isActive, index, onComplete, onAbort, onE
                     return;
                 const end = Date.now();
                 setEndTime(end);
-                setElapsed(calculateElapsed(start));
+                const errorDuration = calculateElapsed(start);
+                setElapsed(errorDuration);
                 setStatus(ExecutionStatus.Failed);
-                onError?.(index, err instanceof Error ? err.message : 'Unknown error');
+                onError?.(index, err instanceof Error ? err.message : 'Unknown error', errorDuration);
             }
         }
         execute();
@@ -77,5 +81,5 @@ export function Task({ label, command, isActive, index, onComplete, onAbort, onE
             onAbort?.(index);
         }
     }, [isActive, status, startTime, index, onAbort]);
-    return (_jsx(Subtask, { label: label, command: command, status: status, startTime: startTime, endTime: endTime, elapsed: status === ExecutionStatus.Running ? currentElapsed : elapsed }));
+    return (_jsx(Subtask, { label: label, command: command, status: status, isActive: isActive, startTime: startTime, endTime: endTime, elapsed: status === ExecutionStatus.Running ? currentElapsed : elapsed }));
 }

package/dist/ui/Validate.js

@@ -4,19 +4,19 @@ import { Box, Text } from 'ink';
 import { ComponentStatus } from '../types/components.js';
 import { TaskType } from '../types/types.js';
 import { Colors, getTextColor } from '../services/colors.js';
-import { addDebugToTimeline } from '../services/components.js';
+import { addDebugToTimeline, createConfigStepsFromSchema, } from '../services/components.js';
+import { DebugLevel, saveConfig, unflattenConfig, } from '../services/configuration.js';
 import { useInput } from '../services/keyboard.js';
 import { formatErrorMessage } from '../services/messages.js';
 import { ensureMinimumTime } from '../services/timing.js';
-import { DebugLevel, saveConfig, unflattenConfig, } from '../services/configuration.js';
-import { Config, StepType } from './Config.js';
+import { Config } from './Config.js';
 import { Spinner } from './Spinner.js';
 const MIN_PROCESSING_TIME = 1000;
 export function Validate({ missingConfig, userRequest, state, status, service, children, debug = DebugLevel.None, onError, onComplete, onAborted, handlers, }) {
     const isActive = status === ComponentStatus.Active;
-    const [error, setError] = useState(null);
-    const [completionMessage, setCompletionMessage] = useState(null);
-    const [configRequirements, setConfigRequirements] = useState(null);
+    const [error, setError] = useState(state?.error ?? null);
+    const [completionMessage, setCompletionMessage] = useState(state?.completionMessage ?? null);
+    const [configRequirements, setConfigRequirements] = useState(state?.configRequirements ?? null);
     const [showConfig, setShowConfig] = useState(false);
     useInput((_, key) => {
         if (key.escape && isActive && !showConfig) {
@@ -74,8 +74,10 @@ export function Validate({ missingConfig, userRequest, state, status, service, c
                     setConfigRequirements(withDescriptions);
                     // Save state after validation completes
                     handlers?.updateState({
+                        completionMessage: message,
                         configRequirements: withDescriptions,
                         validated: true,
+                        error: null,
                     });
                 }
             }
@@ -83,16 +85,17 @@ export function Validate({ missingConfig, userRequest, state, status, service, c
                 await ensureMinimumTime(startTime, MIN_PROCESSING_TIME);
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
+                    setError(errorMessage);
                     // Save error state
                     handlers?.updateState({
                         error: errorMessage,
+                        completionMessage: null,
+                        configRequirements: null,
+                        validated: false,
                     });
                     if (onError) {
                         onError(errorMessage);
                     }
-                    else {
-                        setError(errorMessage);
-                    }
                 }
             }
         }
@@ -113,16 +116,19 @@ export function Validate({ missingConfig, userRequest, state, status, service, c
     if (!isActive && !completionMessage && !error && !children) {
         return null;
     }
-    // Create ConfigSteps from requirements
+    // Create ConfigSteps from requirements using createConfigStepsFromSchema
+    // to load current values from config file, then override descriptions
     const configSteps = configRequirements
-        ? configRequirements.map((req) => ({
-            description: req.description || req.path,
-            key: req.path,
-            path: req.path,
-            type: StepType.Text,
-            value: null,
-            validate: () => true,
-        }))
+        ? (() => {
+            const keys = configRequirements.map((req) => req.path);
+            const steps = createConfigStepsFromSchema(keys);
+            // Override descriptions with LLM-generated ones
+            return steps.map((step, index) => ({
+                ...step,
+                description: configRequirements[index].description ||
+                    configRequirements[index].path,
+            }));
+        })()
         : null;
     const handleConfigFinished = (config) => {
         // Convert flat dotted keys to nested structure grouped by section

package/dist/ui/Workflow.js

@@ -5,8 +5,8 @@ import { ComponentStatus, } from '../types/components.js';
 import { ComponentName, FeedbackType } from '../types/types.js';
 import { createFeedback, isStateless, markAsDone, } from '../services/components.js';
 import { DebugLevel } from '../services/configuration.js';
-import { exitApp } from '../services/process.js';
 import { getCancellationMessage } from '../services/messages.js';
+import { exitApp } from '../services/process.js';
 import { Component } from './Component.js';
 export const Workflow = ({ initialQueue, debug }) => {
     const [timeline, setTimeline] = useState([]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prompt-language-shell",
-  "version": "0.7.8",
+  "version": "0.8.0",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",
@@ -47,22 +47,22 @@
   },
   "homepage": "https://github.com/aswitalski/pls#readme",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.70.1",
-    "ink": "^6.5.1",
+    "@anthropic-ai/sdk": "^0.71.2",
+    "ink": "^6.6.0",
     "ink-text-input": "^6.0.0",
-    "react": "^19.2.0",
-    "yaml": "^2.8.1"
+    "react": "^19.2.3",
+    "yaml": "^2.8.2"
   },
   "devDependencies": {
-    "@types/node": "^24.10.1",
-    "@types/react": "^19.2.6",
-    "@vitest/coverage-v8": "^4.0.12",
-    "eslint": "^9.39.1",
+    "@types/node": "^25.0.3",
+    "@types/react": "^19.2.7",
+    "@vitest/coverage-v8": "^4.0.16",
+    "eslint": "^9.39.2",
     "husky": "^9.1.7",
     "ink-testing-library": "^4.0.0",
-    "prettier": "^3.6.2",
+    "prettier": "^3.7.4",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.47.0",
-    "vitest": "^4.0.12"
+    "typescript-eslint": "^8.50.1",
+    "vitest": "^4.0.16"
   }
 }