erosolar-cli 1.7.412 → 1.7.413

package/dist/shell/interactiveShell.js

@@ -6,6 +6,7 @@ import { join } from 'node:path';
 import { display } from '../ui/display.js';
 import { isPlainOutputMode } from '../ui/outputMode.js';
 import { theme } from '../ui/theme.js';
+import { renderDivider } from '../ui/unified/layout.js';
 import { StreamingResponseFormatter } from '../ui/streamingFormatter.js';
 import { getContextWindowTokens } from '../core/contextWindow.js';
 import { ensureSecretForProvider, getSecretDefinitionForProvider, getSecretValue, listSecretDefinitions, maskSecret, setSecretValue, } from '../core/secretStore.js';
@@ -71,7 +72,7 @@ const BASE_SLASH_COMMANDS = getSlashCommands().map((cmd) => ({
 // Load PROVIDER_LABELS from centralized schema
 const PROVIDER_LABELS = Object.fromEntries(getProviders().map((provider) => [provider.id, provider.label]));
 // Allow enough time for paste detection to kick in before flushing buffered lines
-const CONTEXT_USAGE_THRESHOLD = 0.9;
+const CONTEXT_USAGE_THRESHOLD = 0.97;
 const CONTEXT_AUTOCOMPACT_PERCENT = Math.round(CONTEXT_USAGE_THRESHOLD * 100);
 const CONTEXT_AUTOCOMPACT_FLOOR = 0.6;
 const MIN_COMPACTION_TOKEN_SAVINGS = 200;
@@ -79,12 +80,11 @@ const MIN_COMPACTION_PERCENT_SAVINGS = 0.5;
 const CONTEXT_RECENT_MESSAGE_COUNT = 12;
 const CONTEXT_CLEANUP_CHARS_PER_CHUNK = 6000;
 const CONTEXT_CLEANUP_MAX_OUTPUT_TOKENS = 800;
-const CONTEXT_CLEANUP_SYSTEM_PROMPT = `You condense earlier IDE collaboration logs so the agent can keep working.
-- Merge any prior summary with the new conversation chunk.
-- Capture key decisions, TODOs, file edits, tool observations, and open questions.
-- Clearly distinguish resolved work from outstanding follow-ups.
-- Keep the response under roughly 200 words, prefer short bullet lists.
-- Never call tools or run shell commands; respond with plain Markdown text only.`;
+const CONTEXT_CLEANUP_SYSTEM_PROMPT = `Summarize earlier IDE collaboration so the agent can keep working.
+- Merge any prior summary with the new chunk.
+- Capture decisions, file edits/paths, tool findings, and open questions.
+- Separate finished work from follow-ups; keep it under ~180 words with tight bullets.
+- Respond in plain Markdown only (no tool or shell calls).`;
 export class InteractiveShell {
     agent = null;
     profile;
@@ -124,6 +124,7 @@ export class InteractiveShell {
     latestTokenUsage = { used: null, limit: null };
     planApprovalBridgeRegistered = false;
     contextCompactionInFlight = false;
+    contextCompactionLog = [];
     lastContextWarningLevel = null;
     sessionPreferences;
     autosaveEnabled;
@@ -163,11 +164,14 @@ export class InteractiveShell {
     streamingHeartbeatFrame = 0;
     streamingStatusLabel = null;
     lastStreamingElapsedSeconds = null; // Preserve final elapsed time
+    aiRuntimeStart = null;
+    aiRuntimeTotalMs = 0;
     streamingFormatter = null;
     statusLineState = null;
     statusMessageOverride = null;
     promptRefreshTimer = null;
     launchPaletteShown = false;
+    launchBannerText = null;
     version;
     alternateScreenEnabled;
     constructor(config) {
@@ -373,7 +377,30 @@ export class InteractiveShell {
         display.showInfo(this.sessionResumeNotice);
         this.sessionResumeNotice = null;
     }
+    renderWelcomeBanner(force = false) {
+        if (isPlainOutputMode() || !output.isTTY) {
+            return;
+        }
+        const header = `${theme.fields.model(this.sessionState.model)} ${theme.ui.muted('@')} ${theme.fields.agent(this.providerLabel(this.sessionState.provider))}`;
+        const profileLine = `${theme.fields.profile(this.profileLabel)} ${theme.ui.muted(`(${this.profile})`)}`;
+        const workspaceLine = theme.fields.workspace(this.workingDir);
+        const versionLine = this.version ? theme.ui.muted(`v${this.version} · support@ero.solar`) : null;
+        const hintLine = theme.ui.muted('/help for commands · /model to switch · /secrets for keys');
+        const width = output.columns ?? 80;
+        const banner = [header, profileLine, workspaceLine, versionLine, hintLine, renderDivider(width)]
+            .filter(Boolean)
+            .join('\n');
+        if (!force && this.launchBannerText) {
+            return;
+        }
+        if (this.launchBannerText === banner) {
+            return;
+        }
+        display.stream(`${banner}\n`);
+        this.launchBannerText = banner;
+    }
     async start(initialPrompt) {
+        this.renderWelcomeBanner();
         if (initialPrompt) {
             await this.processInputBlock(initialPrompt);
             return;
@@ -583,26 +610,35 @@ export class InteractiveShell {
         }
         // Trigger context compaction
         display.showInfo('Compacting context... This will summarize the conversation and free up space.');
-        void this.performContextCompaction();
+        void this.performContextCompaction('Manual shortcut compaction');
     }
     /**
      * Perform context compaction by summarizing conversation history.
      */
-    async performContextCompaction() {
+    async performContextCompaction(reason = 'Manual context compaction') {
         try {
-            // For now, just clear the history and show a message
-            // A full implementation would summarize the conversation
-            const oldLength = this.cachedHistory.length;
-            if (oldLength === 0) {
-                display.showInfo('Context is already empty.');
+            const agent = this.agent;
+            if (!agent) {
+                display.showWarning('No active agent to compact context.');
                 return;
             }
-            // Keep the last few messages for continuity
-            const keepCount = Math.min(4, oldLength);
-            this.cachedHistory = this.cachedHistory.slice(-keepCount);
-            display.showSuccess(`Context compacted: ${oldLength} messages reduced to ${keepCount}. ` +
-                `Context usage reset. Continue your conversation.`);
-            this.refreshControlBar();
+            const contextManager = agent.getContextManager();
+            if (!contextManager) {
+                display.showWarning('Context manager unavailable. Try sending a message first.');
+                return;
+            }
+            const history = agent.getHistory();
+            if (history.length <= 1) {
+                display.showInfo('Context is already minimal.');
+                return;
+            }
+            const stats = contextManager.getStats(history);
+            const windowTokens = this.activeContextWindowTokens ?? this.latestTokenUsage.limit ?? null;
+            await this.runContextCleanup(windowTokens, stats.totalTokens, {
+                reason,
+                forced: true,
+                source: 'manual',
+            });
         }
         catch (error) {
             display.showError('Failed to compact context', error);
@@ -714,6 +750,7 @@ export class InteractiveShell {
         // Stop any active spinner to prevent process hang
         display.stopThinking(false);
         this.stopStreamingHeartbeat();
+        this.endAiRuntime();
         this.uiUpdates.dispose();
         this.clearPromptRefreshTimer();
         this.teardownStatusTracking();
@@ -1159,6 +1196,25 @@ export class InteractiveShell {
             process.stdout.write(content);
         }, 'interactiveShell.stdout');
     }
+    beginAiRuntime() {
+        if (this.aiRuntimeStart === null) {
+            this.aiRuntimeStart = Date.now();
+        }
+    }
+    endAiRuntime() {
+        if (this.aiRuntimeStart !== null) {
+            this.aiRuntimeTotalMs += Date.now() - this.aiRuntimeStart;
+            this.aiRuntimeStart = null;
+        }
+    }
+    getAiRuntimeSeconds() {
+        const runningMs = this.aiRuntimeStart ? Date.now() - this.aiRuntimeStart : 0;
+        const totalMs = this.aiRuntimeTotalMs + runningMs;
+        if (totalMs <= 0 && this.aiRuntimeStart === null) {
+            return null;
+        }
+        return Math.max(0, Math.floor(totalMs / 1000));
+    }
     /**
      * Refresh the status line in the persistent input area.
      * Uses combined status display: streaming label + override + main status.
@@ -1173,20 +1229,7 @@ export class InteractiveShell {
         const statusText = this.formatStatusLine(this.statusLineState);
         this.terminalInput.setStatusMessage(statusText);
         // Surface meta header (elapsed + context usage) above the divider
-        // Use streaming elapsed time if available, otherwise fall back to status line state
-        let elapsedSeconds = null;
-        if (this.streamingHeartbeatStart) {
-            // Actively streaming - compute live elapsed
-            elapsedSeconds = Math.max(0, Math.floor((Date.now() - this.streamingHeartbeatStart) / 1000));
-        }
-        else if (this.lastStreamingElapsedSeconds !== null) {
-            // Just finished streaming - use preserved final time
-            elapsedSeconds = this.lastStreamingElapsedSeconds;
-        }
-        else if (this.statusLineState) {
-            // Fallback to status line state elapsed
-            elapsedSeconds = Math.max(0, Math.floor((Date.now() - this.statusLineState.startedAt) / 1000));
-        }
+        const elapsedSeconds = this.getAiRuntimeSeconds();
         const thinkingMs = display.isSpinnerActive() ? display.getThinkingElapsedMs() : null;
         const tokensUsed = this.latestTokenUsage.used;
         const tokenLimit = this.latestTokenUsage.limit ?? this.activeContextWindowTokens;
@@ -1365,6 +1408,8 @@ export class InteractiveShell {
             this.terminalInput.streamContent(closing);
         }
         this.streamingFormatter = null;
+        // Force the prompt to re-render after streaming so it stays below the last response
+        this.requestPromptRefresh(true);
     }
     buildStreamingStatus(label, _elapsedSeconds) {
         // Model + elapsed time already live in the pinned meta header; keep the streaming
@@ -1678,7 +1723,7 @@ export class InteractiveShell {
                 this.handleCostCommand();
                 break;
             case '/usage':
-                this.handleUsageCommand();
+                this.handleUsageCommand(input);
                 break;
             case '/clear':
                 this.handleClearCommand();
@@ -3465,7 +3510,13 @@ export class InteractiveShell {
         lines.push(theme.ui.muted('Token usage is tracked automatically during the session.'));
         display.showSystemMessage(lines.join('\n'));
     }
-    handleUsageCommand() {
+    handleUsageCommand(input) {
+        const tokens = input ? input.trim().split(/\s+/) : [];
+        const subcommand = tokens[1]?.toLowerCase();
+        if (subcommand === 'history' || subcommand === 'log') {
+            this.showCompactionHistory();
+            return;
+        }
         const percentage = this.latestTokenUsage.limit && this.latestTokenUsage.used
             ? Math.round((this.latestTokenUsage.used / this.latestTokenUsage.limit) * 100)
             : 0;
@@ -3486,6 +3537,37 @@ export class InteractiveShell {
         else {
             lines.push(theme.success('Plenty of context available.'));
         }
+        if (this.contextCompactionLog.length > 0) {
+            lines.push('');
+            lines.push(theme.secondary('Tip: /usage history shows recent context compactions.'));
+        }
+        display.showSystemMessage(lines.join('\n'));
+    }
+    showCompactionHistory() {
+        if (!this.contextCompactionLog.length) {
+            display.showInfo('No context compactions recorded yet.');
+            return;
+        }
+        const entries = [...this.contextCompactionLog].slice(-10).reverse();
+        const lines = [];
+        lines.push(theme.bold('Context Compaction History'));
+        lines.push('');
+        for (const entry of entries) {
+            const time = new Date(entry.timestamp).toLocaleTimeString();
+            const reason = entry.reason || (entry.source === 'auto' ? 'Auto-compaction' : 'Manual compaction');
+            const before = entry.beforeTokens.toLocaleString('en-US');
+            const after = entry.afterTokens.toLocaleString('en-US');
+            const saved = Math.max(0, entry.beforeTokens - entry.afterTokens);
+            const savedLabel = saved > 0 ? `${saved.toLocaleString('en-US')} saved` : 'no savings';
+            const pctBefore = entry.percentBefore ?? null;
+            const pctAfter = entry.percentAfter ?? null;
+            const pctLabel = pctBefore !== null && pctAfter !== null
+                ? `(${pctBefore}% → ${pctAfter}%)`
+                : '';
+            const summaryNote = entry.summarized ? 'summary applied' : 'prune only';
+            lines.push(`  ${time} · ${reason} [${entry.source} · ${entry.model}]`);
+            lines.push(`    ${before} → ${after} tokens ${pctLabel} · ${savedLabel} · ${summaryNote}`);
+        }
         display.showSystemMessage(lines.join('\n'));
     }
     handleClearCommand() {
@@ -3622,13 +3704,7 @@ export class InteractiveShell {
             return;
         }
         display.showInfo('Compacting conversation context...');
-        // Check if compaction is needed based on tracked usage
-        const { used, limit } = this.latestTokenUsage;
-        if (used && limit && used / limit < 0.5) {
-            display.showInfo('Context usage is low. No compaction needed.');
-            return;
-        }
-        await this.processRequest('Please summarize our conversation so far in a concise way, preserving key decisions, code changes, and next steps. This will help compact the context.');
+        await this.performContextCompaction('Manual /compact request');
     }
     // ==================== End Claude Code Style Commands ====================
     updateActiveSession(summary, remember = false) {
@@ -4570,6 +4646,7 @@ export class InteractiveShell {
         this.currentToolCalls = [];
         this.uiAdapter.startProcessing('Working on your request');
         this.setProcessingStatus();
+        this.beginAiRuntime();
         let responseText = '';
         try {
             // Start streaming - no header needed, the input area already provides context
@@ -4635,6 +4712,7 @@ export class InteractiveShell {
             display.stopThinking(false);
             this.uiUpdates.setMode('processing');
             this.stopStreamingHeartbeat();
+            this.endAiRuntime();
             this.isProcessing = false;
             this.terminalInput.setStreaming(false);
             this.uiAdapter.endProcessing('Ready for prompts');
@@ -4690,6 +4768,7 @@ export class InteractiveShell {
         display.showSystemMessage(`Continuous mode active. Ctrl+C to stop.`);
         this.uiAdapter.startProcessing('Continuous execution mode');
         this.setProcessingStatus();
+        this.beginAiRuntime();
         // No streaming header - just start streaming directly
         this.startStreamingHeartbeat('Streaming');
         let iteration = 0;
@@ -4865,6 +4944,7 @@ What's the next action?`;
             resetTaskCompletionDetector();
             this.uiUpdates.setMode('processing');
             this.stopStreamingHeartbeat();
+            this.endAiRuntime();
             this.isProcessing = false;
             this.terminalInput.setStreaming(false);
             this.uiAdapter.endProcessing('Ready for prompts');
@@ -5421,6 +5501,7 @@ Return ONLY JSON array:
         try {
             ensureSecretForProvider(this.sessionState.provider);
             this.runtimeSession.updateToolContext(this.sessionState);
+            this.ensureActiveSummarizer(this.runtimeSession.contextManager);
             const selection = {
                 provider: this.sessionState.provider,
                 model: this.sessionState.model,
@@ -5571,6 +5652,7 @@ Return ONLY JSON array:
      * Ensures the input area is visible and ready for input, just like on startup.
      */
     resetChatBoxAfterModelSwap() {
+        this.renderWelcomeBanner(true);
         this.updateStatusMessage(null);
         this.terminalInput.setStreaming(false);
         this.terminalInput.render();
@@ -5686,7 +5768,7 @@ Return ONLY JSON array:
         if (!trigger) {
             return null;
         }
-        return this.runContextCleanup(windowTokens, total, trigger);
+        return this.runContextCleanup(windowTokens, total, { ...trigger, source: 'auto' });
     }
     totalTokens(usage) {
         if (!usage) {
@@ -5713,58 +5795,104 @@ Return ONLY JSON array:
         if (history.length <= 1) {
             return;
         }
+        if (!this.areToolTurnsComplete(history)) {
+            display.showInfo('Context compaction postponed until all tool calls have returned results.');
+            return;
+        }
+        this.ensureActiveSummarizer(contextManager);
         this.cleanupInProgress = true;
         this.contextCompactionInFlight = true;
         const cleanupStatusId = 'context-cleanup';
         let cleanupOverlayActive = false;
         try {
-            const percentUsed = Math.round((totalTokens / windowTokens) * 100);
-            const statusDetailParts = [`${percentUsed}% full`];
-            if (trigger?.reason) {
-                statusDetailParts.push(trigger.reason);
-            }
+            const beforeStats = contextManager.getStats(history);
+            const resolvedWindowTokens = windowTokens ?? this.activeContextWindowTokens ?? this.latestTokenUsage.limit ?? null;
+            const resolvedTotalTokens = totalTokens ?? beforeStats.totalTokens;
+            const percentUsed = resolvedWindowTokens && resolvedWindowTokens > 0
+                ? Math.min(100, Math.round((resolvedTotalTokens / resolvedWindowTokens) * 100))
+                : beforeStats.percentage;
+            const statusDetailParts = [
+                `${percentUsed}% full`,
+                trigger?.reason,
+            ].filter(Boolean);
             this.statusTracker.pushOverride(cleanupStatusId, 'Running context cleanup', {
                 detail: statusDetailParts.join(' · '),
                 tone: 'warning',
             });
             cleanupOverlayActive = true;
             const triggerReason = trigger?.reason ?? 'Context optimization';
+            const limitLabel = resolvedWindowTokens
+                ? `of ${resolvedWindowTokens.toLocaleString('en-US')} tokens`
+                : 'of estimated context';
             display.showSystemMessage([
-                `Context usage: ${totalTokens.toLocaleString('en-US')} of ${windowTokens.toLocaleString('en-US')} tokens`,
+                `Context usage: ${resolvedTotalTokens.toLocaleString('en-US')} ${limitLabel}`,
                 `(${percentUsed}% full). Auto-compacting${triggerReason ? `: ${triggerReason}` : '...'}`,
             ].join(' '));
-            const beforeStats = contextManager.getStats(history);
             const result = await contextManager.intelligentCompact(history);
-            const afterStats = contextManager.getStats(result.compacted);
-            const tokenSavings = Math.max(0, beforeStats.totalTokens - afterStats.totalTokens);
-            const percentSavings = beforeStats.totalTokens > 0 ? (tokenSavings / beforeStats.totalTokens) * 100 : 0;
-            const changed = this.historiesDiffer(history, result.compacted);
-            const meaningfulSavings = changed &&
-                (tokenSavings >= MIN_COMPACTION_TOKEN_SAVINGS || percentSavings >= MIN_COMPACTION_PERCENT_SAVINGS);
-            if (!meaningfulSavings) {
-                if (trigger?.forced || percentUsed >= 85) {
-                    display.showInfo('Auto-compaction completed but did not meaningfully reduce context size. Keeping existing history.');
+            let afterStats = contextManager.getStats(result.compacted);
+            let appliedHistory = result.compacted;
+            let appliedSummarized = result.summarized;
+            const initialTokenSavings = Math.max(0, beforeStats.totalTokens - afterStats.totalTokens);
+            let bestTokenSavings = initialTokenSavings;
+            let bestPercentSavings = beforeStats.totalTokens > 0 ? (initialTokenSavings / beforeStats.totalTokens) * 100 : 0;
+            let changed = this.historiesDiffer(history, appliedHistory);
+            if (!this.hasMeaningfulCompaction(changed, bestTokenSavings, bestPercentSavings, trigger?.forced)) {
+                const fallback = await contextManager.pruneMessagesWithSummary(history, { force: true });
+                const fallbackStats = contextManager.getStats(fallback.pruned);
+                const fallbackTokenSavings = Math.max(0, beforeStats.totalTokens - fallbackStats.totalTokens);
+                const fallbackPercentSavings = beforeStats.totalTokens > 0
+                    ? (fallbackTokenSavings / beforeStats.totalTokens) * 100
+                    : 0;
+                if (this.historiesDiffer(history, fallback.pruned) &&
+                    (fallbackTokenSavings > bestTokenSavings || !changed)) {
+                    appliedHistory = fallback.pruned;
+                    afterStats = fallbackStats;
+                    appliedSummarized = fallback.summarized;
+                    bestTokenSavings = fallbackTokenSavings;
+                    bestPercentSavings = fallbackPercentSavings;
+                    changed = true;
                 }
+            }
+            if (!changed) {
+                display.showInfo('Context compaction completed but no changes were applied.');
+                return;
+            }
+            if (!this.hasMeaningfulCompaction(changed, bestTokenSavings, bestPercentSavings, trigger?.forced)) {
+                display.showInfo('Auto-compaction completed but did not meaningfully reduce context size. Keeping existing history.');
                 return;
             }
-            agent.loadHistory(result.compacted);
-            this.cachedHistory = result.compacted;
-            const newPercentUsed = windowTokens > 0
-                ? Math.round((afterStats.totalTokens / windowTokens) * 100)
+            agent.loadHistory(appliedHistory);
+            this.cachedHistory = appliedHistory;
+            const newPercentUsed = resolvedWindowTokens && resolvedWindowTokens > 0
+                ? Math.min(100, Math.round((afterStats.totalTokens / resolvedWindowTokens) * 100))
                 : afterStats.percentage;
             this.latestTokenUsage = {
                 used: afterStats.totalTokens,
-                limit: windowTokens,
+                limit: resolvedWindowTokens,
             };
             this.updateContextUsage(newPercentUsed, CONTEXT_AUTOCOMPACT_PERCENT);
             this.lastContextWarningLevel = this.getContextWarningLevel(newPercentUsed);
             this.refreshStatusLine(true);
             const primarySignal = result.analysis.signals[0]?.reason ?? triggerReason;
+            const savingsLabel = bestTokenSavings > 0
+                ? `(saved ~${bestTokenSavings.toLocaleString('en-US')} tokens, ~${bestPercentSavings.toFixed(1)}%)`
+                : '(no token savings)';
             display.showSystemMessage([
                 `Context compacted: ${beforeStats.percentage}% → ${afterStats.percentage}%`,
-                `(saved ~${tokenSavings.toLocaleString('en-US')} tokens).`,
+                savingsLabel,
                 primarySignal ? `Reason: ${primarySignal}.` : '',
             ].filter(Boolean).join(' '));
+            this.recordContextCompaction({
+                timestamp: Date.now(),
+                source: trigger?.source ?? 'auto',
+                reason: triggerReason,
+                beforeTokens: beforeStats.totalTokens,
+                afterTokens: afterStats.totalTokens,
+                summarized: appliedSummarized,
+                percentBefore: resolvedWindowTokens ? percentUsed : beforeStats.percentage,
+                percentAfter: newPercentUsed,
+                model: this.sessionState.model,
+            });
         }
         catch (error) {
             display.showError('Context compaction failed.', error);
@@ -5777,7 +5905,35 @@ Return ONLY JSON array:
             this.contextCompactionInFlight = false;
         }
     }
-    shouldAutoCompactContext(usageRatio, windowTokens, totalTokens) {
+    recordContextCompaction(event) {
+        this.contextCompactionLog.push(event);
+        if (this.contextCompactionLog.length > 20) {
+            this.contextCompactionLog.shift();
+        }
+    }
+    ensureActiveSummarizer(contextManager) {
+        if (!contextManager?.updateConfig) {
+            return;
+        }
+        const summarizer = async (messages) => {
+            const summary = await this.buildContextSummary(messages);
+            return summary ?? '[No content to summarize]';
+        };
+        contextManager.updateConfig({
+            summarizationCallback: summarizer,
+            useLLMSummarization: true,
+        });
+    }
+    hasMeaningfulCompaction(changed, tokenSavings, percentSavings, forced) {
+        if (!changed) {
+            return false;
+        }
+        if (tokenSavings >= MIN_COMPACTION_TOKEN_SAVINGS || percentSavings >= MIN_COMPACTION_PERCENT_SAVINGS) {
+            return true;
+        }
+        return Boolean(forced && tokenSavings > 0);
+    }
+    shouldAutoCompactContext(usageRatio, _windowTokens, _totalTokens) {
         const featureFlags = loadFeatureFlags();
         if (featureFlags.autoCompact === false) {
             return null;
@@ -5898,6 +6054,25 @@ Return ONLY JSON array:
         }
         return false;
     }
+    areToolTurnsComplete(messages) {
+        const pending = new Set();
+        for (const message of messages) {
+            if (message.role === 'assistant' && message.toolCalls && message.toolCalls.length > 0) {
+                for (const call of message.toolCalls) {
+                    if (call.id) {
+                        pending.add(call.id);
+                    }
+                }
+            }
+            if (message.role === 'tool') {
+                const toolCallId = message.toolCallId;
+                if (toolCallId && pending.has(toolCallId)) {
+                    pending.delete(toolCallId);
+                }
+            }
+        }
+        return pending.size === 0;
+    }
     partitionHistory(history) {
         const system = [];
         const conversation = [];
@@ -5989,10 +6164,10 @@ Return ONLY JSON array:
         sections.push(`Conversation chunk:\n${chunk}`);
         sections.push([
             'Instructions:',
-            '- Merge the chunk into the running summary.',
-            '- Preserve critical TODOs, bugs, test gaps, and file references.',
-            '- Call out what is resolved vs. still pending.',
-            '- Keep the output concise (<= 200 words) using short headings or bullets.',
+            '- Merge with the running summary.',
+            '- Keep TODOs/bugs/test gaps and file references.',
+            '- Mark what is done vs. pending.',
+            '- Stay concise (<180 words) with short bullets.',
         ].join('\n'));
         return sections.join('\n\n');
     }