@shuyhere/takotako 0.0.1 → 0.0.21

package/dist/core/agent-loop.js

@@ -190,510 +190,525 @@ export class AgentLoop {
             return;
         }
         userMessage = sanitized_input.text;
+        // New inbound user turn supersedes pending retries for this session.
+        this.deps.retryQueue?.cancelSession(session.id);
         // 1a3. Start typing indicator
         const chatId = session.metadata?.channelTarget ?? session.metadata?.channelId ?? session.id;
         if (this.deps.typingManager && this.deps.channel) {
             this.deps.typingManager.start(this.deps.channel, chatId);
         }
-        // 1b. React with 👀 (received)
-        const messageId = session.metadata?.messageId;
-        if (this.deps.reactionManager && this.deps.channel && messageId) {
-            await this.deps.reactionManager.react(this.deps.channel, chatId, messageId, 'received');
-        }
-        // 1c. Check if message is a command
-        const parsed = parseCommand(userMessage);
-        if (parsed) {
-            // /think <level> — set thinking level for this session
-            if (parsed.command === 'think' && this.deps.thinkingManager) {
-                const levels = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh'];
-                const level = parsed.args.trim().toLowerCase();
-                if (levels.includes(level)) {
-                    this.deps.thinkingManager.setLevel(session.id, level);
-                    this.deps.typingManager?.stop(chatId);
-                    yield `Thinking level set to **${level}** for this session.`;
-                    return;
-                }
-                this.deps.typingManager?.stop(chatId);
-                yield `Invalid thinking level. Use one of: ${levels.join(', ')}`;
-                return;
+        try {
+            // 1b. React with 👀 (received)
+            const messageId = session.metadata?.messageId;
+            if (this.deps.reactionManager && this.deps.channel && messageId) {
+                await this.deps.reactionManager.react(this.deps.channel, chatId, messageId, 'received');
             }
-            // Built-in commands (/help, /status, etc.)
-            if (this.deps.commandRegistry) {
-                const builtinResult = await this.deps.commandRegistry.handle(userMessage, {
-                    channelId: session.metadata?.channelId ?? '',
-                    authorId: session.metadata?.authorId ?? '',
-                    authorName: session.metadata?.authorName ?? '',
-                    session,
-                    agentId: this.deps.agentId ?? '',
-                });
-                if (builtinResult !== null) {
+            // 1c. Check if message is a command
+            const parsed = parseCommand(userMessage);
+            if (parsed) {
+                // /think <level> — set thinking level for this session
+                if (parsed.command === 'think' && this.deps.thinkingManager) {
+                    const levels = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh'];
+                    const level = parsed.args.trim().toLowerCase();
+                    if (levels.includes(level)) {
+                        this.deps.thinkingManager.setLevel(session.id, level);
+                        this.deps.typingManager?.stop(chatId);
+                        yield `Thinking level set to **${level}** for this session.`;
+                        return;
+                    }
                     this.deps.typingManager?.stop(chatId);
-                    yield builtinResult;
+                    yield `Invalid thinking level. Use one of: ${levels.join(', ')}`;
                     return;
                 }
-            }
-            // Skill commands
-            if (this.deps.skillCommandSpecs && this.deps.skillCommandSpecs.length > 0 && skillLoader) {
-                const dispatchCtx = {
-                    toolRegistry,
-                    skillLoader,
-                    toolContext: {
-                        sessionId: session.id,
-                        workDir: this.deps.workspaceRoot ?? process.cwd(),
-                        workspaceRoot: this.deps.workspaceRoot ?? process.cwd(),
-                        agentId: this.deps.agentId,
-                        agentRole: this.deps.agentRole ?? 'admin',
-                    },
-                };
-                const result = await dispatchSkillCommand(parsed, this.deps.skillCommandSpecs, dispatchCtx);
-                if (result.kind === 'tool-result') {
-                    this.deps.typingManager?.stop(chatId);
-                    yield result.response ?? '';
-                    return;
+                // Built-in commands (/help, /status, etc.)
+                if (this.deps.commandRegistry) {
+                    const builtinResult = await this.deps.commandRegistry.handle(userMessage, {
+                        channelId: session.metadata?.channelId ?? '',
+                        authorId: session.metadata?.authorId ?? '',
+                        authorName: session.metadata?.authorName ?? '',
+                        session,
+                        agentId: this.deps.agentId ?? '',
+                    });
+                    if (builtinResult !== null) {
+                        this.deps.typingManager?.stop(chatId);
+                        yield builtinResult;
+                        return;
+                    }
                 }
-                if (result.kind === 'skill-inject') {
-                    // Rewrite userMessage with the args and inject skill instructions below
-                    userMessage = result.forwardMessage ?? userMessage;
-                    // We'll inject the skill instructions when building the system prompt
-                    // Store it so the prompt builder can pick it up
-                    session.metadata = {
-                        ...session.metadata,
-                        _injectedSkillInstructions: result.instructions,
-                        _injectedSkillName: result.skillName,
+                // Skill commands
+                if (this.deps.skillCommandSpecs && this.deps.skillCommandSpecs.length > 0 && skillLoader) {
+                    const dispatchCtx = {
+                        toolRegistry,
+                        skillLoader,
+                        toolContext: {
+                            sessionId: session.id,
+                            workDir: this.deps.workspaceRoot ?? process.cwd(),
+                            workspaceRoot: this.deps.workspaceRoot ?? process.cwd(),
+                            agentId: this.deps.agentId,
+                            agentRole: this.deps.agentRole ?? 'admin',
+                        },
                     };
+                    const result = await dispatchSkillCommand(parsed, this.deps.skillCommandSpecs, dispatchCtx);
+                    if (result.kind === 'tool-result') {
+                        this.deps.typingManager?.stop(chatId);
+                        yield result.response ?? '';
+                        return;
+                    }
+                    if (result.kind === 'skill-inject') {
+                        // Rewrite userMessage with the args and inject skill instructions below
+                        userMessage = result.forwardMessage ?? userMessage;
+                        // We'll inject the skill instructions when building the system prompt
+                        // Store it so the prompt builder can pick it up
+                        session.metadata = {
+                            ...session.metadata,
+                            _injectedSkillInstructions: result.instructions,
+                            _injectedSkillName: result.skillName,
+                        };
+                    }
                 }
             }
-        }
-        // 1d. Transition reaction to processing
-        if (this.deps.reactionManager && this.deps.channel && messageId) {
-            await this.deps.reactionManager.transition(this.deps.channel, chatId, messageId, 'received', 'processing');
-        }
-        // 2. Build system prompt
-        if (hooks) {
-            await hooks.emit('before_prompt_build', {
-                event: 'before_prompt_build',
-                sessionId: session.id,
-                data: {},
-                timestamp: Date.now(),
-            });
-        }
-        // Inject self-awareness context into prompt builder
-        promptBuilder.setTools(toolRegistry.getActiveTools());
-        if (skillLoader) {
-            promptBuilder.setSkills(skillLoader.getAll());
-        }
-        if (this.deps.model) {
-            promptBuilder.setModel(this.deps.model);
-        }
-        if (this.deps.workspaceRoot) {
-            promptBuilder.setWorkingDir(this.deps.workspaceRoot);
-        }
-        // Inject timezone context
-        if (this.deps.timezoneManager) {
-            promptBuilder.setTimezoneContext(this.deps.timezoneManager.getContextString());
-        }
-        let systemPrompt = await promptBuilder.build({ mode: 'full' });
-        // Dynamic skill injection: check trigger conditions against the user message
-        if (skillLoader) {
-            const matchingSkills = skillLoader.getMatchingSkills(userMessage);
-            for (const skill of matchingSkills) {
-                // Avoid duplicating instructions already in the base prompt
-                const snippet = skill.instructions.slice(0, 100);
-                if (!systemPrompt.includes(snippet)) {
-                    systemPrompt += `\n\n---\n\n# Skill: ${skill.manifest.name}\n\n${skill.instructions}`;
+            // 1d. Transition reaction to processing
+            if (this.deps.reactionManager && this.deps.channel && messageId) {
+                await this.deps.reactionManager.transition(this.deps.channel, chatId, messageId, 'received', 'processing');
+            }
+            // 2. Build system prompt
+            if (hooks) {
+                await hooks.emit('before_prompt_build', {
+                    event: 'before_prompt_build',
+                    sessionId: session.id,
+                    data: {},
+                    timestamp: Date.now(),
+                });
+            }
+            // Inject self-awareness context into prompt builder
+            promptBuilder.setTools(toolRegistry.getActiveTools());
+            if (skillLoader) {
+                promptBuilder.setSkills(skillLoader.getAll());
+            }
+            if (this.deps.model) {
+                promptBuilder.setModel(this.deps.model);
+            }
+            if (this.deps.workspaceRoot) {
+                promptBuilder.setWorkingDir(this.deps.workspaceRoot);
+            }
+            // Inject timezone context
+            if (this.deps.timezoneManager) {
+                promptBuilder.setTimezoneContext(this.deps.timezoneManager.getContextString());
+            }
+            let systemPrompt = await promptBuilder.build({ mode: 'full' });
+            // Dynamic skill injection: check trigger conditions against the user message
+            if (skillLoader) {
+                const matchingSkills = skillLoader.getMatchingSkills(userMessage);
+                for (const skill of matchingSkills) {
+                    // Avoid duplicating instructions already in the base prompt
+                    const snippet = skill.instructions.slice(0, 100);
+                    if (!systemPrompt.includes(snippet)) {
+                        systemPrompt += `\n\n---\n\n# Skill: ${skill.manifest.name}\n\n${skill.instructions}`;
+                    }
                 }
             }
-        }
-        // Inject skill instructions from command dispatch (if applicable)
-        const injectedInstructions = session.metadata?._injectedSkillInstructions;
-        const injectedSkillName = session.metadata?._injectedSkillName;
-        if (injectedInstructions && injectedSkillName) {
-            const snippet = injectedInstructions.slice(0, 100);
-            if (!systemPrompt.includes(snippet)) {
-                systemPrompt += `\n\n---\n\n# Skill: ${injectedSkillName}\n\n${injectedInstructions}`;
+            // Inject skill instructions from command dispatch (if applicable)
+            const injectedInstructions = session.metadata?._injectedSkillInstructions;
+            const injectedSkillName = session.metadata?._injectedSkillName;
+            if (injectedInstructions && injectedSkillName) {
+                const snippet = injectedInstructions.slice(0, 100);
+                if (!systemPrompt.includes(snippet)) {
+                    systemPrompt += `\n\n---\n\n# Skill: ${injectedSkillName}\n\n${injectedInstructions}`;
+                }
+                // Clean up metadata
+                delete session.metadata?._injectedSkillInstructions;
+                delete session.metadata?._injectedSkillName;
             }
-            // Clean up metadata
-            delete session.metadata?._injectedSkillInstructions;
-            delete session.metadata?._injectedSkillName;
-        }
-        // 3. Append user message to session (with image attachments as content blocks)
-        const imageAttachments = attachments?.filter((a) => (a.type === 'image' || a.mimeType?.startsWith('image/')) && a.url) ?? [];
-        if (imageAttachments.length > 0) {
-            // Download images and convert to base64 for provider compatibility
-            const imageParts = [];
-            for (const a of imageAttachments) {
-                try {
-                    const resp = await fetch(a.url);
-                    if (resp.ok) {
-                        const buffer = Buffer.from(await resp.arrayBuffer());
-                        const mediaType = a.mimeType || resp.headers.get('content-type') || 'image/png';
-                        imageParts.push({
-                            type: 'image_base64',
-                            media_type: mediaType,
-                            data: buffer.toString('base64'),
-                        });
+            // 3. Append user message to session (with image attachments as content blocks)
+            const imageAttachments = attachments?.filter((a) => (a.type === 'image' || a.mimeType?.startsWith('image/')) && a.url) ?? [];
+            if (imageAttachments.length > 0) {
+                // Download images and convert to base64 for provider compatibility
+                const imageParts = [];
+                for (const a of imageAttachments) {
+                    try {
+                        const resp = await fetch(a.url);
+                        if (resp.ok) {
+                            const buffer = Buffer.from(await resp.arrayBuffer());
+                            const mediaType = a.mimeType || resp.headers.get('content-type') || 'image/png';
+                            imageParts.push({
+                                type: 'image_base64',
+                                media_type: mediaType,
+                                data: buffer.toString('base64'),
+                            });
+                        }
+                        else {
+                            console.warn(`[agent-loop] Failed to fetch image ${a.url}: HTTP ${resp.status}`);
+                        }
                     }
-                    else {
-                        console.warn(`[agent-loop] Failed to fetch image ${a.url}: HTTP ${resp.status}`);
+                    catch (err) {
+                        console.warn(`[agent-loop] Failed to fetch image ${a.url}:`, err instanceof Error ? err.message : err);
                     }
                 }
-                catch (err) {
-                    console.warn(`[agent-loop] Failed to fetch image ${a.url}:`, err instanceof Error ? err.message : err);
+                if (imageParts.length > 0) {
+                    const contentParts = [
+                        { type: 'text', text: userMessage || 'What is in this image?' },
+                        ...imageParts,
+                    ];
+                    session.messages.push({ role: 'user', content: contentParts });
+                }
+                else {
+                    session.messages.push({ role: 'user', content: userMessage });
                 }
-            }
-            if (imageParts.length > 0) {
-                const contentParts = [
-                    { type: 'text', text: userMessage || 'What is in this image?' },
-                    ...imageParts,
-                ];
-                session.messages.push({ role: 'user', content: contentParts });
             }
             else {
                 session.messages.push({ role: 'user', content: userMessage });
             }
-        }
-        else {
-            session.messages.push({ role: 'user', content: userMessage });
-        }
-        // 4. Assemble context
-        const messages = [
-            { role: 'system', content: systemPrompt },
-            ...session.messages,
-        ];
-        // 5. Get tool definitions
-        const tools = toolRegistry.getActiveTools().map((t) => ({
-            name: t.name,
-            description: t.description,
-            parameters: t.parameters,
-        }));
-        // 6. Agent loop (may iterate if tool calls occur)
-        let turns = 0;
-        while (turns < this.config.maxTurns) {
-            turns++;
-            if (contextManager.needsCompaction(messages) && this.deps.compactor) {
-                const compactionResult = await this.deps.compactor.checkAndCompact(session);
-                // Rebuild messages array from compacted session
-                messages.length = 0;
-                messages.push({ role: 'system', content: systemPrompt }, ...session.messages);
-                // Inject session init context after compaction
-                if (compactionResult && this.deps.progressTracker) {
-                    const initContext = await buildSessionInitContext(this.deps.progressTracker, this.deps.sessionInitConfig);
-                    const initMsg = { role: 'system', content: initContext };
-                    session.messages.push(initMsg);
-                    messages.push(initMsg);
+            // 4. Assemble context
+            const messages = [
+                { role: 'system', content: systemPrompt },
+                ...session.messages,
+            ];
+            // 5. Get tool definitions
+            const tools = toolRegistry.getActiveTools().map((t) => ({
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters,
+            }));
+            // 6. Agent loop (may iterate if tool calls occur)
+            let turns = 0;
+            while (turns < this.config.maxTurns) {
+                turns++;
+                // Progressive pruning before compaction to reduce context pressure.
+                const pruningResult = contextManager.pruneMessages(session.messages);
+                if (pruningResult.tokensSaved > 0) {
+                    session.messages = pruningResult.messages;
+                    messages.length = 0;
+                    messages.push({ role: 'system', content: systemPrompt }, ...session.messages);
                 }
-            }
-            const model = this.deps.model ?? 'anthropic/claude-sonnet-4-6';
-            // Sanitize messages: merge consecutive same-role messages for API compatibility
-            const sanitized = this.sanitizeMessages(messages);
-            let fullText = '';
-            let pendingToolCalls = [];
-            const turnStartMs = Date.now();
-            let lastUsage;
-            // Set up streaming if a channel is available and streaming is enabled
-            const streamingCfg = this.deps.streamingConfig;
-            const channelRef = session.metadata?.channelRef;
-            const channelTarget = session.metadata?.channelTarget;
-            // reference runtime-style default: streaming off unless explicitly enabled in config
-            const streamEnabled = streamingCfg?.enabled === true && channelRef && channelTarget;
-            let streamer;
-            if (streamEnabled) {
-                const maxLen = channelRef.id === 'telegram' ? 4096 : 2000;
-                streamer = new ResponseStreamer({
-                    enabled: true,
-                    minChunkSize: streamingCfg?.minChunkSize ?? 50,
-                    flushIntervalMs: streamingCfg?.flushIntervalMs ?? 500,
-                    maxMessageLength: maxLen,
-                }, { channelId: channelTarget, channel: channelRef });
-            }
-            // Collect chunks — only yield text to caller on final turn (no tool calls)
-            const chunks = [];
-            try {
-                for await (const chunk of provider.chat({
-                    model,
-                    messages: sanitized,
-                    tools: tools.length > 0 ? tools : undefined,
-                    stream: true,
-                    ...(this.config.maxTokens != null && { max_tokens: this.config.maxTokens }),
-                })) {
-                    if (chunk.text) {
-                        fullText += chunk.text;
-                        chunks.push(chunk.text);
-                        // Push to streamer for real-time delivery
-                        if (streamer) {
-                            await streamer.push(chunk.text);
+                if (this.deps.compactor && this.deps.compactor.needsCompaction(session)) {
+                    const compactionResult = await this.deps.compactor.checkAndCompact(session);
+                    // Rebuild messages array from compacted session
+                    messages.length = 0;
+                    messages.push({ role: 'system', content: systemPrompt }, ...session.messages);
+                    // Inject session init context after compaction
+                    if (compactionResult && this.deps.progressTracker) {
+                        const initContext = await buildSessionInitContext(this.deps.progressTracker, this.deps.sessionInitConfig);
+                        const initMsg = { role: 'system', content: initContext };
+                        session.messages.push(initMsg);
+                        messages.push(initMsg);
+                    }
+                }
+                const model = this.deps.model ?? 'anthropic/claude-sonnet-4-6';
+                // Sanitize messages: merge consecutive same-role messages for API compatibility
+                const sanitized = this.sanitizeMessages(messages);
+                let fullText = '';
+                let pendingToolCalls = [];
+                const turnStartMs = Date.now();
+                let lastUsage;
+                // Set up streaming if a channel is available and streaming is enabled
+                const streamingCfg = this.deps.streamingConfig;
+                const channelRef = session.metadata?.channelRef;
+                const channelTarget = session.metadata?.channelTarget;
+                // reference runtime-style default: streaming off unless explicitly enabled in config
+                const streamEnabled = streamingCfg?.enabled === true && channelRef && channelTarget;
+                let streamer;
+                if (streamEnabled) {
+                    const maxLen = channelRef.id === 'telegram' ? 4096 : 2000;
+                    streamer = new ResponseStreamer({
+                        enabled: true,
+                        minChunkSize: streamingCfg?.minChunkSize ?? 50,
+                        flushIntervalMs: streamingCfg?.flushIntervalMs ?? 500,
+                        maxMessageLength: maxLen,
+                    }, { channelId: channelTarget, channel: channelRef });
+                }
+                // Collect chunks — only yield text to caller on final turn (no tool calls)
+                const chunks = [];
+                try {
+                    for await (const chunk of provider.chat({
+                        model,
+                        messages: sanitized,
+                        tools: tools.length > 0 ? tools : undefined,
+                        stream: true,
+                        ...(this.config.maxTokens != null && { max_tokens: this.config.maxTokens }),
+                    })) {
+                        if (chunk.text) {
+                            fullText += chunk.text;
+                            chunks.push(chunk.text);
+                            // Push to streamer for real-time delivery
+                            if (streamer) {
+                                await streamer.push(chunk.text);
+                            }
+                        }
+                        if (chunk.tool_calls) {
+                            pendingToolCalls.push(...chunk.tool_calls);
+                        }
+                        if (chunk.done && chunk.usage) {
+                            lastUsage = chunk.usage;
                         }
                     }
-                    if (chunk.tool_calls) {
-                        pendingToolCalls.push(...chunk.tool_calls);
+                }
+                catch (err) {
+                    // Cancel streamer on error
+                    if (streamer)
+                        await streamer.cancel();
+                    // All model providers failed — enqueue for retry if available
+                    if (this.deps.retryQueue) {
+                        this.deps.retryQueue.enqueue({
+                            userMessage,
+                            sessionId: session.id,
+                            channelId: session.metadata?.channelId,
+                            messageId: session.metadata?.messageId,
+                            channel: session.metadata?.channelRef,
+                        });
                     }
-                    if (chunk.done && chunk.usage) {
-                        lastUsage = chunk.usage;
+                    this.deps.typingManager?.stop(chatId);
+                    // Transition reaction to failed
+                    if (this.deps.reactionManager && this.deps.channel && messageId) {
+                        await this.deps.reactionManager.transition(this.deps.channel, chatId, messageId, 'processing', 'failed');
                     }
+                    throw err;
                 }
-            }
-            catch (err) {
-                // Cancel streamer on error
-                if (streamer)
-                    await streamer.cancel();
-                // All model providers failed — enqueue for retry if available
-                if (this.deps.retryQueue) {
-                    this.deps.retryQueue.enqueue({
-                        userMessage,
+                // Finish streaming for this turn (flush remaining buffer)
+                if (streamer) {
+                    await streamer.finish();
+                }
+                // Record usage for this turn
+                if (this.deps.usageTracker && lastUsage) {
+                    const cachedTokens = (lastUsage.cache_read_input_tokens ?? 0);
+                    this.deps.usageTracker.record({
                         sessionId: session.id,
-                        channelId: session.metadata?.channelId,
-                        messageId: session.metadata?.messageId,
-                        channel: session.metadata?.channelRef,
+                        model,
+                        provider: model.includes('/') ? model.split('/')[0] : 'unknown',
+                        timestamp: Date.now(),
+                        inputTokens: lastUsage.prompt_tokens,
+                        outputTokens: lastUsage.completion_tokens,
+                        cachedTokens,
+                        totalTokens: lastUsage.total_tokens,
+                        durationMs: Date.now() - turnStartMs,
                     });
                 }
-                this.deps.typingManager?.stop(chatId);
-                // Transition reaction to failed
-                if (this.deps.reactionManager && this.deps.channel && messageId) {
-                    await this.deps.reactionManager.transition(this.deps.channel, chatId, messageId, 'processing', 'failed');
-                }
-                throw err;
-            }
-            // Finish streaming for this turn (flush remaining buffer)
-            if (streamer) {
-                await streamer.finish();
-            }
-            // Record usage for this turn
-            if (this.deps.usageTracker && lastUsage) {
-                const cachedTokens = (lastUsage.cache_read_input_tokens ?? 0);
-                this.deps.usageTracker.record({
-                    sessionId: session.id,
-                    model,
-                    provider: model.includes('/') ? model.split('/')[0] : 'unknown',
-                    timestamp: Date.now(),
-                    inputTokens: lastUsage.prompt_tokens,
-                    outputTokens: lastUsage.completion_tokens,
-                    cachedTokens,
-                    totalTokens: lastUsage.total_tokens,
-                    durationMs: Date.now() - turnStartMs,
-                });
-            }
-            // Scan model output for secrets before yielding
-            if (fullText) {
-                const scannedText = scanSecrets(fullText);
-                if (scannedText !== fullText) {
-                    // Rebuild chunks from scanned text
-                    chunks.length = 0;
-                    chunks.push(scannedText);
-                    fullText = scannedText;
-                }
-            }
-            // Only yield text from the final turn (no pending tool calls).
-            // Intermediate turns often repeat the same intro text before each tool call,
-            // which clutters the output. The final turn has the actual response.
-            if (pendingToolCalls.length === 0 && !fullText && turns > 1) {
-                // Final turn after tool calls produced no text — yield a minimal acknowledgment
-                // so the user isn't left with silence.
-                console.warn(`[agent-loop] Turn ${turns}: no text after tool calls (${chunks.length} chunks, fullText empty)`);
-                if (!streamer)
-                    yield '✅ Done.';
-            }
-            if (pendingToolCalls.length === 0 && !streamer) {
-                let emitted = 0;
-                for (const c of chunks) {
-                    const remaining = this.config.maxOutputChars - emitted;
-                    if (remaining <= 0) {
-                        yield '\n\n[Output truncated — response exceeded character limit]';
-                        break;
-                    }
-                    const accepted = c.length <= remaining ? c : c.slice(0, remaining);
-                    yield accepted;
-                    emitted += accepted.length;
-                    if (accepted.length < c.length) {
-                        yield '\n\n[Output truncated — response exceeded character limit]';
-                        break;
+                // Scan model output for secrets before yielding
+                if (fullText) {
+                    const scannedText = scanSecrets(fullText);
+                    if (scannedText !== fullText) {
+                        // Rebuild chunks from scanned text
+                        chunks.length = 0;
+                        chunks.push(scannedText);
+                        fullText = scannedText;
                     }
                 }
-            }
-            // Append assistant message to session history.
-            // For intermediate turns (with tool calls), strip the preamble text to prevent
-            // context pollution — the model sees its own repeated intros and reinforces them.
-            // Only keep tool_use blocks in intermediate turns; final turn keeps full text.
-            if (fullText || pendingToolCalls.length > 0) {
-                const contentParts = [];
-                if (pendingToolCalls.length > 0) {
-                    // Intermediate turn: replace verbose preamble with a short marker.
-                    // This prevents the model from seeing N copies of "I'll help you..." in context.
-                    contentParts.push({ type: 'text', text: '[Calling tools]' });
+                // Only yield text from the final turn (no pending tool calls).
+                // Intermediate turns often repeat the same intro text before each tool call,
+                // which clutters the output. The final turn has the actual response.
+                if (pendingToolCalls.length === 0 && !fullText && turns > 1) {
+                    // Final turn after tool calls produced no text — yield a minimal acknowledgment
+                    // so the user isn't left with silence.
+                    console.warn(`[agent-loop] Turn ${turns}: no text after tool calls (${chunks.length} chunks, fullText empty)`);
+                    if (!streamer)
+                        yield '✅ Done.';
                 }
-                else if (fullText) {
-                    contentParts.push({ type: 'text', text: fullText });
+                if (pendingToolCalls.length === 0 && !streamer) {
+                    let emitted = 0;
+                    for (const c of chunks) {
+                        const remaining = this.config.maxOutputChars - emitted;
+                        if (remaining <= 0) {
+                            yield '\n\n[Output truncated — response exceeded character limit]';
+                            break;
+                        }
+                        const accepted = c.length <= remaining ? c : c.slice(0, remaining);
+                        yield accepted;
+                        emitted += accepted.length;
+                        if (accepted.length < c.length) {
+                            yield '\n\n[Output truncated — response exceeded character limit]';
+                            break;
+                        }
+                    }
                 }
-                for (const tc of pendingToolCalls) {
-                    contentParts.push({ type: 'tool_use', id: tc.id, name: tc.name, input: tc.input });
+                // Append assistant message to session history.
+                // For intermediate turns (with tool calls), strip the preamble text to prevent
+                // context pollution — the model sees its own repeated intros and reinforces them.
+                // Only keep tool_use blocks in intermediate turns; final turn keeps full text.
+                if (fullText || pendingToolCalls.length > 0) {
+                    const contentParts = [];
+                    if (pendingToolCalls.length > 0) {
+                        // Intermediate turn: replace verbose preamble with a short marker.
+                        // This prevents the model from seeing N copies of "I'll help you..." in context.
+                        contentParts.push({ type: 'text', text: '[Calling tools]' });
+                    }
+                    else if (fullText) {
+                        contentParts.push({ type: 'text', text: fullText });
+                    }
+                    for (const tc of pendingToolCalls) {
+                        contentParts.push({ type: 'tool_use', id: tc.id, name: tc.name, input: tc.input });
+                    }
+                    const assistantMsg = {
+                        role: 'assistant',
+                        content: pendingToolCalls.length > 0 ? contentParts : fullText,
+                    };
+                    session.messages.push(assistantMsg);
+                    messages.push(assistantMsg);
                 }
-                const assistantMsg = {
-                    role: 'assistant',
-                    content: pendingToolCalls.length > 0 ? contentParts : fullText,
+                if (pendingToolCalls.length === 0)
+                    break;
+                // Execute tool calls
+                const roleName = this.deps.agentRole ?? 'admin';
+                const role = getRole(roleName);
+                const toolCtx = {
+                    sessionId: session.id,
+                    workDir: this.deps.workspaceRoot ?? process.cwd(),
+                    workspaceRoot: this.deps.workspaceRoot ?? process.cwd(),
+                    agentId: this.deps.agentId,
+                    agentRole: roleName,
+                    channelType: session.metadata?.channelType,
+                    channelTarget: session.metadata?.channelTarget,
+                    channel: session.metadata?.channelRef,
                 };
-                session.messages.push(assistantMsg);
-                messages.push(assistantMsg);
-            }
-            if (pendingToolCalls.length === 0)
-                break;
-            // Execute tool calls
-            const roleName = this.deps.agentRole ?? 'admin';
-            const role = getRole(roleName);
-            const toolCtx = {
-                sessionId: session.id,
-                workDir: this.deps.workspaceRoot ?? process.cwd(),
-                workspaceRoot: this.deps.workspaceRoot ?? process.cwd(),
-                agentId: this.deps.agentId,
-                agentRole: roleName,
-                channelType: session.metadata?.channelType,
-                channelTarget: session.metadata?.channelTarget,
-                channel: session.metadata?.channelRef,
-            };
-            for (const tc of pendingToolCalls) {
-                // Check for tool loops before execution
-                if (this.deps.toolLoopDetector) {
-                    const loopWarning = this.deps.toolLoopDetector.recordAndCheck(session.id, tc.name, (tc.input ?? {}));
-                    if (loopWarning) {
-                        const loopMsg = { role: 'system', content: loopWarning };
-                        session.messages.push(loopMsg);
-                        messages.push(loopMsg);
+                for (const tc of pendingToolCalls) {
+                    // Check for tool loops before execution
+                    if (this.deps.toolLoopDetector) {
+                        const loopWarning = this.deps.toolLoopDetector.recordAndCheck(session.id, tc.name, (tc.input ?? {}));
+                        if (loopWarning) {
+                            const loopMsg = { role: 'system', content: loopWarning };
+                            session.messages.push(loopMsg);
+                            messages.push(loopMsg);
+                            const toolMsg = {
+                                role: 'tool',
+                                content: loopWarning,
+                                tool_call_id: tc.id,
+                            };
+                            session.messages.push(toolMsg);
+                            messages.push(toolMsg);
+                            continue;
+                        }
+                    }
+                    // Check role-based permissions before execution
+                    if (role && !isToolAllowed(role, tc.name)) {
+                        const deniedResult = {
+                            output: `Permission denied: agent role "${roleName}" cannot use tool "${tc.name}"`,
+                            success: false,
+                        };
+                        if (hooks) {
+                            await hooks.emit('after_tool_call', {
+                                event: 'after_tool_call',
+                                sessionId: session.id,
+                                data: { toolName: tc.name, result: deniedResult },
+                                timestamp: Date.now(),
+                            });
+                        }
                         const toolMsg = {
                             role: 'tool',
-                            content: loopWarning,
+                            content: deniedResult.output,
                             tool_call_id: tc.id,
                         };
                         session.messages.push(toolMsg);
                         messages.push(toolMsg);
                         continue;
                     }
-                }
-                // Check role-based permissions before execution
-                if (role && !isToolAllowed(role, tc.name)) {
-                    const deniedResult = {
-                        output: `Permission denied: agent role "${roleName}" cannot use tool "${tc.name}"`,
-                        success: false,
-                    };
                     if (hooks) {
-                        await hooks.emit('after_tool_call', {
-                            event: 'after_tool_call',
+                        await hooks.emit('before_tool_call', {
+                            event: 'before_tool_call',
                             sessionId: session.id,
-                            data: { toolName: tc.name, result: deniedResult },
+                            data: { toolName: tc.name, params: tc.input },
                             timestamp: Date.now(),
                         });
                     }
-                    const toolMsg = {
-                        role: 'tool',
-                        content: deniedResult.output,
-                        tool_call_id: tc.id,
-                    };
-                    session.messages.push(toolMsg);
-                    messages.push(toolMsg);
-                    continue;
-                }
-                if (hooks) {
-                    await hooks.emit('before_tool_call', {
-                        event: 'before_tool_call',
-                        sessionId: session.id,
-                        data: { toolName: tc.name, params: tc.input },
-                        timestamp: Date.now(),
-                    });
-                }
-                // Validate tool arguments before execution
-                const validator = getToolValidator();
-                if (validator && tc.input && typeof tc.input === 'object') {
-                    const input = tc.input;
-                    // Validate path arguments
-                    if (typeof input.path === 'string') {
-                        const pathCheck = validator.validatePath(input.path, toolCtx.workDir, ['write', 'edit', 'apply_patch'].includes(tc.name));
-                        if (!pathCheck.allowed) {
-                            const toolMsg = {
-                                role: 'tool',
-                                content: `Blocked: ${pathCheck.blockReason}`,
-                                tool_call_id: tc.id,
-                            };
-                            session.messages.push(toolMsg);
-                            messages.push(toolMsg);
-                            continue;
+                    // Validate tool arguments before execution
+                    const validator = getToolValidator();
+                    if (validator && tc.input && typeof tc.input === 'object') {
+                        const input = tc.input;
+                        // Validate path arguments
+                        if (typeof input.path === 'string') {
+                            const pathCheck = validator.validatePath(input.path, toolCtx.workDir, ['write', 'edit', 'apply_patch'].includes(tc.name));
+                            if (!pathCheck.allowed) {
+                                const toolMsg = {
+                                    role: 'tool',
+                                    content: `Blocked: ${pathCheck.blockReason}`,
+                                    tool_call_id: tc.id,
+                                };
+                                session.messages.push(toolMsg);
+                                messages.push(toolMsg);
+                                continue;
+                            }
                         }
-                    }
-                    // Validate command arguments
-                    if (typeof input.command === 'string' && ['exec', 'process'].includes(tc.name)) {
-                        const cmdCheck = validator.validateCommand(input.command);
-                        if (!cmdCheck.allowed) {
-                            const toolMsg = {
-                                role: 'tool',
-                                content: `Blocked: ${cmdCheck.blockReason}`,
-                                tool_call_id: tc.id,
-                            };
-                            session.messages.push(toolMsg);
-                            messages.push(toolMsg);
-                            continue;
+                        // Validate command arguments
+                        if (typeof input.command === 'string' && ['exec', 'process'].includes(tc.name)) {
+                            const cmdCheck = validator.validateCommand(input.command);
+                            if (!cmdCheck.allowed) {
+                                const toolMsg = {
+                                    role: 'tool',
+                                    content: `Blocked: ${cmdCheck.blockReason}`,
+                                    tool_call_id: tc.id,
+                                };
+                                session.messages.push(toolMsg);
+                                messages.push(toolMsg);
+                                continue;
+                            }
+                        }
+                        // Validate URL arguments
+                        if (typeof input.url === 'string' && ['web_fetch', 'browser_navigate'].includes(tc.name)) {
+                            const urlCheck = validator.validateUrl(input.url);
+                            if (!urlCheck.allowed) {
+                                const toolMsg = {
+                                    role: 'tool',
+                                    content: `Blocked: ${urlCheck.blockReason}`,
+                                    tool_call_id: tc.id,
+                                };
+                                session.messages.push(toolMsg);
+                                messages.push(toolMsg);
+                                continue;
+                            }
                         }
                     }
-                    // Validate URL arguments
-                    if (typeof input.url === 'string' && ['web_fetch', 'browser_navigate'].includes(tc.name)) {
-                        const urlCheck = validator.validateUrl(input.url);
-                        if (!urlCheck.allowed) {
-                            const toolMsg = {
-                                role: 'tool',
-                                content: `Blocked: ${urlCheck.blockReason}`,
-                                tool_call_id: tc.id,
-                            };
-                            session.messages.push(toolMsg);
-                            messages.push(toolMsg);
-                            continue;
+                    const tool = toolRegistry.getTool(tc.name);
+                    let result;
+                    try {
+                        if (tool) {
+                            result = await tool.execute(tc.input, toolCtx);
+                        }
+                        else {
+                            result = { output: `Unknown tool: ${tc.name}`, success: false };
                         }
                     }
-                }
-                const tool = toolRegistry.getTool(tc.name);
-                let result;
-                try {
-                    if (tool) {
-                        result = await tool.execute(tc.input, toolCtx);
+                    catch (err) {
+                        result = {
+                            output: `Error executing ${tc.name}: ${err instanceof Error ? err.message : String(err)}`,
+                            success: false,
+                            error: err instanceof Error ? err.message : String(err),
+                        };
                     }
-                    else {
-                        result = { output: `Unknown tool: ${tc.name}`, success: false };
+                    if (hooks) {
+                        await hooks.emit('after_tool_call', {
+                            event: 'after_tool_call',
+                            sessionId: session.id,
+                            data: { toolName: tc.name, result },
+                            timestamp: Date.now(),
+                        });
                     }
-                }
-                catch (err) {
-                    result = {
-                        output: `Error executing ${tc.name}: ${err instanceof Error ? err.message : String(err)}`,
-                        success: false,
-                        error: err instanceof Error ? err.message : String(err),
+                    const toolMsg = {
+                        role: 'tool',
+                        content: result.output,
+                        tool_call_id: tc.id,
                     };
+                    session.messages.push(toolMsg);
+                    messages.push(toolMsg);
                 }
-                if (hooks) {
-                    await hooks.emit('after_tool_call', {
-                        event: 'after_tool_call',
-                        sessionId: session.id,
-                        data: { toolName: tc.name, result },
-                        timestamp: Date.now(),
-                    });
-                }
-                const toolMsg = {
-                    role: 'tool',
-                    content: result.output,
-                    tool_call_id: tc.id,
-                };
-                session.messages.push(toolMsg);
-                messages.push(toolMsg);
+                pendingToolCalls = [];
+            }
+            // Stop typing indicator
+            this.deps.typingManager?.stop(chatId);
+            // Transition reaction to completed
+            if (this.deps.reactionManager && this.deps.channel && messageId) {
+                await this.deps.reactionManager.transition(this.deps.channel, chatId, messageId, 'processing', 'completed');
+            }
+            // Clear tool loop history for this session turn
+            this.deps.toolLoopDetector?.clearSession(session.id);
+            if (hooks) {
+                await hooks.emit('agent_end', {
+                    event: 'agent_end',
+                    sessionId: session.id,
+                    data: { turns },
+                    timestamp: Date.now(),
+                });
             }
-            pendingToolCalls = [];
-        }
-        // Stop typing indicator
-        this.deps.typingManager?.stop(chatId);
-        // Transition reaction to completed
-        if (this.deps.reactionManager && this.deps.channel && messageId) {
-            await this.deps.reactionManager.transition(this.deps.channel, chatId, messageId, 'processing', 'completed');
         }
-        // Clear tool loop history for this session turn
-        this.deps.toolLoopDetector?.clearSession(session.id);
-        if (hooks) {
-            await hooks.emit('agent_end', {
-                event: 'agent_end',
-                sessionId: session.id,
-                data: { turns },
-                timestamp: Date.now(),
-            });
+        finally {
+            // Safety: always clear typing interval even if any unexpected error escapes.
+            this.deps.typingManager?.stop(chatId);
         }
     }
 }