@denizokcu/haze 0.0.3 → 0.1.0

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## Unreleased
 
+## 0.1.0 - 2026-06-07
+
+- Added ripgrep-backed `grep` for fast workspace search with regex, glob, context-line, case-insensitive, and result-limit options.
+- Added focused `subagent` delegation for independent parallel tasks with fresh context, step caps, concise summaries, tool-call metadata, and parent abort propagation.
+- Added compact inline diff display for successful `editFile` and `replaceLines` calls, including added/removed counts, colored additions/removals, one context line around small changes, and hidden summaries for large diffs.
+- Improved agent-loop completion handling for truncated model output and long-running tool loops.
+- Refined subagent prompting and parent transcript summaries to reduce noise and discourage single-task delegation.
+- Updated release documentation and roadmap state for the 0.1.0 foundation release.
+
 ## 0.0.3 - 2026-06-06
 
 - Added stable transcript rendering for long sessions, compact placeholders for large multiline pastes, and clearer goal/status display.

package/README.md

@@ -2,11 +2,16 @@
 
 A minimal LLM harness for your terminal.
 
-## What's new in 0.0.3
+## What's new in 0.1.0
 
-Haze 0.0.3 keeps long sessions calmer with stable transcript rendering, compact placeholders for large multiline pastes, and clearer goal/status display. Pasted text is still sent to the model with line breaks preserved.
+Haze 0.1.0 is the foundation release: the agent can now *find*, *delegate*, and *show its work* without turning your terminal into soup.
 
-Haze gives an AI model a small set of transparent local tools — read files, edit files, write files, list files, and run commands — then gets out of the way. Start with chat. Build your workflows as you work. Teach Haze with Markdown skills when a pattern repeats. Tiny spell, useful goblin.
+- `grep` gives the model fast, targeted codebase search with regex, globs, context lines, and `.gitignore` awareness — no more brute-force file spelunking.
+- Subagents let Haze fan out independent investigations into fresh contexts, then fold the result back into the main turn as a concise summary.
+- File edits now render compact, colorized inline diffs with one context line around the change; big diffs stay summarized so signal beats scrollback.
+- Long-turn handling is calmer: truncated model output and tool-heavy loops recover more gracefully.
+
+The result is a more capable agent loop while keeping the core small and inspectable. Haze gives an AI model transparent local tools — read, search, edit, write, list, and run commands — plus focused delegation when work can split safely. Tiny spell, sharper goblin.
 
 Haze works with OpenAI-compatible providers, including OpenRouter and local endpoints. Use `/provider` to choose or add one, then `/model` to select a model.
 
@@ -47,7 +52,7 @@ On first run, create or choose a provider, then choose your first model:
 `/model` selects the model Haze should use. You can also set one directly:
 
 ```txt
-/model x-ai/grok-build-0.1
+/model anthropic/claude-sonnet-4.6
 /model local:llama3.1
 ```
 
@@ -57,7 +62,7 @@ Or use environment variables for any OpenAI-compatible endpoint:
 # e.g. OpenRouter, OpenAI, LM Studio, Ollama, or an OpenAI-compatible proxy
 export OPENAI_API_KEY=... # provider API key, if needed; local providers may not need one
 export OPENAI_BASE_URL=https://openrouter.ai/api/v1 # or http://localhost:1234/v1, http://localhost:11434/v1, ...
-export HAZE_MODEL=x-ai/grok-build-0.1 # or gpt-4.1, llama3.1, qwen2.5-coder, ...
+export HAZE_MODEL=anthropic/claude-sonnet-4.6 # or gpt-4.1, llama3.1, qwen2.5-coder, ...
 ```
 
 Saved settings live in `~/.haze/settings.json`. Providers can include API keys, base URLs, and model lists; local OpenAI-compatible providers can be configured without a key.
@@ -72,7 +77,7 @@ Open a project and ask for work:
 create a calculator in calc-app in ruby with add subtract multiply divide
 ```
 
-Haze will inspect, write files, run commands, and show compact tool activity inline. Sessions are saved by default so you can resume the latest workspace conversation with `haze --continue` or `/resume`.
+Haze will inspect, search, write files, run commands, and show compact tool activity inline. Small file edits include a colorized line diff with one context line before and after the change; large diffs stay summarized so the transcript does not become a wall of noise. Sessions are saved by default so you can resume the latest workspace conversation with `haze --continue` or `/resume`.
 
 Use `/` to discover commands and skills. `Tab` completes the top suggestion.
 
@@ -185,13 +190,20 @@ Haze exposes a deliberately small toolset:
 
 - `listFiles` — structured discovery, recursive with cursor pagination when needed.
 - `readFile` — read UTF-8 files with optional line ranges.
+- `grep` — ripgrep-backed regex search with path, glob, context-line, case, and result-limit controls.
 - `editFile` — unique text replacements, with line-number-prefix tolerance for common model mistakes.
 - `replaceLines` — line-range edits when exact replacements are awkward; slightly-too-large EOF ranges are clamped.
 - `writeFile` — create files and parent directories.
 - `bash` — run tests, builds, git commands, and inspections.
 - `skill_*` — load Markdown skill instructions on demand.
 
-Tool calls are grouped in the transcript so you can see what happened without reading a novella. File-tool failures return structured recovery hints instead of mystery stack traces.
+Tool calls are grouped in the transcript so you can see what happened without reading a novella. Successful targeted file edits show a compact diff with colored additions/removals and one context line around the change when the diff is small; larger diffs are summarized with a pointer to `git diff`. File-tool failures return structured recovery hints instead of mystery stack traces.
+
+## Subagents
+
+Subagents are a delegation feature, not another file operation. When a request clearly splits into independent parallel work, Haze can spin up focused agents with fresh context, let them inspect or act with their own capped tool loop, then fold their concise summaries back into the main conversation.
+
+Use them for parallel investigation across separate areas of a codebase. Do not use them for single sequential tasks where the main agent already has the best context.
 
 ## Context files
 

package/dist/cli/commands/chat.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import { useEffect, useRef, useState } from 'react';
 import { execFile as execFileCallback } from 'node:child_process';
 import { promisify } from 'node:util';
@@ -87,6 +87,17 @@ function fullWidthBlankLine(width) {
 function ToolMessageText({ text, streaming }) {
     const lines = text.split('\n');
     return _jsx(Box, { flexDirection: "column", children: lines.map((line, index) => {
+            const diffRow = /^(\s*\d+\s+)([+-])(.*)$/.exec(line);
+            if (diffRow) {
+                const [, prefix, marker, rest] = diffRow;
+                const isAdd = marker === '+';
+                return _jsxs(Text, { color: "white", backgroundColor: isAdd ? theme.successBg : theme.dangerBg, children: [_jsxs(Text, { color: isAdd ? theme.success : theme.danger, backgroundColor: isAdd ? theme.successBg : theme.dangerBg, children: [prefix, marker] }), rest] }, `${index}-${line}`);
+            }
+            const contextRow = /^(\s*\d+\s+)\s(.*)$/.exec(line);
+            if (contextRow) {
+                const [, prefix, rest] = contextRow;
+                return _jsxs(Text, { color: "white", children: [_jsxs(Text, { color: theme.muted, children: [prefix, " "] }), rest] }, `${index}-${line}`);
+            }
             const row = /^(\s*)([✓✗…])\s+(\S+)(.*)$/.exec(line);
             if (!row) {
                 return _jsxs(Text, { color: theme.muted, children: [index === 0 && streaming ? _jsxs(_Fragment, { children: [_jsx(Spinner, { type: "dots" }), " "] }) : null, line] }, `${index}-${line}`);
@@ -133,6 +144,15 @@ function ChatScreen({ debug = false, version, continueSession = false, noSession
     const [messages, setMessages] = useState([
         { role: 'system', text: 'Welcome to Haze. Use /help for commands.' }
     ]);
+    const [liveMessages, setLiveMessages] = useState([]);
+    const liveMessagesRef = useRef([]);
+    const setLiveMessagesState = (updater) => {
+        setLiveMessages(previous => {
+            const next = updater(previous);
+            liveMessagesRef.current = next;
+            return next;
+        });
+    };
     const [settings, setSettings] = useState({});
     const conversationRef = useRef([]);
     const lastAssistantTextRef = useRef('');
@@ -224,6 +244,7 @@ function ChatScreen({ debug = false, version, continueSession = false, noSession
                 sessionRef.current = session;
                 conversationRef.current = conversation;
                 setSessionLabel(session.id);
+                setLiveMessagesState(() => []);
                 setMessages(m => [...m, { role: 'system', text: `Resumed session: ${formatSession(session)}` }, ...displayMessagesFromConversation(conversation)]);
                 return;
             }
@@ -233,6 +254,7 @@ function ChatScreen({ debug = false, version, continueSession = false, noSession
     function clearConversation() {
         conversationRef.current = [];
         lastAssistantTextRef.current = '';
+        setLiveMessagesState(() => []);
         setMessages([{ role: 'system', text: 'Cleared. The void is productive.' }]);
         const session = sessionRef.current;
         if (session)
@@ -263,6 +285,7 @@ function ChatScreen({ debug = false, version, continueSession = false, noSession
         sessionRef.current = session;
         conversationRef.current = conversation;
         setSessionLabel(session.id);
+        setLiveMessagesState(() => []);
         setMessages([{ role: 'system', text: `Resumed session: ${formatSession(session)}` }, ...displayMessagesFromConversation(conversation)]);
     }
     function cancelThinking() {
@@ -507,6 +530,7 @@ function ChatScreen({ debug = false, version, continueSession = false, noSession
             newSession: async () => {
                 conversationRef.current = [];
                 lastAssistantTextRef.current = '';
+                setLiveMessagesState(() => []);
                 setMessages([{ role: 'system', text: 'Started fresh. The fog parts.' }]);
                 await startNewSession('Started a new session.');
             },
@@ -572,14 +596,39 @@ function ChatScreen({ debug = false, version, continueSession = false, noSession
         }
     }
     async function runSingleAgentTurn(value, displayValue) {
+        const persistUiMessage = (msg) => {
+            const session = sessionRef.current;
+            if (session)
+                void appendSessionEntry(session, { type: 'ui_message', at: new Date().toISOString(), role: msg.role, text: msg.text }).catch(() => undefined);
+        };
+        const finalizeMessage = (msg) => {
+            if (msg.hidden)
+                return;
+            setMessages(m => [...m, msg]);
+            persistUiMessage(msg);
+        };
         await runAgentTurn(value, displayValue, contextFiles, {
             addMessage: msg => {
-                setMessages(m => [...m, msg]);
-                const session = sessionRef.current;
-                if (session)
-                    void appendSessionEntry(session, { type: 'ui_message', at: new Date().toISOString(), role: msg.role, text: msg.text }).catch(() => undefined);
+                if (msg.streaming) {
+                    setLiveMessagesState(m => [...m, msg]);
+                    return;
+                }
+                finalizeMessage(msg);
+            },
+            updateMessage: (id, update) => {
+                const liveMessage = liveMessagesRef.current.find(msg => msg.id === id);
+                if (liveMessage) {
+                    const updated = { ...liveMessage, ...update };
+                    if (updated.streaming === false) {
+                        setLiveMessagesState(m => m.filter(msg => msg.id !== id));
+                        finalizeMessage(updated);
+                        return;
+                    }
+                    setLiveMessagesState(m => m.map(msg => msg.id === id ? { ...msg, ...update } : msg));
+                    return;
+                }
+                setMessages(m => m.map(msg => msg.id === id ? { ...msg, ...update } : msg));
             },
-            updateMessage: (id, update) => setMessages(m => m.map(msg => msg.id === id ? { ...msg, ...update } : msg)),
             setConversation: msgs => {
                 conversationRef.current = msgs;
                 const session = sessionRef.current;
@@ -587,6 +636,7 @@ function ChatScreen({ debug = false, version, continueSession = false, noSession
                     void appendSessionEntry(session, { type: 'conversation_snapshot', at: new Date().toISOString(), messages: msgs }).catch(() => undefined);
             },
             setBusy,
+            setBusyLabel,
             debugLog,
             getConversation: () => conversationRef.current,
             getLastAssistantText: () => lastAssistantTextRef.current,
@@ -602,10 +652,8 @@ function ChatScreen({ debug = false, version, continueSession = false, noSession
         });
     }
     const visible = messages.filter(message => !message.hidden);
-    const transcriptItems = visible
-        .map((message, index) => ({ key: messageKey(message, index), message }))
-        .filter(item => !item.message.streaming);
-    const liveMessages = visible.filter(message => message.streaming);
+    const transcriptItems = visible.map((message, index) => ({ key: messageKey(message, index), message }));
+    const activeLiveMessages = liveMessages.filter(message => !message.hidden);
     const activeSelection = activeModel(settings);
     const placeholder = mode === 'provider'
         ? 'Choose provider'
@@ -639,8 +687,9 @@ function ChatScreen({ debug = false, version, continueSession = false, noSession
         ].join('\n')
         : 'First things first: run /provider to choose or add a provider, then select a model.';
     const workspaceLabel = `${process.cwd()}${branchName ? ` (${branchName})` : ''}`;
-    const toolsUsed = toolCallCount(messages);
-    const estimatedTokens = estimateConversationTokens(messages);
+    const allDisplayMessages = [...messages, ...liveMessages];
+    const toolsUsed = toolCallCount(allDisplayMessages);
+    const estimatedTokens = estimateConversationTokens(allDisplayMessages);
     const statusDetailLabel = `${conversationRef.current.length} messages / ${toolsUsed} tool call${toolsUsed === 1 ? '' : 's'} / ↑ ~${formatTokenCount(estimatedTokens.input)} ↓ ~${formatTokenCount(estimatedTokens.output)} / ${skills.length} skill${skills.length === 1 ? '' : 's'}${sessionLabel ? ` / ${sessionLabel}` : ''}`;
     const goalText = activeGoalStatus?.replace(/^Goal:\s*/, '');
     const [rawGoalRequest, ...goalStatusParts] = goalText?.split(' · ') ?? [];
@@ -672,7 +721,12 @@ function ChatScreen({ debug = false, version, continueSession = false, noSession
     ];
     return _jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: staticItems, children: item => item.kind === 'header'
                     ? _jsx(Header, { subtitle: item.subtitle, version: version }, item.key)
-                    : _jsx(MessageView, { message: item.message, width: width }, item.key) }), liveMessages.length > 0 && _jsx(Box, { flexDirection: "column", flexShrink: 0, children: liveMessages.map((message, index) => _jsx(MessageView, { message: message, width: width }, messageKey(message, index))) }), debug && debugLogs.length > 0 && _jsxs(Box, { flexDirection: "column", flexShrink: 0, marginBottom: 1, borderStyle: "round", borderColor: theme.muted, paddingX: 1, children: [_jsx(Text, { color: theme.muted, bold: true, children: "Debug" }), debugLogs.map((line, index) => _jsxs(Text, { color: theme.muted, children: ["\u2022 ", line] }, index))] }), queuedFollowUps.length > 0 && _jsxs(Box, { flexDirection: "column", flexShrink: 0, marginBottom: 1, children: [_jsx(Text, { color: theme.muted, children: "Queued follow-ups:" }), queuedFollowUps.map((item, index) => _jsxs(Text, { color: theme.muted, dimColor: true, children: ["  ", index + 1, ". ", item] }, `${index}-${item}`))] }), busy && _jsx(Box, { flexShrink: 0, marginBottom: 1, children: _jsxs(Text, { children: [_jsxs(Text, { color: theme.orange, bold: true, children: [_jsx(Spinner, { type: "dots" }), " ", busyLabel] }), _jsx(Text, { color: theme.muted, dimColor: true, children: " \u00B7 type to queue follow-up \u00B7 esc to interrupt" })] }) }), goalText && _jsx(Box, { flexShrink: 0, children: _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { color: theme.blue, bold: true, children: "Goal:" }), _jsxs(Text, { color: "white", children: [" ", goalRequest] }), goalStatusText ? _jsxs(Text, { color: theme.orange, children: [" \u00B7 ", goalStatusText] }) : null] }) }), _jsx(Box, { borderStyle: "round", borderColor: theme.deepPurple, paddingX: 1, flexShrink: 0, children: _jsx(Box, { flexGrow: 1, minWidth: 0, children: _jsx(TextInput, { placeholder: placeholder, disabled: busy && mode !== 'chat', mask: mode === 'providerAddKey', historyItems: inputHistory, recordHistory: mode === 'chat', suggestions: inputSuggestions, suggestionMode: mode === 'provider' || mode === 'providerAction' || mode === 'model' ? 'always' : 'slash', submitOnEmpty: mode === 'providerAddKey', onHistoryAdd: persistInputHistory, onCancel: cancelThinking, onEscape: closeInputList, onSubmit: submit }) }) }), _jsxs(Box, { flexShrink: 0, justifyContent: "space-between", children: [_jsxs(Box, { flexDirection: "column", flexShrink: 1, minWidth: 0, children: [_jsx(Text, { color: theme.muted, dimColor: true, wrap: "truncate-end", children: workspaceLabel }), _jsx(Text, { color: theme.muted, dimColor: true, wrap: "truncate-end", children: statusDetailLabel })] }), _jsx(Box, { flexShrink: 0, marginLeft: 2, children: _jsx(Text, { color: theme.muted, dimColor: true, wrap: "truncate-start", children: activeModelName }) })] })] });
+                    : _jsx(MessageView, { message: item.message, width: width }, item.key) }), activeLiveMessages.length > 0 && _jsx(Box, { flexDirection: "column", flexShrink: 0, children: activeLiveMessages.map((message, index) => _jsx(MessageView, { message: message, width: width }, messageKey(message, index))) }), debug && debugLogs.length > 0 && _jsxs(Box, { flexDirection: "column", flexShrink: 0, marginBottom: 1, borderStyle: "round", borderColor: theme.muted, paddingX: 1, children: [_jsx(Text, { color: theme.muted, bold: true, children: "Debug" }), debugLogs.map((line, index) => _jsxs(Text, { color: theme.muted, children: ["\u2022 ", line] }, index))] }), queuedFollowUps.length > 0 && _jsxs(Box, { flexDirection: "column", flexShrink: 0, marginBottom: 1, children: [_jsx(Text, { color: theme.muted, children: "Queued follow-ups:" }), queuedFollowUps.map((item, index) => _jsxs(Text, { color: theme.muted, dimColor: true, children: ["  ", index + 1, ". ", item] }, `${index}-${item}`))] }), busy && _jsx(Box, { flexShrink: 0, marginBottom: 1, children: _jsxs(Text, { children: [_jsxs(Text, { color: theme.orange, bold: true, children: [_jsx(Spinner, { type: "dots" }), " ", busyLabel] }), _jsx(Text, { color: theme.muted, dimColor: true, children: " \u00B7 type to queue follow-up \u00B7 esc to interrupt" })] }) }), goalText && _jsx(Box, { flexShrink: 0, children: _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { color: theme.blue, bold: true, children: "Goal:" }), _jsxs(Text, { color: "white", children: [" ", goalRequest] }), goalStatusText ? _jsxs(Text, { color: theme.orange, children: [" \u00B7 ", goalStatusText] }) : null] }) }), _jsx(Box, { borderStyle: "round", borderColor: theme.deepPurple, paddingX: 1, flexShrink: 0, children: _jsx(Box, { flexGrow: 1, minWidth: 0, children: _jsx(TextInput, { placeholder: placeholder, disabled: busy && mode !== 'chat', mask: mode === 'providerAddKey', historyItems: inputHistory, recordHistory: mode === 'chat', suggestions: inputSuggestions, suggestionMode: mode === 'provider' || mode === 'providerAction' || mode === 'model' ? 'always' : 'slash', submitOnEmpty: mode === 'providerAddKey', onHistoryAdd: persistInputHistory, onCancel: cancelThinking, onEscape: () => {
+                            if (busy)
+                                cancelThinking();
+                            else
+                                closeInputList();
+                        }, onSubmit: submit }) }) }), _jsxs(Box, { flexShrink: 0, justifyContent: "space-between", children: [_jsxs(Box, { flexDirection: "column", flexShrink: 1, minWidth: 0, children: [_jsx(Text, { color: theme.muted, dimColor: true, wrap: "truncate-end", children: workspaceLabel }), _jsx(Text, { color: theme.muted, dimColor: true, wrap: "truncate-end", children: statusDetailLabel })] }), _jsx(Box, { flexShrink: 0, marginLeft: 2, children: _jsx(Text, { color: theme.muted, dimColor: true, wrap: "truncate-start", children: activeModelName }) })] })] });
 }
 export async function chatCommand(options = {}) {
     if (process.stdout.isTTY) {

package/dist/cli/commands/formatters.js

@@ -19,6 +19,11 @@ export function toolCallSummary(toolName, input) {
         const timeout = typeof data.timeoutSeconds === 'number' ? ` (timeout ${data.timeoutSeconds}s)` : '';
         return `bash $ ${data.command}${timeout}`;
     }
+    if (toolName === 'grep' && typeof data?.pattern === 'string') {
+        const path = typeof data.path === 'string' && data.path !== '.' ? ` in ${data.path}` : '';
+        const glob = typeof data.glob === 'string' ? ` (${data.glob})` : '';
+        return `grep "${data.pattern}"${path}${glob}`;
+    }
     if (toolName === 'listFiles' && typeof data?.path === 'string')
         return `listFiles ${data.path}`;
     if ((toolName === 'readFile' || toolName === 'writeFile') && typeof data?.path === 'string')
@@ -29,6 +34,10 @@ export function toolCallSummary(toolName, input) {
     }
     if (toolName === 'replaceLines' && typeof data?.path === 'string')
         return `replaceLines ${data.path}:${data.startLine}-${data.endLine}`;
+    if (toolName === 'subagent' && typeof data?.task === 'string') {
+        const taskPreview = data.task.length > 60 ? `${data.task.slice(0, 60).trimEnd()}…` : data.task;
+        return `subagent "${taskPreview}"`;
+    }
     return `${toolName} ${compact(input)}`;
 }
 export function toolResultSummary(event) {
@@ -37,11 +46,29 @@ export function toolResultSummary(event) {
     const output = event.output;
     if (output?.duplicateSkipped === true)
         return 'skipped duplicate';
+    if (typeof output?.totalMatches === 'number') {
+        const count = output.totalMatches;
+        return count === 0 ? 'no matches' : `${count} match${count === 1 ? '' : 'es'}`;
+    }
     if (typeof output?.code === 'number')
         return `exited with code ${output.code}`;
+    if (typeof output?.status === 'string' && typeof output?.summary === 'string') {
+        const summary = output.summary.split('\n')[0] ?? '';
+        const preview = summary.length > 120 ? `${summary.slice(0, 120).trimEnd()}…` : summary;
+        const calls = typeof output.toolCallCount === 'number' ? output.toolCallCount : output.toolCalls?.length ?? 0;
+        const duration = typeof output.durationMs === 'number' ? ` in ${(output.durationMs / 1000).toFixed(1)}s` : '';
+        const meta = calls > 0 ? ` (${calls} call${calls === 1 ? '' : 's'}${duration})` : '';
+        return `${output.status}${meta}: ${preview}`;
+    }
     if (typeof output?.ok === 'boolean') {
-        if (output.ok)
+        if (output.ok) {
+            if (typeof output.addedLines === 'number' || typeof output.removedLines === 'number') {
+                const added = typeof output.addedLines === 'number' ? output.addedLines : 0;
+                const removed = typeof output.removedLines === 'number' ? output.removedLines : 0;
+                return `Added ${added} line${added === 1 ? '' : 's'}, removed ${removed} line${removed === 1 ? '' : 's'}`;
+            }
             return 'completed';
+        }
         return typeof output.error === 'string' ? `failed: ${compact(output.error)}` : 'failed';
     }
     return 'completed';

package/dist/cli/commands/streaming.d.ts

@@ -13,6 +13,7 @@ export interface StreamCallbacks {
     updateMessage: (id: string, update: Partial<Message>) => void;
     setConversation: (messages: ModelMessage[]) => void;
     setBusy: (busy: boolean) => void;
+    setBusyLabel?: (label: string) => void;
     debugLog: (line: string) => void;
     getConversation: () => ModelMessage[];
     getLastAssistantText: () => string;

package/dist/cli/commands/streaming.js

@@ -10,6 +10,7 @@ import { completionDecision, looksIncomplete, noTextAfterToolPrompt, postContinu
 import { createSessionGoal, formatGoalStatus, observeGoalToolEvent } from '../../core/goal/sessionGoal.js';
 import { agentEvent } from '../../core/agent/events.js';
 import { isContextOverflowError, isRetryableModelError } from '../../core/agent/errors.js';
+import { createSubagentTool } from '../../core/subagent/subagentRunner.js';
 function stableToolKey(toolCall) {
     return `${toolCall.toolName}:${JSON.stringify(toolCall.input)}`;
 }
@@ -44,6 +45,19 @@ function hideSyntheticToolCallMarkup(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 isNonSubstantiveAssistantText(text) {
+    return /^[`\s]*$/.test(text);
+}
+function assistantDisplayText(text) {
+    return hideSyntheticToolCallMarkup(text).trim();
+}
+function normalizeAssistantText(text) {
+    return assistantDisplayText(text)
+        .replace(/[`*_~#>\-–—:;,.!?()[\]{}"']/g, '')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .toLowerCase();
+}
 function toolInputPath(input) {
     return typeof input === 'object' && input != null && 'path' in input && typeof input.path === 'string'
         ? input.path
@@ -66,7 +80,15 @@ async function abortableDelay(milliseconds, signal) {
         }, { once: true });
     });
 }
-const DEFAULT_MAX_OUTPUT_TOKENS = 8192;
+const DEFAULT_MAX_OUTPUT_TOKENS = 16384;
+const IDLE_TIMEOUT_MS = 5 * 60_000;
+const MAIN_STEP_LIMIT = 40;
+const MAIN_TOOL_CALL_LIMIT = 40;
+const MAIN_TOOL_ONLY_STEP_LIMIT = 12;
+const FOLLOW_UP_STEP_LIMIT = 30;
+const FOLLOW_UP_TOOL_CALL_LIMIT = 30;
+const FOLLOW_UP_TOOL_ONLY_STEP_LIMIT = 10;
+const COMPLETION_CONTINUATION_LIMIT = 30;
 function toolOutputOk(output, success) {
     if (!success)
         return false;
@@ -86,7 +108,7 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks,
     const resetIdleTimer = () => {
         if (idleTimer)
             clearTimeout(idleTimer);
-        idleTimer = setTimeout(() => abortController.abort('Haze turn timed out after no model/tool activity.'), 90_000);
+        idleTimer = setTimeout(() => abortController.abort('Haze turn timed out after no model/tool activity.'), IDLE_TIMEOUT_MS);
     };
     try {
         const m = await model();
@@ -96,7 +118,8 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks,
         }
         const activeModel = m;
         const skillRegistry = await loadSkillRegistry();
-        const availableTools = { ...hazeTools, ...buildSkillTools(skillRegistry) };
+        const subagentTool = createSubagentTool({ model: activeModel, contextFiles });
+        const availableTools = { ...hazeTools, subagent: subagentTool, ...buildSkillTools(skillRegistry) };
         const goal = createSessionGoal(value);
         callbacks.setGoalStatus?.(formatGoalStatus(goal));
         const likelyPlanOnlyRequest = isPlanOnlyRequest(value);
@@ -126,14 +149,35 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks,
         let sawToolCall = false;
         let textAfterTool = false;
         let completionContinuationCount = 0;
-        const maxCompletionContinuations = 4;
+        const maxCompletionContinuations = COMPLETION_CONTINUATION_LIMIT;
         let editRecoveryPath;
         let editRecoveryReadSatisfied = false;
         const toolSummaries = [];
+        const visibleAssistantTexts = new Set();
+        const previousAssistantText = normalizeAssistantText(callbacks.getLastAssistantText());
+        if (previousAssistantText)
+            visibleAssistantTexts.add(previousAssistantText);
+        const rememberVisibleAssistantText = (text) => {
+            const normalized = normalizeAssistantText(text);
+            if (!normalized)
+                return;
+            visibleAssistantTexts.add(normalized);
+            callbacks.setLastAssistantText(text);
+        };
+        const isDuplicateVisibleAssistantText = (text) => {
+            const normalized = normalizeAssistantText(text);
+            return normalized.length > 0 && visibleAssistantTexts.has(normalized);
+        };
+        const isPrefixOfVisibleAssistantText = (text) => {
+            const normalized = normalizeAssistantText(text);
+            return normalized.length > 0 && [...visibleAssistantTexts].some(previous => previous.startsWith(normalized) && previous !== normalized);
+        };
         const toolExecutionContext = { inFlightToolCalls: new Map() };
-        const toolGroupId = `tools-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        let toolGroupId = `tools-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        const INLINE_DIFF_LINE_LIMIT = 20;
         const toolDisplayItems = [];
         let toolGroupStarted = false;
+        let toolGroupFinalized = false;
         function renderToolGroup(streaming) {
             const visibleItems = toolDisplayItems.filter(item => !item.hidden);
             const running = visibleItems.some(item => item.status === 'running');
@@ -156,12 +200,29 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks,
             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 lines = [];
+            for (const { item, count } of rows) {
                 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}`;
-            });
+                lines.push(`  ${icon} ${item.summary}${countText}${result}`);
+                if (item.diff && item.diff.length > 0 && (item.diffLineCount ?? item.diff.length) <= INLINE_DIFF_LINE_LIMIT) {
+                    for (const diffLine of item.diff) {
+                        const lineNumber = diffLine.type === 'add' ? diffLine.newLine : diffLine.oldLine;
+                        const marker = diffLine.type === 'add' ? '+' : diffLine.type === 'remove' ? '-' : ' ';
+                        lines.push(`    ${String(lineNumber ?? '').padStart(5)} ${marker} ${diffLine.text}`);
+                    }
+                }
+                else if ((item.diffLineCount ?? 0) > INLINE_DIFF_LINE_LIMIT) {
+                    lines.push(`          diff hidden (${item.diffLineCount} changed lines; run git diff to inspect)`);
+                }
+                if (item.subItems && item.subItems.length > 0) {
+                    for (const sub of item.subItems) {
+                        const subDuration = sub.durationMs > 1000 ? ` (${formatSeconds(sub.durationMs)})` : '';
+                        lines.push(`    · ${sub.name} — ${sub.summary}${subDuration}`);
+                    }
+                }
+            }
             return [header, ...lines].join('\n');
         }
         function updateToolGroup(streaming = true) {
@@ -173,11 +234,22 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks,
             else {
                 callbacks.updateMessage(toolGroupId, { text, streaming });
             }
+            if (!streaming)
+                toolGroupFinalized = true;
         }
         function recordToolStart(toolCall) {
+            if (toolGroupFinalized) {
+                toolDisplayItems.length = 0;
+                toolGroupId = `tools-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+                toolGroupFinalized = false;
+                toolGroupStarted = false;
+            }
             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);
+            const runningSubagents = toolDisplayItems.filter(item => item.status === 'running' && item.summary.startsWith('subagent')).length;
+            if (runningSubagents > 0)
+                callbacks.setBusyLabel?.(`Running ${runningSubagents} subagent${runningSubagents === 1 ? '' : 's'}`);
         }
         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 }));
@@ -188,7 +260,29 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks,
             item.result = toolResultSummary(event);
             item.durationMs = event.durationMs;
             item.hidden = isDuplicateSkippedOutput(event.output);
+            if (typeof event.output === 'object' && event.output != null) {
+                const output = event.output;
+                if (typeof output.diffLineCount === 'number')
+                    item.diffLineCount = output.diffLineCount;
+                if (Array.isArray(output.diff))
+                    item.diff = output.diff;
+            }
+            if (event.toolCall.toolName === 'subagent' && typeof event.output === 'object' && event.output != null) {
+                const out = event.output;
+                if (Array.isArray(out.toolCalls)) {
+                    item.subItems = out.toolCalls.map(tc => ({
+                        name: tc.name,
+                        summary: tc.summary,
+                        durationMs: tc.durationMs,
+                    }));
+                }
+            }
             updateToolGroup(toolDisplayItems.some(candidate => candidate.status === 'running'));
+            const runningSubagents = toolDisplayItems.filter(i => i.status === 'running' && i.summary.startsWith('subagent')).length;
+            if (runningSubagents === 0)
+                callbacks.setBusyLabel?.('Haze is thinking');
+            else
+                callbacks.setBusyLabel?.(`Running ${runningSubagents} subagent${runningSubagents === 1 ? '' : 's'}`);
         }
         callbacks.debugLog(`request started with ${requestMessages.length} conversation messages; intent=${goal.normalizedIntent}; action=${likelyActionRequest}`);
         function recordToolFinish(event) {
@@ -241,12 +335,12 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks,
                 messages: continuationMessages,
                 tools: availableTools,
                 toolChoice: allowTools ? 'auto' : 'none',
-                stopWhen: stepCountIs(10),
+                stopWhen: stepCountIs(FOLLOW_UP_STEP_LIMIT),
                 abortSignal: abortController.signal,
                 experimental_context: toolExecutionContext,
                 prepareStep({ steps, messages }) {
                     continuationToolCalls = steps.flatMap(step => step.toolCalls).length;
-                    if (continuationToolCalls >= 10 || toolOnlyStepCount(steps) >= 5) {
+                    if (continuationToolCalls >= FOLLOW_UP_TOOL_CALL_LIMIT || toolOnlyStepCount(steps) >= FOLLOW_UP_TOOL_ONLY_STEP_LIMIT) {
                         return {
                             toolChoice: 'none',
                             messages: [
@@ -308,8 +402,8 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks,
                 resetIdleTimer();
                 const delta = sanitizeAssistantText(rawDelta);
                 responseText += delta;
-                const displayText = hideSyntheticToolCallMarkup(responseText);
-                if (!displayText && !responseStarted)
+                const displayText = assistantDisplayText(responseText);
+                if ((!displayText || isNonSubstantiveAssistantText(displayText) || isPrefixOfVisibleAssistantText(displayText)) && !responseStarted)
                     continue;
                 if (!responseStarted) {
                     responseStarted = true;
@@ -327,15 +421,19 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks,
             catch (error) {
                 throw followUpStreamError ?? error;
             }
-            const finalText = hideSyntheticToolCallMarkup(responseText).trim();
+            const finalText = assistantDisplayText(responseText);
+            const visibleFinalText = finalText;
+            const hidden = visibleFinalText.length === 0 || isNonSubstantiveAssistantText(visibleFinalText) || isDuplicateVisibleAssistantText(visibleFinalText);
             if (responseStarted) {
-                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 });
+                if (!hidden)
+                    rememberVisibleAssistantText(visibleFinalText);
+                callbacks.onEvent?.(agentEvent({ type: 'message_end', id: responseId, text: visibleFinalText, hidden }));
+                callbacks.updateMessage(responseId, { text: visibleFinalText, streaming: false, hidden });
             }
             return { text: finalText, id: responseId, started: responseStarted };
         }
         let streamError;
+        let lastFinishReason;
         const result = streamText({
             model: activeModel,
             temperature: 0,
@@ -343,7 +441,7 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks,
             system: buildSystemPrompt(contextFiles),
             messages: requestMessages,
             tools: availableTools,
-            stopWhen: stepCountIs(12),
+            stopWhen: stepCountIs(MAIN_STEP_LIMIT),
             abortSignal: abortController.signal,
             experimental_context: toolExecutionContext,
             onError({ error }) {
@@ -384,7 +482,7 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks,
                         ],
                     };
                 }
-                if (likelyActionRequest && !mutatingToolSucceeded && consecutiveToolOnlySteps >= 3 && toolCalls.length < 10) {
+                if (likelyActionRequest && !mutatingToolSucceeded && consecutiveToolOnlySteps >= 3 && toolCalls.length < MAIN_TOOL_CALL_LIMIT) {
                     callbacks.debugLog('nudging action request toward mutation after read-only steps');
                     return {
                         messages: [
@@ -393,7 +491,7 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks,
                         ],
                     };
                 }
-                if (toolCalls.length >= 12 || consecutiveToolOnlySteps >= 5) {
+                if (toolCalls.length >= MAIN_TOOL_CALL_LIMIT || consecutiveToolOnlySteps >= MAIN_TOOL_ONLY_STEP_LIMIT) {
                     callbacks.debugLog('forcing text response to avoid tool loop');
                     return {
                         toolChoice: 'none',
@@ -408,6 +506,7 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks,
                 return undefined;
             },
             onStepFinish({ stepNumber, text, toolCalls, toolResults, finishReason }) {
+                lastFinishReason = finishReason;
                 callbacks.debugLog(`step ${stepNumber} finished: ${finishReason}; text=${text.length}; toolCalls=${toolCalls.length}; toolResults=${toolResults.length}`);
             },
             onFinish(event) {
@@ -440,8 +539,12 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks,
             if (sawToolCall)
                 textAfterTool = true;
             if (currentAssistantStarted && currentAssistantText.length > 0 && toolEpoch > currentAssistantToolEpoch) {
-                callbacks.onEvent?.(agentEvent({ type: 'message_end', id: currentAssistantId, text: hideSyntheticToolCallMarkup(currentAssistantText).trim() }));
-                callbacks.updateMessage(currentAssistantId, { streaming: false });
+                const intermediateText = assistantDisplayText(currentAssistantText);
+                const hidden = intermediateText.length === 0 || isNonSubstantiveAssistantText(intermediateText) || isDuplicateVisibleAssistantText(intermediateText);
+                if (!hidden)
+                    rememberVisibleAssistantText(intermediateText);
+                callbacks.onEvent?.(agentEvent({ type: 'message_end', id: currentAssistantId, text: intermediateText, hidden }));
+                callbacks.updateMessage(currentAssistantId, { text: intermediateText, streaming: false, hidden });
                 currentAssistantId = `assistant-${Date.now()}-${Math.random().toString(36).slice(2)}`;
                 currentAssistantStarted = false;
                 currentAssistantText = '';
@@ -449,8 +552,8 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks,
             }
             assistantText += delta;
             currentAssistantText += delta;
-            const displayText = hideSyntheticToolCallMarkup(currentAssistantText);
-            if (!displayText && !currentAssistantStarted)
+            const displayText = assistantDisplayText(currentAssistantText);
+            if ((!displayText || isNonSubstantiveAssistantText(displayText) || isPrefixOfVisibleAssistantText(displayText)) && !currentAssistantStarted)
                 continue;
             if (!currentAssistantStarted) {
                 assistantStarted = true;
@@ -473,7 +576,16 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks,
             throw streamError ?? error;
         }
         callbacks.debugLog(`response stream finished; session has ${completedConversation.length} model messages`);
-        const finalAssistantText = hideSyntheticToolCallMarkup(assistantText).trim();
+        if (lastFinishReason === 'length' && !sawToolCall && completionContinuationCount < maxCompletionContinuations) {
+            completionContinuationCount += 1;
+            callbacks.debugLog('output token limit reached, auto-continuing');
+            const continuation = await streamAssistantResponse(completedConversation, 'output token limit reached', 'Your response was cut off because you hit the output token limit. Continue from where you left off — do not repeat what you already said, just pick up exactly where you stopped.', true);
+            completedConversation = callbacks.getConversation();
+            if (continuation.text) {
+                assistantText += '\n' + continuation.text;
+            }
+        }
+        const combinedAssistantText = assistantDisplayText(assistantText);
         const decideCompletion = (text) => completionDecision({
             request: value,
             goal,
@@ -486,7 +598,7 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks,
             editFileFailed,
             editRecoveryPath,
         });
-        let decision = decideCompletion(finalAssistantText);
+        let decision = decideCompletion(combinedAssistantText);
         async function runCompletionLoop(seedConversation, seedText) {
             let loopConversation = seedConversation;
             let latestText = seedText;
@@ -499,12 +611,9 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks,
                 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.' });
+                callbacks.addMessage({ role: 'assistant', text: 'Stopped after the autonomous safety limit. 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);
@@ -514,12 +623,14 @@ export async function runAgentTurn(value, displayValue, contextFiles, callbacks,
         }
         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 });
+            const visibleFinalAssistantText = assistantDisplayText(currentAssistantText);
+            const hidden = visibleFinalAssistantText.length === 0 || isNonSubstantiveAssistantText(visibleFinalAssistantText) || isDuplicateVisibleAssistantText(visibleFinalAssistantText) || hidePreToolFragment;
+            if (!hidden)
+                rememberVisibleAssistantText(visibleFinalAssistantText);
+            callbacks.onEvent?.(agentEvent({ type: 'message_end', id: currentAssistantId, text: visibleFinalAssistantText, hidden }));
+            callbacks.updateMessage(currentAssistantId, { text: visibleFinalAssistantText, streaming: false, hidden });
             if (decision.needsActionContinuation || decision.needsValidationContinuation) {
-                callbacks.updateMessage(currentAssistantId, { streaming: false, hidden: true });
-                await runCompletionLoop(completedConversation, finalAssistantText);
+                await runCompletionLoop(completedConversation, combinedAssistantText);
             }
             else if (sawToolCall && !textAfterTool) {
                 const followUp = await streamAssistantResponse(completedConversation, 'tool use completed without follow-up text', noTextAfterToolPrompt(false), false);

package/dist/core/goal/completionPolicy.d.ts

@@ -1,5 +1,6 @@
 import type { SessionGoal } from './sessionGoal.js';
 export declare function looksIncomplete(text: string): boolean;
+export declare function looksTruncated(text: string): boolean;
 export declare function looksBlocked(text: string): boolean;
 export interface CompletionPolicyInput {
     request: string;

package/dist/core/goal/completionPolicy.js

@@ -1,6 +1,23 @@
 import { isActionRequest, isPlanOnlyRequest, isValidationRequest } from './requestClassifier.js';
 export function looksIncomplete(text) {
-    return /\b(incomplete|what remains|remains:|remaining:|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)/i.test(text);
+    return /\b(incomplete|what remains|remains:|remaining:|next:|unfinished|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|tool slice reached)/i.test(text);
+}
+export function looksTruncated(text) {
+    const trimmed = text.trimEnd();
+    if (!trimmed)
+        return false;
+    const lines = trimmed.split('\n');
+    const lastLine = lines[lines.length - 1].trim();
+    if (/^#{1,6}\s+\S/.test(lastLine))
+        return true;
+    if (/^(-{3,}|\*{3,}|_{3,})$/.test(lastLine))
+        return true;
+    if (trimmed.endsWith(':'))
+        return true;
+    const fences = (trimmed.match(/```/g) ?? []).length;
+    if (fences % 2 !== 0)
+        return true;
+    return false;
 }
 export function looksBlocked(text) {
     return /\b(blocked|blocker|needs user|need user|missing permission|permission denied|missing dependency|no practical validation|unable to validate|can't validate|cannot validate)\b/i.test(text);
@@ -9,7 +26,7 @@ export function completionDecision(input) {
     const likelyPlanOnlyRequest = isPlanOnlyRequest(input.request);
     const likelyActionRequest = isActionRequest(input.request);
     const likelyValidationRequest = isValidationRequest(input.request);
-    const assistantAdmitsIncomplete = looksIncomplete(input.assistantText);
+    const assistantAdmitsIncomplete = looksIncomplete(input.assistantText) || looksTruncated(input.assistantText);
     const assistantReportsBlocker = looksBlocked(input.assistantText);
     const requestCompletedByTools = input.mutatingToolSucceeded && input.validationToolSucceeded && !input.editRecoveryPath;
     const changedActionNeedsValidation = likelyActionRequest
@@ -55,7 +72,7 @@ export function completionDecision(input) {
     };
 }
 export function toolLoopBudgetPrompt() {
-    return 'Tool budget reached. You cannot call tools now, and you must not output XML, JSON tool-call syntax, <tool_call> blocks, or function-call markup. 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.';
+    return 'Tool slice reached for this model step. Do not output XML, JSON tool-call syntax, <tool_call> blocks, or function-call markup. If the current request is complete, summarize only current-turn changes and validation. If the requested change is incomplete, state the next concrete unfinished action briefly so Haze can continue autonomously in a fresh tool slice. Do not claim tools are unavailable, recap unrelated earlier tasks, or provide a generic remains list.';
 }
 export function postContinuationPrompt() {
     return '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.';

package/dist/core/subagent/subagentRunner.d.ts

@@ -0,0 +1,33 @@
+import { streamText } from 'ai';
+import type { ContextFile } from '../../config/contextFiles.js';
+export interface SubagentResult {
+    status: 'ok' | 'error' | 'timeout' | 'cancelled';
+    summary: string;
+    toolCalls: Array<{
+        name: string;
+        summary: string;
+        durationMs: number;
+    }>;
+    toolCallCount: number;
+    tokens: {
+        in: number;
+        out: number;
+    };
+    durationMs: number;
+    error?: string;
+}
+export declare function runSubagent(task: string, options: {
+    model: Parameters<typeof streamText>[0]['model'];
+    contextFiles: ContextFile[];
+    allowedTools?: readonly string[];
+    maxSteps?: number;
+    abortSignal?: AbortSignal;
+}): Promise<SubagentResult>;
+export declare function createSubagentTool(options: {
+    model: Parameters<typeof streamText>[0]['model'];
+    contextFiles: ContextFile[];
+}): import("ai").Tool<{
+    task: string;
+    tools?: ("editFile" | "replaceLines" | "writeFile" | "listFiles" | "readFile" | "grep" | "bash")[] | undefined;
+    maxSteps?: number | undefined;
+}, SubagentResult>;

package/dist/core/subagent/subagentRunner.js

@@ -0,0 +1,140 @@
+import { streamText, stepCountIs, tool } from 'ai';
+import { z } from 'zod';
+import { buildSystemPrompt } from '../../llm/systemPrompt.js';
+import { hazeTools } from '../../llm/hazeTools.js';
+const SUBAGENT_SYSTEM_PROMPT = `You are a focused subagent. Complete the assigned task using all tools available to you, then return a clear summary.
+
+Rules:
+- Use whatever tools you need. You have full access to file tools and bash.
+- If the task requires creating or modifying files, do it directly — do not ask for permission.
+- If a tool fails, read the file again and retry with the correct content.
+- After completing the task, summarize what you did, what files you created or changed, and any important findings.
+- If you cannot complete the task, explain exactly what blocked you and what you tried.
+- Your summary is all the parent agent will see. Be specific: include file paths, function names, and concrete results.`;
+const ALL_TOOLS = ['listFiles', 'readFile', 'grep', 'bash', 'editFile', 'replaceLines', 'writeFile'];
+const STEP_LIMIT = 25;
+const MAX_SUMMARY = 4000;
+const TOOL_ONLY_LIMIT = 12;
+function toolSummary(output) {
+    if (typeof output !== 'object' || output == null)
+        return 'completed';
+    const o = output;
+    if (typeof o.totalMatches === 'number')
+        return o.totalMatches === 0 ? 'no matches' : `${o.totalMatches} matches`;
+    if (typeof o.code === 'number')
+        return `exit ${o.code}`;
+    if (o.ok === true)
+        return 'completed';
+    if (o.ok === false && typeof o.error === 'string')
+        return `failed: ${o.error.slice(0, 120)}`;
+    return 'completed';
+}
+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;
+}
+export async function runSubagent(task, options) {
+    const start = performance.now();
+    const toolNames = (options.allowedTools ?? ALL_TOOLS).filter(t => ALL_TOOLS.includes(t));
+    const maxSteps = Math.min(options.maxSteps ?? STEP_LIMIT, STEP_LIMIT);
+    const scopedTools = {};
+    for (const name of toolNames) {
+        const key = name;
+        if (key in hazeTools)
+            scopedTools[name] = hazeTools[key];
+    }
+    const toolCallLog = [];
+    let tokensIn = 0;
+    let tokensOut = 0;
+    let lastStep = 0;
+    let totalToolCalls = 0;
+    try {
+        const result = streamText({
+            model: options.model,
+            temperature: 0,
+            maxOutputTokens: 4096,
+            system: `${SUBAGENT_SYSTEM_PROMPT}\n\n${buildSystemPrompt(options.contextFiles)}`,
+            messages: [{ role: 'user', content: task }],
+            tools: scopedTools,
+            stopWhen: stepCountIs(maxSteps),
+            abortSignal: options.abortSignal,
+            experimental_context: { inFlightToolCalls: new Map() },
+            prepareStep({ steps }) {
+                const calls = steps.flatMap(step => step.toolCalls);
+                const consecutiveToolOnly = toolOnlyStepCount(steps);
+                if (consecutiveToolOnly >= TOOL_ONLY_LIMIT || calls.length >= maxSteps * 2) {
+                    return {
+                        toolChoice: 'none',
+                        messages: [
+                            { role: 'user', content: 'You have done enough tool work. Summarize what you found or did right now.' },
+                        ],
+                    };
+                }
+                return undefined;
+            },
+            onStepFinish({ stepNumber }) {
+                lastStep = stepNumber;
+            },
+            onFinish(event) {
+                if (event.usage) {
+                    tokensIn = event.usage.inputTokens ?? 0;
+                    tokensOut = event.usage.outputTokens ?? 0;
+                }
+            },
+            experimental_onToolCallFinish(event) {
+                if (!event.toolCall)
+                    return;
+                totalToolCalls += 1;
+                toolCallLog.push({
+                    name: event.toolCall.toolName,
+                    summary: toolSummary(event.output),
+                    durationMs: event.durationMs,
+                });
+            },
+        });
+        let text = '';
+        for await (const delta of result.textStream) {
+            text += delta;
+        }
+        await result.response;
+        const summary = (text.trim() || 'Subagent completed without text output.').slice(0, MAX_SUMMARY);
+        const durationMs = performance.now() - start;
+        const status = options.abortSignal?.aborted ? 'cancelled'
+            : lastStep >= maxSteps ? 'timeout'
+                : 'ok';
+        return { status, summary, toolCalls: toolCallLog, toolCallCount: totalToolCalls, tokens: { in: tokensIn, out: tokensOut }, durationMs };
+    }
+    catch (error) {
+        return {
+            status: options.abortSignal?.aborted ? 'cancelled' : 'error',
+            summary: error instanceof Error ? error.message : String(error),
+            toolCalls: toolCallLog,
+            toolCallCount: totalToolCalls,
+            tokens: { in: tokensIn, out: tokensOut },
+            durationMs: performance.now() - start,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export function createSubagentTool(options) {
+    return tool({
+        description: 'Spawn subagents to run independent tasks in parallel. ONLY use when a request clearly decomposes into 2+ independent subtasks that can run concurrently — spawn all of them in one step. Do NOT use for single tasks, sequential work, or anything that benefits from conversation context; do those directly instead. Subagents have no conversation history and return a summary.',
+        inputSchema: z.object({
+            task: z.string().min(1).describe('Clear, specific task for the subagent to complete.'),
+            tools: z.array(z.enum(['listFiles', 'readFile', 'grep', 'bash', 'editFile', 'replaceLines', 'writeFile'])).optional().describe('Tools the subagent can use. Defaults to all tools. Restrict to a subset only when the subagent should be read-only.'),
+            maxSteps: z.number().int().positive().max(50).optional().describe('Maximum tool-call rounds. Default 25.'),
+        }),
+        execute: async ({ task, tools, maxSteps }, context) => runSubagent(task, {
+            model: options.model,
+            contextFiles: options.contextFiles,
+            allowedTools: tools,
+            maxSteps,
+            abortSignal: context.abortSignal,
+        }),
+    });
+}

package/dist/llm/hazeTools.d.ts

@@ -1,3 +1,9 @@
+type ToolDiffLine = {
+    type: 'add' | 'remove' | 'context';
+    oldLine?: number;
+    newLine?: number;
+    text: string;
+};
 export declare const hazeTools: {
     listFiles: import("ai").Tool<{
         path: string;
@@ -67,6 +73,39 @@ export declare const hazeTools: {
         totalLines: number;
         lineNumberedText: string;
     }>;
+    grep: import("ai").Tool<{
+        pattern: string;
+        path: string;
+        contextLines: number;
+        maxMatches: number;
+        caseInsensitive: boolean;
+        glob?: string | undefined;
+    }, {
+        ok: boolean;
+        toolName: string;
+        path: string | undefined;
+        error: string;
+        recoverable: boolean;
+        suggestedNextStep: string;
+    } | {
+        ok: true;
+        duplicateSkipped: true;
+        toolName: string;
+        reason: string;
+    } | {
+        pattern: string;
+        path: string;
+        glob: string | null;
+        caseInsensitive: boolean;
+        matches: {
+            file: string;
+            line: number;
+            content: string;
+            isContext: boolean;
+        }[];
+        totalMatches: number;
+        truncated: boolean;
+    }>;
     replaceLines: import("ai").Tool<{
         path: string;
         startLine: number;
@@ -94,6 +133,10 @@ export declare const hazeTools: {
         endLineClamped: boolean;
         replacementLines: number;
         appended: boolean;
+        addedLines: number;
+        removedLines: number;
+        diffLineCount: number;
+        diff: ToolDiffLine[] | undefined;
     }>;
     writeFile: import("ai").Tool<{
         path: string;
@@ -142,6 +185,10 @@ export declare const hazeTools: {
         path: string;
         edits: number;
         approximateMatches: number;
+        addedLines: number;
+        removedLines: number;
+        diffLineCount: number;
+        diff: ToolDiffLine[] | undefined;
     }>;
     bash: import("ai").Tool<{
         command: string;
@@ -150,3 +197,4 @@ export declare const hazeTools: {
     }, unknown>;
 };
 export type HazeTools = typeof hazeTools;
+export {};

package/dist/llm/hazeTools.js

@@ -106,7 +106,7 @@ function isMutatingTool(toolName) {
     return ['editFile', 'replaceLines', 'writeFile'].includes(toolName);
 }
 function isReadOnlyFileTool(toolName) {
-    return ['listFiles', 'readFile'].includes(toolName);
+    return ['listFiles', 'readFile', 'grep'].includes(toolName);
 }
 function inputPath(input) {
     return typeof input === 'object' && input != null && 'path' in input && typeof input.path === 'string'
@@ -120,6 +120,32 @@ function structuredToolFailure(toolName, error, suggestedNextStep, pathForError)
     const message = error instanceof Error ? error.message : String(error);
     return { ok: false, toolName, path: pathForError, error: message, recoverable: true, suggestedNextStep };
 }
+const INLINE_DIFF_LINE_LIMIT = 20;
+function splitDiffLines(text) {
+    const lines = text.split(/\r?\n/);
+    if (text.endsWith('\n') || text.endsWith('\r\n'))
+        lines.pop();
+    return lines;
+}
+function lineNumberAtOffset(text, offset) {
+    let line = 1;
+    for (let index = 0; index < offset; index++) {
+        if (text.charCodeAt(index) === 10)
+            line += 1;
+    }
+    return line;
+}
+function replacementDiff(oldText, newText, oldStartLine, newStartLine, context) {
+    const oldLines = splitDiffLines(oldText);
+    const newLines = splitDiffLines(newText);
+    const diff = [];
+    if (context?.before)
+        diff.push({ type: 'context', ...context.before });
+    diff.push(...oldLines.map((text, index) => ({ type: 'remove', oldLine: oldStartLine + index, text })), ...newLines.map((text, index) => ({ type: 'add', newLine: newStartLine + index, text })));
+    if (context?.after)
+        diff.push({ type: 'context', ...context.after });
+    return { diff, addedLines: newLines.length, removedLines: oldLines.length };
+}
 async function runDedupedTool(toolName, input, context, execute) {
     const ctx = hazeContext(context);
     if (!ctx)
@@ -279,6 +305,67 @@ export const hazeTools = {
             }
         }),
     }),
+    grep: tool({
+        description: 'Search file contents with a regex pattern using ripgrep. Use this to find symbol definitions, usages, string literals, import paths, and code patterns across the workspace. Much faster and more targeted than reading files one by one with readFile. Respects .gitignore by default.',
+        inputSchema: z.object({
+            pattern: z.string().min(1).describe('Regex pattern to search for (PCRE-compatible). Examples: "function handleClick", "import.*from.*react", "class UserService", "TODO|FIXME"'),
+            path: z.string().default('.').describe('Directory or file path to search in, relative to the workspace. Narrow this to focus results.'),
+            glob: z.string().optional().describe('File glob filter. Examples: "*.ts", "*.{js,jsx}", "src/**/*.py". Narrows search to matching files.'),
+            contextLines: z.number().int().nonnegative().max(5).default(2).describe('Number of context lines before and after each match (0-5). Use 0 for compact output, 2-3 for understanding surrounding code.'),
+            maxMatches: z.number().int().positive().max(200).default(50).describe('Maximum number of matches to return. Increase for broad searches, decrease for focused lookups.'),
+            caseInsensitive: z.boolean().default(false).describe('Case-insensitive matching. Useful for symbol names that may vary in casing.'),
+        }),
+        execute: async ({ pattern, path: searchPath, glob, contextLines, maxMatches, caseInsensitive }, context) => runDedupedTool('grep', { pattern, path: searchPath, glob, contextLines, maxMatches, caseInsensitive }, context, async () => {
+            try {
+                const absolutePath = resolveWorkspacePath(searchPath);
+                const args = [
+                    '--no-heading', '--line-number', '--color=never',
+                    '--max-count', String(maxMatches),
+                    '--context', String(contextLines),
+                ];
+                if (caseInsensitive)
+                    args.push('--ignore-case');
+                if (glob)
+                    args.push('--glob', glob);
+                args.push('--', pattern, absolutePath);
+                let stdout = '';
+                try {
+                    const result = await execFile('rg', args, { cwd: workspaceRoot(), timeout: 30_000 });
+                    stdout = result.stdout;
+                }
+                catch (error) {
+                    const code = typeof error === 'object' && error != null && 'code' in error ? error.code : undefined;
+                    if (code === 1) {
+                        stdout = '';
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+                if (!stdout) {
+                    return { pattern, path: searchPath, glob: glob ?? null, caseInsensitive, matches: [], totalMatches: 0, truncated: false };
+                }
+                const { text: output, truncated } = truncate(stdout);
+                const lines = output.split('\n').filter(Boolean);
+                const matches = [];
+                for (const line of lines) {
+                    const match = line.match(/^(\S+?):(\d+)[-:](.*)$/);
+                    if (!match)
+                        continue;
+                    const [, file, lineStr, content] = match;
+                    if (file && lineStr && content !== undefined) {
+                        const isContext = line.includes('-');
+                        const relativePath = path.relative(workspaceRoot(), file);
+                        matches.push({ file: relativePath, line: Number(lineStr), content, isContext });
+                    }
+                }
+                return { pattern, path: searchPath, glob: glob ?? null, caseInsensitive, matches, totalMatches: matches.filter(m => !m.isContext).length, truncated };
+            }
+            catch (error) {
+                return structuredToolFailure('grep', error, 'Check that the search path exists and the pattern is valid regex. Try a narrower path or simpler pattern.', searchPath);
+            }
+        }),
+    }),
     replaceLines: tool({
         description: 'Replace a 1-based inclusive line range in an existing UTF-8 text file. Prefer this after reading a file when exact editFile replacements are ambiguous or fail. If endLine is slightly beyond EOF, it is clamped to the current last line.',
         inputSchema: z.object({
@@ -304,6 +391,11 @@ export const hazeTools = {
                     throw new Error(`startLine ${startLine} is beyond end of file (${lines.length} lines)`);
                 const effectiveEndLine = !isAppend && endLine > lines.length ? lines.length : endLine;
                 const replacementLines = content.length === 0 ? [] : content.split(/\r?\n/);
+                const removedText = isAppend ? '' : lines.slice(startLine - 1, effectiveEndLine).join('\n');
+                const beforeContext = startLine > 1 ? { oldLine: startLine - 1, newLine: startLine - 1, text: lines[startLine - 2] ?? '' } : undefined;
+                const afterContext = !isAppend && effectiveEndLine < lines.length
+                    ? { oldLine: effectiveEndLine + 1, newLine: startLine + replacementLines.length, text: lines[effectiveEndLine] ?? '' }
+                    : undefined;
                 if (isAppend) {
                     lines.push(...replacementLines);
                 }
@@ -311,8 +403,10 @@ export const hazeTools = {
                     lines.splice(startLine - 1, effectiveEndLine - startLine + 1, ...replacementLines);
                 }
                 const updated = lines.join('\n') + (hasTrailingNewline ? '\n' : '');
+                const { diff, addedLines, removedLines } = replacementDiff(removedText, content, startLine, startLine, { before: beforeContext, after: afterContext });
+                const diffLineCount = diff.length;
                 await fs.writeFile(absolutePath, updated, 'utf8');
-                return { ok: true, path: filePath, startLine, endLine: effectiveEndLine, requestedEndLine: endLine, endLineClamped: effectiveEndLine !== endLine, replacementLines: replacementLines.length, appended: isAppend };
+                return { ok: true, path: filePath, startLine, endLine: effectiveEndLine, requestedEndLine: endLine, endLineClamped: effectiveEndLine !== endLine, replacementLines: replacementLines.length, appended: isAppend, addedLines, removedLines, diffLineCount, diff: diffLineCount <= INLINE_DIFF_LINE_LIMIT ? diff : undefined };
             }
             catch (error) {
                 return structuredToolFailure('replaceLines', error, 'Read the file again for current line numbers, then retry replaceLines with a valid range.', filePath);
@@ -383,8 +477,30 @@ export const hazeTools = {
                 for (const range of [...ranges].sort((a, b) => b.start - a.start)) {
                     updated = updated.slice(0, range.start) + range.edit.newText + updated.slice(range.end);
                 }
+                const originalLines = splitDiffLines(original);
+                let lineDelta = 0;
+                let addedLines = 0;
+                let removedLines = 0;
+                const diff = [];
+                for (const range of ranges) {
+                    const oldStartLine = lineNumberAtOffset(original, range.start);
+                    const newStartLine = oldStartLine + lineDelta;
+                    const oldLineCount = splitDiffLines(range.edit.oldText).length;
+                    const newLineCount = splitDiffLines(range.edit.newText).length;
+                    const beforeContext = oldStartLine > 1 ? { oldLine: oldStartLine - 1, newLine: newStartLine - 1, text: originalLines[oldStartLine - 2] ?? '' } : undefined;
+                    const afterOldLine = oldStartLine + oldLineCount;
+                    const afterContext = afterOldLine <= originalLines.length
+                        ? { oldLine: afterOldLine, newLine: newStartLine + newLineCount, text: originalLines[afterOldLine - 1] ?? '' }
+                        : undefined;
+                    const rangeDiff = replacementDiff(range.edit.oldText, range.edit.newText, oldStartLine, newStartLine, { before: beforeContext, after: afterContext });
+                    diff.push(...rangeDiff.diff);
+                    addedLines += rangeDiff.addedLines;
+                    removedLines += rangeDiff.removedLines;
+                    lineDelta += rangeDiff.addedLines - rangeDiff.removedLines;
+                }
+                const diffLineCount = diff.length;
                 await fs.writeFile(absolutePath, updated, 'utf8');
-                return { ok: true, path: filePath, edits: edits.length, approximateMatches: ranges.filter(range => range.approximate).length };
+                return { ok: true, path: filePath, edits: edits.length, approximateMatches: ranges.filter(range => range.approximate).length, addedLines, removedLines, diffLineCount, diff: diffLineCount <= INLINE_DIFF_LINE_LIMIT ? diff : undefined };
             }
             catch (error) {
                 return structuredToolFailure('editFile', error, 'Read the file again, then retry with exact current text or use replaceLines with the latest line numbers.', filePath);

package/dist/llm/systemPrompt.js

@@ -5,21 +5,25 @@ export function buildSystemPrompt(contextFiles = []) {
     return `You are Haze, an expert coding assistant operating inside a terminal-based agent CLI. You help users build apps by understanding the current conversation, inspecting projects, running commands, and editing files.
 
 Available tools:
-- listFiles: List files and directories in the current workspace. Supports recursive listings and cursor pagination. Prefer this over bash ls/find for project discovery.
-- readFile: Read UTF-8 files with optional line ranges. Returns lineNumberedText for line-based edits.
+- grep: Fast regex search across the workspace using ripgrep. Use to find symbol definitions, usages, string literals, import paths, and code patterns. Prefer grep over readFile when you need to locate something in the codebase -- grep searches all files at once and returns matching lines with file paths and line numbers. Use glob to narrow to specific file types and path to narrow to specific directories.
+- listFiles: List files and directories in the current workspace. Supports recursive listings and cursor pagination. Use for project structure discovery, not for finding specific code.
+- readFile: Read a specific file when you already know which file to look at. Returns numbered lines for precise edits. Use after grep to read the full context around a match, not to search for code across files.
 - editFile: Edit files with unique text replacements. Use only for small, unambiguous replacements. Put multiple edits to the same file in one editFile call; do not issue parallel separate edits for the same file.
 - replaceLines: Replace a 1-based inclusive line range. Use when editFile is ambiguous or has failed once. To append at EOF, use startLine=totalLines+1 and endLine=totalLines from the latest readFile result. Slightly-too-large endLine values are clamped to EOF.
 - writeFile: Create files, or overwrite existing files only when overwriteExisting=true is intentionally set for a complete rewrite. Prefer editFile/replaceLines for existing files.
 - bash: Run shell commands for tests, builds, scripts, and inspection that cannot be done with file tools. Do not use bash to mutate files unless explicitly requested or file tools cannot do the job.
+- subagent: Spawn focused subagents to run independent tasks in parallel. Each subagent gets a fresh context and full tool access. ONLY use subagents when a request clearly decomposes into 2+ independent subtasks that can run concurrently. Do NOT use subagents for single tasks, sequential work, or tasks that benefit from your full conversation context — do those yourself. Subagents have no access to the conversation history, so the main agent should always handle complex, context-dependent work directly.
 - skill_*: Markdown skills installed in ~/.haze/skills. Use a skill tool when its description matches the user's request; it returns workflow instructions and explicitly referenced files.
 
 Guidelines:
 - Be concise, technical, and practical.
+- Only spawn subagents when a request clearly splits into 2+ independent parallel tasks (e.g. "check auth, payments, and users" -> 3 subagents). For everything else, do the work yourself — you have the most context. Never spawn a single subagent for a task you could do directly.
 - You have access to the tools listed above. Never claim that you cannot inspect files, run shell commands, or make file changes when an available tool can do it.
 - Skills are optional instruction bundles. Call a skill tool only when relevant, then follow the returned SKILL.md instructions and references.
 - If answering requires current workspace information, inspect it with tools instead of guessing or saying you cannot access it.
 - When the user asks you to run a command, inspect command output, or reason about local project state, use bash or file tools rather than only explaining what the user could run.
 - Preserve user-provided content exactly. When the user asks to add, modify, or use "this", "that", "it", or previous content, refer to the current conversation and do not substitute different text.
+- Use grep to find code across the workspace. Do not read multiple files one by one to locate a symbol, import, or string -- use grep with a targeted pattern and glob filter instead. Only use readFile after grep has identified the relevant file and line range, or when the user names a specific file.
 - Use listFiles for project discovery instead of bash ls/find. Start non-recursive, use recursive for focused directories, and follow nextCursor only when more listing is genuinely needed.
 - Do not list or read the same path repeatedly unless the file changed or the previous result was insufficient.
 - Read only directly relevant files, usually once. Do not read README/package files unless needed for the task.
@@ -29,7 +33,7 @@ Guidelines:
 - Use writeFile for new files. For existing files, prefer editFile or replaceLines; only set writeFile overwriteExisting=true when a complete rewrite is intentional and safer than targeted edits.
 - Use bash mainly for tests, builds, package scripts, and commands that are not covered by file tools. Do not combine validation with file mutation in one shell command; use file tools for edits and bash only for validation/inspection.
 - After making changes, validate with the project's relevant test/typecheck/build command when practical. After editing source or test files in languages with syntax checkers, run the syntax check before the full test command when practical. Once a requested change is edited and validation passes, summarize; do not continue inspecting files.
-- For action requests such as "add", "create", "write", "implement", "update", "fix", "test", or "document", do not stop after only inspecting files. Make the requested file/code changes unless blocked or clarification is required.
+- For action requests such as "add", "create", "write", "implement", "update", "fix", "test", or "document", work autonomously until the requested goal is complete, validation has run when practical, a concrete blocker prevents progress, or a user decision is required. Do not stop after only inspecting files.
 - Requests like "create a plan", "make a plan", or "outline a plan" are planning requests, not implementation requests. If you create a plan document, summarize it; do not start implementing or validating unless asked.
 - If editFile or replaceLines fails, read the affected file again with readFile before another edit attempt, then make one smaller targeted change; do not batch speculative replacements. Bash/cat does not satisfy this recovery step.
 - For plan-only requests, stop after creating/updating the plan artifact and summarize it; do not edit source files or run validation in the same turn.
@@ -37,7 +41,7 @@ Guidelines:
 - After tool use, always respond with a concise summary of what changed or what failed for the current user request only. Do not recap unrelated earlier tasks unless directly relevant.
 - Do not call ordinary unfinished work or unresolved optional scope a blocker. A blocker is a concrete tool failure, missing/ambiguous requirement, permission problem, or unavailable dependency.
 - For Ruby ad-hoc checks, prefer adding/running Minitest tests. If a one-liner is truly useful, use ruby -I. -e with require "file" rather than require_relative from -e.
-- Do not say tools are unavailable just because a tool budget or loop guard was mentioned; if you can still call tools in the current turn, continue the requested work.
+- Do not say tools are unavailable just because a tool slice or loop guard was mentioned; if you can still call tools in the current turn, continue the requested work. If a local tool slice ends and work remains, state the next concrete unfinished action rather than asking the user to type continue.
 - Do not claim tests passed or commands succeeded unless you actually ran them in the current turn and saw success.
 - Ask before destructive actions.
 - Show file paths clearly when working with files.${projectContext}

package/dist/ui/theme.d.ts

@@ -5,7 +5,9 @@ export declare const theme: {
     blue: string;
     muted: string;
     danger: string;
+    dangerBg: string;
     success: string;
+    successBg: string;
     warning: string;
     orange: string;
     codeBg: string;

package/dist/ui/theme.js

@@ -5,7 +5,9 @@ export const theme = {
     blue: '#60a5fa',
     muted: '#9ca3af',
     danger: '#fb7185',
+    dangerBg: '#3a1720',
     success: '#39ff14',
+    successBg: '#14331f',
     warning: '#fbbf24',
     orange: '#f59e0b',
     codeBg: '#1f1633',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@denizokcu/haze",
-  "version": "0.0.3",
+  "version": "0.1.0",
   "description": "A pragmatic agentic CLI for building apps from the terminal.",
   "type": "module",
   "license": "MIT",