pulseed 0.4.4 → 0.4.7

package/dist/interface/chat/chat-runner.js

@@ -10,13 +10,16 @@ import { verifyChatAction } from "./chat-verifier.js";
 import { toToolDefinitionsFiltered } from "../../tools/tool-definition-adapter.js";
 import { TendCommand } from "./tend-command.js";
 import { EventSubscriber } from "./event-subscriber.js";
+import { recognizeRuntimeControlIntent } from "../../runtime/control/index.js";
 const DEFAULT_TIMEOUT_MS = 120_000;
 const MAX_VERIFY_RETRIES = 2;
 const MAX_TOOL_LOOPS = 5;
+const ACTIVITY_PREVIEW_CHARS = 40;
 // ─── Command help text ───
 const COMMAND_HELP = `Available commands:
   /help    Show this help message
   /clear   Clear conversation history
+  /resume  Resume the last native agentloop turn when resumable state exists
   /exit    Exit chat mode
   /track   Promote session to Tier 2 goal pursuit (not yet implemented)
   /tend    Generate a goal from chat history and start autonomous daemon execution`;
@@ -28,6 +31,14 @@ function checkGitChanges(cwd) {
         });
     });
 }
+function previewActivityText(value, maxChars = ACTIVITY_PREVIEW_CHARS) {
+    const normalized = value.replace(/\s+/g, " ").trim();
+    return normalized.length > maxChars ? `${normalized.slice(0, maxChars)}...` : normalized;
+}
+function formatToolActivity(action, toolName, detail) {
+    const preview = detail ? previewActivityText(detail) : "";
+    return preview ? `${action} tool: ${toolName} - ${preview}` : `${action} tool: ${toolName}`;
+}
 // ─── ChatRunner ───
 export class ChatRunner {
     deps;
@@ -49,6 +60,8 @@ export class ChatRunner {
      */
     onNotification = undefined;
     onEvent = undefined;
+    nativeAgentLoopStatePath = null;
+    runtimeControlContext = null;
     constructor(deps) {
         this.deps = deps;
     }
@@ -63,6 +76,10 @@ export class ChatRunner {
         this.history = new ChatHistory(this.deps.stateManager, sessionId, gitRoot);
         this.sessionCwd = gitRoot;
         this.sessionActive = true;
+        this.nativeAgentLoopStatePath = `chat/agentloop/${sessionId}.state.json`;
+    }
+    setRuntimeControlContext(context) {
+        this.runtimeControlContext = context;
     }
     async handleCommand(input) {
         const trimmed = input.trim();
@@ -244,8 +261,9 @@ export class ChatRunner {
      */
     async execute(input, cwd, timeoutMs = DEFAULT_TIMEOUT_MS) {
         const eventContext = this.createEventContext();
+        const resumeOnly = this.isResumeCommand(input);
         // Intercept commands before any adapter call
-        const commandResult = await this.handleCommand(input);
+        const commandResult = resumeOnly ? null : await this.handleCommand(input);
         if (commandResult !== null) {
             if (commandResult.output) {
                 this.emitEvent({
@@ -259,7 +277,7 @@ export class ChatRunner {
             return commandResult;
         }
         // Intercept plain Y/n responses (and any other input) when a /tend confirmation is pending
-        if (this.pendingTend !== null) {
+        if (this.pendingTend !== null && !resumeOnly) {
             const confirmationResult = await this.handleTendConfirmation(input.trim(), Date.now());
             if (confirmationResult.output) {
                 this.emitEvent({
@@ -272,22 +290,40 @@ export class ChatRunner {
             this.emitLifecycleEndEvent(confirmationResult.success ? "completed" : "error", confirmationResult.elapsed_ms, eventContext, false);
             return confirmationResult;
         }
+        const runtimeControlResult = resumeOnly
+            ? null
+            : await this.handleRuntimeControlIntent(input, cwd, Date.now());
+        if (runtimeControlResult !== null) {
+            if (runtimeControlResult.output) {
+                this.emitEvent({
+                    type: "assistant_final",
+                    text: runtimeControlResult.output,
+                    persisted: false,
+                    ...this.eventBase(eventContext),
+                });
+            }
+            this.emitLifecycleEndEvent(runtimeControlResult.success ? "completed" : "error", runtimeControlResult.elapsed_ms, eventContext, false);
+            return runtimeControlResult;
+        }
         // Reuse session (interactive mode) or create a fresh one per call (1-shot mode)
         if (!this.sessionActive) {
             const gitRoot = resolveGitRoot(cwd);
             const sessionId = crypto.randomUUID();
             this.history = new ChatHistory(this.deps.stateManager, sessionId, gitRoot);
+            this.nativeAgentLoopStatePath = `chat/agentloop/${sessionId}.state.json`;
         }
         const gitRoot = this.sessionCwd ?? resolveGitRoot(cwd);
         // history is always assigned by this point (either by startSession or the block above)
         const history = this.history;
-        // Persist-before-execute: user message written to disk first
-        await history.appendUserMessage(input);
         this.emitEvent({
             type: "lifecycle_start",
             input,
             ...this.eventBase(eventContext),
         });
+        // Persist-before-execute: user message written to disk before model or adapter execution.
+        if (!resumeOnly) {
+            await history.appendUserMessage(input);
+        }
         // Build static grounding once per session; dynamic context is rebuilt each turn.
         if (this.cachedStaticSystemPrompt === null) {
             try {
@@ -299,6 +335,7 @@ export class ChatRunner {
         }
         let dynamicSystemPrompt = "";
         try {
+            this.emitActivity("lifecycle", "Preparing context...", eventContext, "lifecycle:context");
             dynamicSystemPrompt = await buildDynamicContextPrompt({ stateManager: this.deps.stateManager });
         }
         catch {
@@ -310,17 +347,111 @@ export class ChatRunner {
             .trim();
         // Build conversation history from prior turns (last 10)
         const messages = history.getMessages();
-        const priorTurns = messages.slice(0, -1).slice(-10);
+        const priorTurns = resumeOnly ? messages.slice(-10) : messages.slice(0, -1).slice(-10);
         let historyBlock = "";
         if (priorTurns.length > 0) {
             const lines = priorTurns.map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content}`).join("\n");
             historyBlock = `Previous conversation:\n${lines}\n\nCurrent message:\n`;
         }
-        const context = await buildChatContext(input, gitRoot);
-        const basePrompt = context ? `${context}\n\n${input}` : input;
+        const context = resumeOnly ? "" : await buildChatContext(input, gitRoot);
+        const basePrompt = resumeOnly ? "" : (context ? `${context}\n\n${input}` : input);
         const prompt = historyBlock ? `${historyBlock}${basePrompt}` : basePrompt;
         const start = Date.now();
         const assistantBuffer = { text: "" };
+        if (resumeOnly && !this.deps.chatAgentLoopRunner) {
+            const elapsed_ms = Date.now() - start;
+            const output = "Resume requires the native chat agentloop runtime.";
+            this.emitEvent({
+                type: "assistant_final",
+                text: output,
+                persisted: false,
+                ...this.eventBase(eventContext),
+            });
+            this.emitLifecycleEndEvent("error", elapsed_ms, eventContext, false);
+            return {
+                success: false,
+                output,
+                elapsed_ms,
+            };
+        }
+        if (this.deps.chatAgentLoopRunner) {
+            try {
+                const resumeState = resumeOnly ? await this.loadResumableAgentLoopState() : null;
+                if (resumeOnly && !resumeState) {
+                    const elapsed_ms = Date.now() - start;
+                    const output = "No resumable native agentloop state found.";
+                    this.emitEvent({
+                        type: "assistant_final",
+                        text: output,
+                        persisted: false,
+                        ...this.eventBase(eventContext),
+                    });
+                    this.emitLifecycleEndEvent("error", elapsed_ms, eventContext, false);
+                    return {
+                        success: false,
+                        output,
+                        elapsed_ms,
+                    };
+                }
+                this.emitActivity("lifecycle", "Calling model...", eventContext, "lifecycle:model");
+                const result = await this.deps.chatAgentLoopRunner.execute({
+                    message: basePrompt,
+                    cwd,
+                    goalId: this.deps.goalId,
+                    history: priorTurns.map((m) => ({
+                        role: m.role === "assistant" ? "assistant" : "user",
+                        content: m.content,
+                    })),
+                    eventSink: this.createAgentLoopEventSink(eventContext),
+                    approvalFn: async (request) => {
+                        if (this.deps.approvalFn) {
+                            return this.deps.approvalFn(request.reason);
+                        }
+                        return false;
+                    },
+                    ...(this.nativeAgentLoopStatePath ? { resumeStatePath: this.nativeAgentLoopStatePath } : {}),
+                    ...(resumeState ? { resumeState } : {}),
+                    ...(resumeOnly ? { resumeOnly: true } : {}),
+                    ...(systemPrompt ? { systemPrompt } : {}),
+                });
+                const elapsed_ms = Date.now() - start;
+                if (result.output) {
+                    this.pushAssistantDelta(result.output, assistantBuffer, eventContext);
+                }
+                if (result.success) {
+                    await history.appendAssistantMessage(result.output);
+                    this.emitActivity("lifecycle", "Finalizing response...", eventContext, "lifecycle:finalizing");
+                    this.emitEvent({
+                        type: "assistant_final",
+                        text: result.output,
+                        persisted: true,
+                        ...this.eventBase(eventContext),
+                    });
+                    this.emitLifecycleEndEvent("completed", elapsed_ms, eventContext, true);
+                }
+                else {
+                    this.emitLifecycleErrorEvent(result.output || result.error || "Unknown error", assistantBuffer.text, eventContext);
+                    this.emitLifecycleEndEvent("error", elapsed_ms, eventContext, false);
+                }
+                return {
+                    success: result.success,
+                    output: result.output,
+                    elapsed_ms,
+                };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                this.emitLifecycleErrorEvent(message, assistantBuffer.text, eventContext);
+                this.emitLifecycleEndEvent("error", Date.now() - start, eventContext, false);
+                return {
+                    success: false,
+                    output: assistantBuffer.text
+                        ? `${assistantBuffer.text}\n\n[interrupted: ${message}]`
+                        : `Error: ${message}`,
+                    elapsed_ms: Date.now() - start,
+                };
+            }
+        }
         // Use llmClient with self-knowledge tools when available (function calling path)
         // Skip executeWithTools for clients that don't support tool calling (e.g. CodexLLMClient)
         if (this.deps.llmClient && this.deps.llmClient.supportsToolCalling?.() !== false) {
@@ -328,6 +459,7 @@ export class ChatRunner {
                 const toolResult = await this.executeWithTools(prompt, eventContext, assistantBuffer, systemPrompt || undefined);
                 const elapsed_ms = Date.now() - start;
                 await history.appendAssistantMessage(toolResult);
+                this.emitActivity("lifecycle", "Finalizing response...", eventContext, "lifecycle:finalizing");
                 this.emitEvent({
                     type: "assistant_final",
                     text: toolResult,
@@ -358,6 +490,7 @@ export class ChatRunner {
             ...(systemPrompt ? { system_prompt: systemPrompt } : {}),
         };
         const resolvedTimeoutMs = task.timeout_ms ?? DEFAULT_TIMEOUT_MS;
+        this.emitActivity("lifecycle", "Calling adapter...", eventContext, "lifecycle:adapter");
         const adapterPromise = this.deps.adapter.execute(task);
         const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Chat adapter timed out after ${resolvedTimeoutMs}ms`)), resolvedTimeoutMs));
         let result = await Promise.race([adapterPromise, timeoutPromise]);
@@ -374,6 +507,7 @@ export class ChatRunner {
         if (gitChanges !== null && gitChanges !== "") {
             let retries = 0;
             const VERIFY_TIMEOUT_MS = 30_000;
+            this.emitActivity("lifecycle", "Checking result...", eventContext, "lifecycle:checking");
             let verification = await Promise.race([
                 verifyChatAction(gitRoot, this.deps.toolExecutor),
                 new Promise((resolve) => setTimeout(() => resolve({ passed: true }), VERIFY_TIMEOUT_MS)),
@@ -397,6 +531,7 @@ export class ChatRunner {
         }
         if (result.success) {
             await history.appendAssistantMessage(result.output);
+            this.emitActivity("lifecycle", "Finalizing response...", eventContext, "lifecycle:finalizing");
             this.emitEvent({
                 type: "assistant_final",
                 text: result.output,
@@ -416,6 +551,40 @@ export class ChatRunner {
             elapsed_ms,
         };
     }
+    async handleRuntimeControlIntent(input, cwd, start) {
+        const intent = recognizeRuntimeControlIntent(input);
+        if (intent === null)
+            return null;
+        if (!this.deps.runtimeControlService) {
+            return {
+                success: false,
+                output: "Runtime control is not available in this chat surface yet.",
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        const replyTarget = this.runtimeControlContext?.replyTarget ?? this.deps.runtimeReplyTarget;
+        const actor = this.runtimeControlContext?.actor ?? this.deps.runtimeControlActor;
+        const result = await this.deps.runtimeControlService.request({
+            intent,
+            cwd,
+            requestedBy: actor ?? {
+                surface: replyTarget?.surface ?? "chat",
+                platform: replyTarget?.platform,
+                conversation_id: replyTarget?.conversation_id,
+                identity_key: replyTarget?.identity_key,
+                user_id: replyTarget?.user_id,
+            },
+            replyTarget: replyTarget ?? { surface: "chat" },
+            approvalFn: this.runtimeControlContext?.approvalFn
+                ?? this.deps.runtimeControlApprovalFn
+                ?? this.deps.approvalFn,
+        });
+        return {
+            success: result.success,
+            output: result.message,
+            elapsed_ms: Date.now() - start,
+        };
+    }
     /**
      * Execute a chat turn using llmClient with self-knowledge tools (function calling).
      * Loops up to MAX_TOOL_LOOPS times to resolve tool calls, then returns final text.
@@ -431,6 +600,7 @@ export class ChatRunner {
                 : [];
             let response;
             try {
+                this.emitActivity("lifecycle", "Calling model...", eventContext, "lifecycle:model");
                 response = await this.sendLLMMessage(llmClient, messages, {
                     tools,
                     ...(systemPrompt ? { system: systemPrompt } : {}),
@@ -487,19 +657,165 @@ export class ChatRunner {
             // Non-JSON result or unexpected shape — ignore
         }
     }
+    createAgentLoopEventSink(eventContext) {
+        return {
+            emit: async (event) => {
+                if (event.type === "tool_call_started") {
+                    const detail = event.inputPreview ? previewActivityText(event.inputPreview) : undefined;
+                    this.emitActivity("tool", formatToolActivity("Running", event.toolName, detail), eventContext, event.callId);
+                    this.emitEvent({
+                        type: "tool_start",
+                        toolCallId: event.callId,
+                        toolName: event.toolName,
+                        args: this.parseAgentLoopPreview(event.inputPreview),
+                        ...this.eventBase(eventContext),
+                    });
+                    this.emitEvent({
+                        type: "tool_update",
+                        toolCallId: event.callId,
+                        toolName: event.toolName,
+                        status: "running",
+                        message: "started",
+                        ...this.eventBase(eventContext),
+                    });
+                    return;
+                }
+                if (event.type === "tool_call_finished") {
+                    this.emitActivity("tool", formatToolActivity(event.success ? "Finished" : "Failed", event.toolName, event.outputPreview), eventContext, event.callId);
+                    this.emitEvent({
+                        type: "tool_end",
+                        toolCallId: event.callId,
+                        toolName: event.toolName,
+                        success: event.success,
+                        summary: event.outputPreview,
+                        durationMs: event.durationMs,
+                        ...this.eventBase(eventContext),
+                    });
+                    return;
+                }
+                if (event.type === "assistant_message" && event.phase === "commentary" && event.contentPreview) {
+                    this.emitActivity("commentary", previewActivityText(event.contentPreview, 120), eventContext, `commentary:${event.eventId}`);
+                    return;
+                }
+                if (event.type === "plan_update") {
+                    this.emitActivity("tool", `Updated plan: ${previewActivityText(event.summary)}`, eventContext, `plan:${event.turnId}`);
+                    this.emitEvent({
+                        type: "tool_update",
+                        toolCallId: `plan:${event.turnId}:${event.createdAt}`,
+                        toolName: "update_plan",
+                        status: "result",
+                        message: event.summary,
+                        ...this.eventBase(eventContext),
+                    });
+                    return;
+                }
+                if (event.type === "approval_request") {
+                    this.emitActivity("tool", formatToolActivity("Running", event.toolName, `awaiting approval: ${event.reason}`), eventContext, event.callId);
+                    this.emitEvent({
+                        type: "tool_update",
+                        toolCallId: event.callId,
+                        toolName: event.toolName,
+                        status: "awaiting_approval",
+                        message: event.reason,
+                        ...this.eventBase(eventContext),
+                    });
+                    return;
+                }
+                if (event.type === "approval") {
+                    this.emitActivity("tool", formatToolActivity("Finished", event.toolName, `approval ${event.status}: ${event.reason}`), eventContext);
+                    this.emitEvent({
+                        type: "tool_update",
+                        toolCallId: `approval:${event.turnId}:${event.createdAt}`,
+                        toolName: event.toolName,
+                        status: "result",
+                        message: `approval ${event.status}: ${event.reason}`,
+                        ...this.eventBase(eventContext),
+                    });
+                    return;
+                }
+                if (event.type === "resumed") {
+                    this.emitEvent({
+                        type: "tool_update",
+                        toolCallId: `resume:${event.turnId}:${event.createdAt}`,
+                        toolName: "agentloop_resume",
+                        status: "result",
+                        message: `resumed ${event.restoredMessages} message(s) from ${event.fromUpdatedAt}`,
+                        ...this.eventBase(eventContext),
+                    });
+                    return;
+                }
+                if (event.type === "context_compaction") {
+                    this.emitEvent({
+                        type: "tool_update",
+                        toolCallId: `compaction:${event.turnId}:${event.createdAt}`,
+                        toolName: "context_compaction",
+                        status: "result",
+                        message: `${event.phase} ${event.reason}: ${event.inputMessages} -> ${event.outputMessages}`,
+                        ...this.eventBase(eventContext),
+                    });
+                }
+            },
+        };
+    }
+    parseAgentLoopPreview(preview) {
+        try {
+            const parsed = JSON.parse(preview);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                return parsed;
+            }
+        }
+        catch {
+            // fall through
+        }
+        return preview ? { preview } : {};
+    }
+    isResumeCommand(input) {
+        return input.trim().toLowerCase() === "/resume";
+    }
+    async loadResumableAgentLoopState() {
+        if (!this.nativeAgentLoopStatePath)
+            return null;
+        const raw = await this.deps.stateManager.readRaw(this.nativeAgentLoopStatePath);
+        if (!this.isAgentLoopSessionState(raw))
+            return null;
+        if (raw.status === "completed")
+            return null;
+        return {
+            ...raw,
+            messages: [...raw.messages],
+            calledTools: [...raw.calledTools],
+        };
+    }
+    isAgentLoopSessionState(value) {
+        if (!value || typeof value !== "object")
+            return false;
+        const candidate = value;
+        return typeof candidate["sessionId"] === "string"
+            && typeof candidate["traceId"] === "string"
+            && typeof candidate["turnId"] === "string"
+            && typeof candidate["goalId"] === "string"
+            && typeof candidate["cwd"] === "string"
+            && typeof candidate["modelRef"] === "string"
+            && Array.isArray(candidate["messages"])
+            && Array.isArray(candidate["calledTools"])
+            && typeof candidate["status"] === "string";
+    }
     /** Dispatch a tool call through the registry. */
     async dispatchToolCall(toolCallId, name, args, context, eventContext) {
         if (!this.deps.registry) {
+            this.emitActivity("tool", formatToolActivity("Failed", name, "No tool registry configured"), eventContext, toolCallId);
             return JSON.stringify({ error: `No tool registry configured` });
         }
         const tool = this.deps.registry.get(name);
         if (!tool) {
+            this.emitActivity("tool", formatToolActivity("Failed", name, `Unknown tool: ${name}`), eventContext, toolCallId);
             return JSON.stringify({ error: `Unknown tool: ${name}` });
         }
         const startTime = Date.now();
         try {
             const parsed = tool.inputSchema.safeParse(args);
             if (!parsed.success) {
+                this.emitActivity("tool", formatToolActivity("Failed", name, `Invalid input: ${parsed.error.message}`), eventContext, toolCallId);
                 this.emitEvent({
                     type: "tool_end",
                     toolCallId,
@@ -518,62 +834,80 @@ export class ChatRunner {
                 args,
                 ...this.eventBase(eventContext),
             });
-            // Gate: check permissions before execution
-            const permResult = await tool.checkPermissions(parsed.data, context);
-            if (permResult.status === "denied") {
-                this.emitEvent({
-                    type: "tool_end",
-                    toolCallId,
-                    toolName: name,
-                    success: false,
-                    summary: permResult.reason,
-                    durationMs: Date.now() - startTime,
-                    ...this.eventBase(eventContext),
-                });
-                return `Tool ${name} denied: ${permResult.reason}`;
-            }
-            if (permResult.status === "needs_approval") {
+            this.emitActivity("tool", formatToolActivity("Running", name, JSON.stringify(args)), eventContext, toolCallId);
+            let result;
+            if (this.deps.toolExecutor) {
                 this.emitEvent({
                     type: "tool_update",
                     toolCallId,
                     toolName: name,
-                    status: "awaiting_approval",
-                    message: permResult.reason,
+                    status: "running",
+                    message: "running",
                     ...this.eventBase(eventContext),
                 });
-                const approved = await context.approvalFn({
-                    toolName: name,
-                    input: parsed.data,
-                    reason: permResult.reason,
-                    permissionLevel: tool.metadata.permissionLevel,
-                    isDestructive: tool.metadata.isDestructive,
-                    reversibility: "unknown",
-                });
-                if (!approved) {
+                this.deps.onToolStart?.(name, args);
+                result = await this.deps.toolExecutor.execute(name, parsed.data, context);
+            }
+            else {
+                // Gate: check permissions before execution
+                const permResult = await tool.checkPermissions(parsed.data, context);
+                if (permResult.status === "denied") {
                     this.emitEvent({
                         type: "tool_end",
                         toolCallId,
                         toolName: name,
                         success: false,
-                        summary: `Not approved: ${permResult.reason}`,
+                        summary: permResult.reason,
                         durationMs: Date.now() - startTime,
                         ...this.eventBase(eventContext),
                     });
-                    return `Tool ${name} not approved: ${permResult.reason}`;
+                    return `Tool ${name} denied: ${permResult.reason}`;
+                }
+                if (permResult.status === "needs_approval") {
+                    this.emitActivity("tool", formatToolActivity("Running", name, `awaiting approval: ${permResult.reason}`), eventContext, toolCallId);
+                    this.emitEvent({
+                        type: "tool_update",
+                        toolCallId,
+                        toolName: name,
+                        status: "awaiting_approval",
+                        message: permResult.reason,
+                        ...this.eventBase(eventContext),
+                    });
+                    const approved = await context.approvalFn({
+                        toolName: name,
+                        input: parsed.data,
+                        reason: permResult.reason,
+                        permissionLevel: tool.metadata.permissionLevel,
+                        isDestructive: tool.metadata.isDestructive,
+                        reversibility: "unknown",
+                    });
+                    if (!approved) {
+                        this.emitEvent({
+                            type: "tool_end",
+                            toolCallId,
+                            toolName: name,
+                            success: false,
+                            summary: `Not approved: ${permResult.reason}`,
+                            durationMs: Date.now() - startTime,
+                            ...this.eventBase(eventContext),
+                        });
+                        return `Tool ${name} not approved: ${permResult.reason}`;
+                    }
                 }
+                this.emitEvent({
+                    type: "tool_update",
+                    toolCallId,
+                    toolName: name,
+                    status: "running",
+                    message: "running",
+                    ...this.eventBase(eventContext),
+                });
+                this.deps.onToolStart?.(name, args);
+                result = await tool.call(parsed.data, context);
             }
-            this.emitEvent({
-                type: "tool_update",
-                toolCallId,
-                toolName: name,
-                status: "running",
-                message: "running",
-                ...this.eventBase(eventContext),
-            });
-            this.deps.onToolStart?.(name, args);
-            const result = await tool.call(parsed.data, context);
             const durationMs = Date.now() - startTime;
             this.deps.onToolEnd?.(name, { success: result.success, summary: result.summary || '...', durationMs });
+            this.emitActivity("tool", formatToolActivity(result.success ? "Finished" : "Failed", name, result.summary || "..."), eventContext, toolCallId);
             this.emitEvent({
                 type: "tool_update",
                 toolCallId,
@@ -598,6 +932,7 @@ export class ChatRunner {
             const message = err instanceof Error ? err.message : String(err);
             const durationMs = Date.now() - startTime;
             this.deps.onToolEnd?.(name, { success: false, summary: message, durationMs });
+            this.emitActivity("tool", formatToolActivity("Failed", name, message), eventContext, toolCallId);
             this.emitEvent({
                 type: "tool_end",
                 toolCallId,
@@ -643,6 +978,18 @@ export class ChatRunner {
         const handler = this.onEvent ?? this.deps.onEvent;
         handler?.(event);
     }
+    emitActivity(kind, message, eventContext, sourceId) {
+        if (!message.trim())
+            return;
+        this.emitEvent({
+            type: "activity",
+            kind,
+            message,
+            ...(sourceId ? { sourceId } : {}),
+            transient: true,
+            ...this.eventBase(eventContext),
+        });
+    }
     pushAssistantDelta(delta, assistantBuffer, eventContext) {
         if (!delta)
             return;