prompt-language-shell 0.8.6 → 0.9.0

package/dist/ui/Execute.js

@@ -1,83 +1,118 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useCallback, useEffect, useReducer } from 'react';
+import { useCallback, useEffect, useReducer, useRef } from 'react';
 import { Box, Text } from 'ink';
 import { ComponentStatus, } from '../types/components.js';
 import { getTextColor } from '../services/colors.js';
 import { useInput } from '../services/keyboard.js';
-import { formatErrorMessage } from '../services/messages.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 { processTasks } from '../execution/processing.js';
 import { executeReducer, initialState } from '../execution/reducer.js';
 import { ExecuteActionType } from '../execution/types.js';
+import { createFeedback, createMessage, markAsDone, } from '../services/components.js';
+import { FeedbackType } from '../types/types.js';
 import { Message } from './Message.js';
 import { Spinner } from './Spinner.js';
 import { Task } from './Task.js';
 const MINIMUM_PROCESSING_TIME = 400;
-export const ExecuteView = ({ state, status, onTaskComplete, onTaskAbort, onTaskError, }) => {
+/**
+ * Create an ExecuteState with defaults
+ */
+function createExecuteState(overrides = {}) {
+    return {
+        message: '',
+        summary: '',
+        tasks: [],
+        completed: 0,
+        completionMessage: null,
+        error: null,
+        ...overrides,
+    };
+}
+export const ExecuteView = ({ state, status, workdir, onOutputChange, onTaskComplete, onTaskAbort, onTaskError, }) => {
     const isActive = status === ComponentStatus.Active;
-    const { error, taskInfos, message, completed, completionMessage } = state;
-    const hasProcessed = taskInfos.length > 0;
+    const { error, tasks, message, completed, completionMessage } = state;
+    const hasProcessed = tasks.length > 0;
     // Derive loading state from current conditions
-    const isLoading = isActive && taskInfos.length === 0 && !error && !hasProcessed;
-    const isExecuting = completed < taskInfos.length;
+    const isLoading = isActive && tasks.length === 0 && !error && !hasProcessed;
+    const isExecuting = completed < tasks.length;
     // 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 })] }));
+    const showTasks = !isActive && tasks.length > 0;
+    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isLoading && (_jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: "Preparing commands. " }), _jsx(Spinner, {})] })), (isExecuting || showTasks) && (_jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [message && (_jsxs(Box, { marginBottom: 1, gap: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: message }), isExecuting && _jsx(Spinner, {})] })), tasks.map((taskInfo, index) => {
+                        // Merge workdir into active task's command
+                        const taskCommand = isActive && index === completed && workdir
+                            ? { ...taskInfo.command, workdir }
+                            : taskInfo.command;
+                        return (_jsx(Box, { marginBottom: index < tasks.length - 1 ? 1 : 0, children: _jsx(Task, { label: taskInfo.label, command: taskCommand, isActive: isActive && index === completed, isFinished: index < completed, index: index, initialStatus: taskInfo.status, initialElapsed: taskInfo.elapsed, initialOutput: taskInfo.stdout || taskInfo.stderr || taskInfo.error
+                                    ? {
+                                        stdout: taskInfo.stdout ?? '',
+                                        stderr: taskInfo.stderr ?? '',
+                                        error: taskInfo.error ?? '',
+                                    }
+                                    : undefined, onOutputChange: onOutputChange, onComplete: onTaskComplete, onAbort: onTaskAbort, onError: onTaskError }) }, index));
+                    })] })), completionMessage && !isActive && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsx(Text, { color: getTextColor(false), children: completionMessage }) })), error && _jsx(Message, { text: error, status: status })] }));
 };
 /**
  * Execute controller: Runs tasks sequentially
  */
-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;
+    // Ref to store current output for each task (avoids re-renders)
+    const taskOutputRef = useRef(new Map());
+    // Track working directory across commands (persists cd changes)
+    const workdirRef = useRef(undefined);
+    const { error, tasks, message, completed, hasProcessed, completionMessage, summary, } = localState;
     // Derive loading state from current conditions
-    const isLoading = isActive && taskInfos.length === 0 && !error && !hasProcessed;
-    const isExecuting = completed < taskInfos.length;
+    const isLoading = isActive && tasks.length === 0 && !error && !hasProcessed;
+    const isExecuting = completed < tasks.length;
+    // Handle output changes from Task - store in ref (no re-render)
+    const handleOutputChange = useCallback((index, taskOutput) => {
+        taskOutputRef.current.set(index, taskOutput);
+    }, []);
     // Handle cancel with useCallback to ensure we capture latest state
     const handleCancel = useCallback(() => {
         dispatch({
             type: ExecuteActionType.CancelExecution,
             payload: { completed },
         });
-        // Get updated task infos after cancel
-        const updatedTaskInfos = taskInfos.map((task, taskIndex) => {
+        // Get updated task infos after cancel, merging output from ref
+        const updatedTaskInfos = tasks.map((task, taskIndex) => {
+            const output = taskOutputRef.current.get(taskIndex);
+            const baseTask = output
+                ? {
+                    ...task,
+                    stdout: output.stdout,
+                    stderr: output.stderr,
+                    error: output.error,
+                }
+                : task;
             if (taskIndex < completed) {
-                return { ...task, status: ExecutionStatus.Success };
+                return { ...baseTask, status: ExecutionStatus.Success };
             }
             else if (taskIndex === completed) {
-                return { ...task, status: ExecutionStatus.Aborted };
+                return { ...baseTask, status: ExecutionStatus.Aborted };
             }
             else {
-                return { ...task, status: ExecutionStatus.Cancelled };
+                return { ...baseTask, status: ExecutionStatus.Cancelled };
             }
         });
         // Expose final state
-        const finalState = {
+        const finalState = createExecuteState({
             message,
             summary,
-            taskInfos: updatedTaskInfos,
+            tasks: updatedTaskInfos,
             completed,
-            taskExecutionTimes,
-            completionMessage: null,
-            error: null,
-        };
+        });
         requestHandlers.onCompleted(finalState);
         requestHandlers.onAborted('execution');
-    }, [
-        message,
-        summary,
-        taskInfos,
-        completed,
-        taskExecutionTimes,
-        requestHandlers,
-    ]);
+    }, [message, summary, tasks, completed, requestHandlers]);
     useInput((_, key) => {
         if (key.escape && (isLoading || isExecuting) && isActive) {
             handleCancel();
@@ -85,14 +120,14 @@ export function Execute({ tasks, status, service, requestHandlers, lifecycleHand
     }, { 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;
@@ -101,47 +136,46 @@ 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)
+                        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 tasks = 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,
                     },
                 });
                 // 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,
+                }));
             }
             catch (err) {
                 await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
@@ -151,16 +185,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);
                 }
             }
@@ -170,81 +195,100 @@ 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 handleTaskComplete = useCallback((index, elapsed, taskOutput) => {
+        // Track working directory for subsequent commands
+        if (taskOutput.workdir) {
+            workdirRef.current = taskOutput.workdir;
+        }
+        // Update tasks with output before calling handler
+        const tasksWithOutput = tasks.map((task, i) => i === index
+            ? {
+                ...task,
+                stdout: taskOutput.stdout,
+                stderr: taskOutput.stderr,
+                error: taskOutput.error,
+            }
+            : task);
         const result = handleTaskCompletion(index, elapsed, {
-            taskInfos,
+            tasks: tasksWithOutput,
             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) => {
+    }, [tasks, message, summary, requestHandlers, lifecycleHandlers]);
+    const handleTaskError = useCallback((index, error, elapsed, taskOutput) => {
+        // Track working directory for subsequent commands (even on error)
+        if (taskOutput.workdir) {
+            workdirRef.current = taskOutput.workdir;
+        }
+        // Update tasks with output before calling handler
+        const tasksWithOutput = tasks.map((task, i) => i === index
+            ? {
+                ...task,
+                stdout: taskOutput.stdout,
+                stderr: taskOutput.stderr,
+                error: taskOutput.error,
+            }
+            : task);
         const result = handleTaskFailure(index, error, elapsed, {
-            taskInfos,
+            tasks: tasksWithOutput,
             message,
             summary,
-            taskExecutionTimes,
         });
         dispatch(result.action);
         requestHandlers.onCompleted(result.finalState);
-        if (result.shouldReportError) {
-            requestHandlers.onError(error);
+        // Add error feedback to queue for critical failures
+        if (result.action.type === ExecuteActionType.TaskErrorCritical) {
+            const errorMessage = getExecutionErrorMessage(error);
+            workflowHandlers.addToQueue(createFeedback(FeedbackType.Failed, errorMessage));
         }
         if (result.shouldComplete) {
             lifecycleHandlers.completeActive();
         }
     }, [
-        taskInfos,
+        tasks,
         message,
         summary,
-        taskExecutionTimes,
         requestHandlers,
         lifecycleHandlers,
+        workflowHandlers,
     ]);
-    const handleTaskAbort = useCallback((_index) => {
+    const handleTaskAbort = useCallback((index, taskOutput) => {
         // 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);
+        // Update tasks with output before building state
+        const tasksWithOutput = tasks.map((task, i) => i === index
+            ? {
+                ...task,
+                stdout: taskOutput.stdout,
+                stderr: taskOutput.stderr,
+                error: taskOutput.error,
+            }
+            : task);
+        const finalState = buildAbortedState(tasksWithOutput, message, summary, completed);
         requestHandlers.onCompleted(finalState);
-    }, [
-        taskInfos,
-        message,
-        summary,
-        completed,
-        taskExecutionTimes,
-        requestHandlers,
-    ]);
+    }, [tasks, message, summary, completed, requestHandlers]);
     // Controller always renders View with current state
-    const viewState = {
+    const viewState = createExecuteState({
         error,
-        taskInfos,
+        tasks,
         message,
         summary,
         completed,
-        taskExecutionTimes,
         completionMessage,
-    };
-    return (_jsx(ExecuteView, { tasks: tasks, state: viewState, status: status, onTaskComplete: handleTaskComplete, onTaskAbort: handleTaskAbort, onTaskError: handleTaskError }));
+    });
+    return (_jsx(ExecuteView, { state: viewState, status: status, workdir: workdirRef.current, onOutputChange: handleOutputChange, onTaskComplete: handleTaskComplete, onTaskAbort: handleTaskAbort, onTaskError: handleTaskError }));
 }

package/dist/ui/Feedback.js

@@ -1,5 +1,6 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
+import { ComponentStatus } from '../types/components.js';
 import { FeedbackType } from '../types/types.js';
 import { getFeedbackColor } from '../services/colors.js';
 function getSymbol(type) {
@@ -12,7 +13,7 @@ function getSymbol(type) {
     }[type];
 }
 export function Feedback({ type, message }) {
-    const color = getFeedbackColor(type, false);
+    const color = getFeedbackColor(type, ComponentStatus.Done);
     const symbol = getSymbol(type);
     return (_jsx(Box, { marginLeft: 1, children: _jsxs(Text, { color: color, children: [symbol, " ", message] }) }));
 }

package/dist/ui/Label.js

@@ -3,7 +3,8 @@ import { Box, Text } from 'ink';
 import { getTaskColors, getTaskTypeLabel } from '../services/colors.js';
 import { DebugLevel } from '../configuration/types.js';
 import { Separator } from './Separator.js';
-export function Label({ description, taskType, showType = false, isCurrent = false, debug = DebugLevel.None, }) {
-    const colors = getTaskColors(taskType, isCurrent);
+import { ComponentStatus } from '../types/components.js';
+export function Label({ description, taskType, showType = false, status = ComponentStatus.Done, debug = DebugLevel.None, }) {
+    const colors = getTaskColors(taskType, status);
     return (_jsxs(Box, { children: [_jsx(Text, { color: colors.description, children: description }), showType && (_jsxs(_Fragment, { children: [_jsx(Separator, {}), _jsx(Text, { color: colors.type, children: getTaskTypeLabel(taskType, debug) })] }))] }));
 }

package/dist/ui/List.js

@@ -4,7 +4,8 @@ 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;
-    return (_jsx(Box, { flexDirection: "column", marginLeft: marginLeft, children: items.map((item, index) => {
+    const gap = level === 0 ? 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
             const shouldHighlightChildren = level === 0 ? highlightedParentIndex === index : false;
@@ -23,6 +24,6 @@ export const List = ({ items, level = 0, highlightedIndex = null, highlightedPar
                 (isHighlighted && item.type.highlightedColor
                     ? item.type.highlightedColor
                     : 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));
+            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(Box, { marginTop: 1, children: _jsx(List, { items: item.children, level: level + 1, highlightedIndex: shouldHighlightChildren ? highlightedIndex : null, showType: showType }) }))] }, index));
         }) }));
 };

package/dist/ui/Output.js

@@ -0,0 +1,54 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { Palette } from '../services/colors.js';
+import { ExecutionStatus } from '../services/shell.js';
+const MAX_LINES = 8;
+const MAX_WIDTH = 75;
+const SHORT_OUTPUT_THRESHOLD = 4;
+const MINIMAL_INFO_THRESHOLD = 2;
+/**
+ * Get the last N lines from text, filtering out empty/whitespace-only lines
+ */
+export function getLastLines(text, maxLines = MAX_LINES) {
+    const lines = text
+        .trim()
+        .split(/\r?\n/)
+        .filter((line) => line.trim().length > 0);
+    return lines.length <= maxLines ? lines : lines.slice(-maxLines);
+}
+/**
+ * Compute display configuration for output rendering.
+ * Encapsulates the logic for what to show and how to style it.
+ */
+export function computeDisplayConfig(stdout, stderr, status, isFinished) {
+    const hasStdout = stdout.trim().length > 0;
+    const hasStderr = stderr.trim().length > 0;
+    if (!hasStdout && !hasStderr)
+        return null;
+    const stdoutLines = hasStdout ? getLastLines(stdout) : [];
+    const stderrLines = hasStderr ? getLastLines(stderr) : [];
+    // Show stdout if no stderr, or if stderr is minimal (provides context)
+    const showStdout = hasStdout && (!hasStderr || stderrLines.length <= MINIMAL_INFO_THRESHOLD);
+    // Use word wrapping for short outputs to show more detail
+    const totalLines = stdoutLines.length + stderrLines.length;
+    const wrapMode = totalLines <= SHORT_OUTPUT_THRESHOLD ? 'wrap' : 'truncate-end';
+    // Darker colors for finished tasks
+    const baseColor = isFinished ? Palette.DarkGray : Palette.Gray;
+    const stderrColor = status === ExecutionStatus.Failed ? Palette.Yellow : baseColor;
+    return {
+        stdoutLines,
+        stderrLines,
+        showStdout,
+        wrapMode,
+        stdoutColor: baseColor,
+        stderrColor,
+    };
+}
+export function Output({ stdout, stderr, status, isFinished }) {
+    const config = computeDisplayConfig(stdout, stderr, status, isFinished ?? false);
+    if (!config)
+        return null;
+    const { stdoutLines, stderrLines, showStdout, wrapMode, stdoutColor, stderrColor, } = config;
+    return (_jsxs(Box, { marginTop: 1, marginLeft: 5, flexDirection: "column", width: MAX_WIDTH, children: [showStdout &&
+                stdoutLines.map((line, index) => (_jsx(Text, { color: stdoutColor, wrap: wrapMode, children: line }, `out-${index}`))), stderrLines.map((line, index) => (_jsx(Text, { color: stderrColor, wrap: wrapMode, children: line }, `err-${index}`)))] }));
+}

package/dist/ui/Schedule.js

@@ -3,17 +3,22 @@ import { useEffect, useState } from 'react';
 import { Box } from 'ink';
 import { ComponentStatus, } from '../types/components.js';
 import { TaskType } from '../types/types.js';
-import { getTaskColors, getTaskTypeLabel } from '../services/colors.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';
-function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutSelection = false, isCurrent = false, debug = DebugLevel.None) {
-    const taskColors = getTaskColors(task.type, isCurrent);
+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: taskColors.description,
+            color: descriptionColor,
         },
         type: { text: getTaskTypeLabel(task.type, debug), color: taskColors.type },
         children: [],
@@ -21,7 +26,7 @@ function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutS
     // Mark define tasks with right arrow when no selection has been made
     if (isDefineTaskWithoutSelection) {
         item.marker = '  → ';
-        item.markerColor = getTaskColors(TaskType.Schedule, isCurrent).type;
+        item.markerColor = getTaskColors(TaskType.Schedule, status).type;
     }
     // Add children for Define tasks with options
     if (task.type === TaskType.Define && Array.isArray(task.params?.options)) {
@@ -33,8 +38,8 @@ function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutS
                 childType =
                     index === highlightedChildIndex ? TaskType.Execute : TaskType.Discard;
             }
-            const colors = getTaskColors(childType, isCurrent);
-            const planColors = getTaskColors(TaskType.Schedule, isCurrent);
+            const colors = getTaskColors(childType, status);
+            const planColors = getTaskColors(TaskType.Schedule, status);
             return {
                 description: {
                     text: option,
@@ -56,11 +61,11 @@ function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutS
         Array.isArray(scheduledTask.subtasks) &&
         scheduledTask.subtasks.length > 0) {
         item.children = scheduledTask.subtasks.map((subtask) => {
-            const subtaskColors = getTaskColors(subtask.type, isCurrent);
+            const subtaskColors = getTaskColors(subtask.type, status);
             return {
                 description: {
                     text: subtask.action,
-                    color: subtaskColors.description,
+                    color: Palette.AshGray,
                 },
                 type: {
                     text: getTaskTypeLabel(subtask.type, debug),
@@ -107,9 +112,9 @@ export const ScheduleView = ({ message, tasks, state, status, debug = DebugLevel
             defineGroupIndex === currentDefineGroupIndex &&
             highlightedIndex === null &&
             isActive;
-        return taskToListItem(task, childIndex, isDefineWithoutSelection, isActive, debug);
+        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, isCurrent: isActive, debug: debug }) })), _jsx(Box, { marginLeft: 1, children: _jsx(List, { items: listItems, highlightedIndex: currentDefineTaskIndex >= 0 ? highlightedIndex : null, highlightedParentIndex: currentDefineTaskIndex, showType: debug !== DebugLevel.None }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [message && (_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Label, { description: message, taskType: TaskType.Schedule, showType: debug !== DebugLevel.None, status: status, debug: debug }) })), _jsx(Box, { marginLeft: 1, children: _jsx(List, { items: listItems, highlightedIndex: currentDefineTaskIndex >= 0 ? highlightedIndex : null, highlightedParentIndex: currentDefineTaskIndex, showType: debug !== DebugLevel.None }) })] }));
 };
 /**
  * Schedule controller: Manages task selection and navigation