prompt-language-shell 0.9.0 → 0.9.4

package/dist/services/router.js

@@ -2,10 +2,11 @@ import { asScheduledTasks } from '../types/guards.js';
 import { FeedbackType, TaskType } from '../types/types.js';
 import { saveConfig } from '../configuration/io.js';
 import { getConfigSchema } from '../configuration/schema.js';
+import { createConfigStepsFromSchema } from '../configuration/steps.js';
 import { unflattenConfig } from '../configuration/transformation.js';
-import { saveConfigLabels } from './config-labels.js';
-import { createAnswerDefinition, createConfigDefinitionWithKeys, createConfirmDefinition, createExecuteDefinition, createFeedback, createIntrospectDefinition, createMessage, createScheduleDefinition, createValidateDefinition, } from './components.js';
-import { getCancellationMessage, getMixedTaskTypesError, getUnknownRequestMessage, } from './messages.js';
+import { saveConfigLabels } from '../configuration/labels.js';
+import { createAnswer, createConfig, createConfirm, createExecute, createFeedback, createIntrospect, createMessage, createSchedule, createValidate, } from './components.js';
+import { getCancellationMessage, getConfirmationMessage, getMixedTaskTypesError, getUnknownRequestMessage, } from './messages.js';
 import { validateExecuteTasks } from './validator.js';
 /**
  * Determine the operation name based on task types
@@ -30,7 +31,7 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, life
     const validTasks = tasks.filter((task) => task.type !== TaskType.Ignore && task.type !== TaskType.Discard);
     // Check if no valid tasks remain after filtering
     if (validTasks.length === 0) {
-        const msg = createMessage(getUnknownRequestMessage());
+        const msg = createMessage({ text: getUnknownRequestMessage() });
         workflowHandlers.addToQueue(msg);
         return;
     }
@@ -45,7 +46,7 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, life
     if (hasDefineTask) {
         // Has DEFINE tasks - add Schedule to queue for user selection
         // Refinement flow will call this function again with refined tasks
-        const scheduleDefinition = createScheduleDefinition(message, validTasks);
+        const scheduleDefinition = createSchedule({ message, tasks: validTasks });
         workflowHandlers.addToQueue(scheduleDefinition);
     }
     else {
@@ -53,19 +54,27 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, life
         // When Schedule activates, Command moves to timeline
         // When Schedule completes, it moves to pending
         // When Confirm activates, Schedule stays pending (visible for context)
-        const scheduleDefinition = createScheduleDefinition(message, validTasks, () => {
-            // Schedule completed - add Confirm to queue
-            const confirmDefinition = createConfirmDefinition(() => {
-                // User confirmed - complete both Confirm and Schedule, then route
-                lifecycleHandlers.completeActiveAndPending();
-                executeTasksAfterConfirm(validTasks, context);
-            }, () => {
-                // User cancelled - complete both Confirm and Schedule, then show cancellation
-                lifecycleHandlers.completeActiveAndPending();
-                const message = getCancellationMessage(operation);
-                workflowHandlers.addToQueue(createFeedback(FeedbackType.Aborted, message));
-            });
-            workflowHandlers.addToQueue(confirmDefinition);
+        const scheduleDefinition = createSchedule({
+            message,
+            tasks: validTasks,
+            onSelectionConfirmed: () => {
+                // Schedule completed - add Confirm to queue
+                const confirmDefinition = createConfirm({
+                    message: getConfirmationMessage(),
+                    onConfirmed: () => {
+                        // User confirmed - complete both Confirm and Schedule, then route
+                        lifecycleHandlers.completeActiveAndPending();
+                        executeTasksAfterConfirm(validTasks, context);
+                    },
+                    onCancelled: () => {
+                        // User cancelled - complete both Confirm and Schedule, then show cancellation
+                        lifecycleHandlers.completeActiveAndPending();
+                        const message = getCancellationMessage(operation);
+                        workflowHandlers.addToQueue(createFeedback({ type: FeedbackType.Aborted, message }));
+                    },
+                });
+                workflowHandlers.addToQueue(confirmDefinition);
+            },
         });
         workflowHandlers.addToQueue(scheduleDefinition);
     }
@@ -134,18 +143,28 @@ function executeTasksAfterConfirm(tasks, context) {
                         .join('\n');
                     return `Invalid skill definition "${error.skill}":\n\n${issuesList}`;
                 });
-                workflowHandlers.addToQueue(createFeedback(FeedbackType.Failed, errorMessages.join('\n\n')));
+                workflowHandlers.addToQueue(createFeedback({
+                    type: FeedbackType.Failed,
+                    message: errorMessages.join('\n\n'),
+                }));
                 return;
             }
             else if (validation.missingConfig.length > 0) {
                 // Missing config detected - create ONE Validate component for ALL missing config
-                workflowHandlers.addToQueue(createValidateDefinition(validation.missingConfig, userRequest, service, (error) => {
-                    requestHandlers.onError(error);
-                }, () => {
-                    // After config is complete, resume task routing
-                    routeTasksAfterConfig(scheduledTasks, context);
-                }, (operation) => {
-                    requestHandlers.onAborted(operation);
+                workflowHandlers.addToQueue(createValidate({
+                    missingConfig: validation.missingConfig,
+                    userRequest,
+                    service,
+                    onError: (error) => {
+                        requestHandlers.onError(error);
+                    },
+                    onValidationComplete: () => {
+                        // After config is complete, resume task routing
+                        routeTasksAfterConfig(scheduledTasks, context);
+                    },
+                    onAborted: (operation) => {
+                        requestHandlers.onAborted(operation);
+                    },
                 }));
                 return;
             }
@@ -158,11 +177,37 @@ function executeTasksAfterConfirm(tasks, context) {
     // No missing config - proceed with normal routing
     routeTasksAfterConfig(scheduledTasks, context);
 }
+/**
+ * Task types that should appear in the upcoming display
+ */
+const UPCOMING_TASK_TYPES = [TaskType.Execute, TaskType.Answer];
+/**
+ * Collect names of all upcoming execution units (groups and standalone tasks)
+ * for display during task execution
+ */
+function collectUpcomingNames(scheduledTasks) {
+    const names = [];
+    for (const task of scheduledTasks) {
+        if (task.type === TaskType.Group && task.subtasks?.length) {
+            const subtasks = task.subtasks;
+            if (UPCOMING_TASK_TYPES.includes(subtasks[0].type)) {
+                names.push(task.action);
+            }
+        }
+        else if (UPCOMING_TASK_TYPES.includes(task.type)) {
+            names.push(task.action);
+        }
+    }
+    return names;
+}
 /**
  * Route tasks after config is complete (or when no config is needed)
  * Processes tasks in order, grouping by type
  */
 function routeTasksAfterConfig(scheduledTasks, context) {
+    // Collect all unit names for upcoming display
+    const allUnitNames = collectUpcomingNames(scheduledTasks);
+    let currentUnitIndex = 0;
     // Process tasks in order, preserving Group boundaries
     // Track consecutive standalone tasks to group them by type
     let consecutiveStandaloneTasks = [];
@@ -182,7 +227,18 @@ function routeTasksAfterConfig(scheduledTasks, context) {
             const taskType = type;
             if (typeTasks.length === 0)
                 continue;
-            routeTasksByType(taskType, typeTasks, context);
+            // For tasks that appear in upcoming, calculate from remaining units
+            if (UPCOMING_TASK_TYPES.includes(taskType)) {
+                // Each task advances the unit index
+                for (const task of typeTasks) {
+                    const upcoming = allUnitNames.slice(currentUnitIndex + 1);
+                    currentUnitIndex++;
+                    routeTasksByType(taskType, [task], context, upcoming);
+                }
+            }
+            else {
+                routeTasksByType(taskType, typeTasks, context, []);
+            }
         }
         consecutiveStandaloneTasks = [];
     };
@@ -195,7 +251,20 @@ function routeTasksAfterConfig(scheduledTasks, context) {
             if (task.subtasks.length > 0) {
                 const subtasks = task.subtasks;
                 const taskType = subtasks[0].type;
-                routeTasksByType(taskType, subtasks, context);
+                // Calculate upcoming (all units after this one)
+                const upcoming = UPCOMING_TASK_TYPES.includes(taskType)
+                    ? allUnitNames.slice(currentUnitIndex + 1)
+                    : [];
+                if (UPCOMING_TASK_TYPES.includes(taskType)) {
+                    currentUnitIndex++;
+                }
+                // Pass group name as label for Execute groups
+                if (taskType === TaskType.Execute) {
+                    routeExecuteTasks(subtasks, context, upcoming, task.action);
+                }
+                else {
+                    routeTasksByType(taskType, subtasks, context, upcoming);
+                }
             }
         }
         else {
@@ -209,21 +278,29 @@ function routeTasksAfterConfig(scheduledTasks, context) {
 /**
  * Route Answer tasks - creates separate Answer component for each question
  */
-function routeAnswerTasks(tasks, context) {
-    for (const task of tasks) {
-        context.workflowHandlers.addToQueue(createAnswerDefinition(task.action, context.service));
+function routeAnswerTasks(tasks, context, upcoming) {
+    for (let i = 0; i < tasks.length; i++) {
+        const task = tasks[i];
+        // Calculate upcoming: remaining answer tasks + original upcoming
+        const remainingAnswers = tasks.slice(i + 1).map((t) => t.action);
+        const taskUpcoming = [...remainingAnswers, ...upcoming];
+        context.workflowHandlers.addToQueue(createAnswer({
+            question: task.action,
+            service: context.service,
+            upcoming: taskUpcoming,
+        }));
     }
 }
 /**
  * Route Introspect tasks - creates single Introspect component for all tasks
  */
-function routeIntrospectTasks(tasks, context) {
-    context.workflowHandlers.addToQueue(createIntrospectDefinition(tasks, context.service));
+function routeIntrospectTasks(tasks, context, _upcoming) {
+    context.workflowHandlers.addToQueue(createIntrospect({ tasks, service: context.service }));
 }
 /**
  * Route Config tasks - extracts keys, caches labels, creates Config component
  */
-function routeConfigTasks(tasks, context) {
+function routeConfigTasks(tasks, context, _upcoming) {
     const configKeys = tasks
         .map((task) => task.params?.key)
         .filter((key) => key !== undefined);
@@ -240,31 +317,35 @@ function routeConfigTasks(tasks, context) {
     if (Object.keys(labels).length > 0) {
         saveConfigLabels(labels);
     }
-    context.workflowHandlers.addToQueue(createConfigDefinitionWithKeys(configKeys, (config) => {
-        // Save config - Config component will handle completion and feedback
-        try {
-            // Convert flat dotted keys to nested structure grouped by section
-            const configBySection = unflattenConfig(config);
-            // Save each section
-            for (const [section, sectionConfig] of Object.entries(configBySection)) {
-                saveConfig(section, sectionConfig);
+    context.workflowHandlers.addToQueue(createConfig({
+        steps: createConfigStepsFromSchema(configKeys),
+        onFinished: (config) => {
+            // Save config - Config component will handle completion and feedback
+            try {
+                // Convert flat dotted keys to nested structure grouped by section
+                const configBySection = unflattenConfig(config);
+                // Save each section
+                for (const [section, sectionConfig] of Object.entries(configBySection)) {
+                    saveConfig(section, sectionConfig);
+                }
             }
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error
-                ? error.message
-                : 'Failed to save configuration';
-            throw new Error(errorMessage);
-        }
-    }, (operation) => {
-        context.requestHandlers.onAborted(operation);
+            catch (error) {
+                const errorMessage = error instanceof Error
+                    ? error.message
+                    : 'Failed to save configuration';
+                throw new Error(errorMessage);
+            }
+        },
+        onAborted: (operation) => {
+            context.requestHandlers.onAborted(operation);
+        },
     }));
 }
 /**
  * Route Execute tasks - creates Execute component (validation already done)
  */
-function routeExecuteTasks(tasks, context) {
-    context.workflowHandlers.addToQueue(createExecuteDefinition(tasks, context.service));
+function routeExecuteTasks(tasks, context, upcoming, label) {
+    context.workflowHandlers.addToQueue(createExecute({ tasks, service: context.service, upcoming, label }));
 }
 /**
  * Registry mapping task types to their route handlers
@@ -279,9 +360,9 @@ const taskRouteHandlers = {
  * Route tasks by type to appropriate components
  * Uses registry pattern for extensibility
  */
-function routeTasksByType(taskType, tasks, context) {
+function routeTasksByType(taskType, tasks, context, upcoming) {
     const handler = taskRouteHandlers[taskType];
     if (handler) {
-        handler(tasks, context);
+        handler(tasks, context, upcoming);
     }
 }

package/dist/services/shell.js

@@ -61,6 +61,14 @@ export class DummyExecutor {
 }
 // Marker for extracting pwd from command output
 const PWD_MARKER = '__PWD_MARKER_7x9k2m__';
+const MAX_OUTPUT_LINES = 128;
+/**
+ * Limit output to last MAX_OUTPUT_LINES lines.
+ */
+function limitLines(output) {
+    const lines = output.split('\n');
+    return lines.slice(-MAX_OUTPUT_LINES).join('\n');
+}
 /**
  * Parse stdout to extract workdir and clean output.
  * Returns the cleaned output and the extracted workdir.
@@ -93,6 +101,12 @@ class OutputStreamer {
      */
     pushStdout(data) {
         this.chunks.push(data);
+        // Collapse when we have too many chunks to prevent memory growth
+        if (this.chunks.length > 16) {
+            const accumulated = this.chunks.join('');
+            this.chunks = [limitLines(accumulated)];
+            this.emittedLength = 0;
+        }
         if (!this.callback)
             return;
         const accumulated = this.chunks.join('');
@@ -123,7 +137,7 @@ class OutputStreamer {
      * Get the accumulated raw output.
      */
     getAccumulated() {
-        return this.chunks.join('');
+        return limitLines(this.chunks.join(''));
     }
 }
 /**
@@ -189,6 +203,13 @@ export class RealExecutor {
             child.stderr.on('data', (data) => {
                 const text = data.toString();
                 stderr.push(text);
+                // Collapse when we have too many chunks to prevent memory growth
+                if (stderr.length > 16) {
+                    const accumulated = stderr.join('');
+                    const limited = limitLines(accumulated);
+                    stderr.length = 0;
+                    stderr.push(limited);
+                }
                 this.outputCallback?.(text, 'stderr');
             });
             child.on('error', (error) => {
@@ -200,7 +221,7 @@ export class RealExecutor {
                     description: cmd.description,
                     command: cmd.command,
                     output: stdoutStreamer.getAccumulated(),
-                    errors: error.message,
+                    errors: limitLines(stderr.join('')) || error.message,
                     result: ExecutionResult.Error,
                     error: error.message,
                 };
@@ -218,7 +239,7 @@ export class RealExecutor {
                     description: cmd.description,
                     command: cmd.command,
                     output,
-                    errors: stderr.join(''),
+                    errors: limitLines(stderr.join('')),
                     result: success ? ExecutionResult.Success : ExecutionResult.Error,
                     error: success ? undefined : `Exit code: ${code}`,
                     workdir,
@@ -278,9 +299,8 @@ export async function executeCommands(commands, onProgress) {
                 : ExecutionStatus.Failed,
             output,
         });
-        // Stop if critical command failed
-        const isCritical = cmd.critical !== false;
-        if (output.result !== ExecutionResult.Success && isCritical) {
+        // Stop on failure
+        if (output.result !== ExecutionResult.Success) {
             break;
         }
     }

package/dist/services/timing.js

@@ -1,6 +1,7 @@
 /**
  * Timing utilities for UI components
  */
+export const ELAPSED_UPDATE_INTERVAL = 250;
 /**
  * Waits for at least the minimum processing time.
  * Ensures async operations don't complete too quickly for good UX.

package/dist/skills/execute.md

@@ -24,6 +24,12 @@ You will receive:
 - Tasks from user-defined skills include params.skill (skill name) and
   parameter values that were substituted into the action
 
+**CRITICAL - Command Count Rule**: You MUST generate EXACTLY one command
+per input task, no more, no less. The number of commands in your response
+MUST match the number of tasks you received. Do NOT split a single task
+into multiple commands or generate extra commands beyond what was
+scheduled.
+
 ## Skill-Based Command Generation
 
 **CRITICAL**: The "Available Skills" section in the prompt defines the ONLY
@@ -133,6 +139,18 @@ Given tasks from this skill:
 Do NOT invent different commands - use exactly what the skill specifies,
 with parameter placeholders replaced by actual values.
 
+### Handling Skipped Steps
+
+**CRITICAL - STEP ORDER PRESERVATION**: When some steps from a skill are
+omitted during scheduling, you MUST maintain alignment with the
+original step positions in both the Steps and Execution sections. Each
+task corresponds to a specific line number in the skill definition, NOT
+to its sequential position in the task list. If you receive tasks for
+steps 1 and 3 (with step 2 skipped), use Execution lines 1 and 3
+(NOT lines 1 and 2). The step numbers in the task actions indicate
+which Execution line to use - always match by original position, never
+by sequential task index.
+
 **CRITICAL - VERBATIM EXECUTION**: Run shell commands EXACTLY as written in
 the ### Execution section. Do NOT:
 - Modify the command string in any way
@@ -174,7 +192,6 @@ Return a structured response with commands to execute:
 - **workdir**: Optional working directory for the command (defaults to
   current)
 - **timeout**: Optional timeout in milliseconds (defaults to 30000)
-- **critical**: Whether failure should stop execution (defaults to true)
 
 ## Command Generation Guidelines
 
@@ -358,14 +375,12 @@ commands:
 
 For complex multi-step operations:
 
-1. **Sequential dependencies**: Mark early commands as critical so failure
-   stops the chain
+1. **Sequential dependencies**: Commands execute in order; any failure stops
+   the chain
 2. **Long-running processes**: Set appropriate timeouts (build processes
    may need 10+ minutes)
 3. **Working directories**: Use workdir to ensure commands run in the
    right location
-4. **Error handling**: For non-critical cleanup steps, set critical:
-   false
 
 ## Handling Config Placeholders
 
@@ -424,17 +439,28 @@ Example:
 
 Before returning commands:
 
-1. **CRITICAL: If tasks have params.skill, verify Available Skills
+1. **CRITICAL: Verify command count matches input task count** - you must
+   have exactly one command per input task
+2. **CRITICAL: If tasks have params.skill, verify Available Skills
    section exists**
-2. **CRITICAL: If tasks have params.skill, verify the skill exists in
+3. **CRITICAL: If tasks have params.skill, verify the skill exists in
    Available Skills section**
-3. **CRITICAL: If tasks have params.skill, verify the skill has both
+4. **CRITICAL: If tasks have params.skill, verify the skill has both
    Steps and Execution sections**
-4. **CRITICAL: If any validation fails, return error response with empty
+5. **CRITICAL: If any validation fails, return error response with empty
    commands array**
-5. Verify each command matches its task description
-6. Check that all task params are incorporated
-7. Ensure paths are properly quoted
-8. Confirm timeouts are reasonable for each operation
-9. Validate that critical flags are set appropriately
+6. Verify each command matches its task description
+7. Check that all task params are incorporated
+8. Ensure paths are properly quoted
+9. Confirm timeouts are reasonable for each operation
 10. Review for any safety concerns
+
+## Confirmed Schedule
+
+CRITICAL: The user message contains the confirmed schedule that the user
+has reviewed and approved. You MUST generate exactly one command per task
+listed in the confirmed schedule. The number of commands in your response
+MUST equal the number of tasks below. DO NOT add extra commands, DO NOT
+skip tasks, and DO NOT split tasks into multiple commands.
+
+Your response MUST contain exactly N commands corresponding to these N tasks.

package/dist/tools/execute.tool.js

@@ -34,10 +34,6 @@ export const executeTool = {
                             type: 'number',
                             description: 'Optional timeout in milliseconds. Defaults to 30000 (30 seconds).',
                         },
-                        critical: {
-                            type: 'boolean',
-                            description: 'Whether failure should stop execution of subsequent commands. Defaults to true.',
-                        },
                     },
                     required: ['description', 'command'],
                 },

package/dist/types/schemas.js

@@ -56,7 +56,6 @@ export const ExecuteCommandSchema = z.object({
     command: z.string().min(1),
     workdir: z.string().optional(),
     timeout: z.number().int().positive().optional(),
-    critical: z.boolean().optional(),
 });
 /**
  * Zod schema for Capability type.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prompt-language-shell",
-  "version": "0.9.0",
+  "version": "0.9.4",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",

package/dist/parser.js

@@ -1,13 +0,0 @@
-/**
- * Parses a comma-separated list of tasks from command-line prompt
- * Strips exclamation marks and periods from each task
- *
- * @param prompt - Raw command-line input string
- * @returns Array of parsed task strings
- */
-export function parseCommands(prompt) {
-    return prompt
-        .split(',')
-        .map((task) => task.trim().replace(/[!.]/g, '').trim())
-        .filter((task) => task.length > 0);
-}

package/dist/services/config-utils.js

@@ -1,20 +0,0 @@
-/**
- * Utility functions for config manipulation
- */
-/**
- * Flatten nested config object to dot notation
- * Example: { a: { b: 1 } } => { 'a.b': 1 }
- */
-export function flattenConfig(obj, prefix = '') {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-        const fullKey = prefix ? `${prefix}.${key}` : key;
-        if (value && typeof value === 'object' && !Array.isArray(value)) {
-            Object.assign(result, flattenConfig(value, fullKey));
-        }
-        else {
-            result[fullKey] = value;
-        }
-    }
-    return result;
-}

package/dist/ui/Confirm.js

@@ -1,62 +0,0 @@
-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 { Colors, getTextColor, Palette } from '../services/colors.js';
-import { useInput } from '../services/keyboard.js';
-import { UserQuery } from './UserQuery.js';
-export const ConfirmView = ({ message, state, status }) => {
-    const isActive = status === ComponentStatus.Active;
-    const { selectedIndex } = state;
-    const options = [
-        { label: 'yes', value: 'yes', color: Palette.BrightGreen },
-        { label: 'no', value: 'no', color: Colors.Status.Error },
-    ];
-    // Timeline rendering (Done status)
-    if (status === ComponentStatus.Done) {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Text, { color: undefined, children: message }) }), _jsxs(UserQuery, { children: ["> ", options[selectedIndex].label] })] }));
-    }
-    // Active/Pending rendering
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Text, { color: getTextColor(isActive), children: message }) }), _jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: Colors.Action.Select, children: ">" }), _jsx(Text, { children: " " }), _jsx(Box, { children: options.map((option, index) => {
-                            const isSelected = index === selectedIndex;
-                            return (_jsx(Box, { marginRight: 2, children: _jsx(Text, { color: isSelected ? option.color : undefined, dimColor: !isSelected, children: option.label }) }, option.value));
-                        }) })] })] }));
-};
-/**
- * Confirm controller: Manages yes/no selection
- */
-export function Confirm({ message, status, requestHandlers, onConfirmed, onCancelled, }) {
-    const isActive = status === ComponentStatus.Active;
-    const [selectedIndex, setSelectedIndex] = useState(0); // 0 = Yes, 1 = No
-    useInput((input, key) => {
-        if (!isActive)
-            return;
-        if (key.escape) {
-            // Escape: highlight "No" and cancel
-            const finalState = { selectedIndex: 1, confirmed: false };
-            requestHandlers.onCompleted(finalState);
-            onCancelled();
-        }
-        else if (key.tab) {
-            // Toggle between Yes (0) and No (1)
-            setSelectedIndex((prev) => (prev === 0 ? 1 : 0));
-        }
-        else if (key.return) {
-            // Confirm selection
-            const finalState = {
-                selectedIndex,
-                confirmed: true,
-            };
-            requestHandlers.onCompleted(finalState);
-            if (selectedIndex === 0) {
-                onConfirmed();
-            }
-            else {
-                onCancelled();
-            }
-        }
-    }, { isActive });
-    // Controller always renders View, passing current state
-    const state = { selectedIndex, confirmed: false };
-    return _jsx(ConfirmView, { message: message, state: state, status: status });
-}