prompt-language-shell 0.9.8 → 1.0.0

package/dist/components/views/Output.js

@@ -1,17 +1,35 @@
-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 MINIMAL_INFO_THRESHOLD = 2;
+const INCOMPLETE_LINE_DELAY = 3000;
 /**
- * Get the last N lines from text, filtering out empty/whitespace-only lines.
- * Handles carriage returns used in progress output by keeping only the
- * content after the last \r in each line.
+ * Determine if an incomplete line should be shown.
+ * Shows incomplete lines if they are older than the delay threshold.
+ */
+function shouldShowIncompleteLine(lastChunk) {
+    return Date.now() - lastChunk.timestamp >= INCOMPLETE_LINE_DELAY;
+}
+/**
+ * Split a line into chunks of maxWidth characters.
  */
-export function getLastLines(text, maxLines = MAX_LINES) {
-    const lines = text
+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/)
         .map((line) => {
@@ -19,38 +37,72 @@ export function getLastLines(text, maxLines = MAX_LINES) {
         const lastCR = line.lastIndexOf('\r');
         return lastCR >= 0 ? line.slice(lastCR + 1) : line;
     })
-        .filter((line) => line.trim().length > 0);
-    return lines.length <= maxLines ? lines : lines.slice(-maxLines);
+        .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);
-    // 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,
-        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, 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: "wrap", children: line }, `out-${index}`))), stderrLines.map((line, index) => (_jsx(Text, { color: stderrColor, wrap: "wrap", 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/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);
@@ -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/services/anthropic.js

@@ -1,6 +1,6 @@
 import Anthropic from '@anthropic-ai/sdk';
 import { getAvailableConfigStructure, getConfiguredKeys, } from '../configuration/schema.js';
-import { logPrompt, logResponse } from './logger.js';
+import { formatConfigContext, formatSkillsContext, logPrompt, logResponse, } from './logger.js';
 import { loadSkillsForPrompt } from './skills.js';
 import { toolRegistry } from './registry.js';
 import { CommandResultSchema, IntrospectResultSchema, } from '../types/schemas.js';
@@ -77,13 +77,13 @@ export class AnthropicService {
         // Load base instructions and skills
         const baseInstructions = customInstructions || toolRegistry.getInstructions(toolName);
         let formattedSkills = '';
-        let skillDefinitions = [];
         let systemPrompt = baseInstructions;
+        let context;
         if (!customInstructions && usesSkills) {
             const skillsResult = loadSkillsForPrompt();
             formattedSkills = skillsResult.formatted;
-            skillDefinitions = skillsResult.definitions;
             systemPrompt += formattedSkills;
+            context = formatSkillsContext(skillsResult.definitions);
         }
         // Add config structure for configure tool only
         if (!customInstructions && toolName === 'configure') {
@@ -95,6 +95,7 @@ export class AnthropicService {
                 '\n\nConfigured keys (keys that exist in config file):\n' +
                 JSON.stringify(configuredKeys, null, 2);
             systemPrompt += configSection;
+            context = formatConfigContext(configStructure, configuredKeys);
         }
         // Build tools array - add web search for answer tool
         const tools = [tool];
@@ -107,7 +108,7 @@ export class AnthropicService {
         // Collect debug components
         const debug = [];
         // Log prompt at Verbose level
-        const promptDebug = logPrompt(toolName, command, baseInstructions, formattedSkills, skillDefinitions);
+        const promptDebug = logPrompt(toolName, command, baseInstructions, formattedSkills, context);
         if (promptDebug) {
             debug.push(promptDebug);
         }

package/dist/services/logger.js

@@ -243,9 +243,9 @@ function formatSkillsForDisplay(formattedSkills) {
  *
  * - LLM: Returns header + base instructions + formatted skills (as sent to LLM)
  * - Skills: Returns header + skills with visual separators (no base instructions)
- * - Summary: Returns header + skill summaries (Name, Steps, Execution)
+ * - Summary: Returns header + context (caller-provided summary)
  */
-export function formatPromptContent(toolName, command, baseInstructions, formattedSkills, mode, definitions) {
+export function formatPromptContent(toolName, command, baseInstructions, formattedSkills, mode, context) {
     switch (mode) {
         case PromptDisplay.LLM: {
             const header = ['', `**Tool:** ${toolName}`];
@@ -258,13 +258,41 @@ export function formatPromptContent(toolName, command, baseInstructions, formatt
         }
         case PromptDisplay.Summary: {
             const header = `\nTool: ${toolName}\nCommand: ${command}`;
-            const summary = definitions
-                ? formatSkillsSummary(definitions)
-                : '(no skills)';
-            return joinWithSeparators([header, summary]);
+            return context
+                ? joinWithSeparators([header, context])
+                : joinWithSeparators([header]);
         }
     }
 }
+/**
+ * Context for tools that have no skills or custom context
+ */
+export const NO_SKILLS_CONTEXT = '(no skills)';
+/**
+ * Format skill definitions as context for debug display
+ * Returns NO_SKILLS_CONTEXT when definitions array is empty
+ */
+export function formatSkillsContext(definitions) {
+    if (definitions.length === 0) {
+        return NO_SKILLS_CONTEXT;
+    }
+    return formatSkillsSummary(definitions);
+}
+/**
+ * Format config structure as context for debug display
+ */
+export function formatConfigContext(structure, configuredKeys) {
+    const structureYaml = Object.entries(structure)
+        .map(([key, desc]) => `${key}: ${String(desc)}`)
+        .join('\n');
+    const keysSection = configuredKeys.length > 0
+        ? configuredKeys.map((k) => `- ${k}`).join('\n')
+        : '(none)';
+    return ('## Config Structure\n\n' +
+        structureYaml +
+        '\n\n## Configured Keys\n\n' +
+        keysSection);
+}
 /**
  * Create debug component for system prompts sent to the LLM
  * Creates UI component at Verbose level, writes to file at Info or Verbose
@@ -273,9 +301,9 @@ export function formatPromptContent(toolName, command, baseInstructions, formatt
  * @param command - User command being processed
  * @param baseInstructions - Base tool instructions (without skills)
  * @param formattedSkills - Formatted skills section (as sent to LLM)
- * @param definitions - Parsed skill definitions for summary display
+ * @param context - Context summary to display in debug output
  */
-export function logPrompt(toolName, command, baseInstructions, formattedSkills, definitions = []) {
+export function logPrompt(toolName, command, baseInstructions, formattedSkills, context) {
     // Write to file at Info or Verbose level (full LLM format)
     if (currentDebugLevel !== DebugLevel.None) {
         const userPrompt = `# User Command\n\n\`\`\`\n${command}\n\`\`\`\n\n`;
@@ -286,7 +314,7 @@ export function logPrompt(toolName, command, baseInstructions, formattedSkills,
     if (currentDebugLevel !== DebugLevel.Verbose) {
         return null;
     }
-    const content = formatPromptContent(toolName, command, baseInstructions, formattedSkills, PromptDisplay.Summary, definitions);
+    const content = formatPromptContent(toolName, command, baseInstructions, formattedSkills, PromptDisplay.Summary, context);
     // Calculate stats for the full prompt
     const fullPrompt = baseInstructions + formattedSkills;
     const lines = fullPrompt.split('\n').length;

package/dist/services/monitor.js

@@ -3,7 +3,7 @@ import { existsSync, readFileSync } from 'fs';
 import { platform } from 'os';
 import { promisify } from 'util';
 // Memory monitoring constants
-const MEMORY_CHECK_INTERVAL = 1000;
+const MEMORY_CHECK_INTERVAL = 250;
 const DEFAULT_PAGE_SIZE = 4096;
 export const SIGKILL_GRACE_PERIOD = 3000;
 /**
@@ -183,25 +183,29 @@ export class MemoryMonitor {
     memoryLimit;
     limitBytes;
     onExceeded;
+    onMemoryUpdate;
     state = MonitorState.Idle;
     getMemoryFn;
-    constructor(child, memoryLimitMB, onExceeded, getMemoryFn) {
+    currentMemoryMB = 0;
+    constructor(child, memoryLimitMB, onExceeded, getMemoryFn, onMemoryUpdate) {
         this.child = child;
         this.memoryLimit = memoryLimitMB;
         this.limitBytes = memoryLimitMB * 1024 * 1024;
         this.onExceeded = onExceeded;
+        this.onMemoryUpdate = onMemoryUpdate;
         // Always monitor full process tree by default
         this.getMemoryFn = getMemoryFn ?? getProcessTreeMemoryBytes;
     }
     /**
      * Start monitoring the child process memory.
      * Uses async self-scheduling loop instead of setInterval for non-blocking.
+     * Performs an immediate check, then polls at regular intervals.
      */
     start() {
         if (!this.child.pid)
             return;
         this.state = MonitorState.Running;
-        this.scheduleNextCheck();
+        void this.checkMemory();
     }
     /**
      * Schedule the next memory check after the configured interval.
@@ -231,6 +235,11 @@ export class MemoryMonitor {
         // Re-check after async operation - state may have changed
         if (this.state !== MonitorState.Running)
             return; // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+        // Track current memory
+        if (memoryBytes !== undefined) {
+            this.currentMemoryMB = Math.ceil(memoryBytes / 1024 / 1024);
+            this.onMemoryUpdate?.(this.currentMemoryMB);
+        }
         if (memoryBytes !== undefined && memoryBytes >= this.limitBytes) {
             this.terminateProcess(memoryBytes);
         }
@@ -285,4 +294,11 @@ export class MemoryMonitor {
     wasKilledByMemoryLimit() {
         return this.state === MonitorState.Killed;
     }
+    /**
+     * Get current memory in MB.
+     * Returns 0 if no memory has been recorded yet.
+     */
+    getCurrentMemoryMB() {
+        return this.currentMemoryMB;
+    }
 }

package/dist/services/refinement.js

@@ -1,6 +1,5 @@
-import { ComponentStatus, } from '../types/components.js';
 import { formatTaskAsYaml } from '../execution/processing.js';
-import { createCommand, createRefinement } from './components.js';
+import { createRefinement } from './components.js';
 import { formatErrorMessage, getRefiningMessage } from './messages.js';
 import { routeTasksWithConfirm } from './router.js';
 /**
@@ -8,11 +7,6 @@ import { routeTasksWithConfirm } from './router.js';
  * Called when user selects options from a plan with DEFINE tasks
  */
 export async function handleRefinement(selectedTasks, service, originalCommand, lifecycleHandlers, workflowHandlers, requestHandlers) {
-    // Display the resolved command (from user's selection)
-    // The first task's action contains the full resolved command
-    const resolvedCommand = selectedTasks[0]?.action || originalCommand;
-    const commandDisplay = createCommand({ command: resolvedCommand, service, onAborted: requestHandlers.onAborted }, ComponentStatus.Done);
-    workflowHandlers.addToTimeline(commandDisplay);
     // Create and add refinement component to queue
     const refinementDef = createRefinement({
         text: getRefiningMessage(),