prompt-language-shell 0.9.8 → 1.0.0

package/dist/services/router.js

@@ -8,6 +8,20 @@ import { saveConfigLabels } from '../configuration/labels.js';
 import { createAnswer, createConfig, createConfirm, createExecute, createFeedback, createIntrospect, createSchedule, createValidate, } from './components.js';
 import { getCancellationMessage, getConfirmationMessage, getUnknownRequestMessage, } from './messages.js';
 import { validateExecuteTasks } from './validator.js';
+/**
+ * Task Routing Architecture
+ *
+ * Flow: Command -> SCHEDULE -> routeTasksWithConfirm() -> extractTaskGroups()
+ *       -> routeAllGroups() -> routeGroupTasks() -> Workflow queue
+ *
+ * Key Concepts:
+ * - TaskGroup: Logical grouping for sequential processing
+ * - Routing Category: Determines which tasks can be grouped together
+ * - Two-Phase Routing: Config/Introspect first, then Execute/Answer
+ *
+ * Isolation Principle: Explicit Group tasks always become their own
+ * TaskGroup, preventing cross-contamination between user-defined groups.
+ */
 /**
  * Flatten inner task structure completely - removes all nested groups.
  * Used internally to flatten subtasks within a top-level group.
@@ -92,10 +106,10 @@ export function getOperationName(tasks) {
 export function routeTasksWithConfirm(tasks, message, service, userRequest, lifecycleHandlers, workflowHandlers, requestHandlers, hasDefineTask = false) {
     if (tasks.length === 0)
         return;
-    // Filter out ignore and discard tasks early
-    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) {
+    // Check executable tasks (ignore/discard are shown but not executed)
+    const executableTasks = tasks.filter((task) => task.type !== TaskType.Ignore && task.type !== TaskType.Discard);
+    // Check if no executable tasks remain after filtering
+    if (executableTasks.length === 0) {
         // Use action from first ignore task if available, otherwise generic message
         const ignoreTask = tasks.find((task) => task.type === TaskType.Ignore);
         const message = ignoreTask?.action
@@ -104,7 +118,7 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, life
         workflowHandlers.addToQueue(createFeedback({ type: FeedbackType.Warning, message }));
         return;
     }
-    const operation = getOperationName(validTasks);
+    const operation = getOperationName(executableTasks);
     // Create routing context for downstream functions
     const context = {
         service,
@@ -115,7 +129,8 @@ 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 = createSchedule({ message, tasks: validTasks });
+        // Show all tasks (including ignore) for display
+        const scheduleDefinition = createSchedule({ message, tasks });
         workflowHandlers.addToQueue(scheduleDefinition);
     }
     else {
@@ -123,9 +138,10 @@ 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)
+        // Show all tasks (including ignore) for display
         const scheduleDefinition = createSchedule({
             message,
-            tasks: validTasks,
+            tasks,
             onSelectionConfirmed: () => {
                 // Schedule completed - add Confirm to queue
                 const confirmDefinition = createConfirm({
@@ -133,7 +149,8 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, life
                     onConfirmed: () => {
                         // User confirmed - complete both Confirm and Schedule, then route
                         lifecycleHandlers.completeActiveAndPending();
-                        executeTasksAfterConfirm(validTasks, context);
+                        // Only execute non-ignore/non-discard tasks
+                        executeTasksAfterConfirm(executableTasks, context);
                     },
                     onCancelled: () => {
                         // User cancelled - complete both Confirm and Schedule, then show cancellation
@@ -230,88 +247,187 @@ function executeTasksAfterConfirm(tasks, context) {
     routeTasksAfterConfig(flatTasks, context);
 }
 /**
- * Task types that should appear in the upcoming display
+ * Collect action names for upcoming display.
+ * All task types are shown so users see the full queue of work ahead.
  */
-const UPCOMING_TASK_TYPES = [TaskType.Execute, TaskType.Answer, TaskType.Group];
+function collectUpcomingNames(tasks) {
+    return tasks.map((t) => t.action);
+}
 /**
- * Collect action names for tasks that appear in upcoming display.
- * Groups are included with their group name (not individual subtask names).
+ * Get the routing category for a task type.
+ * Tasks in the same category can be grouped together.
+ * Config and Introspect are special categories that should be isolated.
  */
-function collectUpcomingNames(tasks) {
-    return tasks
-        .filter((t) => UPCOMING_TASK_TYPES.includes(t.type))
-        .map((t) => t.action);
+export function getRoutingCategory(task) {
+    // Groups with subtasks get their own category (based on subtask types)
+    if (task.type === TaskType.Group &&
+        task.subtasks &&
+        task.subtasks.length > 0) {
+        // Check what types of subtasks this group has
+        const hasConfig = task.subtasks.some((t) => t.type === TaskType.Config);
+        const hasIntrospect = task.subtasks.some((t) => t.type === TaskType.Introspect);
+        const hasExecute = task.subtasks.some((t) => t.type === TaskType.Execute);
+        const hasAnswer = task.subtasks.some((t) => t.type === TaskType.Answer);
+        // Mixed types get unique category to ensure isolation
+        const typeCount = (hasConfig ? 1 : 0) +
+            (hasIntrospect ? 1 : 0) +
+            (hasExecute ? 1 : 0) +
+            (hasAnswer ? 1 : 0);
+        if (typeCount > 1) {
+            return `mixed:${task.action}`;
+        }
+        // Single type groups use that type's category
+        if (hasConfig)
+            return 'config';
+        if (hasIntrospect)
+            return 'introspect';
+        if (hasExecute)
+            return 'execute';
+        if (hasAnswer)
+            return 'answer';
+        return 'group';
+    }
+    // Standalone tasks use their type as category
+    switch (task.type) {
+        case TaskType.Config:
+            return 'config';
+        case TaskType.Introspect:
+            return 'introspect';
+        case TaskType.Execute:
+            return 'execute';
+        case TaskType.Answer:
+            return 'answer';
+        default:
+            return task.type;
+    }
 }
 /**
- * Route tasks after config is complete (or when no config is needed)
- * Processes task list, routing each task type to its handler.
- * Top-level groups are preserved: their subtasks are routed with the group name.
- * Config tasks are grouped together; Execute/Answer are routed individually.
+ * Extract logical task groups from a flat task list.
+ * Each explicit Group (TaskType.Group) becomes its own TaskGroup for isolation.
+ * Consecutive standalone tasks of the same routing category are grouped together.
  */
-function routeTasksAfterConfig(tasks, context) {
-    if (tasks.length === 0)
-        return;
-    // Collect all upcoming names for display (Execute, Answer, and Group tasks)
-    const allUpcomingNames = collectUpcomingNames(tasks);
-    let upcomingIndex = 0;
-    // Task types that should be grouped together (one component for all tasks)
-    const groupedTypes = [TaskType.Config, TaskType.Introspect];
-    // Route grouped task types together (collect from all tasks including subtasks)
-    for (const groupedType of groupedTypes) {
-        const typeTasks = [];
-        for (const task of tasks) {
-            if (task.type === groupedType) {
-                typeTasks.push(task);
+export function extractTaskGroups(tasks) {
+    const groups = [];
+    let currentGroup = null;
+    let currentCategory = null;
+    for (const task of tasks) {
+        // Skip empty groups
+        if (task.type === TaskType.Group &&
+            (!task.subtasks || task.subtasks.length === 0)) {
+            continue;
+        }
+        // Explicit Groups always become their own TaskGroup for isolation
+        if (task.type === TaskType.Group) {
+            // Save current group if exists
+            if (currentGroup !== null) {
+                groups.push(currentGroup);
+                currentGroup = null;
+                currentCategory = null;
             }
-            else if (task.type === TaskType.Group && task.subtasks) {
-                typeTasks.push(...task.subtasks.filter((t) => t.type === groupedType));
+            // Create standalone TaskGroup for this Group
+            groups.push({
+                name: task.action,
+                tasks: [task],
+            });
+            continue;
+        }
+        const category = getRoutingCategory(task);
+        // Start new group when category changes (or first task)
+        if (currentGroup === null || category !== currentCategory) {
+            if (currentGroup !== null) {
+                groups.push(currentGroup);
             }
+            currentGroup = {
+                name: task.action,
+                tasks: [task],
+            };
+            currentCategory = category;
         }
-        if (typeTasks.length > 0) {
-            routeTasksByType(groupedType, typeTasks, context, []);
+        else {
+            // Same category - add to current group
+            currentGroup.tasks.push(task);
         }
     }
-    // Process Execute, Answer, and Group tasks individually (with upcoming support)
+    // Don't forget the last group
+    if (currentGroup !== null) {
+        groups.push(currentGroup);
+    }
+    return groups;
+}
+/**
+ * Route all groups in order, calculating correct upcoming for each.
+ * Groups are processed sequentially by the Workflow's queue mechanism.
+ */
+function routeAllGroups(groups, context) {
+    for (let i = 0; i < groups.length; i++) {
+        const group = groups[i];
+        // Calculate upcoming from LATER groups (not current group)
+        const laterGroups = groups.slice(i + 1);
+        const laterUpcoming = laterGroups.flatMap((g) => collectUpcomingNames(g.tasks));
+        // Route this group's tasks with upcoming from later groups
+        routeGroupTasks(group, context, laterUpcoming);
+    }
+}
+/**
+ * Route all tasks within a single group in the order received from LLM.
+ * Standalone tasks become individual components.
+ * Group subtasks are batched by type (Execute subtasks together, etc.).
+ */
+function routeGroupTasks(group, context, groupUpcoming) {
+    const tasks = group.tasks;
+    const withinGroupUpcoming = collectUpcomingNames(tasks);
     for (let i = 0; i < tasks.length; i++) {
         const task = tasks[i];
         const taskType = task.type;
-        // Skip grouped task types (already routed above)
-        if (groupedTypes.includes(taskType))
-            continue;
+        // Calculate upcoming: remaining tasks in this group + tasks from later groups
+        const remainingInGroup = withinGroupUpcoming.slice(i + 1);
+        const taskUpcoming = [...remainingInGroup, ...groupUpcoming];
+        // Handle Group tasks with subtasks - batch subtasks by type
         if (taskType === TaskType.Group && task.subtasks) {
-            // Route group's subtasks - Execute tasks get group label, others routed normally
-            const upcoming = allUpcomingNames.slice(upcomingIndex + 1);
-            upcomingIndex++;
-            // Separate subtasks by type
+            // Batch Execute subtasks together (sent to LLM as single request)
             const executeSubtasks = task.subtasks.filter((t) => t.type === TaskType.Execute);
-            const answerSubtasks = task.subtasks.filter((t) => t.type === TaskType.Answer);
-            // Route Execute subtasks with group name as label
             if (executeSubtasks.length > 0) {
-                routeExecuteTasks(executeSubtasks, context, upcoming, task.action);
+                routeExecuteTasks(executeSubtasks, context, taskUpcoming, task.action);
             }
-            // Route Answer subtasks individually
+            // Route Answer subtasks (each becomes its own component)
+            const answerSubtasks = task.subtasks.filter((t) => t.type === TaskType.Answer);
             if (answerSubtasks.length > 0) {
-                routeAnswerTasks(answerSubtasks, context, upcoming);
+                routeAnswerTasks(answerSubtasks, context, taskUpcoming);
+            }
+            // Route other subtask types individually
+            for (const subtask of task.subtasks) {
+                if (subtask.type !== TaskType.Execute &&
+                    subtask.type !== TaskType.Answer) {
+                    routeTasksByType(subtask.type, [subtask], context, taskUpcoming);
+                }
             }
         }
         else if (taskType === TaskType.Execute) {
-            // Calculate upcoming for this Execute task
-            const upcoming = allUpcomingNames.slice(upcomingIndex + 1);
-            upcomingIndex++;
-            routeExecuteTasks([task], context, upcoming);
+            routeExecuteTasks([task], context, taskUpcoming);
         }
         else if (taskType === TaskType.Answer) {
-            // Calculate upcoming for this Answer task
-            const upcoming = allUpcomingNames.slice(upcomingIndex + 1);
-            upcomingIndex++;
-            routeTasksByType(taskType, [task], context, upcoming);
+            routeAnswerTasks([task], context, taskUpcoming);
         }
         else {
-            // For other types (Report, etc.), route without upcoming
-            routeTasksByType(taskType, [task], context, []);
+            routeTasksByType(taskType, [task], context, taskUpcoming);
         }
     }
 }
+/**
+ * Route tasks after config is complete (or when no config is needed)
+ * Processes task groups in order - groups with different task types are
+ * kept separate to ensure proper lifecycle handling.
+ */
+function routeTasksAfterConfig(tasks, context) {
+    if (tasks.length === 0)
+        return;
+    // Extract logical task groups
+    const groups = extractTaskGroups(tasks);
+    if (groups.length === 0)
+        return;
+    // Route all groups in order
+    routeAllGroups(groups, context);
+}
 /**
  * Route Answer tasks - creates separate Answer component for each question
  */
@@ -335,48 +451,60 @@ function routeIntrospectTasks(tasks, context, _upcoming) {
     context.workflowHandlers.addToQueue(createIntrospect({ tasks, service: context.service }));
 }
 /**
- * Route Config tasks - extracts keys, caches labels, creates Config component
+ * Route Config tasks - extracts keys or uses query, creates Config component
  */
 function routeConfigTasks(tasks, context, _upcoming) {
+    // Extract specific keys from task params
     const configKeys = tasks
         .map((task) => task.params?.key)
         .filter((key) => key !== undefined);
-    // Extract and cache labels from task descriptions
-    // Only cache labels for dynamically discovered keys (not in schema)
-    const schema = getConfigSchema();
-    const labels = {};
-    for (const task of tasks) {
-        const key = task.params?.key;
-        if (key && task.action && !(key in schema)) {
-            labels[key] = task.action;
+    // Handler for saving config values
+    const onFinished = (config) => {
+        try {
+            const configBySection = unflattenConfig(config);
+            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);
+        }
+    };
+    const onAborted = (operation) => {
+        context.requestHandlers.onAborted(operation);
+    };
+    if (configKeys.length > 0) {
+        // Has specific keys - create steps directly
+        const schema = getConfigSchema();
+        const labels = {};
+        for (const task of tasks) {
+            const key = task.params?.key;
+            if (key && task.action && !(key in schema)) {
+                labels[key] = task.action;
+            }
         }
+        if (Object.keys(labels).length > 0) {
+            saveConfigLabels(labels);
+        }
+        context.workflowHandlers.addToQueue(createConfig({
+            steps: createConfigStepsFromSchema(configKeys),
+            onFinished,
+            onAborted,
+        }));
     }
-    if (Object.keys(labels).length > 0) {
-        saveConfigLabels(labels);
+    else {
+        // No keys - use query (Config will resolve via CONFIGURE tool)
+        const query = tasks[0]?.params?.query;
+        if (query) {
+            context.workflowHandlers.addToQueue(createConfig({
+                query,
+                service: context.service,
+                onFinished,
+                onAborted,
+            }));
+        }
     }
-    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);
-            }
-        },
-        onAborted: (operation) => {
-            context.requestHandlers.onAborted(operation);
-        },
-    }));
 }
 /**
  * Route Execute tasks - creates Execute component (validation already done)

package/dist/services/shell.js

@@ -105,8 +105,10 @@ export class OutputStreamer {
         // 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;
+            const limited = limitLines(accumulated);
+            this.chunks = [limited];
+            // Mark all collapsed content as emitted to prevent re-emission
+            this.emittedLength = limited.length;
         }
         if (!this.callback)
             return;
@@ -146,6 +148,7 @@ export class OutputStreamer {
  */
 export class RealExecutor {
     outputCallback;
+    memoryCallback;
     constructor(outputCallback) {
         this.outputCallback = outputCallback;
     }
@@ -155,6 +158,12 @@ export class RealExecutor {
     setOutputCallback(callback) {
         this.outputCallback = callback;
     }
+    /**
+     * Set or update the memory callback
+     */
+    setMemoryCallback(callback) {
+        this.memoryCallback = callback;
+    }
     execute(cmd, onProgress, _ = 0) {
         return new Promise((resolve) => {
             onProgress?.(ExecutionStatus.Running);
@@ -197,7 +206,7 @@ export class RealExecutor {
             if (cmd.memoryLimit) {
                 memoryMonitor = new MemoryMonitor(child, cmd.memoryLimit, (info) => {
                     memoryInfo = info;
-                });
+                }, undefined, this.memoryCallback);
                 memoryMonitor.start();
             }
             // Use OutputStreamer for buffered stdout streaming
@@ -278,6 +287,12 @@ const executor = realExecutor;
 export function setOutputCallback(callback) {
     realExecutor.setOutputCallback(callback);
 }
+/**
+ * Set a callback to receive memory updates during execution
+ */
+export function setMemoryCallback(callback) {
+    realExecutor.setMemoryCallback(callback);
+}
 /**
  * Execute a single shell command
  */

package/dist/services/utils.js

@@ -25,6 +25,17 @@ export function formatDuration(ms) {
     }
     return parts.join(' ');
 }
+/**
+ * Formats memory in megabytes to a human-readable string.
+ * Uses MB for values under 1024 MB, GB for larger values.
+ */
+export function formatMemory(mb) {
+    if (mb >= 1024) {
+        const gb = mb / 1024;
+        return `${gb.toFixed(1)} GB`;
+    }
+    return `${mb} MB`;
+}
 /**
  * Recursively extracts all leaf tasks from a hierarchical task structure.
  * Leaf tasks are tasks without subtasks.

package/dist/skills/schedule.md

@@ -129,6 +129,13 @@ Before creating tasks, evaluate the request type:
      capabilities", "show skills"
    - Example: "flex" → introspect type
 
+   **CRITICAL - Introspection is ALWAYS a single task:**
+   - Introspection requests MUST result in exactly ONE introspect leaf task
+   - NEVER create multiple introspect tasks for a single request
+   - NEVER nest introspect tasks within groups
+   - NEVER break down capabilities into separate introspect tasks
+   - The single introspect task will list ALL capabilities
+
 2. **Information requests** (questions) - Use question keywords:
    - "explain", "describe", "tell me", "what is", "how does", "find",
      "search"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prompt-language-shell",
-  "version": "0.9.8",
+  "version": "1.0.0",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",
@@ -17,8 +17,8 @@
     "dev": "npm run build && tsc --watch",
     "prepare": "husky",
     "prepublishOnly": "npm run check",
-    "test": "vitest run --exclude 'tests/tools/schedule/*.test.tsx' --exclude 'tests/shell/*.test.ts'",
-    "test:watch": "vitest --exclude 'tests/tools/schedule/*.test.tsx' --exclude 'tests/shell/*.test.ts'",
+    "test": "vitest run --exclude 'tests/tools/' --exclude 'tests/shell/'",
+    "test:watch": "vitest --exclude 'tests/tools/' --exclude 'tests/shell/'",
     "test:llm": "vitest run tests/tools/schedule/*.test.tsx",
     "test:shell": "vitest run tests/shell/*.test.ts",
     "format": "prettier --write '**/*.{ts,tsx}'",
@@ -53,18 +53,18 @@
     "ink-text-input": "^6.0.0",
     "react": "^19.2.3",
     "yaml": "^2.8.2",
-    "zod": "^4.2.1"
+    "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@types/node": "^25.0.3",
-    "@types/react": "^19.2.7",
-    "@vitest/coverage-v8": "^4.0.16",
+    "@types/node": "^25.0.10",
+    "@types/react": "^19.2.9",
+    "@vitest/coverage-v8": "^4.0.18",
     "eslint": "^9.39.2",
     "husky": "^9.1.7",
     "ink-testing-library": "^4.0.0",
-    "prettier": "^3.7.4",
+    "prettier": "^3.8.1",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.50.1",
-    "vitest": "^4.0.16"
+    "typescript-eslint": "^8.53.1",
+    "vitest": "^4.0.18"
   }
 }