prompt-language-shell 0.3.6 → 0.4.0

package/README.md

@@ -45,6 +45,12 @@ Your configuration is stored in `~/.plsrc` as a YAML file. Supported settings:
 - `anthropic.key` - Your API key
 - `anthropic.model` - The model to use
 
+## Skills
+
+You can extend `pls` with custom workflows by creating markdown files in `~/.pls/skills/`. Skills define domain-specific operations, parameters, and steps that guide both planning and execution of tasks.
+
+Your skills are referenced when planning requests, enabling `pls` to understand specific workflows, create and execute structured plans tailored to your environment.
+
 ## Development
 
 See [CLAUDE.md](./CLAUDE.md) for development guidelines and architecture.

package/dist/config/INTROSPECT.md

@@ -0,0 +1,139 @@
+## Overview
+
+You are the introspection execution component of "pls" (please), a professional
+command-line concierge. Your role is to **execute** the listing of available
+capabilities when a task with type "introspect" has been planned and confirmed.
+
+## Execution Flow
+
+This tool is invoked AFTER:
+1. PLAN detected an introspection request and created a task with type
+   "introspect"
+2. User reviewed and confirmed the plan
+3. The introspect task is now being executed
+
+Your task is to present available capabilities in a clear, organized list based
+on the confirmed task's parameters.
+
+## Input
+
+You will receive:
+- A task action describing what to list (e.g., "List available capabilities")
+- Optional params with a "filter" field if user requested filtered results
+  (e.g., params: { filter: "deployment" })
+
+## Task
+
+Present the concierge's capabilities as a list of tasks, each representing one
+capability.
+
+## Response Format
+
+Every response MUST include an introductory message before the capability list.
+
+**Critical rules:**
+- The message is MANDATORY - every single response must include one
+- NEVER repeat the same message - each response should use different wording
+- Must be a SINGLE sentence, maximum 64 characters (including the colon)
+- The message introduces the capabilities that follow
+- ALWAYS end the message with a colon (:)
+- Match the tone to the request (professional, helpful, clear)
+- **NEVER repeat keywords** - If the message uses "skills", the task action
+  must use different words like "capabilities" or "operations". If the message
+  uses "capabilities", the action must use "skills" or other alternatives.
+  Avoid redundancy between the message and task descriptions.
+
+**Correct examples:**
+- "Here are my capabilities:" (then use "skills" or "operations" in actions)
+- "I can help with these operations:" (then use "capabilities" or "skills")
+- "Here's what I can do:" (then use "capabilities", "skills", or "operations")
+- "These are my available skills:" (then use "capabilities" or "operations")
+- "Here's an overview of my capabilities:" (then use "skills" or "purposes")
+- "Here's what I can help you with:" (then use "skills" or "capabilities")
+
+## Capabilities Structure
+
+Present capabilities in two categories:
+
+### 1. Built-in Capabilities
+
+These are the core operations available to all users:
+
+- **CONFIG**: Configuration changes, settings updates
+- **PLAN**: Plan and structure tasks from natural language requests, breaking
+  them down into clear, actionable steps
+- **INTROSPECT**: List and describe available capabilities and skills
+- **ANSWER**: Answer questions, explain concepts, provide information
+- **EXECUTE**: Run shell commands, execute programs, process operations
+- **REPORT**: Generate summaries, create reports, display results
+
+### 2. User-Defined Skills
+
+If skills are provided in the "Available Skills" section below, include them
+in the response. For each skill:
+- Extract the skill name from the first heading (# Skill Name)
+- Extract a brief description from the Description or Overview section
+- Keep descriptions concise (1-2 lines maximum)
+- If the user specified a filter (e.g., "skills for deployment"), only include
+  skills whose name or description matches the filter
+
+## Task Definition Guidelines
+
+Create tasks with type "introspect" for each capability. Each task should:
+
+- **Action**: The capability name and a concise description
+  - Format: "CAPABILITY: Description"
+  - Examples:
+    - "PLAN: Break down requests into actionable steps"
+    - "EXECUTE: Run shell commands and process operations"
+    - "Deploy Application: Build and deploy to staging or production"
+- **Type**: Always use "introspect"
+- **Params**: Omit params field
+
+**Keep action descriptions concise, at most 64 characters.**
+
+## Filtering
+
+When the user specifies a filter (e.g., "skills for deployment", "what can you
+do with files"):
+1. Parse the filter keyword(s) from the request
+2. Match against skill names and descriptions (case-insensitive)
+3. Include built-in capabilities if they match the filter
+4. Only present capabilities that match the filter
+
+Examples:
+- "skills for deployment" → Only show skills with "deploy" in name/description
+- "what can you do with files" → Show EXECUTE and any file-related skills
+- "list all skills" → Show all built-in capabilities + all user skills
+
+## Examples
+
+### Example 1: List All Capabilities
+
+When user asks "list your skills", create an introductory message like "here
+are my capabilities:" followed by a task for each built-in capability: PLAN,
+INTROSPECT, ANSWER, EXECUTE, REPORT, and CONFIG. Each task uses type
+"introspect" with an action describing the capability.
+
+### Example 2: Filtered Skills
+
+When user asks "skills for deployment" and a "deploy app" skill exists, create
+an introductory message like "these skills match 'deployment':" followed by
+only the tasks that match the filter. In this case, show the deploy app skill
+with its description.
+
+### Example 3: With User Skills
+
+When user asks "what can you do" and user-defined skills like "process data"
+and "backup files" exist, create an introductory message like "i can help with
+these operations:" followed by all built-in capabilities plus the user-defined
+skills. Each capability and skill becomes a task with type "introspect".
+
+## Final Validation
+
+Before finalizing:
+1. Ensure every task has type "introspect"
+2. Verify action descriptions are concise (≤64 characters)
+3. Confirm the introductory message ends with a colon
+4. Check that filtering was applied correctly if specified
+5. Ensure no duplicate capabilities are listed

package/dist/config/PLAN.md

@@ -32,22 +32,25 @@ This message should introduce the PLAN, not the execution itself.
 **Critical rules:**
 - The message is MANDATORY - every single response must include one
 - NEVER repeat the same message - each response should use different wording
-- Must be a SINGLE sentence, maximum 64 characters (including the colon)
+- Must be a SINGLE sentence, maximum 64 characters (including punctuation)
 - The message introduces the plan/steps that follow, NOT the action itself
-- ALWAYS end the message with a colon (:)
+- ALWAYS end the message with a period (.)
 - Match the tone to the request (professional, helpful, reassuring)
 - Avoid formulaic patterns - vary your phrasing naturally
+- **Special case for introspect-only plans**: When ALL tasks are type
+  "introspect", use a message that acknowledges the user is asking about
+  capabilities. Avoid technical terms like "introspection".
 
 **Correct examples (introducing the plan):**
-- "Here is my plan:"
-- "Here's what I'll do:"
-- "Let me break this down:"
-- "I've planned the following steps:"
-- "Here's how I'll approach this:"
-- "Here are the steps I'll take:"
-- "This is my plan:"
-- "Let me outline the approach:"
-- "Here's the plan:"
+- "Here is my plan."
+- "Here's what I'll do."
+- "Let me break this down."
+- "I've planned the following steps."
+- "Here's how I'll approach this."
+- "Here are the steps I'll take."
+- "This is my plan."
+- "Let me outline the approach."
+- "Here's the plan."
 
 **DO NOT:**
 - Use the exact same phrase repeatedly
@@ -55,10 +58,10 @@ This message should introduce the PLAN, not the execution itself.
 - Include unnecessary pleasantries or apologies
 - Use the same sentence structure every time
 - Phrase it as if you're executing (use "plan" language, not "doing" language)
-- Forget the colon at the end
+- Forget the period at the end
 
 Remember: You are presenting a PLAN, not performing the action. The message
-should naturally lead into a list of planned steps. Always end with a colon.
+should naturally lead into a list of planned steps. Always end with a period.
 
 ## Skills Integration
 
@@ -230,16 +233,30 @@ Examples that should be aborted as offensive:
 
 **For requests with clear intent:**
 
-1. **Information requests** - Use "answer" type when request asks for
+1. **Introspection requests** - Use "introspect" type when request asks about
+   capabilities or skills:
+   - Verbs: "list skills", "show skills", "what can you do", "list
+     capabilities", "show capabilities", "what skills", "describe skills",
+     "flex", "show off"
+   - **Filtering**: If the request specifies a category, domain, or context
+     (e.g., "for deployment", "related to files", "about testing"), add a
+     params object with a filter field containing the specified context
+   - **IMPORTANT**: Introspection has HIGHER PRIORITY than "answer" for these
+     queries. If asking about capabilities/skills, use "introspect", NOT
+     "answer"
+
+2. **Information requests** - Use "answer" type when request asks for
    information:
    - Verbs: "explain", "answer", "describe", "tell me", "say", "what
      is", "how does"
    - Examples:
-     - "explain TypeScript" → type: "answer"
-     - "tell me about Docker" → type: "answer"
+     - "explain typescript" → type: "answer"
+     - "tell me about docker" → type: "answer"
      - "what is the current directory" → type: "answer"
+   - **Exception**: Questions about capabilities/skills should use
+     "introspect" instead
 
-2. **Skill-based requests** - Use skills when verb matches a defined skill:
+3. **Skill-based requests** - Use skills when verb matches a defined skill:
    - If "process" skill exists and user says "process" → Use the process skill
    - If "deploy" skill exists and user says "deploy" → Use the deploy skill
    - Extract steps from the matching skill and create tasks for each step
@@ -359,7 +376,10 @@ When creating task definitions, focus on:
   - `execute` - Shell commands, running programs, scripts, processing
     operations
   - `answer` - Answering questions, explaining concepts, providing
-    information
+    information (EXCEPT for capability/skill queries - use introspect)
+  - `introspect` - Listing available capabilities and skills when user
+    asks what the concierge can do. Include params { filter: "keyword" }
+    if user specifies a filter like "skills for deployment"
   - `report` - Generating summaries, creating reports, displaying
     results
   - `define` - Presenting skill-based options when request matches
@@ -367,7 +387,8 @@ When creating task definitions, focus on:
     (selecting ONE variant, ONE environment, ONE target), NOT sequences of
     steps. Each option represents a single selection that will later be
     expanded into individual sequential steps. NEVER bundle multiple steps
-    into a single option like "Process X, run validation, deploy Y".**
+    into a single option like "Process X, run validation, deploy Y". The
+    action text must ALWAYS end with a colon (:) to introduce the options.**
   - `ignore` - Request is too vague and cannot be mapped to skills or
     inferred from context
 
@@ -590,7 +611,7 @@ Split only when multiple distinct queries or operations are needed:
 Examples showing proper use of skills and disambiguation:
 
 - "process" with process skill requiring {TARGET} parameter (Alpha, Beta, Gamma,
-  Delta) → One task: type "define", action "Clarify which target to process",
+  Delta) → One task: type "define", action "Clarify which target to process:",
   params { options: ["Process Alpha", "Process Beta", "Process Gamma", "Process
   Delta"] }. NOTE: If variants have descriptions, format as "Process Alpha, the
   legacy version" NOT "Process Alpha (the legacy version)"
@@ -599,7 +620,7 @@ Examples showing proper use of skills and disambiguation:
   target generation script", "Run the Alpha processing pipeline"
 - "process all" with same process skill → Twelve tasks (3 steps × 4 targets)
 - "deploy" with deploy skill (staging, production, canary) → One task: type
-  "define", action "Clarify which environment to deploy to", params
+  "define", action "Clarify which environment to deploy to:", params
   { options: ["Deploy to staging environment", "Deploy to production
   environment", "Deploy to canary environment"] }
 - "deploy all" with deploy skill (staging, production) → Two tasks: one for

package/dist/index.js

@@ -20,6 +20,7 @@ const app = {
     version: packageJson.version,
     description: packageJson.description,
     isDev,
+    isDebug: false,
 };
 // Get command from command-line arguments
 const args = process.argv.slice(2);

package/dist/services/components.js

@@ -1,21 +1,11 @@
 import { randomUUID } from 'node:crypto';
 import { ComponentName } from '../types/types.js';
 import { AnthropicModel, isValidAnthropicApiKey, isValidAnthropicModel, } from './config.js';
+import { getConfirmationMessage } from './messages.js';
 import { StepType } from '../ui/Config.js';
 export function markAsDone(component) {
     return { ...component, state: { ...component.state, done: true } };
 }
-export function getRefiningMessage() {
-    const messages = [
-        'Let me work out the specifics for you.',
-        "I'll figure out the concrete steps.",
-        'Let me break this down into tasks.',
-        "I'll plan out the details.",
-        'Let me arrange the steps.',
-        "I'll prepare everything you need.",
-    ];
-    return messages[Math.floor(Math.random() * messages.length)];
-}
 export function createWelcomeDefinition(app) {
     return {
         id: randomUUID(),
@@ -123,6 +113,18 @@ export function createRefinement(text, onAborted) {
         },
     };
 }
+export function createConfirmDefinition(onConfirmed, onCancelled) {
+    return {
+        id: randomUUID(),
+        name: ComponentName.Confirm,
+        state: { done: false },
+        props: {
+            message: getConfirmationMessage(),
+            onConfirmed,
+            onCancelled,
+        },
+    };
+}
 export function isStateless(component) {
     return !('state' in component);
 }

package/dist/services/config.js

@@ -50,6 +50,14 @@ function validateConfig(parsed) {
     if (model && typeof model === 'string' && isValidAnthropicModel(model)) {
         validatedConfig.anthropic.model = model;
     }
+    // Optional settings section
+    if (config.settings && typeof config.settings === 'object') {
+        const settings = config.settings;
+        validatedConfig.settings = {};
+        if ('debug' in settings && typeof settings.debug === 'boolean') {
+            validatedConfig.settings.debug = settings.debug;
+        }
+    }
     return validatedConfig;
 }
 export function loadConfig() {
@@ -116,6 +124,18 @@ export function saveConfig(section, config) {
 export function saveAnthropicConfig(config) {
     saveConfig('anthropic', config);
 }
+export function saveDebugSetting(debug) {
+    saveConfig('settings', { debug });
+}
+export function loadDebugSetting() {
+    try {
+        const config = loadConfig();
+        return config.settings?.debug ?? false;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Returns a message requesting initial setup.
  * Provides natural language variations that sound like a professional concierge

package/dist/services/messages.js

@@ -0,0 +1,50 @@
+/**
+ * Returns a natural language confirmation message for plan execution.
+ * Randomly selects from variations to sound less robotic.
+ */
+export function getConfirmationMessage() {
+    const messages = [
+        'Should I execute this plan?',
+        'Do you want me to proceed with these tasks?',
+        'Ready to execute?',
+        'Shall I execute this plan?',
+        'Would you like me to run these tasks?',
+        'Execute this plan?',
+    ];
+    return messages[Math.floor(Math.random() * messages.length)];
+}
+/**
+ * Returns a refining message shown during plan refinement.
+ * Randomly selects from variations to sound natural.
+ */
+export function getRefiningMessage() {
+    const messages = [
+        'Let me work out the specifics for you.',
+        "I'll figure out the concrete steps.",
+        'Let me break this down into tasks.',
+        "I'll plan out the details.",
+        'Let me arrange the steps.',
+        "I'll prepare everything you need.",
+    ];
+    return messages[Math.floor(Math.random() * messages.length)];
+}
+/**
+ * Returns a cancellation message for the given operation.
+ * Randomly selects from variations to sound natural.
+ */
+export function getCancellationMessage(operation) {
+    const templates = [
+        `I've cancelled the ${operation.toLowerCase()}.`,
+        `I've aborted the ${operation.toLowerCase()}.`,
+        `The ${operation.toLowerCase()} was cancelled.`,
+        `The ${operation.toLowerCase()} has been aborted.`,
+    ];
+    return templates[Math.floor(Math.random() * templates.length)];
+}
+/**
+ * Feedback messages for various operations
+ */
+export const FeedbackMessages = {
+    ConfigurationComplete: 'Configuration complete.',
+    UnexpectedError: 'Unexpected error occurred:',
+};

package/dist/services/tool-registry.js

@@ -33,8 +33,13 @@ class ToolRegistry {
 // Create singleton instance
 export const toolRegistry = new ToolRegistry();
 // Register built-in tools
+import { introspectTool } from '../tools/introspect.tool.js';
 import { planTool } from '../tools/plan.tool.js';
 toolRegistry.register('plan', {
     schema: planTool,
     instructionsPath: 'config/PLAN.md',
 });
+toolRegistry.register('introspect', {
+    schema: introspectTool,
+    instructionsPath: 'config/INTROSPECT.md',
+});

package/dist/tools/introspect.tool.js

@@ -0,0 +1,32 @@
+export const introspectTool = {
+    name: 'introspect',
+    description: 'Execute a task with type "introspect" to list available capabilities and skills. Called after PLAN has identified an introspection request and user has confirmed. Takes the task action and optional filter parameter to present built-in capabilities and user-defined skills.',
+    input_schema: {
+        type: 'object',
+        properties: {
+            message: {
+                type: 'string',
+                description: 'Introductory reply to display before the capabilities list. Must be a single sentence, maximum 64 characters (including the colon at the end). Vary this naturally - try to use a different phrase each time. Always end with a colon.',
+            },
+            tasks: {
+                type: 'array',
+                description: 'Array of capabilities, each with type "introspect". Include built-in capabilities (PLAN, INTROSPECT, ANSWER, EXECUTE, REPORT, CONFIG) and user-defined skills from the Available Skills section.',
+                items: {
+                    type: 'object',
+                    properties: {
+                        action: {
+                            type: 'string',
+                            description: 'Capability name and description. Format: "NAME: Brief description". Maximum 64 characters. Examples: "PLAN: Break down requests into steps", "Deploy App: Build and deploy application".',
+                        },
+                        type: {
+                            type: 'string',
+                            description: 'Always "introspect" for capability listings.',
+                        },
+                    },
+                    required: ['action', 'type'],
+                },
+            },
+        },
+        required: ['message', 'tasks'],
+    },
+};

package/dist/tools/plan.tool.js

@@ -20,7 +20,7 @@ export const planTool = {
                         },
                         type: {
                             type: 'string',
-                            description: 'Type of task: "config" (settings), "plan" (planning), "execute" (shell/programs/finding files), "answer" (questions), "report" (summaries), "define" (skill-based disambiguation), "ignore" (too vague)',
+                            description: 'Type of task: "config" (settings), "plan" (planning), "execute" (shell/programs/finding files), "answer" (questions, NOT for capability queries), "introspect" (list capabilities/skills), "report" (summaries), "define" (skill-based disambiguation), "ignore" (too vague)',
                         },
                         params: {
                             type: 'object',

package/dist/types/colors.js

@@ -0,0 +1,90 @@
+import { FeedbackType, TaskType } from './types.js';
+/**
+ * Semantic color palette - colors organized by their purpose/meaning.
+ * Prefer adding semantic names here rather than to DescriptiveColors.
+ */
+export const Colors = {
+    Action: {
+        Execute: '#5aaa8a', // green
+        Discard: '#a85c3f', // dark orange
+        Select: '#5c8cbc', // steel blue
+    },
+    Status: {
+        Success: '#22aa22', // green
+        Error: '#cc5c5c', // red
+        Warning: '#cc9c5c', // orange
+        Info: '#5c9ccc', // cyan
+    },
+    Label: {
+        Default: '#ffffff', // white
+        Inactive: '#888888', // gray
+        Discarded: '#666666', // dark gray
+        Skipped: '#cccc5c', // yellow
+    },
+    Type: {
+        Config: '#5c9ccc', // cyan
+        Plan: '#5ccccc', // magenta
+        Execute: '#5aaa8a', // green
+        Answer: '#9c5ccc', // purple
+        Introspect: '#9c5ccc', // purple
+        Report: '#cc9c5c', // orange
+        Define: '#cc9c5c', // amber
+        Ignore: '#cc7a5c', // dark orange
+        Select: '#5c8cbc', // steel blue
+        Discard: '#a85c3f', // dark orange
+    },
+};
+/**
+ * Task-specific color mappings
+ */
+export const TaskColors = {
+    [TaskType.Config]: {
+        description: Colors.Label.Default,
+        type: Colors.Type.Config,
+    },
+    [TaskType.Plan]: {
+        description: Colors.Label.Default,
+        type: Colors.Type.Plan,
+    },
+    [TaskType.Execute]: {
+        description: Colors.Label.Default,
+        type: Colors.Type.Execute,
+    },
+    [TaskType.Answer]: {
+        description: Colors.Label.Default,
+        type: Colors.Type.Answer,
+    },
+    [TaskType.Introspect]: {
+        description: Colors.Label.Default,
+        type: Colors.Type.Introspect,
+    },
+    [TaskType.Report]: {
+        description: Colors.Label.Default,
+        type: Colors.Type.Report,
+    },
+    [TaskType.Define]: {
+        description: Colors.Label.Default,
+        type: Colors.Type.Define,
+    },
+    [TaskType.Ignore]: {
+        description: Colors.Label.Skipped,
+        type: Colors.Type.Ignore,
+    },
+    [TaskType.Select]: {
+        description: Colors.Label.Inactive,
+        type: Colors.Type.Select,
+    },
+    [TaskType.Discard]: {
+        description: Colors.Label.Discarded,
+        type: Colors.Type.Discard,
+    },
+};
+/**
+ * Feedback-specific color mappings
+ */
+export const FeedbackColors = {
+    [FeedbackType.Info]: Colors.Status.Info,
+    [FeedbackType.Succeeded]: Colors.Status.Success,
+    [FeedbackType.Aborted]: Colors.Status.Warning,
+    [FeedbackType.Failed]: Colors.Status.Error,
+};

package/dist/types/types.js

@@ -7,6 +7,7 @@ export var ComponentName;
     ComponentName["Plan"] = "plan";
     ComponentName["Refinement"] = "refinement";
     ComponentName["Feedback"] = "feedback";
+    ComponentName["Confirm"] = "confirm";
 })(ComponentName || (ComponentName = {}));
 export var TaskType;
 (function (TaskType) {
@@ -14,6 +15,7 @@ export var TaskType;
     TaskType["Plan"] = "plan";
     TaskType["Execute"] = "execute";
     TaskType["Answer"] = "answer";
+    TaskType["Introspect"] = "introspect";
     TaskType["Report"] = "report";
     TaskType["Define"] = "define";
     TaskType["Ignore"] = "ignore";

package/dist/ui/Column.js

@@ -1,6 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
 import { Box } from 'ink';
 import { Component } from './Component.js';
-export const Column = ({ items }) => {
-    return (_jsx(Box, { marginTop: 1, marginBottom: 1, marginLeft: 1, flexDirection: "column", gap: 1, children: items.map((item) => (_jsx(Box, { children: _jsx(Component, { def: item }) }, item.id))) }));
-};
+export const Column = React.memo(({ items, debug }) => {
+    return (_jsx(Box, { marginTop: 1, marginBottom: 1, marginLeft: 1, flexDirection: "column", gap: 1, children: items.map((item) => (_jsx(Box, { children: _jsx(Component, { def: item, debug: debug }) }, item.id))) }));
+});

package/dist/ui/Component.js

@@ -1,13 +1,15 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
 import { ComponentName } from '../types/types.js';
 import { Command } from './Command.js';
+import { Confirm } from './Confirm.js';
 import { Config } from './Config.js';
 import { Feedback } from './Feedback.js';
 import { Message } from './Message.js';
 import { Plan } from './Plan.js';
 import { Refinement } from './Refinement.js';
 import { Welcome } from './Welcome.js';
-export function Component({ def }) {
+export const Component = React.memo(function Component({ def, debug, }) {
     switch (def.name) {
         case ComponentName.Welcome:
             return _jsx(Welcome, { ...def.props });
@@ -22,7 +24,7 @@ export function Component({ def }) {
             return _jsx(Command, { ...props, state: state });
         }
         case ComponentName.Plan:
-            return _jsx(Plan, { ...def.props });
+            return _jsx(Plan, { ...def.props, debug: debug });
         case ComponentName.Feedback:
             return _jsx(Feedback, { ...def.props });
         case ComponentName.Message:
@@ -32,5 +34,10 @@ export function Component({ def }) {
             const state = def.state;
             return _jsx(Refinement, { ...props, state: state });
         }
+        case ComponentName.Confirm: {
+            const props = def.props;
+            const state = def.state;
+            return _jsx(Confirm, { ...props, state: state });
+        }
     }
-}
+});

package/dist/ui/Config.js

@@ -2,6 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from 'react';
 import { Box, Text, useFocus, useInput } from 'ink';
 import TextInput from 'ink-text-input';
+import { Colors } from '../types/colors.js';
 export var StepType;
 (function (StepType) {
     StepType["Text"] = "text";
@@ -43,7 +44,7 @@ function TextStep({ value, placeholder, validate, onChange, onSubmit, }) {
     }, { isActive: validationFailed });
     // When validation fails, show colored text
     if (validationFailed) {
-        return (_jsxs(Text, { color: "#cc5c5c", children: [inputValue || placeholder, isFocused && _jsx(Text, { inverse: true, children: " " })] }));
+        return (_jsxs(Text, { color: Colors.Status.Error, children: [inputValue || placeholder, isFocused && _jsx(Text, { inverse: true, children: " " })] }));
     }
     return (_jsx(TextInput, { value: inputValue, onChange: handleChange, onSubmit: handleSubmit, placeholder: placeholder }));
 }
@@ -216,6 +217,6 @@ export function Config({ steps, state, onFinished, onAborted }) {
             if (!shouldShow) {
                 return null;
             }
-            return (_jsxs(Box, { flexDirection: "column", marginTop: index === 0 ? 0 : 1, children: [_jsx(Box, { children: _jsxs(Text, { children: [stepConfig.description, ":"] }) }), _jsxs(Box, { children: [_jsx(Text, { children: " " }), _jsx(Text, { color: "#5c8cbc", dimColor: !isCurrentStep, children: ">" }), _jsx(Text, { children: " " }), renderStepInput(stepConfig, isCurrentStep)] })] }, stepConfig.key));
+            return (_jsxs(Box, { flexDirection: "column", marginTop: index === 0 ? 0 : 1, children: [_jsx(Box, { children: _jsxs(Text, { children: [stepConfig.description, ":"] }) }), _jsxs(Box, { children: [_jsx(Text, { children: " " }), _jsx(Text, { color: Colors.Action.Select, dimColor: !isCurrentStep, children: ">" }), _jsx(Text, { children: " " }), renderStepInput(stepConfig, isCurrentStep)] })] }, stepConfig.key));
         }) }));
 }

package/dist/ui/Confirm.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text, useInput } from 'ink';
+import { Colors } from '../types/colors.js';
+export function Confirm({ message, state, onConfirmed, onCancelled, }) {
+    const done = state?.done ?? false;
+    const [selectedIndex, setSelectedIndex] = React.useState(0); // 0 = Yes, 1 = No
+    useInput((input, key) => {
+        if (done)
+            return;
+        if (key.escape) {
+            // Escape: highlight "No" and cancel
+            setSelectedIndex(1);
+            onCancelled?.();
+        }
+        else if (key.tab) {
+            // Toggle between Yes (0) and No (1)
+            setSelectedIndex((prev) => (prev === 0 ? 1 : 0));
+        }
+        else if (key.return) {
+            // Confirm selection
+            if (selectedIndex === 0) {
+                onConfirmed?.();
+            }
+            else {
+                onCancelled?.();
+            }
+        }
+    }, { isActive: !done });
+    const options = [
+        { label: 'Yes', value: 'yes', color: Colors.Action.Execute },
+        { label: 'No', value: 'no', color: Colors.Action.Discard },
+    ];
+    if (done) {
+        // When done, show both the message and user's choice in timeline
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: message }) }), _jsx(Box, { children: _jsxs(Text, { color: "gray", children: ["> ", options[selectedIndex].label] }) })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: message }) }), _jsxs(Box, { 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, bold: isSelected, children: option.label }) }, option.value));
+                        }) })] })] }));
+}

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 { FeedbackColors } from '../types/colors.js';
 import { FeedbackType } from '../types/types.js';
 function getSymbol(type) {
     return {
@@ -9,25 +10,8 @@ function getSymbol(type) {
         [FeedbackType.Failed]: '✗',
     }[type];
 }
-function getSymbolColor(type) {
-    return {
-        [FeedbackType.Info]: '#5c9ccc', // cyan
-        [FeedbackType.Succeeded]: '#00aa00', // green
-        [FeedbackType.Aborted]: '#cc9c5c', // orange
-        [FeedbackType.Failed]: '#cc5c5c', // red
-    }[type];
-}
-function getMessageColor(type) {
-    return {
-        [FeedbackType.Info]: '#aaaaaa', // light grey
-        [FeedbackType.Succeeded]: '#5ccc5c', // green
-        [FeedbackType.Aborted]: '#cc9c5c', // orange
-        [FeedbackType.Failed]: '#cc5c5c', // red
-    }[type];
-}
 export function Feedback({ type, message }) {
-    const symbolColor = getSymbolColor(type);
-    const messageColor = getMessageColor(type);
+    const color = FeedbackColors[type];
     const symbol = getSymbol(type);
-    return (_jsxs(Box, { children: [_jsxs(Text, { color: symbolColor, children: [symbol, " "] }), _jsx(Text, { color: messageColor, children: message })] }));
+    return (_jsx(Box, { children: _jsxs(Text, { color: color, children: [symbol, " ", message] }) }));
 }

package/dist/ui/Label.js

@@ -1,6 +1,6 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { Separator } from './Separator.js';
-export function Label({ description, descriptionColor, type, typeColor, }) {
-    return (_jsxs(Box, { children: [_jsx(Text, { color: descriptionColor, children: description }), _jsx(Separator, {}), _jsx(Text, { color: typeColor, children: type })] }));
+export function Label({ description, descriptionColor, type, typeColor, showType = false, }) {
+    return (_jsxs(Box, { children: [_jsx(Text, { color: descriptionColor, children: description }), showType && (_jsxs(_Fragment, { children: [_jsx(Separator, {}), _jsx(Text, { color: typeColor, children: type })] }))] }));
 }

package/dist/ui/List.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { Label } from './Label.js';
-export const List = ({ items, level = 0, highlightedIndex = null, highlightedParentIndex = null, }) => {
+export const List = ({ items, level = 0, highlightedIndex = null, highlightedParentIndex = null, showType = false, }) => {
     const marginLeft = level > 0 ? 4 : 0;
     return (_jsx(Box, { flexDirection: "column", marginLeft: marginLeft, children: items.map((item, index) => {
             // At level 0, track which parent is active for child highlighting
@@ -16,6 +16,11 @@ export const List = ({ items, level = 0, highlightedIndex = null, highlightedPar
             const typeColor = isHighlighted && item.type.highlightedColor
                 ? item.type.highlightedColor
                 : item.type.color;
-            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "whiteBright", children: marker }), _jsx(Label, { description: item.description.text, descriptionColor: descriptionColor, type: item.type.text, typeColor: typeColor })] }), item.children && item.children.length > 0 && (_jsx(List, { items: item.children, level: level + 1, highlightedIndex: shouldHighlightChildren ? highlightedIndex : null }))] }, index));
+            // Use highlighted type color for arrow markers when highlighted
+            const markerColor = item.markerColor ||
+                (isHighlighted && item.type.highlightedColor
+                    ? item.type.highlightedColor
+                    : 'whiteBright');
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: markerColor, children: marker }), _jsx(Label, { description: item.description.text, descriptionColor: descriptionColor, type: item.type.text, typeColor: typeColor, showType: showType })] }), item.children && item.children.length > 0 && (_jsx(List, { items: item.children, level: level + 1, highlightedIndex: shouldHighlightChildren ? highlightedIndex : null, showType: showType }))] }, index));
         }) }));
 };

package/dist/ui/Main.js

@@ -1,9 +1,11 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
+import { useInput } from 'ink';
 import { ComponentName, FeedbackType, TaskType, } from '../types/types.js';
 import { createAnthropicService, } from '../services/anthropic.js';
-import { getConfigurationRequiredMessage, hasValidAnthropicKey, loadConfig, saveAnthropicConfig, } from '../services/config.js';
-import { createCommandDefinition, createConfigDefinition, createFeedback, createMessage, createRefinement, createPlanDefinition, createWelcomeDefinition, getRefiningMessage, isStateless, markAsDone, } from '../services/components.js';
+import { getConfigurationRequiredMessage, hasValidAnthropicKey, loadConfig, loadDebugSetting, saveAnthropicConfig, saveDebugSetting, } from '../services/config.js';
+import { FeedbackMessages, getCancellationMessage, getRefiningMessage, } from '../services/messages.js';
+import { createCommandDefinition, createConfirmDefinition, createConfigDefinition, createFeedback, createMessage, createRefinement, createPlanDefinition, createWelcomeDefinition, isStateless, markAsDone, } from '../services/components.js';
 import { exitApp } from '../services/process.js';
 import { Column } from './Column.js';
 export const Main = ({ app, command }) => {
@@ -17,6 +19,23 @@ export const Main = ({ app, command }) => {
     });
     const [timeline, setTimeline] = React.useState([]);
     const [queue, setQueue] = React.useState([]);
+    const [isDebug, setIsDebug] = React.useState(() => loadDebugSetting());
+    // Use ref to track latest timeline for callbacks
+    const timelineRef = React.useRef(timeline);
+    React.useEffect(() => {
+        timelineRef.current = timeline;
+    }, [timeline]);
+    // Top-level Shift+Tab handler for debug mode toggle
+    // Child components must ignore Shift+Tab to prevent conflicts
+    useInput((input, key) => {
+        if (key.shift && key.tab) {
+            setIsDebug((prev) => {
+                const newValue = !prev;
+                saveDebugSetting(newValue);
+                return newValue;
+            });
+        }
+    }, { isActive: true });
     const addToTimeline = React.useCallback((...items) => {
         setTimeline((timeline) => [...timeline, ...items]);
     }, []);
@@ -39,7 +58,7 @@ export const Main = ({ app, command }) => {
                 return currentQueue;
             const [first] = currentQueue;
             if (first.name === ComponentName.Command) {
-                addToTimeline(markAsDone(first), createFeedback(FeedbackType.Failed, 'Unexpected error occurred:', error));
+                addToTimeline(markAsDone(first), createFeedback(FeedbackType.Failed, FeedbackMessages.UnexpectedError, error));
             }
             exitApp(1);
             return [];
@@ -51,7 +70,7 @@ export const Main = ({ app, command }) => {
                 return currentQueue;
             const [first] = currentQueue;
             if (!isStateless(first)) {
-                addToTimeline(markAsDone(first), createFeedback(FeedbackType.Aborted, `${operationName} was aborted by user`));
+                addToTimeline(markAsDone(first), createFeedback(FeedbackType.Aborted, getCancellationMessage(operationName)));
             }
             exitApp(0);
             return [];
@@ -63,12 +82,59 @@ export const Main = ({ app, command }) => {
     const handlePlanAborted = React.useCallback(() => {
         handleAborted('Task selection');
     }, [handleAborted]);
+    const createPlanAbortHandler = React.useCallback((tasks) => {
+        const allIntrospect = tasks.every((task) => task.type === TaskType.Introspect);
+        if (allIntrospect) {
+            return () => handleAborted('Introspection');
+        }
+        return handlePlanAborted;
+    }, [handleAborted, handlePlanAborted]);
     const handleCommandAborted = React.useCallback(() => {
         handleAborted('Request');
     }, [handleAborted]);
     const handleRefinementAborted = React.useCallback(() => {
         handleAborted('Plan refinement');
     }, [handleAborted]);
+    const handleExecutionConfirmed = React.useCallback(() => {
+        setQueue((currentQueue) => {
+            if (currentQueue.length === 0)
+                return currentQueue;
+            const [first] = currentQueue;
+            if (first.name === ComponentName.Confirm) {
+                addToTimeline(markAsDone(first));
+            }
+            exitApp(0);
+            return [];
+        });
+    }, [addToTimeline]);
+    const handleExecutionCancelled = React.useCallback(() => {
+        setQueue((currentQueue) => {
+            if (currentQueue.length === 0)
+                return currentQueue;
+            const [first] = currentQueue;
+            if (first.name === ComponentName.Confirm) {
+                // Find the most recent Plan in timeline to check task types
+                const currentTimeline = timelineRef.current;
+                const lastPlanIndex = [...currentTimeline]
+                    .reverse()
+                    .findIndex((item) => item.name === ComponentName.Plan);
+                const lastPlan = lastPlanIndex >= 0
+                    ? currentTimeline[currentTimeline.length - 1 - lastPlanIndex]
+                    : null;
+                const allIntrospect = lastPlan &&
+                    lastPlan.name === ComponentName.Plan &&
+                    'props' in lastPlan &&
+                    lastPlan.props &&
+                    'tasks' in lastPlan.props &&
+                    Array.isArray(lastPlan.props.tasks) &&
+                    lastPlan.props.tasks.every((task) => task.type === TaskType.Introspect);
+                const operation = allIntrospect ? 'introspection' : 'execution';
+                addToTimeline(markAsDone(first), createFeedback(FeedbackType.Aborted, getCancellationMessage(operation)));
+            }
+            exitApp(0);
+            return [];
+        });
+    }, [addToTimeline]);
     const handlePlanSelectionConfirmed = React.useCallback(async (selectedTasks) => {
         // Mark current plan as done and add refinement to queue
         let refinementDef = null;
@@ -101,10 +167,11 @@ export const Main = ({ app, command }) => {
                 }
                 return [];
             });
-            // Show final execution plan
-            const planDefinition = createPlanDefinition(result.message, result.tasks, handlePlanAborted, undefined);
+            // Show final execution plan with confirmation
+            const planDefinition = createPlanDefinition(result.message, result.tasks, createPlanAbortHandler(result.tasks), undefined);
+            const confirmDefinition = createConfirmDefinition(handleExecutionConfirmed, handleExecutionCancelled);
             addToTimeline(planDefinition);
-            exitApp(0);
+            setQueue([confirmDefinition]);
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
@@ -116,10 +183,17 @@ export const Main = ({ app, command }) => {
                 }
                 return [];
             });
-            addToTimeline(createFeedback(FeedbackType.Failed, 'Unexpected error occurred:', errorMessage));
+            addToTimeline(createFeedback(FeedbackType.Failed, FeedbackMessages.UnexpectedError, errorMessage));
             exitApp(1);
         }
-    }, [addToTimeline, service, handleRefinementAborted]);
+    }, [
+        addToTimeline,
+        service,
+        handleRefinementAborted,
+        createPlanAbortHandler,
+        handleExecutionConfirmed,
+        handleExecutionCancelled,
+    ]);
     const handleCommandComplete = React.useCallback((message, tasks) => {
         setQueue((currentQueue) => {
             if (currentQueue.length === 0)
@@ -128,23 +202,29 @@ export const Main = ({ app, command }) => {
             // Check if tasks contain a Define task that requires user interaction
             const hasDefineTask = tasks.some((task) => task.type === TaskType.Define);
             if (first.name === ComponentName.Command) {
-                const planDefinition = createPlanDefinition(message, tasks, handlePlanAborted, hasDefineTask ? handlePlanSelectionConfirmed : undefined);
+                const planDefinition = createPlanDefinition(message, tasks, createPlanAbortHandler(tasks), hasDefineTask ? handlePlanSelectionConfirmed : undefined);
                 if (hasDefineTask) {
                     // Don't exit - keep the plan in the queue for interaction
                     addToTimeline(markAsDone(first));
                     return [planDefinition];
                 }
                 else {
-                    // No define task - add plan to timeline and exit
+                    // No define task - show plan and confirmation
+                    const confirmDefinition = createConfirmDefinition(handleExecutionConfirmed, handleExecutionCancelled);
                     addToTimeline(markAsDone(first), planDefinition);
-                    exitApp(0);
-                    return [];
+                    return [confirmDefinition];
                 }
             }
             exitApp(0);
             return [];
         });
-    }, [addToTimeline, handlePlanSelectionConfirmed]);
+    }, [
+        addToTimeline,
+        createPlanAbortHandler,
+        handlePlanSelectionConfirmed,
+        handleExecutionConfirmed,
+        handleExecutionCancelled,
+    ]);
     const handleConfigFinished = React.useCallback((config) => {
         const anthropicConfig = config;
         saveAnthropicConfig(anthropicConfig);
@@ -156,7 +236,7 @@ export const Main = ({ app, command }) => {
                 return currentQueue;
             const [first, ...rest] = currentQueue;
             if (first.name === ComponentName.Config) {
-                addToTimeline(markAsDone(first), createFeedback(FeedbackType.Succeeded, 'Configuration complete'));
+                addToTimeline(markAsDone(first), createFeedback(FeedbackType.Succeeded, FeedbackMessages.ConfigurationComplete));
             }
             // Add command to queue if we have one
             if (command) {
@@ -203,7 +283,13 @@ export const Main = ({ app, command }) => {
     React.useEffect(() => {
         processNextInQueue();
     }, [queue, processNextInQueue]);
+    // Exit when queue is empty and timeline has content (all stateless components done)
+    React.useEffect(() => {
+        if (queue.length === 0 && timeline.length > 0) {
+            exitApp(0);
+        }
+    }, [queue, timeline]);
     const current = queue.length > 0 ? queue[0] : null;
-    const items = [...timeline, ...(current ? [current] : [])];
-    return _jsx(Column, { items: items });
+    const items = React.useMemo(() => [...timeline, ...(current ? [current] : [])], [timeline, current]);
+    return _jsx(Column, { items: items, debug: isDebug });
 };

package/dist/ui/Plan.js

@@ -1,59 +1,23 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import { Box, useInput } from 'ink';
+import { TaskColors } from '../types/colors.js';
 import { TaskType } from '../types/types.js';
 import { Label } from './Label.js';
 import { List } from './List.js';
-const ColorPalette = {
-    [TaskType.Config]: {
-        description: '#ffffff', // white
-        type: '#5c9ccc', // cyan
-    },
-    [TaskType.Plan]: {
-        description: '#ffffff', // white
-        type: '#5ccccc', // magenta
-    },
-    [TaskType.Execute]: {
-        description: '#ffffff', // white
-        type: '#4a9a7a', // green
-    },
-    [TaskType.Answer]: {
-        description: '#ffffff', // white
-        type: '#9c5ccc', // purple
-    },
-    [TaskType.Report]: {
-        description: '#ffffff', // white
-        type: '#cc9c5c', // orange
-    },
-    [TaskType.Define]: {
-        description: '#ffffff', // white
-        type: '#cc9c5c', // amber
-    },
-    [TaskType.Ignore]: {
-        description: '#cccc5c', // yellow
-        type: '#cc7a5c', // orange
-    },
-    [TaskType.Select]: {
-        description: '#888888', // grey
-        type: '#5c8cbc', // steel blue
-    },
-    [TaskType.Discard]: {
-        description: '#666666', // dark grey
-        type: '#a85c3f', // dark orange
-    },
-};
 function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutSelection = false) {
     const item = {
         description: {
             text: task.action,
-            color: ColorPalette[task.type].description,
+            color: TaskColors[task.type].description,
         },
-        type: { text: task.type, color: ColorPalette[task.type].type },
+        type: { text: task.type, color: TaskColors[task.type].type },
         children: [],
     };
     // Mark define tasks with right arrow when no selection has been made
     if (isDefineTaskWithoutSelection) {
         item.marker = '  → ';
+        item.markerColor = TaskColors[TaskType.Plan].type;
     }
     // Add children for Define tasks with options
     if (task.type === TaskType.Define && Array.isArray(task.params?.options)) {
@@ -65,24 +29,24 @@ function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutS
                 childType =
                     index === highlightedChildIndex ? TaskType.Execute : TaskType.Discard;
             }
-            const colors = ColorPalette[childType];
+            const colors = TaskColors[childType];
             return {
                 description: {
                     text: String(option),
                     color: colors.description,
-                    highlightedColor: ColorPalette[TaskType.Plan].description,
+                    highlightedColor: TaskColors[TaskType.Plan].description,
                 },
                 type: {
                     text: childType,
                     color: colors.type,
-                    highlightedColor: ColorPalette[TaskType.Plan].type,
+                    highlightedColor: TaskColors[TaskType.Plan].type,
                 },
             };
         });
     }
     return item;
 }
-export function Plan({ message, tasks, state, onSelectionConfirmed, onAborted, }) {
+export function Plan({ message, tasks, state, debug = false, onSelectionConfirmed, onAborted, }) {
     const [highlightedIndex, setHighlightedIndex] = useState(state?.highlightedIndex ?? null);
     const [currentDefineGroupIndex, setCurrentDefineGroupIndex] = useState(state?.currentDefineGroupIndex ?? 0);
     const [completedSelections, setCompletedSelections] = useState(state?.completedSelections ?? []);
@@ -208,5 +172,5 @@ export function Plan({ message, tasks, state, onSelectionConfirmed, onAborted, }
             !isDone;
         return taskToListItem(task, childIndex, isDefineWithoutSelection);
     });
-    return (_jsxs(Box, { flexDirection: "column", children: [message && (_jsx(Box, { marginBottom: 1, children: _jsx(Label, { description: message, descriptionColor: ColorPalette[TaskType.Plan].description, type: TaskType.Plan, typeColor: ColorPalette[TaskType.Plan].type }) })), _jsx(List, { items: listItems, highlightedIndex: currentDefineTaskIndex >= 0 ? highlightedIndex : null, highlightedParentIndex: currentDefineTaskIndex })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [message && (_jsx(Box, { marginBottom: 1, children: _jsx(Label, { description: message, descriptionColor: TaskColors[TaskType.Plan].description, type: TaskType.Plan, typeColor: TaskColors[TaskType.Plan].type, showType: debug }) })), _jsx(List, { items: listItems, highlightedIndex: currentDefineTaskIndex >= 0 ? highlightedIndex : null, highlightedParentIndex: currentDefineTaskIndex, showType: debug })] }));
 }

package/dist/ui/Separator.js

@@ -1,6 +1,7 @@
 import { jsxs as _jsxs } from "react/jsx-runtime";
 import { Text } from 'ink';
-export const Separator = ({ color = '#666666', spaces = 1, }) => {
+import { Colors } from '../types/colors.js';
+export const Separator = ({ color = Colors.Label.Discarded, spaces = 1, }) => {
     const spacing = ' '.repeat(spaces);
     return (_jsxs(Text, { color: color, children: [spacing, "\u203A", spacing] }));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prompt-language-shell",
-  "version": "0.3.6",
+  "version": "0.4.0",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",
@@ -46,22 +46,22 @@
   },
   "homepage": "https://github.com/aswitalski/pls#readme",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.68.0",
-    "ink": "^6.4.0",
+    "@anthropic-ai/sdk": "^0.69.0",
+    "ink": "^6.5.0",
     "ink-text-input": "^6.0.0",
     "react": "^19.2.0",
     "yaml": "^2.8.1"
   },
   "devDependencies": {
-    "@types/node": "^20.10.6",
-    "@types/react": "^19.2.2",
-    "@vitest/coverage-v8": "^4.0.8",
-    "eslint": "^9.17.0",
+    "@types/node": "^24.10.1",
+    "@types/react": "^19.2.5",
+    "@vitest/coverage-v8": "^4.0.9",
+    "eslint": "^9.39.1",
     "husky": "^9.1.7",
     "ink-testing-library": "^4.0.0",
     "prettier": "^3.6.2",
-    "typescript": "^5.3.3",
-    "typescript-eslint": "^8.19.1",
-    "vitest": "^4.0.5"
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.46.4",
+    "vitest": "^4.0.9"
   }
 }