prompt-language-shell 0.9.6 → 1.0.0

package/dist/components/controllers/Execute.js

@@ -37,7 +37,10 @@ export function Execute({ tasks: inputTasks, status, service, upcoming, label, r
     // Track working directory across commands (persists cd changes)
     const workdirRef = useRef(undefined);
     // Ref to collect live output during execution (dispatched every second)
-    const outputRef = useRef({ stdout: '', stderr: '' });
+    const outputRef = useRef({
+        chunks: [],
+        currentMemory: undefined,
+    });
     // Ref to track if current task execution is cancelled
     const cancelledRef = useRef(false);
     const { error, tasks, message, hasProcessed, completionMessage, summary } = localState;
@@ -62,8 +65,8 @@ export function Execute({ tasks: inputTasks, status, service, upcoming, label, r
                     index: currentTaskIndex,
                     elapsed,
                     output: {
-                        stdout: outputRef.current.stdout,
-                        stderr: outputRef.current.stderr,
+                        chunks: outputRef.current.chunks,
+                        currentMemory: outputRef.current.currentMemory,
                     },
                 },
             });
@@ -83,8 +86,7 @@ export function Execute({ tasks: inputTasks, status, service, upcoming, label, r
                     ...task,
                     status: ExecutionStatus.Aborted,
                     output: {
-                        stdout: outputRef.current.stdout,
-                        stderr: outputRef.current.stderr,
+                        chunks: outputRef.current.chunks,
                     },
                 };
             }
@@ -139,9 +141,9 @@ export function Execute({ tasks: inputTasks, status, service, upcoming, label, r
                     lifecycleHandlers.completeActive();
                     return;
                 }
-                // Create task data from commands
-                const tasks = result.commands.map((cmd, index) => ({
-                    label: inputTasks[index]?.action ?? cmd.description,
+                // Create task data from commands - use descriptions from execute response
+                const tasks = result.commands.map((cmd) => ({
+                    label: cmd.description,
                     command: cmd,
                     status: ExecutionStatus.Pending,
                     elapsed: 0,
@@ -207,7 +209,7 @@ export function Execute({ tasks: inputTasks, status, service, upcoming, label, r
             payload: { index: currentTaskIndex, startTime: Date.now() },
         });
         // Reset output ref for new task
-        outputRef.current = { stdout: '', stderr: '' };
+        outputRef.current = { chunks: [], currentMemory: undefined };
         // Merge workdir into command
         const command = workdirRef.current
             ? { ...currentTask.command, workdir: workdirRef.current }
@@ -215,7 +217,10 @@ export function Execute({ tasks: inputTasks, status, service, upcoming, label, r
         void executeTask(command, currentTaskIndex, {
             onUpdate: (output) => {
                 if (!cancelledRef.current) {
-                    outputRef.current = { stdout: output.stdout, stderr: output.stderr };
+                    outputRef.current = {
+                        chunks: output.chunks,
+                        currentMemory: output.currentMemory,
+                    };
                 }
             },
             onComplete: (elapsed, execOutput) => {
@@ -229,8 +234,7 @@ export function Execute({ tasks: inputTasks, status, service, upcoming, label, r
                     ? {
                         ...task,
                         output: {
-                            stdout: execOutput.stdout,
-                            stderr: execOutput.stderr,
+                            chunks: execOutput.chunks,
                         },
                     }
                     : task);
@@ -256,8 +260,7 @@ export function Execute({ tasks: inputTasks, status, service, upcoming, label, r
                     ? {
                         ...task,
                         output: {
-                            stdout: execOutput.stdout,
-                            stderr: execOutput.stderr,
+                            chunks: execOutput.chunks,
                         },
                         error: execOutput.error || undefined,
                     }

package/dist/components/controllers/Introspect.js

@@ -54,10 +54,8 @@ export function Introspect({ tasks, status, service, children, debug = DebugLeve
                         message,
                     };
                     requestHandlers.onCompleted(finalState);
-                    // Add Report component to queue
-                    workflowHandlers.addToQueue(createReport({ message, capabilities }));
-                    // Signal completion
-                    lifecycleHandlers.completeActive();
+                    // Signal completion and add Report to timeline (not queue, to preserve order)
+                    lifecycleHandlers.completeActive(createReport({ message, capabilities }));
                 }
             }
             catch (err) {

package/dist/components/controllers/Validate.js

@@ -90,8 +90,9 @@ export function Validate({ missingConfig, userRequest, status, service, onError,
                         },
                     });
                     // Override descriptions with LLM-generated ones
-                    if ('props' in configDef && 'steps' in configDef.props) {
-                        configDef.props.steps = configDef.props.steps.map((step, index) => ({
+                    const configProps = configDef.props;
+                    if (configProps.steps) {
+                        configProps.steps = configProps.steps.map((step, index) => ({
                             ...step,
                             description: withDescriptions[index].description ||
                                 withDescriptions[index].path,

package/dist/components/views/Execute.js

@@ -56,5 +56,5 @@ export const ExecuteView = ({ isLoading, isExecuting, isActive, error, message,
     const isTerminated = upcomingStatus !== ExecutionStatus.Pending;
     // Show upcoming during active execution or when terminated (to show skipped tasks)
     const showUpcoming = upcoming && upcoming.length > 0 && (isActive || isTerminated);
-    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isLoading && (_jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [label && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: getTextColor(isActive), children: label }) })), _jsxs(Box, { marginLeft: label ? 2 : 0, children: [_jsx(Text, { color: Palette.Gray, children: "Preparing commands. " }), _jsx(Spinner, {})] })] })), (isExecuting || showTasks) && (_jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [message && (_jsxs(Box, { marginBottom: 1, gap: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: message }), isExecuting && _jsx(Spinner, {})] })), tasks.map((task, index) => (_jsx(Box, { marginBottom: index < tasks.length - 1 ? 1 : 0, children: _jsx(TaskView, { label: task.label, command: task.command, status: task.status, elapsed: task.elapsed, output: task.output, isFinished: isTaskFinished(task), isActive: isActive }) }, index)))] })), showUpcoming && (_jsx(Box, { marginTop: 1, children: _jsx(Upcoming, { items: upcoming, status: upcomingStatus }) })), completionMessage && !isActive && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsx(Text, { color: getTextColor(false), children: completionMessage }) })), error && (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { children: error }) }))] }));
+    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isLoading && (_jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [label && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: getTextColor(isActive), children: label }) })), _jsxs(Box, { marginLeft: label ? 2 : 0, children: [_jsx(Text, { color: Palette.Gray, children: "Preparing commands. " }), _jsx(Spinner, {})] })] })), (isExecuting || showTasks) && (_jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [message && (_jsxs(Box, { marginBottom: 1, gap: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: message }), isExecuting && _jsx(Spinner, {})] })), tasks.map((task, index) => (_jsx(Box, { marginBottom: index < tasks.length - 1 ? 1 : 0, children: _jsx(TaskView, { label: task.label, command: task.command, status: task.status, elapsed: task.elapsed, currentMemory: task.output?.currentMemory, output: task.output, isFinished: isTaskFinished(task), isActive: isActive }) }, index)))] })), showUpcoming && (_jsx(Box, { marginTop: 1, children: _jsx(Upcoming, { items: upcoming, status: upcomingStatus }) })), completionMessage && !isActive && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsx(Text, { color: getTextColor(false), children: completionMessage }) })), error && (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { children: error }) }))] }));
 };

package/dist/components/views/Output.js

@@ -1,54 +1,108 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { Palette } from '../../services/colors.js';
 import { ExecutionStatus } from '../../services/shell.js';
 const MAX_LINES = 8;
 const MAX_WIDTH = 75;
-const SHORT_OUTPUT_THRESHOLD = 4;
-const MINIMAL_INFO_THRESHOLD = 2;
+const INCOMPLETE_LINE_DELAY = 3000;
 /**
- * Get the last N lines from text, filtering out empty/whitespace-only lines
+ * Determine if an incomplete line should be shown.
+ * Shows incomplete lines if they are older than the delay threshold.
  */
-export function getLastLines(text, maxLines = MAX_LINES) {
-    const lines = text
+function shouldShowIncompleteLine(lastChunk) {
+    return Date.now() - lastChunk.timestamp >= INCOMPLETE_LINE_DELAY;
+}
+/**
+ * Split a line into chunks of maxWidth characters.
+ */
+function splitIntoRows(line, maxWidth) {
+    if (line.length <= maxWidth)
+        return [line];
+    const rows = [];
+    for (let i = 0; i < line.length; i += maxWidth) {
+        rows.push(line.slice(i, i + maxWidth));
+    }
+    return rows;
+}
+/**
+ * Process text into terminal rows.
+ * Handles carriage returns and splits long lines into chunks.
+ */
+function textToRows(text, maxWidth) {
+    return text
         .trim()
         .split(/\r?\n/)
-        .filter((line) => line.trim().length > 0);
-    return lines.length <= maxLines ? lines : lines.slice(-maxLines);
+        .map((line) => {
+        // Handle carriage returns: keep only content after the last \r
+        const lastCR = line.lastIndexOf('\r');
+        return lastCR >= 0 ? line.slice(lastCR + 1) : line;
+    })
+        .filter((line) => line.trim().length > 0)
+        .flatMap((line) => splitIntoRows(line, maxWidth));
+}
+/**
+ * Get the last N terminal rows from text.
+ * Splits long lines into chunks of maxWidth characters, then takes the last N.
+ * Handles carriage returns used in progress output by keeping only the
+ * content after the last \r in each line.
+ */
+export function getLastLines(text, maxLines = MAX_LINES, maxWidth = MAX_WIDTH) {
+    const rows = textToRows(text, maxWidth);
+    return rows.length <= maxLines ? rows : rows.slice(-maxLines);
+}
+/**
+ * Convert output chunks to terminal rows.
+ * Sorts by timestamp, combines text, deduplicates adjacent lines.
+ * When not finished, only shows complete lines (ending with newline),
+ * unless the last chunk is older than INCOMPLETE_LINE_DELAY.
+ */
+export function chunksToRows(chunks, maxLines = MAX_LINES, maxWidth = MAX_WIDTH, isFinished = true) {
+    if (chunks.length === 0)
+        return [];
+    // Sort by timestamp and combine text (chunks already contain line endings)
+    const sorted = [...chunks].sort((a, b) => a.timestamp - b.timestamp);
+    let combined = sorted.map((c) => c.text).join('');
+    // When not finished, only show complete lines (strip trailing incomplete line)
+    // unless the last chunk is old enough to be shown
+    if (!isFinished && !combined.endsWith('\n')) {
+        const lastChunk = sorted[sorted.length - 1];
+        if (!shouldShowIncompleteLine(lastChunk)) {
+            const lastNewline = combined.lastIndexOf('\n');
+            if (lastNewline >= 0) {
+                combined = combined.slice(0, lastNewline + 1);
+            }
+            else {
+                // No complete lines yet
+                return [];
+            }
+        }
+    }
+    // Convert to rows
+    const rows = textToRows(combined, maxWidth);
+    // Deduplicate adjacent identical lines
+    const deduplicated = rows.filter((row, index) => index === 0 || row !== rows[index - 1]);
+    return deduplicated.length <= maxLines
+        ? deduplicated
+        : deduplicated.slice(-maxLines);
 }
 /**
  * Compute display configuration for output rendering.
- * Encapsulates the logic for what to show and how to style it.
  */
-export function computeDisplayConfig(stdout, stderr, status, isFinished) {
-    const hasStdout = stdout.trim().length > 0;
-    const hasStderr = stderr.trim().length > 0;
-    if (!hasStdout && !hasStderr)
+export function computeDisplayConfig(chunks, status, isFinished) {
+    if (chunks.length === 0)
+        return null;
+    const rows = chunksToRows(chunks, MAX_LINES, MAX_WIDTH, isFinished);
+    if (rows.length === 0)
         return null;
-    const stdoutLines = hasStdout ? getLastLines(stdout) : [];
-    const stderrLines = hasStderr ? getLastLines(stderr) : [];
-    // Show stdout if no stderr, or if stderr is minimal (provides context)
-    const showStdout = hasStdout && (!hasStderr || stderrLines.length <= MINIMAL_INFO_THRESHOLD);
-    // Use word wrapping for short outputs to show more detail
-    const totalLines = stdoutLines.length + stderrLines.length;
-    const wrapMode = totalLines <= SHORT_OUTPUT_THRESHOLD ? 'wrap' : 'truncate-end';
-    // Darker colors for finished tasks
+    // Use yellow for failed status, otherwise gray (darker if finished)
     const baseColor = isFinished ? Palette.DarkGray : Palette.Gray;
-    const stderrColor = status === ExecutionStatus.Failed ? Palette.Yellow : baseColor;
-    return {
-        stdoutLines,
-        stderrLines,
-        showStdout,
-        wrapMode,
-        stdoutColor: baseColor,
-        stderrColor,
-    };
+    const color = status === ExecutionStatus.Failed ? Palette.Yellow : baseColor;
+    return { rows, color };
 }
-export function Output({ stdout, stderr, status, isFinished }) {
-    const config = computeDisplayConfig(stdout, stderr, status, isFinished ?? false);
+export function Output({ chunks, status, isFinished }) {
+    const config = computeDisplayConfig(chunks, status, isFinished ?? false);
     if (!config)
         return null;
-    const { stdoutLines, stderrLines, showStdout, wrapMode, stdoutColor, stderrColor, } = config;
-    return (_jsxs(Box, { marginTop: 1, marginLeft: 5, flexDirection: "column", width: MAX_WIDTH, children: [showStdout &&
-                stdoutLines.map((line, index) => (_jsx(Text, { color: stdoutColor, wrap: wrapMode, children: line }, `out-${index}`))), stderrLines.map((line, index) => (_jsx(Text, { color: stderrColor, wrap: wrapMode, children: line }, `err-${index}`)))] }));
+    const { rows, color } = config;
+    return (_jsx(Box, { marginTop: 1, marginLeft: 5, flexDirection: "column", width: MAX_WIDTH, children: rows.map((row, index) => (_jsx(Text, { color: color, wrap: "truncate", children: row }, index))) }));
 }

package/dist/components/views/Subtask.js

@@ -1,25 +1,30 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
+import { loadDebugSetting } from '../../configuration/io.js';
+import { DebugLevel } from '../../configuration/types.js';
 import { getStatusColors, Palette, STATUS_ICONS, } from '../../services/colors.js';
 import { ExecutionStatus } from '../../services/shell.js';
-import { formatDuration } from '../../services/utils.js';
+import { formatDuration, formatMemory } from '../../services/utils.js';
 import { Spinner } from './Spinner.js';
 /**
  * Pure display component for a single subtask.
  * Shows label, command, status icon, and elapsed time.
  */
-export function SubtaskView({ label, command, status, elapsed, }) {
+export function SubtaskView({ label, command, status, elapsed, currentMemory, }) {
     const colors = getStatusColors(status);
+    const debugLevel = loadDebugSetting();
+    const isVerbose = debugLevel === DebugLevel.Verbose;
     const isCancelled = status === ExecutionStatus.Cancelled;
     const isAborted = status === ExecutionStatus.Aborted;
+    const isRunning = status === ExecutionStatus.Running;
     const isFinished = status === ExecutionStatus.Success ||
         status === ExecutionStatus.Failed ||
         status === ExecutionStatus.Aborted;
     // Apply strikethrough for cancelled and aborted tasks
     const shouldStrikethrough = isCancelled || isAborted;
-    const formatText = (text) => shouldStrikethrough ? text.split('').join('\u0336') + '\u0336' : text;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { paddingLeft: 2, gap: 1, children: [_jsx(Text, { color: colors.icon, children: STATUS_ICONS[status] }), _jsx(Text, { color: colors.description, children: shouldStrikethrough
-                            ? formatText(label || command.description)
-                            : label || command.description }), (isFinished || status === ExecutionStatus.Running) &&
-                        elapsed !== undefined && (_jsxs(Text, { color: Palette.DarkGray, children: ["(", formatDuration(elapsed), ")"] }))] }), _jsxs(Box, { paddingLeft: 5, flexDirection: "row", children: [_jsx(Box, { children: _jsx(Text, { color: colors.symbol, children: "\u221F " }) }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { color: colors.command, children: command.command }), status === ExecutionStatus.Running && _jsx(Spinner, {})] })] })] }));
+    // Show memory in verbose mode while running
+    const showMemory = isVerbose && isRunning && currentMemory !== undefined;
+    // Build time/memory display
+    const showTimeInfo = (isFinished || isRunning) && elapsed !== undefined;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { paddingLeft: 2, gap: 1, children: [_jsx(Text, { color: colors.icon, children: STATUS_ICONS[status] }), _jsx(Text, { color: colors.description, strikethrough: shouldStrikethrough, children: label || command.description }), showTimeInfo && (_jsxs(Text, { color: Palette.DarkGray, children: ["(", formatDuration(elapsed), ")"] })), showMemory && (_jsx(Text, { color: Palette.Yellow, children: formatMemory(currentMemory) }))] }), _jsxs(Box, { paddingLeft: 5, flexDirection: "row", children: [_jsx(Box, { children: _jsx(Text, { color: colors.symbol, children: "\u221F " }) }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { color: colors.command, children: command.command }), isRunning && _jsx(Spinner, {})] })] })] }));
 }

package/dist/components/views/Task.js

@@ -6,13 +6,12 @@ import { Output } from './Output.js';
 import { SubtaskView } from './Subtask.js';
 /**
  * Pure display component for a task.
- * Combines SubtaskView (label/command/status) with Output (stdout/stderr).
+ * Combines SubtaskView (label/command/status) with Output (chunks).
  * Output is shown during active execution, or in timeline only with debug mode.
  */
-export function TaskView({ label, command, status, elapsed, output, isFinished, isActive = false, }) {
-    const stdout = output?.stdout ?? '';
-    const stderr = output?.stderr ?? '';
+export function TaskView({ label, command, status, elapsed, currentMemory, output, isFinished, isActive = false, }) {
+    const chunks = output?.chunks ?? [];
     // Show output during active execution, or in timeline only with debug enabled
     const showOutput = isActive || loadDebugSetting() !== DebugLevel.None;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(SubtaskView, { label: label, command: command, status: status, elapsed: elapsed }), showOutput && (_jsx(Output, { stdout: stdout, stderr: stderr, isFinished: isFinished, status: status }, `${stdout.length}-${stderr.length}`))] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(SubtaskView, { label: label, command: command, status: status, elapsed: elapsed, currentMemory: currentMemory }), showOutput && (_jsx(Output, { chunks: chunks, isFinished: isFinished, status: status }))] }));
 }

package/dist/components/views/Upcoming.js

@@ -25,6 +25,6 @@ export const Upcoming = ({ items, status = ExecutionStatus.Pending, }) => {
     return (_jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [_jsx(Text, { color: Palette.Gray, children: STATUS_LABELS[status] }), items.map((name, index) => {
                 const isLast = index === items.length - 1;
                 const symbol = isLast ? BRANCH_LAST : BRANCH_MIDDLE;
-                return (_jsx(Box, { marginLeft: 1, children: _jsxs(Text, { color: Palette.DarkGray, strikethrough: strikethrough, children: [symbol, " ", name] }) }, index));
+                return (_jsxs(Box, { marginLeft: 1, gap: 1, children: [_jsx(Text, { color: Palette.DarkGray, children: symbol }), _jsx(Text, { color: Palette.DarkGray, strikethrough: strikethrough, children: name })] }, index));
             })] }));
 };

package/dist/configuration/io.js

@@ -104,3 +104,13 @@ export function loadDebugSetting(fs = defaultFileSystem) {
         return DebugLevel.None;
     }
 }
+const DEFAULT_MEMORY_LIMIT = 1024;
+export function loadMemorySetting(fs = defaultFileSystem) {
+    try {
+        const config = loadConfig(fs);
+        return config.settings?.memory ?? DEFAULT_MEMORY_LIMIT;
+    }
+    catch {
+        return DEFAULT_MEMORY_LIMIT;
+    }
+}

package/dist/configuration/schema.js

@@ -38,6 +38,12 @@ const coreConfigSchema = {
         default: DebugLevel.None,
         description: 'Debug mode',
     },
+    'settings.memory': {
+        type: ConfigDefinitionType.Number,
+        required: false,
+        default: 1024,
+        description: 'Child process memory limit (MB)',
+    },
 };
 /**
  * Get complete configuration schema

package/dist/configuration/validation.js

@@ -37,6 +37,11 @@ export function validateConfig(parsed) {
                 validatedConfig.settings.debug = settings.debug;
             }
         }
+        if ('memory' in settings) {
+            if (typeof settings.memory === 'number' && settings.memory > 0) {
+                validatedConfig.settings.memory = settings.memory;
+            }
+        }
     }
     return validatedConfig;
 }

package/dist/execution/processing.js

@@ -1,3 +1,5 @@
+import { stringify } from 'yaml';
+import { loadMemorySetting } from '../configuration/io.js';
 import { loadUserConfig } from '../services/loader.js';
 import { replacePlaceholders } from '../services/resolver.js';
 import { validatePlaceholderResolution } from './validation.js';
@@ -10,6 +12,36 @@ export function fixEscapedQuotes(command) {
     // Replace ="value" with =\"value\"
     return command.replace(/="([^"]*)"/g, '=\\"$1\\"');
 }
+/**
+ * Format a task as YAML with action line and metadata block
+ */
+export function formatTaskAsYaml(action, metadata, indent = '') {
+    const normalizedAction = action.charAt(0).toLowerCase() + action.slice(1);
+    if (!metadata || Object.keys(metadata).length === 0) {
+        return normalizedAction;
+    }
+    const metadataYaml = stringify({ metadata })
+        .trim()
+        .split('\n')
+        .map((line) => `${indent}${line}`)
+        .join('\n');
+    return `${normalizedAction}\n\n${metadataYaml}`;
+}
+/**
+ * Build task descriptions for the LLM
+ * Single task: use as-is; multiple tasks: add header and bullet prefix
+ */
+function buildTaskDescriptions(resolvedTasks) {
+    if (resolvedTasks.length === 1) {
+        const { action, params } = resolvedTasks[0];
+        return formatTaskAsYaml(action, params);
+    }
+    const header = `complete these ${resolvedTasks.length} tasks:`;
+    const bulletedTasks = resolvedTasks
+        .map(({ action, params }) => `- ${formatTaskAsYaml(action, params, '  ')}`)
+        .join('\n\n');
+    return `${header}\n\n${bulletedTasks}`;
+}
 /**
  * Processes tasks through the AI service to generate executable commands.
  * Resolves placeholders in task descriptions and validates the results.
@@ -17,27 +49,26 @@ export function fixEscapedQuotes(command) {
 export async function processTasks(tasks, service) {
     // Load user config for placeholder resolution
     const userConfig = loadUserConfig();
-    // Format tasks for the execute tool and resolve placeholders
-    const taskList = tasks
-        .map((task) => {
-        const resolvedAction = replacePlaceholders(task.action, userConfig);
-        const params = task.params
-            ? ` (params: ${JSON.stringify(task.params)})`
-            : '';
-        return `- ${resolvedAction}${params}`;
-    })
-        .join('\n');
-    // Build message with confirmed schedule header
-    const taskDescriptions = `Confirmed schedule (${tasks.length} tasks):\n${taskList}`;
+    const memoryLimitMB = loadMemorySetting();
+    // Resolve placeholders in task actions
+    const resolvedTasks = tasks.map((task) => ({
+        action: replacePlaceholders(task.action, userConfig),
+        params: task.params,
+    }));
+    const taskDescriptions = buildTaskDescriptions(resolvedTasks);
     // Call execute tool to get commands
     const result = await service.processWithTool(taskDescriptions, 'execute');
-    // Resolve placeholders in command strings
+    // Resolve placeholders in command strings and inject memory limit
     const resolvedCommands = (result.commands || []).map((cmd) => {
         // Fix escaped quotes lost in JSON parsing
         const fixed = fixEscapedQuotes(cmd.command);
         const resolved = replacePlaceholders(fixed, userConfig);
         validatePlaceholderResolution(resolved);
-        return { ...cmd, command: resolved };
+        return {
+            ...cmd,
+            command: resolved,
+            memoryLimit: memoryLimitMB,
+        };
     });
     return {
         message: result.message,

package/dist/execution/runner.js

@@ -1,37 +1,31 @@
-import { ExecutionResult, ExecutionStatus, executeCommand, setOutputCallback, } from '../services/shell.js';
+import { ExecutionResult, ExecutionStatus, executeCommand, setMemoryCallback, setOutputCallback, } from '../services/shell.js';
 import { calculateElapsed } from '../services/utils.js';
-// Maximum number of output lines to keep in memory
-const MAX_OUTPUT_LINES = 128;
-/**
- * Limit output to last MAX_OUTPUT_LINES lines to prevent memory exhaustion
- */
-function limitLines(output) {
-    const lines = output.split('\n');
-    return lines.slice(-MAX_OUTPUT_LINES).join('\n');
-}
+// Maximum number of output chunks to keep in memory
+const MAX_OUTPUT_CHUNKS = 256;
 /**
  * Execute a single task and track its progress.
  * All execution logic is contained here, outside of React components.
  */
 export async function executeTask(command, index, callbacks) {
     const startTime = Date.now();
-    let stdout = '';
-    let stderr = '';
+    let chunks = [];
     let error = '';
     let workdir;
+    let currentMemory;
     // Helper to create current output snapshot
     const createOutput = () => ({
-        stdout,
-        stderr,
+        chunks,
         error,
         workdir,
+        currentMemory,
     });
-    // Throttle updates to avoid excessive re-renders (100ms minimum interval)
+    // Throttle updates to avoid excessive re-renders (80ms minimum interval)
     let lastUpdateTime = 0;
     let pendingTimeout;
+    const THROTTLE_INTERVAL = 80;
     const throttledUpdate = () => {
         const now = Date.now();
-        if (now - lastUpdateTime >= 100) {
+        if (now - lastUpdateTime >= THROTTLE_INTERVAL) {
             lastUpdateTime = now;
             callbacks.onUpdate(createOutput());
         }
@@ -40,29 +34,50 @@ export async function executeTask(command, index, callbacks) {
                 pendingTimeout = undefined;
                 lastUpdateTime = Date.now();
                 callbacks.onUpdate(createOutput());
-            }, 100 - (now - lastUpdateTime));
+            }, THROTTLE_INTERVAL - (now - lastUpdateTime));
         }
     };
-    // Set up output streaming callback
+    // Set up output streaming callback - store chunks with timestamps
     setOutputCallback((data, stream) => {
-        if (stream === 'stdout') {
-            stdout = limitLines(stdout + data);
-        }
-        else {
-            stderr = limitLines(stderr + data);
+        chunks.push({
+            text: data,
+            timestamp: Date.now(),
+            source: stream,
+        });
+        // Limit chunks to prevent memory exhaustion
+        if (chunks.length > MAX_OUTPUT_CHUNKS) {
+            chunks = chunks.slice(-MAX_OUTPUT_CHUNKS);
         }
         throttledUpdate();
     });
+    // Set up memory callback to track current memory
+    setMemoryCallback((memoryMB) => {
+        currentMemory = memoryMB;
+        throttledUpdate();
+    });
     try {
         const result = await executeCommand(command, undefined, index);
-        // Clear callback and pending timeout
+        // Clear callbacks and pending timeout
         setOutputCallback(undefined);
+        setMemoryCallback(undefined);
         clearTimeout(pendingTimeout);
         const elapsed = calculateElapsed(startTime);
-        // Update final output from result
-        stdout = result.output;
-        stderr = result.errors;
+        const now = Date.now();
+        // Update workdir from result
         workdir = result.workdir;
+        // Add final output/errors as chunks only if not already captured during streaming
+        const hasStreamedStdout = chunks.some((c) => c.source === 'stdout');
+        const hasStreamedStderr = chunks.some((c) => c.source === 'stderr');
+        if (result.output && result.output.trim() && !hasStreamedStdout) {
+            chunks.push({ text: result.output, timestamp: now, source: 'stdout' });
+        }
+        if (result.errors && result.errors.trim() && !hasStreamedStderr) {
+            chunks.push({
+                text: result.errors,
+                timestamp: now + 1,
+                source: 'stderr',
+            });
+        }
         if (result.result === ExecutionResult.Success) {
             const output = createOutput();
             callbacks.onUpdate(output);
@@ -70,7 +85,7 @@ export async function executeTask(command, index, callbacks) {
             return { status: ExecutionStatus.Success, elapsed, output };
         }
         else {
-            const errorMsg = result.errors || result.error || 'Command failed';
+            const errorMsg = result.error || result.errors || 'Command failed';
             error = errorMsg;
             const output = createOutput();
             callbacks.onUpdate(output);
@@ -79,8 +94,9 @@ export async function executeTask(command, index, callbacks) {
         }
     }
     catch (err) {
-        // Clear callback and pending timeout
+        // Clear callbacks and pending timeout
         setOutputCallback(undefined);
+        setMemoryCallback(undefined);
         clearTimeout(pendingTimeout);
         const elapsed = calculateElapsed(startTime);
         const errorMsg = err instanceof Error ? err.message : 'Unknown error';
@@ -95,5 +111,5 @@ export async function executeTask(command, index, callbacks) {
  * Create an empty execution output
  */
 export function createEmptyOutput() {
-    return { stdout: '', stderr: '', error: '' };
+    return { chunks: [], error: '' };
 }

package/dist/index.js

@@ -5,7 +5,9 @@ import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { render } from 'ink';
 import { DebugLevel } from './configuration/types.js';
+import { preventPerformanceBufferOverflow } from './services/performance.js';
 import { Main } from './Main.js';
+preventPerformanceBufferOverflow();
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Get package info