pulseed 0.2.0 → 0.4.0

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

@@ -5,10 +5,11 @@
 import { execFile } from "node:child_process";
 import { ChatHistory } from "./chat-history.js";
 import { buildChatContext, resolveGitRoot } from "../../platform/observation/context-provider.js";
-import { buildSystemPrompt } from "./grounding.js";
+import { buildDynamicContextPrompt, buildStaticSystemPrompt } from "./grounding.js";
 import { verifyChatAction } from "./chat-verifier.js";
-import { getSelfKnowledgeToolDefinitions, handleSelfKnowledgeToolCall } from "./self-knowledge-tools.js";
-import { getMutationToolDefinitions, handleMutationToolCall } from "./self-knowledge-mutation-tools.js";
+import { toToolDefinitionsFiltered } from "../../tools/tool-definition-adapter.js";
+import { TendCommand } from "./tend-command.js";
+import { EventSubscriber } from "./event-subscriber.js";
 const DEFAULT_TIMEOUT_MS = 120_000;
 const MAX_VERIFY_RETRIES = 2;
 const MAX_TOOL_LOOPS = 5;
@@ -17,7 +18,8 @@ const COMMAND_HELP = `Available commands:
   /help    Show this help message
   /clear   Clear conversation history
   /exit    Exit chat mode
-  /track   Promote session to Tier 2 goal pursuit (not yet implemented)`;
+  /track   Promote session to Tier 2 goal pursuit (not yet implemented)
+  /tend    Generate a goal from chat history and start autonomous daemon execution`;
 // ─── Helpers ───
 function checkGitChanges(cwd) {
     return new Promise((resolve) => {
@@ -33,8 +35,20 @@ export class ChatRunner {
     sessionCwd = null;
     /** True when startSession() has been called — enables session persistence across execute() calls. */
     sessionActive = false;
-    /** Cached system prompt — built once per session, reused across turns. */
-    cachedSystemPrompt = null;
+    /** Deferred tools activated by ToolSearch results — included in tool definitions for subsequent turns. */
+    activatedTools = new Set();
+    /** Cached static system prompt — reused across turns; dynamic context is rebuilt each turn. */
+    cachedStaticSystemPrompt = null;
+    /** Pending /tend state awaiting user confirmation (Y/n). */
+    pendingTend = null;
+    /** Active EventSubscriber instances keyed by goalId. */
+    activeSubscribers = new Map();
+    /**
+     * Callback invoked when a /tend daemon notification arrives.
+     * Can be set after construction (e.g. from a React component via useEffect).
+     */
+    onNotification = undefined;
+    onEvent = undefined;
     constructor(deps) {
         this.deps = deps;
     }
@@ -69,6 +83,14 @@ export class ChatRunner {
         if (cmd === "/track") {
             return this.handleTrack(start);
         }
+        if (cmd === "/tend") {
+            const args = trimmed.slice("/tend".length).trim();
+            return this.handleTend(args, start);
+        }
+        // Check if this is a confirmation response for a pending /tend
+        if (this.pendingTend !== null) {
+            return this.handleTendConfirmation(trimmed, start);
+        }
         return {
             success: false,
             output: `Unknown command: ${input.trim()}. Type /help for available commands.`,
@@ -107,6 +129,107 @@ export class ChatRunner {
             };
         }
     }
+    async handleTend(args, start) {
+        if (!this.deps.llmClient) {
+            return {
+                success: false,
+                output: "Tend not available — missing LLM configuration",
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        if (!this.deps.goalNegotiator) {
+            return {
+                success: false,
+                output: "Tend not available — missing goal negotiator",
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        if (!this.deps.daemonClient) {
+            return {
+                success: false,
+                output: "Tend not available — daemon client not configured. Start the daemon with 'pulseed daemon start' first.",
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        const history = this.history?.getMessages() ?? [];
+        const tendDeps = {
+            llmClient: this.deps.llmClient,
+            goalNegotiator: this.deps.goalNegotiator,
+            daemonClient: this.deps.daemonClient,
+            stateManager: this.deps.stateManager,
+            chatHistory: history,
+        };
+        const tendCommand = new TendCommand();
+        const result = await tendCommand.execute(args, tendDeps);
+        if (result.needsConfirmation && result.goalId) {
+            this.pendingTend = { goalId: result.goalId, maxIterations: result.maxIterations };
+            return {
+                success: true,
+                output: result.confirmation ?? result.message,
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        return {
+            success: result.success,
+            output: result.message,
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    async handleTendConfirmation(input, start) {
+        const pending = this.pendingTend;
+        this.pendingTend = null;
+        const normalized = input.trim().toLowerCase();
+        const confirmed = normalized === "" || normalized === "y" || normalized === "yes";
+        if (!confirmed) {
+            // Bug 2: treat any non-y/yes/empty/n/no input as cancellation too
+            return {
+                success: true,
+                output: "Tend cancelled. Continue chatting to refine your goal, then try /tend again.",
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        if (!this.deps.daemonClient) {
+            return {
+                success: false,
+                output: "Daemon client not available.",
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        try {
+            await this.deps.daemonClient.startGoal(pending.goalId);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return {
+                success: false,
+                output: `Daemon unavailable: ${msg}. Start the daemon with 'pulseed daemon start' first.`,
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        // Subscribe to EventServer progress notifications (non-blocking)
+        const { goalId, maxIterations } = pending;
+        if (this.deps.daemonBaseUrl && !this.activeSubscribers.has(goalId)) {
+            const subscriber = new EventSubscriber(this.deps.daemonBaseUrl, goalId, "normal");
+            this.activeSubscribers.set(goalId, subscriber);
+            subscriber.on("notification", (notification) => {
+                const n = notification;
+                // Invoke both the deps callback (wired at construction) and the public
+                // onNotification property (wired post-construction, e.g. from React useEffect)
+                this.deps.onNotification?.(n.message);
+                this.onNotification?.(n.message);
+            });
+            subscriber.subscribe().catch(() => {
+                // Connection failures are handled inside EventSubscriber
+            });
+        }
+        const iterNote = maxIterations !== undefined ? ` (max ${maxIterations} iterations)` : "";
+        const shortId = goalId.length > 12 ? goalId.slice(0, 12) : goalId;
+        return {
+            success: true,
+            output: `[tend] ${shortId}: Started — daemon is now tending your goal${iterNote}.\nRun 'pulseed status' to check progress.`,
+            elapsed_ms: Date.now() - start,
+        };
+    }
     /**
      * Execute a single chat turn.
      *
@@ -117,14 +240,38 @@ export class ChatRunner {
      *  4. Persist user message BEFORE calling adapter (crash-safe)
      *  5. Execute via adapter
      *  6. Verify changes (git diff + tests); retry up to MAX_VERIFY_RETRIES if tests fail
-     *  7. Persist assistant response (fire-and-forget)
+     *  7. Persist assistant response only after the final assistant text is complete
      */
     async execute(input, cwd, timeoutMs = DEFAULT_TIMEOUT_MS) {
+        const eventContext = this.createEventContext();
         // Intercept commands before any adapter call
         const commandResult = await this.handleCommand(input);
         if (commandResult !== null) {
+            if (commandResult.output) {
+                this.emitEvent({
+                    type: "assistant_final",
+                    text: commandResult.output,
+                    persisted: false,
+                    ...this.eventBase(eventContext),
+                });
+            }
+            this.emitLifecycleEndEvent(commandResult.success ? "completed" : "error", commandResult.elapsed_ms, eventContext, false);
             return commandResult;
         }
+        // Intercept plain Y/n responses (and any other input) when a /tend confirmation is pending
+        if (this.pendingTend !== null) {
+            const confirmationResult = await this.handleTendConfirmation(input.trim(), Date.now());
+            if (confirmationResult.output) {
+                this.emitEvent({
+                    type: "assistant_final",
+                    text: confirmationResult.output,
+                    persisted: false,
+                    ...this.eventBase(eventContext),
+                });
+            }
+            this.emitLifecycleEndEvent(confirmationResult.success ? "completed" : "error", confirmationResult.elapsed_ms, eventContext, false);
+            return confirmationResult;
+        }
         // Reuse session (interactive mode) or create a fresh one per call (1-shot mode)
         if (!this.sessionActive) {
             const gitRoot = resolveGitRoot(cwd);
@@ -136,15 +283,31 @@ export class ChatRunner {
         const history = this.history;
         // Persist-before-execute: user message written to disk first
         await history.appendUserMessage(input);
-        // Build grounding system prompt on first turn, cache for session
-        if (this.cachedSystemPrompt === null) {
+        this.emitEvent({
+            type: "lifecycle_start",
+            input,
+            ...this.eventBase(eventContext),
+        });
+        // Build static grounding once per session; dynamic context is rebuilt each turn.
+        if (this.cachedStaticSystemPrompt === null) {
             try {
-                this.cachedSystemPrompt = await buildSystemPrompt({ stateManager: this.deps.stateManager });
+                this.cachedStaticSystemPrompt = buildStaticSystemPrompt();
             }
             catch {
-                this.cachedSystemPrompt = "";
+                this.cachedStaticSystemPrompt = "";
             }
         }
+        let dynamicSystemPrompt = "";
+        try {
+            dynamicSystemPrompt = await buildDynamicContextPrompt({ stateManager: this.deps.stateManager });
+        }
+        catch {
+            dynamicSystemPrompt = "";
+        }
+        const systemPrompt = [this.cachedStaticSystemPrompt, dynamicSystemPrompt]
+            .filter((section) => section && section.trim().length > 0)
+            .join("\n\n")
+            .trim();
         // Build conversation history from prior turns (last 10)
         const messages = history.getMessages();
         const priorTurns = messages.slice(0, -1).slice(-10);
@@ -157,28 +320,64 @@ export class ChatRunner {
         const basePrompt = context ? `${context}\n\n${input}` : input;
         const prompt = historyBlock ? `${historyBlock}${basePrompt}` : basePrompt;
         const start = Date.now();
+        const assistantBuffer = { text: "" };
         // 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) {
-            const toolResult = await this.executeWithTools(prompt, this.cachedSystemPrompt ?? undefined);
-            const elapsed_ms = Date.now() - start;
-            await history.appendAssistantMessage(toolResult);
-            return { success: true, output: toolResult, elapsed_ms };
+            try {
+                const toolResult = await this.executeWithTools(prompt, eventContext, assistantBuffer, systemPrompt || undefined);
+                const elapsed_ms = Date.now() - start;
+                await history.appendAssistantMessage(toolResult);
+                this.emitEvent({
+                    type: "assistant_final",
+                    text: toolResult,
+                    persisted: true,
+                    ...this.eventBase(eventContext),
+                });
+                this.emitLifecycleEndEvent("completed", elapsed_ms, eventContext, true);
+                return { success: true, output: toolResult, 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,
+                };
+            }
         }
         const task = {
             prompt,
             timeout_ms: timeoutMs,
             adapter_type: this.deps.adapter.adapterType,
             cwd,
-            ...(this.cachedSystemPrompt ? { system_prompt: this.cachedSystemPrompt } : {}),
+            ...(systemPrompt ? { system_prompt: systemPrompt } : {}),
         };
-        let result = await this.deps.adapter.execute(task);
+        const resolvedTimeoutMs = task.timeout_ms ?? DEFAULT_TIMEOUT_MS;
+        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]);
+        // Surface adapter errors into output when output is empty
+        if (!result.output && result.error) {
+            result = { ...result, output: `Error: ${result.error}` };
+        }
         const elapsed_ms = Date.now() - start;
+        if (result.output) {
+            this.pushAssistantDelta(result.output, assistantBuffer, eventContext);
+        }
         // Verification loop: check if git has uncommitted changes; if so, run tests
         const gitChanges = await checkGitChanges(gitRoot);
         if (gitChanges !== null && gitChanges !== "") {
             let retries = 0;
-            let verification = await verifyChatAction(gitRoot, this.deps.toolExecutor);
+            const VERIFY_TIMEOUT_MS = 30_000;
+            let verification = await Promise.race([
+                verifyChatAction(gitRoot, this.deps.toolExecutor),
+                new Promise((resolve) => setTimeout(() => resolve({ passed: true }), VERIFY_TIMEOUT_MS)),
+            ]);
             while (!verification.passed && retries < MAX_VERIFY_RETRIES) {
                 retries++;
                 const retryPrompt = `The previous changes caused test failures. Please fix them.\n\nTest output:\n${verification.testOutput ?? verification.errors.join("\n")}`;
@@ -187,17 +386,30 @@ export class ChatRunner {
                 verification = await verifyChatAction(gitRoot, this.deps.toolExecutor);
             }
             if (!verification.passed) {
-                // Fire-and-forget: persist assistant response
-                history.appendAssistantMessage(result.output);
+                this.emitLifecycleErrorEvent(`Changes applied but tests are still failing after ${MAX_VERIFY_RETRIES} retries.`, assistantBuffer.text, eventContext);
+                this.emitLifecycleEndEvent("error", Date.now() - start, eventContext, false);
                 return {
                     success: false,
-                    output: `Changes applied but tests are still failing after ${MAX_VERIFY_RETRIES} retries. Please intervene manually.\n\nTest output:\n${verification.testOutput ?? verification.errors.join("\n")}`,
+                    output: `${assistantBuffer.text}\n\n[interrupted: tests are still failing after ${MAX_VERIFY_RETRIES} retries]\n\nTest output:\n${verification.testOutput ?? verification.errors.join("\n")}`.trim(),
                     elapsed_ms: Date.now() - start,
                 };
             }
         }
-        // Fire-and-forget: persist assistant response after completion
-        history.appendAssistantMessage(result.output);
+        if (result.success) {
+            await history.appendAssistantMessage(result.output);
+            this.emitEvent({
+                type: "assistant_final",
+                text: result.output,
+                persisted: true,
+                ...this.eventBase(eventContext),
+            });
+            this.emitLifecycleEndEvent("completed", elapsed_ms, eventContext, true);
+        }
+        else {
+            const partialText = assistantBuffer.text !== result.output ? assistantBuffer.text : "";
+            this.emitLifecycleErrorEvent(result.output || result.error || "Unknown error", partialText, eventContext);
+            this.emitLifecycleEndEvent("error", elapsed_ms, eventContext, false);
+        }
         return {
             success: result.success,
             output: result.output,
@@ -208,32 +420,30 @@ export class ChatRunner {
      * 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.
      */
-    async executeWithTools(prompt, systemPrompt) {
+    async executeWithTools(prompt, eventContext, assistantBuffer, systemPrompt) {
         const llmClient = this.deps.llmClient;
-        const tools = [...getSelfKnowledgeToolDefinitions(), ...getMutationToolDefinitions()];
-        const skDeps = this.buildSelfKnowledgeDeps();
-        const mutDeps = this.buildMutationToolDeps();
         const messages = [{ role: "user", content: prompt }];
-        const mutationToolNames = new Set([
-            "set_goal", "update_goal", "archive_goal", "delete_goal",
-            "toggle_plugin", "update_config", "reset_trust",
-        ]);
+        const toolCallContext = this.buildToolCallContext();
         for (let loop = 0; loop < MAX_TOOL_LOOPS; loop++) {
+            // Recompute tools each iteration so newly activated deferred tools are included
+            const tools = this.deps.registry
+                ? toToolDefinitionsFiltered(this.deps.registry.listAll(), { activatedTools: this.activatedTools })
+                : [];
             let response;
             try {
-                response = await llmClient.sendMessage(messages, {
+                response = await this.sendLLMMessage(llmClient, messages, {
                     tools,
                     ...(systemPrompt ? { system: systemPrompt } : {}),
-                });
+                }, assistantBuffer, eventContext);
             }
             catch (err) {
                 console.error("[chat-runner] executeWithTools error:", err);
                 const hint = err instanceof Error ? `: ${err.message}` : "";
-                return `Sorry, I encountered an error processing your request${hint}.`;
+                throw new Error(`Sorry, I encountered an error processing your request${hint}.`);
             }
             // No tool calls — return the text content
             if (!response.tool_calls || response.tool_calls.length === 0) {
-                return response.content || "(no response)";
+                return assistantBuffer.text || response.content || "(no response)";
             }
             // Append assistant message, then process tool calls
             messages.push({ role: "assistant", content: response.content || "" });
@@ -245,9 +455,11 @@ export class ChatRunner {
                 catch {
                     // ignore parse errors, use empty args
                 }
-                const toolResult = mutationToolNames.has(tc.function.name)
-                    ? await handleMutationToolCall(tc.function.name, args, mutDeps)
-                    : await handleSelfKnowledgeToolCall(tc.function.name, args, skDeps);
+                const toolResult = await this.dispatchToolCall(tc.id, tc.function.name, args, toolCallContext, eventContext);
+                // When ToolSearch returns results, activate deferred tools for subsequent turns
+                if (tc.function.name === "tool_search") {
+                    this.activateToolSearchResults(toolResult);
+                }
                 messages.push({ role: "user", content: `Tool result for ${tc.function.name}:\n${toolResult}` });
             }
         }
@@ -255,27 +467,224 @@ export class ChatRunner {
         const lastAssistant = [...messages].reverse().find(m => m.role === "assistant");
         return lastAssistant?.content || "I was unable to complete the request within the allowed tool call limit.";
     }
-    /** Build SelfKnowledgeDeps from ChatRunnerDeps. */
-    buildSelfKnowledgeDeps() {
+    /**
+     * Parse ToolSearch result JSON and activate any deferred tools found.
+     * Called after each tool_search execution so the LLM can call found tools on the next turn.
+     */
+    activateToolSearchResults(toolResult) {
+        try {
+            const parsed = JSON.parse(toolResult);
+            const results = Array.isArray(parsed) ? parsed : null;
+            if (results) {
+                for (const item of results) {
+                    if (item && typeof item === "object" && typeof item["name"] === "string") {
+                        this.activatedTools.add(item["name"]);
+                    }
+                }
+            }
+        }
+        catch {
+            // Non-JSON result or unexpected shape — ignore
+        }
+    }
+    /** Dispatch a tool call through the registry. */
+    async dispatchToolCall(toolCallId, name, args, context, eventContext) {
+        if (!this.deps.registry) {
+            return JSON.stringify({ error: `No tool registry configured` });
+        }
+        const tool = this.deps.registry.get(name);
+        if (!tool) {
+            return JSON.stringify({ error: `Unknown tool: ${name}` });
+        }
+        const startTime = Date.now();
+        try {
+            const parsed = tool.inputSchema.safeParse(args);
+            if (!parsed.success) {
+                this.emitEvent({
+                    type: "tool_end",
+                    toolCallId,
+                    toolName: name,
+                    success: false,
+                    summary: `Invalid input: ${parsed.error.message}`,
+                    durationMs: Date.now() - startTime,
+                    ...this.eventBase(eventContext),
+                });
+                return JSON.stringify({ error: `Invalid input: ${parsed.error.message}` });
+            }
+            this.emitEvent({
+                type: "tool_start",
+                toolCallId,
+                toolName: name,
+                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.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);
+            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.emitEvent({
+                type: "tool_update",
+                toolCallId,
+                toolName: name,
+                status: "result",
+                message: result.summary || "...",
+                ...this.eventBase(eventContext),
+            });
+            this.emitEvent({
+                type: "tool_end",
+                toolCallId,
+                toolName: name,
+                success: result.success,
+                summary: result.summary || "...",
+                durationMs,
+                ...this.eventBase(eventContext),
+            });
+            // Prefer structured data (JSON) over plain summary so the LLM gets actionable content
+            return result.data != null ? JSON.stringify(result.data) : (result.summary ?? "(no result)");
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const durationMs = Date.now() - startTime;
+            this.deps.onToolEnd?.(name, { success: false, summary: message, durationMs });
+            this.emitEvent({
+                type: "tool_end",
+                toolCallId,
+                toolName: name,
+                success: false,
+                summary: message,
+                durationMs,
+                ...this.eventBase(eventContext),
+            });
+            return JSON.stringify({ error: `Tool ${name} failed: ${message}` });
+        }
+    }
+    async sendLLMMessage(llmClient, messages, options, assistantBuffer, eventContext) {
+        let streamed = false;
+        if (llmClient.sendMessageStream) {
+            const response = await llmClient.sendMessageStream(messages, options, {
+                onTextDelta: (delta) => {
+                    streamed = true;
+                    this.pushAssistantDelta(delta, assistantBuffer, eventContext);
+                },
+            });
+            if (!streamed && response.content) {
+                this.pushAssistantDelta(response.content, assistantBuffer, eventContext);
+            }
+            return response;
+        }
+        const response = await llmClient.sendMessage(messages, options);
+        if (response.content) {
+            this.pushAssistantDelta(response.content, assistantBuffer, eventContext);
+        }
+        return response;
+    }
+    createEventContext() {
         return {
-            stateManager: this.deps.stateManager,
-            trustManager: this.deps.trustManager,
-            pluginLoader: this.deps.pluginLoader,
-            homeDir: process.env.HOME ?? process.env.USERPROFILE ?? "/tmp",
+            runId: crypto.randomUUID(),
+            turnId: crypto.randomUUID(),
         };
     }
-    /** Build MutationToolDeps from ChatRunnerDeps. */
-    buildMutationToolDeps() {
-        const tm = this.deps.trustManager;
-        const pl = this.deps.pluginLoader;
+    eventBase(context) {
+        return { ...context, createdAt: new Date().toISOString() };
+    }
+    emitEvent(event) {
+        const handler = this.onEvent ?? this.deps.onEvent;
+        handler?.(event);
+    }
+    pushAssistantDelta(delta, assistantBuffer, eventContext) {
+        if (!delta)
+            return;
+        assistantBuffer.text += delta;
+        this.emitEvent({
+            type: "assistant_delta",
+            delta,
+            text: assistantBuffer.text,
+            ...this.eventBase(eventContext),
+        });
+    }
+    emitLifecycleEndEvent(status, elapsedMs, eventContext, persisted) {
+        this.emitEvent({
+            type: "lifecycle_end",
+            status,
+            elapsedMs,
+            persisted,
+            ...this.eventBase(eventContext),
+        });
+    }
+    emitLifecycleErrorEvent(error, partialText, eventContext) {
+        this.emitEvent({
+            type: "lifecycle_error",
+            error,
+            partialText,
+            persisted: false,
+            ...this.eventBase(eventContext),
+        });
+    }
+    /** Build a ToolCallContext from ChatRunnerDeps for tool dispatch. */
+    buildToolCallContext() {
         return {
-            stateManager: this.deps.stateManager,
-            trustManager: tm && "setOverride" in tm ? tm : undefined,
-            pluginLoader: pl && "getPluginState" in pl && "updatePluginState" in pl
-                ? pl
-                : undefined,
-            approvalFn: this.deps.approvalFn,
-            approvalConfig: this.deps.approvalConfig,
+            cwd: this.sessionCwd ?? process.cwd(),
+            goalId: this.deps.goalId ?? "",
+            trustBalance: 0,
+            preApproved: false,
+            approvalFn: async (req) => {
+                if (this.deps.approvalFn) {
+                    return this.deps.approvalFn(req.reason);
+                }
+                return false;
+            },
         };
     }
 }