@denizokcu/haze 0.0.2 → 0.0.3

package/dist/cli/commands/streaming.js

@@ -5,6 +5,11 @@ import { buildSystemPrompt } from '../../llm/systemPrompt.js';
 import { loadSkillRegistry } from '../../skills/SkillRegistry.js';
 import { buildSkillTools } from '../../skills/skillTools.js';
 import { compact, toolCallSummary, toolResultSummary, formatSeconds } from './formatters.js';
+import { isActionRequest, isPlanImplementationRequest, isPlanOnlyRequest, isValidationRequest } from '../../core/goal/requestClassifier.js';
+import { completionDecision, looksIncomplete, noTextAfterToolPrompt, postContinuationPrompt, toolLoopBudgetPrompt } from '../../core/goal/completionPolicy.js';
+import { createSessionGoal, formatGoalStatus, observeGoalToolEvent } from '../../core/goal/sessionGoal.js';
+import { agentEvent } from '../../core/agent/events.js';
+import { isContextOverflowError, isRetryableModelError } from '../../core/agent/errors.js';
 function stableToolKey(toolCall) {
     return `${toolCall.toolName}:${JSON.stringify(toolCall.input)}`;
 }
@@ -28,31 +33,17 @@ function toolOnlyStepCount(steps) {
     }
     return count;
 }
-function isPlanOnlyRequest(value) {
-    return /\b(create|make|write|draft|outline)\s+(?:a\s+)?plan\b|\bplan\s+(?:for|to)\b/i.test(value) && !/\bimplement|execute|do\b/i.test(value);
-}
-function isLikelyActionRequest(value) {
-    if (isPlanOnlyRequest(value))
-        return false;
-    return /\b(add|create|write|implement|update|fix|change|support|wire|test|tests|document|docs|documentation|run|verify)\b/i.test(value);
-}
-function isValidationRequest(value) {
-    if (isPlanOnlyRequest(value))
-        return false;
-    return /\b(run|verify|test|tests|check|validate)\b/i.test(value);
-}
-function isPlanImplementationRequest(value) {
-    return /\b(implement|execute|do)\b.*\bplan\b|\bplan\.md\b|\btest_plan\.md\b/i.test(value);
-}
-function looksIncomplete(text) {
-    return /\b(incomplete|what remains|remains:|next:|not implemented|not created|no tests exist|created no docs|has not been|have not been|not yet|never executed|not executed|not run|cannot retry|cannot write|cannot validate|tool budget reached)\b/i.test(text);
-}
 function sanitizeAssistantText(text) {
     return [...text].filter(char => {
         const code = char.charCodeAt(0);
         return !(code <= 8 || code === 11 || code === 12 || (code >= 14 && code <= 31) || code === 127 || code === 155);
     }).join('');
 }
+function hideSyntheticToolCallMarkup(text) {
+    return text
+        .replace(/(^|\n)\s*(?:```(?:xml)?\s*)?(?:xml\s*)?<tool_call>[\s\S]*?<\/tool_call>\s*(?:```)?/gi, '$1')
+        .replace(/(^|\n)\s*(?:```(?:xml)?\s*)?(?:xml\s*)?<tool_call>[\s\S]*$/i, '$1');
+}
 function toolInputPath(input) {
     return typeof input === 'object' && input != null && 'path' in input && typeof input.path === 'string'
         ? input.path
@@ -61,13 +52,36 @@ function toolInputPath(input) {
 function isDuplicateSkippedOutput(output) {
     return typeof output === 'object' && output != null && 'duplicateSkipped' in output && output.duplicateSkipped === true;
 }
-export async function runAgentTurn(value, displayValue, contextFiles, callbacks) {
+function retryDelayMs(attempt) {
+    return Math.min(4000, 1000 * 2 ** attempt);
+}
+async function abortableDelay(milliseconds, signal) {
+    if (signal.aborted)
+        return;
+    await new Promise(resolve => {
+        const timer = setTimeout(resolve, milliseconds);
+        signal.addEventListener('abort', () => {
+            clearTimeout(timer);
+            resolve();
+        }, { once: true });
+    });
+}
+const DEFAULT_MAX_OUTPUT_TOKENS = 8192;
+function toolOutputOk(output, success) {
+    if (!success)
+        return false;
+    return !(typeof output === 'object' && output != null && 'ok' in output && output.ok === false);
+}
+export async function runAgentTurn(value, displayValue, contextFiles, callbacks, retryAttempt = 0, retryingExistingRequest = false, contextOverflowRecovered = false) {
     const displayVal = displayValue ?? value;
     const userMessage = { role: 'user', text: displayVal };
+    callbacks.onEvent?.(agentEvent({ type: 'turn_start', request: value }));
     callbacks.setBusy(true);
-    callbacks.addMessage(userMessage);
+    if (!retryingExistingRequest)
+        callbacks.addMessage(userMessage);
     const abortController = new AbortController();
     callbacks.setAbortController?.(abortController);
+    let turnStatus = 'failed';
     let idleTimer;
     const resetIdleTimer = () => {
         if (idleTimer)
@@ -77,24 +91,29 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks)
     try {
         const m = await model();
         if (!m) {
-            callbacks.addMessage({ role: 'assistant', text: 'No API key configured. Run /login, then /model x-ai/grok-build-0.1. Haze cannot hallucinate without credentials. Progress.' });
+            callbacks.addMessage({ role: 'assistant', text: 'No model provider configured. Run /provider to choose or add a provider. Haze cannot hallucinate without a model. Progress.' });
             return;
         }
         const activeModel = m;
         const skillRegistry = await loadSkillRegistry();
         const availableTools = { ...hazeTools, ...buildSkillTools(skillRegistry) };
+        const goal = createSessionGoal(value);
+        callbacks.setGoalStatus?.(formatGoalStatus(goal));
         const likelyPlanOnlyRequest = isPlanOnlyRequest(value);
         const likelyPlanImplementationRequest = isPlanImplementationRequest(value);
-        const likelyActionRequest = isLikelyActionRequest(value);
+        const likelyActionRequest = isActionRequest(value);
         const likelyValidationRequest = isValidationRequest(value);
         const planImplementationGuidance = 'When implementing a plan file, first identify the concrete required checklist items and compare them with the current files. Do not edit source or tests when the required behavior is already present. Implement the smallest clearly required phase or required items, skip optional/design-question items unless explicitly requested, add tests rather than exploratory one-off scripts where possible, use file tools (not bash) for any file changes, run validation once after code/test edits, then update plan status with file tools if requested. Do not call unresolved optional scope a blocker.';
-        const requestMessages = likelyPlanImplementationRequest
-            ? [...callbacks.getConversation(), { role: 'user', content: value }, { role: 'user', content: planImplementationGuidance }]
-            : [...callbacks.getConversation(), { role: 'user', content: value }];
+        const requestMessages = retryingExistingRequest
+            ? callbacks.getConversation()
+            : likelyPlanImplementationRequest
+                ? [...callbacks.getConversation(), { role: 'user', content: value }, { role: 'user', content: planImplementationGuidance }]
+                : [...callbacks.getConversation(), { role: 'user', content: value }];
         callbacks.setConversation(requestMessages);
         resetIdleTimer();
         let currentAssistantId = `assistant-${Date.now()}`;
         let assistantStarted = false;
+        let currentAssistantStarted = false;
         let currentAssistantText = '';
         let assistantText = '';
         let toolEpoch = 0;
@@ -102,11 +121,12 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks)
         let editFileFailed = false;
         let mutatingToolSucceeded = false;
         let validationToolSucceeded = false;
+        let validationToolFailed = false;
         let sawReadOnlyTool = false;
         let sawToolCall = false;
         let textAfterTool = false;
-        let forcedContinuationUsed = false;
-        let secondContinuationUsed = false;
+        let completionContinuationCount = 0;
+        const maxCompletionContinuations = 4;
         let editRecoveryPath;
         let editRecoveryReadSatisfied = false;
         const toolSummaries = [];
@@ -116,8 +136,14 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks)
         let toolGroupStarted = false;
         function renderToolGroup(streaming) {
             const visibleItems = toolDisplayItems.filter(item => !item.hidden);
+            const running = visibleItems.some(item => item.status === 'running');
+            const failures = visibleItems.filter(item => item.status === 'error');
+            const changes = visibleItems.filter(item => /^(editFile|replaceLines|writeFile)\b/.test(item.summary));
+            const compactItems = !running && visibleItems.length > 12
+                ? [...new Map([...failures, ...changes].map(item => [item.id, item])).values()]
+                : visibleItems;
             const grouped = new Map();
-            for (const item of visibleItems) {
+            for (const item of compactItems) {
                 const key = `${item.status}:${item.summary}:${item.result ?? ''}`;
                 const current = grouped.get(key);
                 if (current)
@@ -126,8 +152,10 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks)
                     grouped.set(key, { item, count: 1 });
             }
             const rows = [...grouped.values()];
-            const running = visibleItems.some(item => item.status === 'running');
-            const header = running || streaming ? 'Running tools' : `Tools: ${visibleItems.length} call${visibleItems.length === 1 ? '' : 's'}`;
+            const compactSuffix = !running && visibleItems.length > 12 ? ` · showing ${compactItems.length} important` : '';
+            const header = running || streaming
+                ? 'Running tools'
+                : `${visibleItems.length} call${visibleItems.length === 1 ? '' : 's'} · ${changes.length} change${changes.length === 1 ? '' : 's'} · ${failures.length} failed${compactSuffix}`;
             const lines = rows.map(({ item, count }) => {
                 const icon = item.status === 'running' ? '…' : item.status === 'success' ? '✓' : '✗';
                 const countText = count > 1 ? ` ×${count}` : '';
@@ -147,34 +175,39 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks)
             }
         }
         function recordToolStart(toolCall) {
+            callbacks.onEvent?.(agentEvent({ type: 'tool_start', id: toolCall.toolCallId, name: toolCall.toolName, input: toolCall.input }));
             toolDisplayItems.push({ id: toolCall.toolCallId, summary: toolCallSummary(toolCall.toolName, toolCall.input), status: 'running' });
             updateToolGroup(true);
         }
         function recordToolDisplayFinish(event) {
+            callbacks.onEvent?.(agentEvent({ type: 'tool_end', id: event.toolCall.toolCallId, name: event.toolCall.toolName, success: event.success, output: event.output, error: event.error, durationMs: event.durationMs }));
             const item = toolDisplayItems.find(candidate => candidate.id === event.toolCall.toolCallId);
             if (!item)
                 return;
-            item.status = event.success ? 'success' : 'error';
+            item.status = toolOutputOk(event.output, event.success) ? 'success' : 'error';
             item.result = toolResultSummary(event);
             item.durationMs = event.durationMs;
             item.hidden = isDuplicateSkippedOutput(event.output);
             updateToolGroup(toolDisplayItems.some(candidate => candidate.status === 'running'));
         }
-        callbacks.debugLog(`request started with ${requestMessages.length} conversation messages; action=${likelyActionRequest}`);
+        callbacks.debugLog(`request started with ${requestMessages.length} conversation messages; intent=${goal.normalizedIntent}; action=${likelyActionRequest}`);
         function recordToolFinish(event) {
             const path = toolInputPath(event.toolCall.input);
             const duplicateSkipped = isDuplicateSkippedOutput(event.output);
-            if (!event.success && ['editFile', 'replaceLines', 'writeFile'].includes(event.toolCall.toolName)) {
+            const ok = toolOutputOk(event.output, event.success);
+            observeGoalToolEvent(goal, { ...event.toolCall, success: ok, output: event.output, duplicateSkipped });
+            callbacks.setGoalStatus?.(formatGoalStatus(goal));
+            if (!ok && ['editFile', 'replaceLines', 'writeFile'].includes(event.toolCall.toolName)) {
                 editFileFailed = true;
                 editRecoveryPath = path;
                 editRecoveryReadSatisfied = false;
             }
-            if (event.success && ['listFiles', 'readFile'].includes(event.toolCall.toolName))
+            if (ok && ['listFiles', 'readFile'].includes(event.toolCall.toolName))
                 sawReadOnlyTool = true;
-            if (event.success && event.toolCall.toolName === 'readFile' && path && path === editRecoveryPath && !duplicateSkipped) {
+            if (ok && event.toolCall.toolName === 'readFile' && path && path === editRecoveryPath && !duplicateSkipped) {
                 editRecoveryReadSatisfied = true;
             }
-            if (event.success && ['editFile', 'replaceLines', 'writeFile'].includes(event.toolCall.toolName)) {
+            if (ok && !duplicateSkipped && ['editFile', 'replaceLines', 'writeFile'].includes(event.toolCall.toolName)) {
                 mutatingToolSucceeded = true;
                 if (!path || path === editRecoveryPath) {
                     editRecoveryPath = undefined;
@@ -183,9 +216,10 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks)
                 }
             }
             if (event.success && event.toolCall.toolName === 'bash') {
-                const ok = typeof event.output === 'object' && event.output != null && 'ok' in event.output ? Boolean(event.output.ok) : true;
                 if (ok)
                     validationToolSucceeded = true;
+                else
+                    validationToolFailed = true;
             }
         }
         async function streamAssistantResponse(messages, reason, prompt, allowTools = false) {
@@ -194,6 +228,7 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks)
             let responseStarted = false;
             let responseText = '';
             let continuationToolCalls = 0;
+            let followUpStreamError;
             const continuationMessages = [
                 ...messages,
                 { role: 'user', content: prompt },
@@ -201,6 +236,7 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks)
             const followUp = streamText({
                 model: activeModel,
                 temperature: 0,
+                maxOutputTokens: DEFAULT_MAX_OUTPUT_TOKENS,
                 system: buildSystemPrompt(contextFiles),
                 messages: continuationMessages,
                 tools: availableTools,
@@ -215,7 +251,7 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks)
                             toolChoice: 'none',
                             messages: [
                                 ...messages,
-                                { role: 'user', content: 'Tool budget reached. If the current request is complete, summarize only current-turn changes and validation. If incomplete, state the concrete blocker briefly; do not claim tools are unavailable and do not recap unrelated earlier tasks.' },
+                                { role: 'user', content: toolLoopBudgetPrompt() },
                             ],
                         };
                     }
@@ -242,6 +278,7 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks)
                     return undefined;
                 },
                 onError({ error }) {
+                    followUpStreamError = error;
                     callbacks.debugLog(`stream error: ${error instanceof Error ? error.message : String(error)}`);
                 },
                 onFinish(event) {
@@ -271,23 +308,38 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks)
                 resetIdleTimer();
                 const delta = sanitizeAssistantText(rawDelta);
                 responseText += delta;
+                const displayText = hideSyntheticToolCallMarkup(responseText);
+                if (!displayText && !responseStarted)
+                    continue;
                 if (!responseStarted) {
                     responseStarted = true;
-                    callbacks.addMessage({ id: responseId, role: 'assistant', text: delta, streaming: true });
+                    callbacks.onEvent?.(agentEvent({ type: 'message_start', id: responseId, role: 'assistant' }));
+                    callbacks.addMessage({ id: responseId, role: 'assistant', text: displayText, streaming: true });
                 }
                 else {
-                    callbacks.updateMessage(responseId, { text: responseText });
+                    callbacks.onEvent?.(agentEvent({ type: 'message_update', id: responseId, text: displayText }));
+                    callbacks.updateMessage(responseId, { text: displayText });
                 }
             }
+            try {
+                await followUp.response;
+            }
+            catch (error) {
+                throw followUpStreamError ?? error;
+            }
+            const finalText = hideSyntheticToolCallMarkup(responseText).trim();
             if (responseStarted) {
-                callbacks.setLastAssistantText(responseText.trim());
-                callbacks.updateMessage(responseId, { streaming: false });
+                callbacks.setLastAssistantText(finalText);
+                callbacks.onEvent?.(agentEvent({ type: 'message_end', id: responseId, text: finalText, hidden: finalText.length === 0 }));
+                callbacks.updateMessage(responseId, { text: finalText, streaming: false, hidden: finalText.length === 0 });
             }
-            return responseText.trim();
+            return { text: finalText, id: responseId, started: responseStarted };
         }
+        let streamError;
         const result = streamText({
             model: activeModel,
             temperature: 0,
+            maxOutputTokens: DEFAULT_MAX_OUTPUT_TOKENS,
             system: buildSystemPrompt(contextFiles),
             messages: requestMessages,
             tools: availableTools,
@@ -295,6 +347,7 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks)
             abortSignal: abortController.signal,
             experimental_context: toolExecutionContext,
             onError({ error }) {
+                streamError = error;
                 callbacks.debugLog(`stream error: ${error instanceof Error ? error.message : String(error)}`);
             },
             prepareStep({ steps, messages }) {
@@ -346,7 +399,7 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks)
                         toolChoice: 'none',
                         messages: [
                             ...messages,
-                            { role: 'user', content: 'Tool budget reached. If the current request is complete, summarize only current-turn changes and validation. If the requested change is incomplete, state the concrete blocker briefly. Do not claim tools are unavailable, recap unrelated earlier tasks, or provide a generic remains list.' },
+                            { role: 'user', content: toolLoopBudgetPrompt() },
                         ],
                     };
                 }
@@ -386,20 +439,28 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks)
             const delta = sanitizeAssistantText(rawDelta);
             if (sawToolCall)
                 textAfterTool = true;
-            if (currentAssistantText.length > 0 && toolEpoch > currentAssistantToolEpoch) {
+            if (currentAssistantStarted && currentAssistantText.length > 0 && toolEpoch > currentAssistantToolEpoch) {
+                callbacks.onEvent?.(agentEvent({ type: 'message_end', id: currentAssistantId, text: hideSyntheticToolCallMarkup(currentAssistantText).trim() }));
                 callbacks.updateMessage(currentAssistantId, { streaming: false });
                 currentAssistantId = `assistant-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+                currentAssistantStarted = false;
                 currentAssistantText = '';
                 currentAssistantToolEpoch = toolEpoch;
             }
             assistantText += delta;
             currentAssistantText += delta;
-            if (currentAssistantText === delta) {
+            const displayText = hideSyntheticToolCallMarkup(currentAssistantText);
+            if (!displayText && !currentAssistantStarted)
+                continue;
+            if (!currentAssistantStarted) {
                 assistantStarted = true;
-                callbacks.addMessage({ id: currentAssistantId, role: 'assistant', text: currentAssistantText, streaming: true });
+                currentAssistantStarted = true;
+                callbacks.onEvent?.(agentEvent({ type: 'message_start', id: currentAssistantId, role: 'assistant' }));
+                callbacks.addMessage({ id: currentAssistantId, role: 'assistant', text: displayText, streaming: true });
             }
             else {
-                callbacks.updateMessage(currentAssistantId, { text: currentAssistantText });
+                callbacks.onEvent?.(agentEvent({ type: 'message_update', id: currentAssistantId, text: displayText }));
+                callbacks.updateMessage(currentAssistantId, { text: displayText });
             }
         }
         let completedConversation = callbacks.getConversation();
@@ -408,54 +469,73 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks)
             completedConversation = [...requestMessages, ...response.messages];
             callbacks.setConversation(completedConversation);
         }
-        catch {
-            // Keep the conversation from onFinish if the response promise is unavailable.
+        catch (error) {
+            throw streamError ?? error;
         }
         callbacks.debugLog(`response stream finished; session has ${completedConversation.length} model messages`);
-        const finalAssistantText = assistantText.trim();
-        const assistantAdmitsIncomplete = looksIncomplete(finalAssistantText);
-        const requestCompletedByTools = mutatingToolSucceeded && validationToolSucceeded && !editRecoveryPath;
-        const needsActionContinuation = likelyActionRequest
-            && !requestCompletedByTools
-            && ((sawReadOnlyTool && !mutatingToolSucceeded) || editFileFailed || assistantAdmitsIncomplete);
-        const needsValidationContinuation = likelyValidationRequest && !requestCompletedByTools && !validationToolSucceeded && (sawReadOnlyTool || mutatingToolSucceeded || assistantAdmitsIncomplete);
-        if (assistantStarted) {
-            callbacks.setLastAssistantText(finalAssistantText);
-            callbacks.updateMessage(currentAssistantId, { streaming: false });
-            if ((needsActionContinuation || needsValidationContinuation) && !forcedContinuationUsed) {
-                forcedContinuationUsed = true;
-                callbacks.updateMessage(currentAssistantId, { text: 'Continuing to complete the requested change...', streaming: false });
-                const prompt = editFileFailed
-                    ? 'Your editFile attempt failed. Use the latest readFile line-numbered output and replaceLines to complete the requested change. Continue with any remaining tests or validation if relevant. Do not stop with a summary.'
-                    : needsValidationContinuation
-                        ? 'You have not run the requested validation yet. Continue now by running the appropriate test/check command. Summarize only after the command finishes.'
-                        : mutatingToolSucceeded
-                            ? 'Your previous response says the current request is incomplete. Continue now with the remaining edits and validation for this same request. Do not summarize a plan unless blocked.'
-                            : 'You inspected files but have not made the requested change yet. Continue now by editing or writing the necessary files. Do not summarize a plan unless blocked.';
-                const continuationText = await streamAssistantResponse(completedConversation, 'current-turn completion gate', prompt, true);
-                if (!secondContinuationUsed && looksIncomplete(continuationText) && (likelyActionRequest || likelyValidationRequest)) {
-                    secondContinuationUsed = true;
-                    await streamAssistantResponse(callbacks.getConversation(), 'post-continuation completion gate', 'Your previous response still described unfinished work, missing validation, or a tool-budget issue. If any tools are still available, complete the remaining edit or run the final validation now. Only call something a blocker if a concrete tool failure prevents progress.', true);
+        const finalAssistantText = hideSyntheticToolCallMarkup(assistantText).trim();
+        const decideCompletion = (text) => completionDecision({
+            request: value,
+            goal,
+            assistantText: text,
+            sawReadOnlyTool,
+            sawToolCall,
+            mutatingToolSucceeded,
+            validationToolSucceeded,
+            validationToolFailed,
+            editFileFailed,
+            editRecoveryPath,
+        });
+        let decision = decideCompletion(finalAssistantText);
+        async function runCompletionLoop(seedConversation, seedText) {
+            let loopConversation = seedConversation;
+            let latestText = seedText;
+            while ((decision.needsActionContinuation || decision.needsValidationContinuation) && completionContinuationCount < maxCompletionContinuations) {
+                completionContinuationCount += 1;
+                const prompt = decision.continuationPrompt
+                    ?? (looksIncomplete(latestText) ? postContinuationPrompt() : 'Continue the same user goal until it is complete, blocked by a concrete issue, or needs a user decision. Focus on the concrete blocker, not a generic plan.');
+                const continuation = await streamAssistantResponse(loopConversation, `completion gate ${completionContinuationCount}`, prompt, true);
+                loopConversation = callbacks.getConversation();
+                if (continuation.text)
+                    latestText = continuation.text;
+                decision = decideCompletion(latestText);
+                if (continuation.started && (decision.needsActionContinuation || decision.needsValidationContinuation)) {
+                    callbacks.updateMessage(continuation.id, { hidden: true });
                 }
             }
+            if ((decision.needsActionContinuation || decision.needsValidationContinuation) && completionContinuationCount >= maxCompletionContinuations) {
+                callbacks.addMessage({ role: 'assistant', text: 'Stopped after the bounded completion loop. The current goal may still need work; ask me to continue and I will resume from the latest tool results.' });
+            }
+            if (!latestText && toolSummaries.length > 0) {
+                const followUp = await streamAssistantResponse(loopConversation, 'completion loop ended without text', noTextAfterToolPrompt(false), false);
+                if (!followUp.text)
+                    callbacks.addMessage({ role: 'assistant', text: `Finished tool work but the model did not produce a final response. Last tool result: ${toolSummaries.at(-1)}.` });
+            }
+        }
+        if (assistantStarted) {
+            const hidePreToolFragment = sawToolCall && !textAfterTool;
+            callbacks.setLastAssistantText(hidePreToolFragment ? '' : finalAssistantText);
+            callbacks.onEvent?.(agentEvent({ type: 'message_end', id: currentAssistantId, text: finalAssistantText, hidden: finalAssistantText.length === 0 || hidePreToolFragment }));
+            callbacks.updateMessage(currentAssistantId, { text: finalAssistantText, streaming: false, hidden: finalAssistantText.length === 0 || hidePreToolFragment });
+            if (decision.needsActionContinuation || decision.needsValidationContinuation) {
+                callbacks.updateMessage(currentAssistantId, { streaming: false, hidden: true });
+                await runCompletionLoop(completedConversation, finalAssistantText);
+            }
             else if (sawToolCall && !textAfterTool) {
-                const followUpText = await streamAssistantResponse(completedConversation, 'tool use completed without follow-up text', 'Continue from the tool result and answer my original request. Do not call tools. Summarize only current-turn changes and validation; do not recap unrelated earlier tasks.', false);
-                if (!followUpText) {
+                const followUp = await streamAssistantResponse(completedConversation, 'tool use completed without follow-up text', noTextAfterToolPrompt(false), false);
+                if (!followUp.text) {
                     callbacks.addMessage({ role: 'assistant', text: 'Stopped after tool use without a follow-up response. You can ask me to continue if the task is not complete.' });
                 }
             }
         }
         else if (sawToolCall) {
             const allowTools = (likelyActionRequest && (!mutatingToolSucceeded || editFileFailed)) || (likelyValidationRequest && !validationToolSucceeded);
-            const prompt = allowTools
-                ? 'Continue the original request now. If it asks for a change, edit or write the necessary files. If it asks to run or verify tests, run the command. Do not provide only a retrospective summary unless blocked.'
-                : 'Continue from the tool result and answer my original request. Do not call tools. Summarize only current-turn changes and validation; do not recap unrelated earlier tasks.';
-            const followUpText = await streamAssistantResponse(completedConversation, 'tool-only turn completed without text', prompt, allowTools);
-            if (!secondContinuationUsed && allowTools && looksIncomplete(followUpText)) {
-                secondContinuationUsed = true;
-                await streamAssistantResponse(callbacks.getConversation(), 'post-follow-up completion gate', 'Your previous response still described unfinished work, missing validation, or a tool-budget issue. If any tools are still available, complete the remaining edit or run the final validation now. Only call something a blocker if a concrete tool failure prevents progress.', true);
-            }
-            if (!followUpText) {
+            const prompt = noTextAfterToolPrompt(allowTools);
+            const followUp = await streamAssistantResponse(completedConversation, 'tool-only turn completed without text', prompt, allowTools);
+            decision = decideCompletion(followUp.text);
+            if (allowTools)
+                await runCompletionLoop(callbacks.getConversation(), followUp.text);
+            if (!followUp.text && completionContinuationCount === 0) {
                 const fallback = toolSummaries.length > 0
                     ? `Finished tool work but the model did not produce a final response. Last tool result: ${toolSummaries.at(-1)}.`
                     : 'Finished without a text response.';
@@ -465,21 +545,48 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks)
         else {
             callbacks.addMessage({ id: currentAssistantId, role: 'assistant', text: 'Finished without a text response.', streaming: false });
         }
+        goal.phase = 'done';
+        goal.status = 'complete';
+        turnStatus = 'complete';
+        callbacks.setGoalStatus?.(undefined);
     }
     catch (error) {
         if (abortController.signal.aborted) {
+            turnStatus = 'aborted';
             callbacks.debugLog('request aborted');
             callbacks.addMessage({ role: 'system', text: 'Thinking aborted. You can type again.' });
         }
         else {
             const text = error instanceof Error ? error.message : String(error);
             callbacks.debugLog(`error: ${text}`);
+            if (!contextOverflowRecovered && isContextOverflowError(error)) {
+                const compacted = callbacks.compactConversation?.('Automatic recovery after provider context overflow. Preserve the active user request and concrete next steps.') ?? false;
+                callbacks.onEvent?.(agentEvent({ type: 'context_overflow', recovered: compacted, error: text }));
+                if (compacted) {
+                    callbacks.addMessage({ role: 'system', text: 'Context overflow detected; compacted older context and retrying the same request once.' });
+                    await runAgentTurn(value, displayValue, contextFiles, callbacks, retryAttempt, true, true);
+                    return;
+                }
+                callbacks.addMessage({ role: 'system', text: 'Context overflow detected, but there was not enough conversation history to compact automatically.' });
+            }
+            const maxRetries = 2;
+            if (retryAttempt < maxRetries && isRetryableModelError(error)) {
+                const delay = retryDelayMs(retryAttempt);
+                callbacks.onEvent?.(agentEvent({ type: 'retry', attempt: retryAttempt + 1, maxAttempts: maxRetries, delayMs: delay, error: text }));
+                callbacks.addMessage({ role: 'system', text: `Transient model error; retrying attempt ${retryAttempt + 1}/${maxRetries} in ${formatSeconds(delay)}: ${text}` });
+                await abortableDelay(delay, abortController.signal);
+                if (abortController.signal.aborted)
+                    return;
+                await runAgentTurn(value, displayValue, contextFiles, callbacks, retryAttempt + 1, true, contextOverflowRecovered);
+                return;
+            }
             callbacks.addMessage({ role: 'assistant', text: `Model call failed: ${text}` });
         }
     }
     finally {
         if (idleTimer)
             clearTimeout(idleTimer);
+        callbacks.onEvent?.(agentEvent({ type: 'turn_end', request: value, status: turnStatus }));
         callbacks.setAbortController?.(null);
         callbacks.setBusy(false);
     }

package/dist/cli/index.js

@@ -11,9 +11,12 @@ program
     .name('haze')
     .description('A pragmatic, intentionally limited agentic CLI.')
     .version(pkg.version)
-    .option('--debug', 'show simple model/tool debug logs in the chat UI');
+    .option('--debug', 'show simple model/tool debug logs in the chat UI')
+    .option('-c, --continue', 'resume the latest saved session for this workspace')
+    .option('--no-session', 'run without saving or resuming a durable session');
 program.action(async () => {
-    await chatCommand({ debug: Boolean(program.opts().debug), version: pkg.version });
+    const opts = program.opts();
+    await chatCommand({ debug: Boolean(opts.debug), continueSession: Boolean(opts.continue), noSession: opts.session === false, version: pkg.version });
 });
 program.parseAsync().catch(error => {
     console.error(error instanceof Error ? error.message : error);

package/dist/config/inputHistory.js

@@ -4,17 +4,25 @@ import { HAZE_DIR } from './paths.js';
 const HISTORY_DIR = path.join(HAZE_DIR, 'history');
 export const INPUT_HISTORY_FILE = path.join(HISTORY_DIR, 'input-history.json');
 const MAX_HISTORY_ITEMS = 500;
+const DISABLE_PERSISTENT_HISTORY = process.env.VITEST === 'true' || process.env.NODE_ENV === 'test';
+let testHistory = [];
 function normalizeHistory(value) {
     if (!Array.isArray(value))
         return [];
     return value.filter((item) => typeof item === 'string' && item.trim().length > 0);
 }
 export async function readInputHistory() {
+    if (DISABLE_PERSISTENT_HISTORY)
+        return testHistory.slice(-MAX_HISTORY_ITEMS);
     const data = await fs.readJson(INPUT_HISTORY_FILE).catch(() => []);
     return normalizeHistory(data).slice(-MAX_HISTORY_ITEMS);
 }
 export async function writeInputHistory(history) {
     const normalized = normalizeHistory(history).slice(-MAX_HISTORY_ITEMS);
+    if (DISABLE_PERSISTENT_HISTORY) {
+        testHistory = normalized;
+        return;
+    }
     await fs.ensureDir(HISTORY_DIR);
     await fs.writeJson(INPUT_HISTORY_FILE, normalized, { spaces: 2 });
 }

package/dist/config/providers.d.ts

@@ -0,0 +1,26 @@
+import type { HazeSettings, HazeProviderSettings } from './settings.js';
+export declare const DEFAULT_PROVIDER_NAME = "openrouter";
+export declare const DEFAULT_PROVIDER_URL = "https://openrouter.ai/api/v1";
+export declare const DEFAULT_MODEL = "x-ai/grok-build-0.1";
+export type ModelResolution = {
+    status: 'found';
+    provider: HazeProviderSettings;
+    model: string;
+} | {
+    status: 'ambiguous';
+    model: string;
+    providers: HazeProviderSettings[];
+} | {
+    status: 'missing';
+};
+export declare function configuredProviders(settings: HazeSettings): HazeProviderSettings[];
+export declare function findProvider(settings: HazeSettings, name: string): HazeProviderSettings | undefined;
+export declare function activeProvider(settings: HazeSettings): HazeProviderSettings;
+export declare function activeModel(settings: HazeSettings): {
+    provider: HazeProviderSettings;
+    model: string;
+};
+export declare function resolveModelSelector(settings: HazeSettings, selector: string): ModelResolution;
+export declare function modelSelector(provider: HazeProviderSettings, model: string): string;
+export declare function upsertProvider(settings: HazeSettings, provider: HazeProviderSettings): HazeProviderSettings[];
+export declare function providerHasKey(settings: HazeSettings, provider: HazeProviderSettings): boolean;