@calliopelabs/cli 2.2.0 → 2.5.0

package/dist/ui/agent.js

@@ -4,7 +4,6 @@
  * Core agent execution loop, tool handling, and message validation.
  * Extracted from TerminalChat using an AgentContext state bag.
  */
-import { spawn } from 'child_process';
 import * as config from '../config.js';
 import { chat } from '../providers/index.js';
 import { estimateContextUsage, needsSummarization } from '../providers/types.js';
@@ -17,13 +16,17 @@ import { getAvailableProviders } from '../providers/index.js';
 import * as storage from '../storage.js';
 import * as hooks from '../hooks.js';
 import * as modelRouter from '../model-router.js';
+import { scuttlebotClient } from '../scuttlebot/index.js';
 import * as summarization from '../summarization.js';
+import { autoCompress } from '../auto-compressor.js';
 import { executeParallel, getParallelizationStats } from '../parallel-tools.js';
 import { setMood } from '../companions.js';
 import { checkAndWarnContextLimit } from './context.js';
 import { smartRoute } from '../smart-router.js';
 import { shouldCheckpoint, createCheckpoint } from '../auto-checkpoint.js';
 import { recordEvent } from '../terminal-recording.js';
+import { startPreventSleep, stopPreventSleep } from '../prevent-sleep.js';
+import { resolveIterationLimit, formatIterationProgress, isFiniteIterationLimit, } from '../iteration-limit.js';
 // ============================================================================
 // Tool Result Truncation
 // ============================================================================
@@ -44,6 +47,21 @@ function truncateToolResult(content, modelLimit) {
     const trimmed = content.slice(0, half) + `\n\n... [truncated ${content.length - maxChars} chars] ...\n\n` + content.slice(-half);
     return trimmed;
 }
+function summarizeMessageContent(content) {
+    if (typeof content === 'string') {
+        return content;
+    }
+    return content
+        .map(block => {
+        if (block.type === 'text')
+            return block.text;
+        if (block.type === 'image')
+            return '[image]';
+        return '[content]';
+    })
+        .join(' ')
+        .trim();
+}
 // ============================================================================
 // Validate and Repair Messages
 // ============================================================================
@@ -121,8 +139,19 @@ export async function runAgentImpl(ctx, content) {
             ctx.addMessage('system', `[Auto-route: ${routeDecision.tier} tier - ${routeDecision.reason}]`);
         }
     }
-    const maxIterations = config.get('maxIterations') || Infinity; // 0 = unlimited
+    const maxIterations = resolveIterationLimit(config.get('maxIterations'));
     let completedNaturally = false;
+    const hasParentRun = Boolean(ctx.ledger?.getActiveRun('loop') ||
+        ctx.ledger?.getActiveRun('workflow') ||
+        ctx.ledger?.getActiveRun('swarm') ||
+        ctx.ledger?.getActiveRun('council'));
+    const runId = ctx.ledger && !hasParentRun
+        ? ctx.ledger.startRun('agent', summarizeMessageContent(content), {
+            maxIterations: isFiniteIterationLimit(maxIterations) ? maxIterations : null,
+        })
+        : undefined;
+    let runStatus;
+    let runErrorSummary;
     // Check context limit and warn if approaching capacity
     // Uses model's actual context length from API when available
     let currentContextTokens = ctx.estimateContextTokens();
@@ -130,32 +159,14 @@ export async function runAgentImpl(ctx, content) {
     let contextPercentage = (currentContextTokens / modelLimit) * 100;
     // Adaptive preserveRecent: small models keep fewer messages to leave room for output
     const preserveRecent = modelLimit < 8000 ? 2 : modelLimit < 16000 ? 4 : modelLimit < 32000 ? 6 : modelLimit < 64000 ? 10 : 15;
-    // Auto-compact if we're over 75% capacity to prevent API errors
-    if (contextPercentage > 75) {
-        ctx.addMessage('system', `🔄 Context at ${Math.round(contextPercentage)}% - auto-compacting to prevent errors...`);
-        const result = summarization.summarizeConversation(ctx.llmMessages.current, {
-            maxTokens: Math.floor(modelLimit * 0.7), // Target 70% of limit after compaction
-            preserveRecent,
-        });
-        if (result.summarizedCount > 0) {
-            ctx.llmMessages.current = result.messages;
-            currentContextTokens = ctx.estimateContextTokens();
-            contextPercentage = (currentContextTokens / modelLimit) * 100;
-            ctx.setContextTokens(currentContextTokens);
-            ctx.addMessage('system', `✓ Compacted ${result.summarizedCount} messages. Now at ${Math.round(contextPercentage)}% (${Math.round(currentContextTokens / 1000)}K/${Math.round(modelLimit / 1000)}K)`);
-        }
-        else {
-            // If compaction didn't help enough, force-trim old messages
-            if (contextPercentage > 98) {
-                const systemMsgs = ctx.llmMessages.current.filter(m => m.role === 'system');
-                const recentMsgs = ctx.llmMessages.current.filter(m => m.role !== 'system').slice(-5);
-                ctx.llmMessages.current = [...systemMsgs, ...recentMsgs];
-                currentContextTokens = ctx.estimateContextTokens();
-                contextPercentage = (currentContextTokens / modelLimit) * 100;
-                ctx.setContextTokens(currentContextTokens);
-                ctx.addMessage('system', `⚠️  Force-trimmed to last 5 messages (${Math.round(contextPercentage)}%). Use /clear for a full reset.`);
-            }
-        }
+    // Auto-compact using the new auto-compressor
+    const autoCompressResult = await autoCompress(ctx.llmMessages.current, modelLimit, ctx.provider, effectiveModel);
+    if (autoCompressResult.compressed) {
+        ctx.llmMessages.current = autoCompressResult.messages;
+        currentContextTokens = ctx.estimateContextTokens();
+        contextPercentage = (currentContextTokens / modelLimit) * 100;
+        ctx.setContextTokens(currentContextTokens);
+        ctx.addMessage('system', `🔄 Auto-compressed ${autoCompressResult.summarizedCount} messages using ${autoCompressResult.method} (${Math.round(autoCompressResult.originalTokens / 1000)}K → ${Math.round(autoCompressResult.compressedTokens / 1000)}K tokens)`);
     }
     else if (contextPercentage > 65) {
         ctx.addMessage('system', `⚠️  Context at ${Math.round(contextPercentage)}% capacity (${Math.round(currentContextTokens / 1000)}K/${Math.round(modelLimit / 1000)}K tokens)
@@ -170,31 +181,26 @@ export async function runAgentImpl(ctx, content) {
     }
     for (let i = 0; i < maxIterations; i++) {
         // Start ledger tracking for this iteration
-        ctx.ledger?.startIteration(i + 1);
+        if (ctx.ledger) {
+            ctx.ledger.startIteration(ctx.ledger.getNextIterationNumber());
+        }
         // Safety check at start of each iteration - context may have grown from tool results
         if (i > 0) {
             const iterContextTokens = ctx.estimateContextTokens();
-            const iterContextPercentage = (iterContextTokens / modelLimit) * 100;
-            if (iterContextPercentage > 75) {
-                ctx.addMessage('system', `🔄 Context grew to ${Math.round(iterContextPercentage)}% - auto-compacting...`);
-                const result = summarization.summarizeConversation(ctx.llmMessages.current, {
-                    maxTokens: Math.floor(modelLimit * 0.7),
-                    preserveRecent,
-                });
-                if (result.summarizedCount > 0) {
-                    ctx.llmMessages.current = result.messages;
-                    ctx.setContextTokens(ctx.estimateContextTokens());
-                    ctx.addMessage('system', `✓ Compacted ${result.summarizedCount} messages during iteration ${i + 1}`);
-                }
+            const iterAutoCompressResult = await autoCompress(ctx.llmMessages.current, modelLimit, ctx.provider, effectiveModel);
+            if (iterAutoCompressResult.compressed) {
+                ctx.llmMessages.current = iterAutoCompressResult.messages;
+                ctx.setContextTokens(ctx.estimateContextTokens());
+                ctx.addMessage('system', `🔄 Auto-compressed ${iterAutoCompressResult.summarizedCount} messages during iteration ${i + 1} (${iterAutoCompressResult.method})`);
             }
         }
         try {
             // Update thinking state for LLM call
             ctx.setThinkingState({
                 status: i === 0 ? 'Analyzing request...' : 'Processing response...',
-                detail: `Iteration ${i + 1}/${maxIterations}`,
+                detail: `Iteration ${formatIterationProgress(i + 1, maxIterations)}`,
                 iteration: i + 1,
-                maxIterations,
+                maxIterations: isFiniteIterationLimit(maxIterations) ? maxIterations : undefined,
             });
             ctx.setActivityState({
                 action: i === 0 ? 'Analyzing request' : 'Processing',
@@ -212,7 +218,7 @@ export async function runAgentImpl(ctx, content) {
                     status: `Retrying... (attempt ${attempt + 1})`,
                     detail: `${error.message.substring(0, 40)}... Waiting ${Math.round(delayMs / 1000)}s`,
                     iteration: i + 1,
-                    maxIterations,
+                    maxIterations: isFiniteIterationLimit(maxIterations) ? maxIterations : undefined,
                 });
             };
             ctx.debugLog('chat', 'WAITING for LLM response', `iteration=${i + 1}`);
@@ -276,6 +282,8 @@ export async function runAgentImpl(ctx, content) {
                 ctx.setBreakerHealth?.(ctx.circuitBreaker.getHealth());
                 if (breakerResult.tripped) {
                     ctx.addMessage('system', `\u26a0\ufe0f Circuit breaker tripped: ${breakerResult.breaker}\n${breakerResult.message}\n\nUse /breaker resume to continue, /breaker status for details.`);
+                    runStatus = 'stopped';
+                    runErrorSummary = breakerResult.message;
                     completedNaturally = true;
                     break;
                 }
@@ -287,6 +295,10 @@ export async function runAgentImpl(ctx, content) {
                     content: response.content,
                     toolCalls: response.toolCalls,
                 });
+                // Mirror any text the assistant produced alongside the tool calls
+                if (scuttlebotClient.isEnabled() && response.content) {
+                    scuttlebotClient.mirrorAssistant(response.content).catch(() => { });
+                }
                 const preChecks = [];
                 const executableTools = [];
                 for (const toolCall of response.toolCalls) {
@@ -360,7 +372,7 @@ export async function runAgentImpl(ctx, content) {
                             status: `Executing ${executableTools.length} tools in parallel...`,
                             detail: `${parallelStats.stages} stages, up to ${parallelStats.maxParallel}x speedup`,
                             iteration: i + 1,
-                            maxIterations,
+                            maxIterations: isFiniteIterationLimit(maxIterations) ? maxIterations : undefined,
                         });
                         ctx.setActivityState({
                             action: `Executing ${executableTools.length} tools`,
@@ -370,8 +382,8 @@ export async function runAgentImpl(ctx, content) {
                         // Execute in parallel using dependency-aware staging
                         ctx.debugLog('tools', 'PARALLEL exec start', `count=${executableTools.length}`);
                         const results = await executeParallel(executableTools, async (call) => {
-                            const result = await executeTool(call, process.cwd());
-                            return result.result;
+                            const result = await executeTool(call, ctx.sessionRef.current?.projectPath ?? process.cwd());
+                            return { result: result.result, isError: result.isError };
                         }, (completed, total, current) => {
                             const args = current.arguments;
                             const target = args.path || args.command?.substring(0, 30) || current.name;
@@ -384,7 +396,7 @@ export async function runAgentImpl(ctx, content) {
                                 status: `Executing tools... (${completed + 1}/${total})`,
                                 detail: current.name,
                                 iteration: i + 1,
-                                maxIterations,
+                                maxIterations: isFiniteIterationLimit(maxIterations) ? maxIterations : undefined,
                             });
                         });
                         ctx.debugLog('tools', 'PARALLEL exec done', `results=${results.length}`);
@@ -392,10 +404,14 @@ export async function runAgentImpl(ctx, content) {
                         for (const result of results) {
                             const toolCall = result.toolCall;
                             const args = toolCall.arguments;
+                            // A tool-level failure (result.isError) or a thrown exception (result.error)
+                            // both count as a failure — mirror the sequential branch.
+                            const failed = result.isError || !!result.error;
+                            const failureText = result.error || result.result;
                             recordEvent('tool_call', toolCall.name, { name: toolCall.name, arguments: args });
-                            recordEvent('tool_result', (result.result || result.error || '').slice(0, 1000), { name: toolCall.name, isError: !!result.error });
+                            recordEvent('tool_result', (result.result || result.error || '').slice(0, 1000), { name: toolCall.name, isError: failed });
                             // Record in iteration ledger
-                            ctx.ledger?.recordAction(toolCall.name, args, result.error ? 'error' : 'ok', result.error || undefined);
+                            ctx.ledger?.recordAction(toolCall.name, args, failed ? 'error' : 'ok', failed ? failureText : undefined);
                             // Execute post-tool hooks
                             hooks.executeHooks('post-tool', {
                                 tool: toolCall.name,
@@ -410,11 +426,11 @@ export async function runAgentImpl(ctx, content) {
                                 ctx.addMessage('tool', thought);
                             }
                             else if (result.error) {
-                                ctx.addMessage('tool', `Error: ${result.error}`);
+                                ctx.addMessage('tool', `Error: ${result.error}`, true);
                             }
                             else {
                                 const preview = result.result.split('\n').slice(0, 3).join('\n');
-                                ctx.addMessage('tool', preview + (result.result.split('\n').length > 3 ? '\n...' : ''));
+                                ctx.addMessage('tool', preview + (result.result.split('\n').length > 3 ? '\n...' : ''), failed);
                             }
                             ctx.llmMessages.current.push({
                                 role: 'tool',
@@ -454,7 +470,7 @@ export async function runAgentImpl(ctx, content) {
                                     detail: thought.substring(0, 60) + (thought.length > 60 ? '...' : ''),
                                     thinking: thought,
                                     iteration: i + 1,
-                                    maxIterations,
+                                    maxIterations: isFiniteIterationLimit(maxIterations) ? maxIterations : undefined,
                                 });
                             }
                             else {
@@ -463,7 +479,7 @@ export async function runAgentImpl(ctx, content) {
                                     detail: toolPreview.substring(0, 60),
                                     thinking: undefined,
                                     iteration: i + 1,
-                                    maxIterations,
+                                    maxIterations: isFiniteIterationLimit(maxIterations) ? maxIterations : undefined,
                                 });
                             }
                             ctx.debugLog('tools', 'EXEC', toolCall.name, toolPreview.substring(0, 30));
@@ -484,7 +500,7 @@ export async function runAgentImpl(ctx, content) {
                                     detail: chunk.trimEnd().split('\n').pop()?.substring(0, 60),
                                 });
                             } : undefined;
-                            const result = await executeTool(toolCall, process.cwd(), 60000, shellStreamCallback);
+                            const result = await executeTool(toolCall, ctx.sessionRef.current?.projectPath ?? process.cwd(), 60000, shellStreamCallback);
                             ctx.debugLog('tools', 'DONE', toolCall.name);
                             recordEvent('tool_result', result.result.slice(0, 1000), { name: toolCall.name, isError: result.isError });
                             // Record in iteration ledger
@@ -545,7 +561,7 @@ export async function runAgentImpl(ctx, content) {
                             else {
                                 const display = result.displayResult || result.result;
                                 const preview = display.split('\n').slice(0, 5).join('\n');
-                                ctx.addMessage('tool', preview + (display.split('\n').length > 5 ? '\n...' : ''));
+                                ctx.addMessage('tool', preview + (display.split('\n').length > 5 ? '\n...' : ''), result.isError);
                             }
                             if (toolCall.name !== 'ask_question') {
                                 ctx.llmMessages.current.push({
@@ -567,6 +583,12 @@ export async function runAgentImpl(ctx, content) {
             ctx.llmMessages.current.push({ role: 'assistant', content: response.content });
             ctx.addMessage('assistant', response.content);
             recordEvent('output', response.content.slice(0, 5000));
+            // Mirror assistant message to scuttlebot
+            if (scuttlebotClient.isEnabled()) {
+                scuttlebotClient.mirrorAssistant(response.content).catch(() => {
+                    // Silent fail
+                });
+            }
             ctx.setStreamingResponse('');
             ctx.setContextTokens(ctx.estimateContextTokens());
             checkAndWarnContextLimit(ctx.actualProvider, ctx.actualModel, ctx.estimateContextTokens(), ctx.addMessage);
@@ -578,6 +600,7 @@ export async function runAgentImpl(ctx, content) {
                 continue; // Loop again to get continuation
             }
             completedNaturally = true;
+            runStatus = 'completed';
             // End iteration ledger entry
             ctx.ledger?.endIteration('success');
             // Auto-save full message history for session persistence
@@ -609,6 +632,8 @@ export async function runAgentImpl(ctx, content) {
                 ctx.setBreakerHealth?.(ctx.circuitBreaker.getHealth());
                 if (breakerResult.tripped) {
                     ctx.addMessage('system', `\u26a0\ufe0f Circuit breaker tripped: ${breakerResult.breaker}\n${breakerResult.message}\n\nUse /breaker resume to continue.`);
+                    runStatus = 'stopped';
+                    runErrorSummary = breakerResult.message;
                     completedNaturally = true;
                     break;
                 }
@@ -635,18 +660,30 @@ export async function runAgentImpl(ctx, content) {
             }
             // Non-retryable errors (auth, etc.) still kill the session
             completedNaturally = true;
+            runStatus = 'failed';
+            runErrorSummary = errorMsg;
             // On error, clear queued messages to prevent infinite retry loop
             const currentQueuedOnError = ctx.queuedMessagesRef.current;
             if (currentQueuedOnError.length > 0) {
                 ctx.addMessage('system', `\u26a0\ufe0f Cleared ${currentQueuedOnError.length} queued message(s) due to error. Use /clear to reset conversation.`);
                 ctx.setQueuedMessages([]);
             }
+            if (runId && runStatus) {
+                ctx.ledger?.finishRun(runId, runStatus, { errorSummary: runErrorSummary });
+            }
             return; // Exit early on error - don't process queued messages
         }
     }
     // Only show warning if we actually hit the iteration limit (not errors or natural completion)
-    if (!completedNaturally) {
+    if (!completedNaturally && isFiniteIterationLimit(maxIterations)) {
         ctx.addMessage('system', `⚠️ Reached ${maxIterations} iterations limit. Task may be incomplete. Adjust with /set maxIterations <number>.`);
+        if (!runStatus) {
+            runStatus = 'stopped';
+            runErrorSummary = `Reached ${maxIterations} iterations limit`;
+        }
+    }
+    if (runId) {
+        ctx.ledger?.finishRun(runId, runStatus || 'completed', { errorSummary: runErrorSummary });
     }
     // Update context tokens after agent run
     ctx.setContextTokens(ctx.estimateContextTokens());
@@ -684,29 +721,6 @@ export async function runAgentImpl(ctx, content) {
 // ============================================================================
 // Run Loop
 // ============================================================================
-/**
- * Start caffeinate to prevent system sleep during long operations (macOS).
- */
-function startCaffeinate() {
-    if (process.platform !== 'darwin')
-        return null;
-    try {
-        const proc = spawn('caffeinate', ['-di'], { stdio: 'ignore', detached: true });
-        proc.unref();
-        return proc;
-    }
-    catch {
-        return null;
-    }
-}
-function stopCaffeinate(proc) {
-    if (proc) {
-        try {
-            proc.kill('SIGTERM');
-        }
-        catch { /* already dead */ }
-    }
-}
 /**
  * Agent loop - runs prompt repeatedly until completion promise or max iterations.
  */
@@ -714,55 +728,95 @@ export async function runLoopImpl(ctx, prompt, maxIter, completionPromise) {
     ctx.setIsProcessing(true);
     setMood('focused');
     // Prevent system sleep during long agent loops (macOS)
-    const caffeinateProc = startCaffeinate();
-    for (let i = 0; i < maxIter; i++) {
-        // Check if cancelled
-        if (ctx.loopCancelledRef.current) {
-            ctx.addMessage('system', '🛑 Loop cancelled by user');
-            break;
-        }
-        ctx.setLoopIteration(i + 1);
-        ctx.addMessage('system', `🔄 Loop iteration ${i + 1}/${maxIter}`);
-        // First iteration: send original prompt. Subsequent: send continuation.
-        const iterationPrompt = i === 0
-            ? prompt
-            : `Continue working on the task: "${prompt}"\n\nThis is iteration ${i + 1}. Review what you've done so far and continue making progress.`;
-        ctx.llmMessages.current.push({ role: 'user', content: iterationPrompt });
-        try {
-            // Run the agent
-            await runAgentImpl(ctx, iterationPrompt);
-            // Check for completion promise in the last assistant message
-            if (completionPromise) {
-                const lastMessage = ctx.llmMessages.current[ctx.llmMessages.current.length - 1];
-                if (lastMessage?.role === 'assistant') {
-                    const content = typeof lastMessage.content === 'string'
-                        ? lastMessage.content
-                        : JSON.stringify(lastMessage.content);
-                    if (content.includes(completionPromise)) {
-                        ctx.addMessage('system', `🎉 Completion promise "${completionPromise}" detected! Loop finished.`);
-                        break;
+    startPreventSleep();
+    let completedIterations = 0;
+    let loopOutcome = 'running';
+    let loopErrorSummary;
+    const loopRunId = ctx.ledger?.startRun('loop', prompt, {
+        completionPromise,
+        maxIterations: isFiniteIterationLimit(maxIter) ? maxIter : null,
+    });
+    try {
+        for (let i = 0; i < maxIter; i++) {
+            // Check if cancelled
+            if (ctx.loopCancelledRef.current) {
+                ctx.addMessage('system', '🛑 Loop cancelled by user');
+                loopOutcome = 'cancelled';
+                break;
+            }
+            completedIterations = i + 1;
+            ctx.setLoopIteration(completedIterations);
+            ctx.addMessage('system', `🔄 Loop iteration ${formatIterationProgress(completedIterations, maxIter)}`);
+            // First iteration: send original prompt. Subsequent: send continuation.
+            const iterationPrompt = i === 0
+                ? prompt
+                : `Continue working on the task: "${prompt}"\n\nThis is iteration ${i + 1}. Review what you've done so far and continue making progress.`;
+            try {
+                // Run the agent
+                await runAgentImpl(ctx, iterationPrompt);
+                // Check for completion promise in the last assistant message
+                if (completionPromise) {
+                    const lastMessage = ctx.llmMessages.current[ctx.llmMessages.current.length - 1];
+                    if (lastMessage?.role === 'assistant') {
+                        const content = typeof lastMessage.content === 'string'
+                            ? lastMessage.content
+                            : JSON.stringify(lastMessage.content);
+                        if (content.includes(completionPromise)) {
+                            ctx.addMessage('system', `🎉 Completion promise "${completionPromise}" detected! Loop finished.`);
+                            loopOutcome = 'promise-met';
+                            break;
+                        }
                     }
                 }
+                // Check cancelled again after agent run
+                if (ctx.loopCancelledRef.current) {
+                    ctx.addMessage('system', '🛑 Loop cancelled by user');
+                    loopOutcome = 'cancelled';
+                    break;
+                }
+                // Small delay between iterations
+                if (i + 1 < maxIter) {
+                    await new Promise(r => setTimeout(r, 500));
+                }
             }
-            // Check cancelled again after agent run
-            if (ctx.loopCancelledRef.current) {
-                ctx.addMessage('system', '🛑 Loop cancelled by user');
+            catch (error) {
+                loopErrorSummary = error instanceof Error ? error.message : String(error);
+                ctx.addMessage('error', `Loop error: ${loopErrorSummary}`);
+                loopOutcome = 'error';
                 break;
             }
-            // Small delay between iterations
-            await new Promise(r => setTimeout(r, 500));
         }
-        catch (error) {
-            ctx.addMessage('error', `Loop error: ${error instanceof Error ? error.message : String(error)}`);
-            break;
+        if (loopOutcome === 'running') {
+            if (completionPromise) {
+                ctx.addMessage('system', `⚠️ Loop stopped after ${completedIterations} iteration${completedIterations === 1 ? '' : 's'} without matching completion promise "${completionPromise}".`);
+            }
+            else {
+                ctx.addMessage('system', `✅ Loop completed ${completedIterations} iteration${completedIterations === 1 ? '' : 's'}.`);
+            }
         }
     }
-    // If we completed all iterations without hitting completion promise
-    if (!ctx.loopCancelledRef.current && !completionPromise) {
-        ctx.addMessage('system', `✅ Loop completed ${maxIter} iterations`);
+    finally {
+        if (loopRunId) {
+            const finalStatus = loopOutcome === 'cancelled'
+                ? 'cancelled'
+                : loopOutcome === 'error'
+                    ? 'failed'
+                    : loopOutcome === 'promise-met'
+                        ? 'completed'
+                        : completionPromise
+                            ? 'stopped'
+                            : 'completed';
+            ctx.ledger?.finishRun(loopRunId, finalStatus, {
+                errorSummary: loopErrorSummary
+                    || (finalStatus === 'cancelled' ? 'Stopped by user' : undefined)
+                    || (finalStatus === 'stopped' && completionPromise
+                        ? `Stopped after ${completedIterations} iterations without matching completion promise`
+                        : undefined),
+            });
+        }
+        ctx.setLoopActive(false);
+        ctx.setIsProcessing(false);
+        stopPreventSleep();
     }
-    ctx.setLoopActive(false);
-    ctx.setIsProcessing(false);
-    stopCaffeinate(caffeinateProc);
 }
 //# sourceMappingURL=agent.js.map