@denizokcu/haze 0.0.1 → 0.0.2

package/dist/cli/commands/streaming.js

@@ -2,41 +2,354 @@ import { stepCountIs, streamText } from 'ai';
 import { model } from '../../llm/client.js';
 import { hazeTools } from '../../llm/hazeTools.js';
 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';
+function stableToolKey(toolCall) {
+    return `${toolCall.toolName}:${JSON.stringify(toolCall.input)}`;
+}
+function uniqueRepeatedToolNames(toolCalls) {
+    const seen = new Set();
+    const repeated = new Set();
+    for (const toolCall of toolCalls) {
+        const key = stableToolKey(toolCall);
+        if (seen.has(key))
+            repeated.add(toolCall.toolName);
+        seen.add(key);
+    }
+    return [...repeated];
+}
+function toolOnlyStepCount(steps) {
+    let count = 0;
+    for (const step of [...steps].reverse()) {
+        if (step.toolCalls.length === 0 || step.text.trim().length > 0)
+            break;
+        count += 1;
+    }
+    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 toolInputPath(input) {
+    return typeof input === 'object' && input != null && 'path' in input && typeof input.path === 'string'
+        ? input.path
+        : undefined;
+}
+function isDuplicateSkippedOutput(output) {
+    return typeof output === 'object' && output != null && 'duplicateSkipped' in output && output.duplicateSkipped === true;
+}
 export async function runAgentTurn(value, displayValue, contextFiles, callbacks) {
     const displayVal = displayValue ?? value;
     const userMessage = { role: 'user', text: displayVal };
     callbacks.setBusy(true);
     callbacks.addMessage(userMessage);
+    const abortController = new AbortController();
+    callbacks.setAbortController?.(abortController);
+    let idleTimer;
+    const resetIdleTimer = () => {
+        if (idleTimer)
+            clearTimeout(idleTimer);
+        idleTimer = setTimeout(() => abortController.abort('Haze turn timed out after no model/tool activity.'), 90_000);
+    };
     try {
         const m = await model();
         if (!m) {
-            callbacks.addMessage({ role: 'assistant', text: 'No model configured. Run /login, then /model <model-name>. Haze cannot hallucinate without credentials. Progress.' });
+            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.' });
             return;
         }
-        const lastAssistantText = callbacks.getLastAssistantText();
-        const refersToPrevious = /\b(this|that|previous|above|it)\b/i.test(value) && lastAssistantText.trim().length > 0;
-        const userContent = refersToPrevious
-            ? `${value}\n\nReferenced previous Haze response to preserve exactly:\n${lastAssistantText}`
-            : value;
-        const requestMessages = [...callbacks.getConversation(), { role: 'user', content: userContent }];
+        const activeModel = m;
+        const skillRegistry = await loadSkillRegistry();
+        const availableTools = { ...hazeTools, ...buildSkillTools(skillRegistry) };
+        const likelyPlanOnlyRequest = isPlanOnlyRequest(value);
+        const likelyPlanImplementationRequest = isPlanImplementationRequest(value);
+        const likelyActionRequest = isLikelyActionRequest(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 }];
         callbacks.setConversation(requestMessages);
-        const assistantId = `assistant-${Date.now()}`;
+        resetIdleTimer();
+        let currentAssistantId = `assistant-${Date.now()}`;
         let assistantStarted = false;
+        let currentAssistantText = '';
         let assistantText = '';
+        let toolEpoch = 0;
+        let currentAssistantToolEpoch = 0;
         let editFileFailed = false;
         let mutatingToolSucceeded = false;
+        let validationToolSucceeded = false;
+        let sawReadOnlyTool = false;
+        let sawToolCall = false;
+        let textAfterTool = false;
+        let forcedContinuationUsed = false;
+        let secondContinuationUsed = false;
+        let editRecoveryPath;
+        let editRecoveryReadSatisfied = false;
         const toolSummaries = [];
-        callbacks.debugLog(`request started with ${requestMessages.length} conversation messages${refersToPrevious ? ' and previous-response reference' : ''}`);
+        const toolExecutionContext = { inFlightToolCalls: new Map() };
+        const toolGroupId = `tools-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        const toolDisplayItems = [];
+        let toolGroupStarted = false;
+        function renderToolGroup(streaming) {
+            const visibleItems = toolDisplayItems.filter(item => !item.hidden);
+            const grouped = new Map();
+            for (const item of visibleItems) {
+                const key = `${item.status}:${item.summary}:${item.result ?? ''}`;
+                const current = grouped.get(key);
+                if (current)
+                    current.count += 1;
+                else
+                    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 lines = rows.map(({ item, count }) => {
+                const icon = item.status === 'running' ? '…' : item.status === 'success' ? '✓' : '✗';
+                const countText = count > 1 ? ` ×${count}` : '';
+                const result = item.status === 'running' ? '' : ` — ${item.result ?? item.status}${item.durationMs == null ? '' : ` in ${formatSeconds(item.durationMs)}`}`;
+                return `  ${icon} ${item.summary}${countText}${result}`;
+            });
+            return [header, ...lines].join('\n');
+        }
+        function updateToolGroup(streaming = true) {
+            const text = renderToolGroup(streaming);
+            if (!toolGroupStarted) {
+                toolGroupStarted = true;
+                callbacks.addMessage({ id: toolGroupId, role: 'tool', text, streaming });
+            }
+            else {
+                callbacks.updateMessage(toolGroupId, { text, streaming });
+            }
+        }
+        function recordToolStart(toolCall) {
+            toolDisplayItems.push({ id: toolCall.toolCallId, summary: toolCallSummary(toolCall.toolName, toolCall.input), status: 'running' });
+            updateToolGroup(true);
+        }
+        function recordToolDisplayFinish(event) {
+            const item = toolDisplayItems.find(candidate => candidate.id === event.toolCall.toolCallId);
+            if (!item)
+                return;
+            item.status = 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}`);
+        function recordToolFinish(event) {
+            const path = toolInputPath(event.toolCall.input);
+            const duplicateSkipped = isDuplicateSkippedOutput(event.output);
+            if (!event.success && ['editFile', 'replaceLines', 'writeFile'].includes(event.toolCall.toolName)) {
+                editFileFailed = true;
+                editRecoveryPath = path;
+                editRecoveryReadSatisfied = false;
+            }
+            if (event.success && ['listFiles', 'readFile'].includes(event.toolCall.toolName))
+                sawReadOnlyTool = true;
+            if (event.success && event.toolCall.toolName === 'readFile' && path && path === editRecoveryPath && !duplicateSkipped) {
+                editRecoveryReadSatisfied = true;
+            }
+            if (event.success && ['editFile', 'replaceLines', 'writeFile'].includes(event.toolCall.toolName)) {
+                mutatingToolSucceeded = true;
+                if (!path || path === editRecoveryPath) {
+                    editRecoveryPath = undefined;
+                    editRecoveryReadSatisfied = false;
+                    editFileFailed = false;
+                }
+            }
+            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;
+            }
+        }
+        async function streamAssistantResponse(messages, reason, prompt, allowTools = false) {
+            callbacks.debugLog(`requesting assistant ${allowTools ? 'continuation' : 'text'}: ${reason}`);
+            const responseId = `assistant-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+            let responseStarted = false;
+            let responseText = '';
+            let continuationToolCalls = 0;
+            const continuationMessages = [
+                ...messages,
+                { role: 'user', content: prompt },
+            ];
+            const followUp = streamText({
+                model: activeModel,
+                temperature: 0,
+                system: buildSystemPrompt(contextFiles),
+                messages: continuationMessages,
+                tools: availableTools,
+                toolChoice: allowTools ? 'auto' : 'none',
+                stopWhen: stepCountIs(10),
+                abortSignal: abortController.signal,
+                experimental_context: toolExecutionContext,
+                prepareStep({ steps, messages }) {
+                    continuationToolCalls = steps.flatMap(step => step.toolCalls).length;
+                    if (continuationToolCalls >= 10 || toolOnlyStepCount(steps) >= 5) {
+                        return {
+                            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.' },
+                            ],
+                        };
+                    }
+                    if (likelyPlanOnlyRequest && mutatingToolSucceeded) {
+                        return {
+                            toolChoice: 'none',
+                            messages: [
+                                ...messages,
+                                { role: 'user', content: 'This was a planning request and the plan artifact has been created or updated. Stop using tools and summarize the plan file only; do not implement or validate it.' },
+                            ],
+                        };
+                    }
+                    if (editRecoveryPath && !editRecoveryReadSatisfied) {
+                        return {
+                            activeTools: ['readFile'],
+                            messages: [
+                                ...messages,
+                                { role: 'user', content: `A previous edit failed for ${editRecoveryPath}. Before any further edit or bash inspection, call readFile on exactly ${editRecoveryPath}. Bash/cat does not satisfy this recovery step.` },
+                            ],
+                        };
+                    }
+                    if (editFileFailed)
+                        return { activeTools: ['listFiles', 'readFile', 'replaceLines', 'writeFile', 'bash'] };
+                    return undefined;
+                },
+                onError({ error }) {
+                    callbacks.debugLog(`stream error: ${error instanceof Error ? error.message : String(error)}`);
+                },
+                onFinish(event) {
+                    callbacks.setConversation([...continuationMessages, ...event.response.messages]);
+                    callbacks.debugLog(`conversation updated to ${continuationMessages.length + event.response.messages.length} messages after follow-up`);
+                },
+                experimental_onToolCallStart({ toolCall }) {
+                    sawToolCall = true;
+                    recordToolStart(toolCall);
+                    resetIdleTimer();
+                    callbacks.debugLog(`follow-up tool start: ${toolCall.toolName} ${compact(toolCall.input)}`);
+                },
+                experimental_onToolCallFinish(event) {
+                    resetIdleTimer();
+                    recordToolFinish(event);
+                    const summary = toolResultSummary(event);
+                    toolSummaries.push(`${event.toolCall.toolName}: ${summary}`);
+                    recordToolDisplayFinish(event);
+                    if (!isDuplicateSkippedOutput(event.output))
+                        toolEpoch += 1;
+                    callbacks.debugLog(event.success
+                        ? `follow-up tool done: ${event.toolCall.toolName} after ${event.durationMs}ms ${compact(event.output)}`
+                        : `follow-up tool error: ${event.toolCall.toolName} after ${event.durationMs}ms ${compact(event.error)}`);
+                },
+            });
+            for await (const rawDelta of followUp.textStream) {
+                resetIdleTimer();
+                const delta = sanitizeAssistantText(rawDelta);
+                responseText += delta;
+                if (!responseStarted) {
+                    responseStarted = true;
+                    callbacks.addMessage({ id: responseId, role: 'assistant', text: delta, streaming: true });
+                }
+                else {
+                    callbacks.updateMessage(responseId, { text: responseText });
+                }
+            }
+            if (responseStarted) {
+                callbacks.setLastAssistantText(responseText.trim());
+                callbacks.updateMessage(responseId, { streaming: false });
+            }
+            return responseText.trim();
+        }
         const result = streamText({
-            model: m,
+            model: activeModel,
+            temperature: 0,
             system: buildSystemPrompt(contextFiles),
             messages: requestMessages,
-            tools: hazeTools,
-            stopWhen: stepCountIs(15),
-            prepareStep() {
-                if (mutatingToolSucceeded)
-                    return { toolChoice: 'none' };
+            tools: availableTools,
+            stopWhen: stepCountIs(12),
+            abortSignal: abortController.signal,
+            experimental_context: toolExecutionContext,
+            onError({ error }) {
+                callbacks.debugLog(`stream error: ${error instanceof Error ? error.message : String(error)}`);
+            },
+            prepareStep({ steps, messages }) {
+                const toolCalls = steps.flatMap(step => step.toolCalls);
+                const repeatedToolNames = uniqueRepeatedToolNames(toolCalls);
+                const repeatedToolCall = repeatedToolNames.length > 0;
+                const consecutiveToolOnlySteps = toolOnlyStepCount(steps);
+                if (likelyPlanOnlyRequest && mutatingToolSucceeded) {
+                    return {
+                        toolChoice: 'none',
+                        messages: [
+                            ...messages,
+                            { role: 'user', content: 'This was a planning request and the plan artifact has been created or updated. Stop using tools and summarize the plan file only; do not implement or validate it.' },
+                        ],
+                    };
+                }
+                if (editRecoveryPath && !editRecoveryReadSatisfied) {
+                    return {
+                        activeTools: ['readFile'],
+                        messages: [
+                            ...messages,
+                            { role: 'user', content: `A previous edit failed for ${editRecoveryPath}. Before any further edit or bash inspection, call readFile on exactly ${editRecoveryPath}. Bash/cat does not satisfy this recovery step.` },
+                        ],
+                    };
+                }
+                if (repeatedToolCall) {
+                    const activeTools = Object.keys(availableTools).filter(name => !repeatedToolNames.includes(name));
+                    callbacks.debugLog(`disabling repeated tools for next step: ${repeatedToolNames.join(', ')}`);
+                    return {
+                        activeTools,
+                        messages: [
+                            ...messages,
+                            { role: 'user', content: `You already called ${repeatedToolNames.join(', ')} with the same input. Do not repeat that tool call. Use a different relevant tool. If this is an action request and no file change has been made yet, continue with edit/write tools rather than summarizing.` },
+                        ],
+                    };
+                }
+                if (likelyActionRequest && !mutatingToolSucceeded && consecutiveToolOnlySteps >= 3 && toolCalls.length < 10) {
+                    callbacks.debugLog('nudging action request toward mutation after read-only steps');
+                    return {
+                        messages: [
+                            ...messages,
+                            { role: 'user', content: 'You have inspected enough for now. This is an action request; make the requested change with editFile, replaceLines, or writeFile instead of saying tools are unavailable or summarizing.' },
+                        ],
+                    };
+                }
+                if (toolCalls.length >= 12 || consecutiveToolOnlySteps >= 5) {
+                    callbacks.debugLog('forcing text response to avoid tool loop');
+                    return {
+                        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.' },
+                        ],
+                    };
+                }
                 if (editFileFailed)
                     return { activeTools: ['listFiles', 'readFile', 'replaceLines', 'writeFile', 'bash'] };
                 return undefined;
@@ -44,58 +357,130 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks)
             onStepFinish({ stepNumber, text, toolCalls, toolResults, finishReason }) {
                 callbacks.debugLog(`step ${stepNumber} finished: ${finishReason}; text=${text.length}; toolCalls=${toolCalls.length}; toolResults=${toolResults.length}`);
             },
-            onFinish({ response }) {
-                const nextConversation = [...requestMessages, ...response.messages];
+            onFinish(event) {
+                const nextConversation = [...requestMessages, ...event.response.messages];
                 callbacks.setConversation(nextConversation);
                 callbacks.debugLog(`conversation updated to ${nextConversation.length} messages`);
             },
             experimental_onToolCallStart({ toolCall }) {
-                const text = toolCallSummary(toolCall.toolName, toolCall.input);
-                callbacks.addMessage({ id: `tool-${toolCall.toolCallId}`, role: 'tool', text, streaming: true });
+                sawToolCall = true;
+                recordToolStart(toolCall);
+                resetIdleTimer();
                 callbacks.debugLog(`tool start: ${toolCall.toolName} ${compact(toolCall.input)}`);
             },
             experimental_onToolCallFinish(event) {
+                resetIdleTimer();
                 const summary = toolResultSummary(event);
-                const text = `${toolCallSummary(event.toolCall.toolName, event.toolCall.input)}\n${event.success ? '✓' : '✗'} ${summary} in ${formatSeconds(event.durationMs)}`;
-                if (!event.success && event.toolCall.toolName === 'editFile')
-                    editFileFailed = true;
-                if (event.success && ['editFile', 'replaceLines', 'writeFile'].includes(event.toolCall.toolName))
-                    mutatingToolSucceeded = true;
+                recordToolFinish(event);
                 toolSummaries.push(`${event.toolCall.toolName}: ${summary}`);
-                callbacks.updateMessage(`tool-${event.toolCall.toolCallId}`, { text, streaming: false });
+                recordToolDisplayFinish(event);
+                if (!isDuplicateSkippedOutput(event.output))
+                    toolEpoch += 1;
                 callbacks.debugLog(event.success
                     ? `tool done: ${event.toolCall.toolName} after ${event.durationMs}ms ${compact(event.output)}`
                     : `tool error: ${event.toolCall.toolName} after ${event.durationMs}ms ${compact(event.error)}`);
             }
         });
-        for await (const delta of result.textStream) {
+        for await (const rawDelta of result.textStream) {
+            resetIdleTimer();
+            const delta = sanitizeAssistantText(rawDelta);
+            if (sawToolCall)
+                textAfterTool = true;
+            if (currentAssistantText.length > 0 && toolEpoch > currentAssistantToolEpoch) {
+                callbacks.updateMessage(currentAssistantId, { streaming: false });
+                currentAssistantId = `assistant-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+                currentAssistantText = '';
+                currentAssistantToolEpoch = toolEpoch;
+            }
             assistantText += delta;
-            if (!assistantStarted) {
+            currentAssistantText += delta;
+            if (currentAssistantText === delta) {
                 assistantStarted = true;
-                callbacks.addMessage({ id: assistantId, role: 'assistant', text: delta, streaming: true });
+                callbacks.addMessage({ id: currentAssistantId, role: 'assistant', text: currentAssistantText, streaming: true });
             }
             else {
-                callbacks.updateMessage(assistantId, { text: assistantText });
+                callbacks.updateMessage(currentAssistantId, { text: currentAssistantText });
             }
         }
-        callbacks.debugLog(`response stream finished; session has ${callbacks.getConversation().length} model messages`);
+        let completedConversation = callbacks.getConversation();
+        try {
+            const response = await result.response;
+            completedConversation = [...requestMessages, ...response.messages];
+            callbacks.setConversation(completedConversation);
+        }
+        catch {
+            // Keep the conversation from onFinish if the response promise is unavailable.
+        }
+        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(assistantText.trim());
-            callbacks.updateMessage(assistantId, { streaming: false });
+            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);
+                }
+            }
+            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) {
+                    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 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.';
+                callbacks.addMessage({ id: currentAssistantId, role: 'assistant', text: fallback, streaming: false });
+            }
         }
         else {
-            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.';
-            callbacks.addMessage({ id: assistantId, role: 'assistant', text: fallback, streaming: false });
+            callbacks.addMessage({ id: currentAssistantId, role: 'assistant', text: 'Finished without a text response.', streaming: false });
         }
     }
     catch (error) {
-        const text = error instanceof Error ? error.message : String(error);
-        callbacks.debugLog(`error: ${text}`);
-        callbacks.addMessage({ role: 'assistant', text: `Model call failed: ${text}` });
+        if (abortController.signal.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}`);
+            callbacks.addMessage({ role: 'assistant', text: `Model call failed: ${text}` });
+        }
     }
     finally {
+        if (idleTimer)
+            clearTimeout(idleTimer);
+        callbacks.setAbortController?.(null);
         callbacks.setBusy(false);
     }
 }

package/dist/cli/index.js

@@ -3,9 +3,6 @@ import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 import { Command } from 'commander';
-import { listSkills, infoSkill, removeSkill, validateSkill } from './commands/skills.js';
-import { buildSkill } from '../skills/builder/SkillBuilder.js';
-import { installSkill } from '../skills/installer/SkillInstaller.js';
 import { chatCommand } from './commands/chat.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf8'));
@@ -16,15 +13,8 @@ program
     .version(pkg.version)
     .option('--debug', 'show simple model/tool debug logs in the chat UI');
 program.action(async () => {
-    await chatCommand({ debug: Boolean(program.opts().debug) });
+    await chatCommand({ debug: Boolean(program.opts().debug), version: pkg.version });
 });
-program.command('build-skill <description...>').description('Deliberately design and create a new file-based skill').action(async (d) => buildSkill(d.join(' ')));
-program.command('install-skill <githubRepo>').description('Install a skill from GitHub with mandatory approval').action(installSkill);
-const skills = program.command('skills').description('Manage skills');
-skills.command('list').description('List installed skills').action(listSkills);
-skills.command('info <name>').description('Show skill details').action(infoSkill);
-skills.command('remove <name>').description('Remove an installed skill').action(removeSkill);
-skills.command('validate <dir>').description('Validate a skill directory').action(validateSkill);
 program.parseAsync().catch(error => {
     console.error(error instanceof Error ? error.message : error);
     process.exit(1);

package/dist/config/paths.d.ts

@@ -1,3 +1,2 @@
 export declare const HAZE_DIR: string;
 export declare const GLOBAL_SKILLS_DIR: string;
-export declare const LOCAL_SKILLS_DIR: string;

package/dist/config/paths.js

@@ -2,4 +2,3 @@ import os from 'node:os';
 import path from 'node:path';
 export const HAZE_DIR = path.join(os.homedir(), '.haze');
 export const GLOBAL_SKILLS_DIR = path.join(HAZE_DIR, 'skills');
-export const LOCAL_SKILLS_DIR = path.join(process.cwd(), '.haze', 'skills');

package/dist/llm/client.js

@@ -4,7 +4,7 @@ export async function model() {
     const settings = await readSettings();
     const baseURL = process.env.OPENAI_BASE_URL ?? settings.baseURL;
     const apiKey = process.env.OPENAI_API_KEY ?? settings.apiKey;
-    const name = process.env.HAZE_MODEL ?? settings.model ?? 'openai/gpt-4o-mini';
+    const name = process.env.HAZE_MODEL ?? settings.model ?? 'x-ai/grok-build-0.1';
     if (!apiKey)
         return null;
     return createOpenAI({ apiKey, baseURL })(name);

package/dist/llm/hazeTools.d.ts

@@ -4,10 +4,18 @@ export declare const hazeTools: {
         recursive: boolean;
         maxEntries: number;
         includeIgnored: boolean;
+        cursor?: string | undefined;
     }, {
+        ok: true;
+        duplicateSkipped: true;
+        toolName: string;
+        reason: string;
+    } | {
         path: string;
         recursive: boolean;
         includeIgnored: boolean;
+        cursor: string | undefined;
+        nextCursor: string | undefined;
         ignoredSkipped: number;
         entries: {
             path: string;
@@ -22,6 +30,11 @@ export declare const hazeTools: {
         offset?: number | undefined;
         limit?: number | undefined;
     }, {
+        ok: true;
+        duplicateSkipped: true;
+        toolName: string;
+        reason: string;
+    } | {
         text: string;
         truncated: boolean;
         omittedChars?: undefined;
@@ -47,20 +60,33 @@ export declare const hazeTools: {
         content: string;
         allowIgnored: boolean;
     }, {
+        ok: true;
+        duplicateSkipped: true;
+        toolName: string;
+        reason: string;
+    } | {
         ok: boolean;
         path: string;
         startLine: number;
         endLine: number;
         replacementLines: number;
+        appended: boolean;
     }>;
     writeFile: import("ai").Tool<{
         path: string;
         content: string;
+        overwriteExisting: boolean;
         allowIgnored: boolean;
     }, {
+        ok: true;
+        duplicateSkipped: true;
+        toolName: string;
+        reason: string;
+    } | {
         ok: boolean;
         path: string;
         bytes: number;
+        overwritten: boolean;
     }>;
     editFile: import("ai").Tool<{
         path: string;
@@ -70,12 +96,18 @@ export declare const hazeTools: {
         }[];
         allowIgnored: boolean;
     }, {
+        ok: true;
+        duplicateSkipped: true;
+        toolName: string;
+        reason: string;
+    } | {
         ok: boolean;
         path: string;
         edits: number;
     }>;
     bash: import("ai").Tool<{
         command: string;
+        allowMutation: boolean;
         timeoutSeconds?: number | undefined;
     }, unknown>;
 };