pulseed 0.4.18 → 0.4.20

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

@@ -0,0 +1,1970 @@
+// ─── ChatRunner ───
+//
+// Central coordinator for 1-shot chat execution (Tier 1).
+// Bypasses TaskLifecycle — calls adapter.execute() directly.
+import { execFile } from "node:child_process";
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+import { loadProviderConfig } from "../../base/llm/provider-config.js";
+import { ChatHistory } from "./chat-history.js";
+import { ChatSessionCatalog, ChatSessionSelectorError, } from "./chat-session-store.js";
+import { buildChatContext, resolveGitRoot } from "../../platform/observation/context-provider.js";
+import { buildDynamicContextPrompt, buildStaticSystemPrompt } from "./grounding.js";
+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 { buildPromptedToolProtocolSystemPrompt, extractPromptedToolCalls, } from "../../orchestrator/execution/agent-loop/prompted-tool-protocol.js";
+import { recognizeRuntimeControlIntent } from "../../runtime/control/index.js";
+import { formatAgentLoopResolvedProfileSummary, resolveAgentLoopDefaultProfile, summarizeAgentLoopResolvedProfile, } from "../../orchestrator/execution/agent-loop/agent-loop-default-profile.js";
+import { summarizeExecutionPolicy, withExecutionPolicyOverrides, } from "../../orchestrator/execution/agent-loop/execution-policy.js";
+import { ChatStateService } from "./chat-state-service.js";
+const DEFAULT_TIMEOUT_MS = 120_000;
+const MAX_VERIFY_RETRIES = 2;
+const MAX_TOOL_LOOPS = 5;
+const ACTIVITY_PREVIEW_CHARS = 40;
+const DIRECT_ANSWER_MAX_TOKENS = 256;
+// ─── Command help text ───
+const COMMAND_HELP = `Available commands:
+Session
+  /help                 Show this help message
+  /clear                Clear conversation history
+  /sessions             List prior chat sessions
+  /history [id|title]   Show saved chat history
+  /title <title>        Rename the current session
+  /resume [id|title]    Resume native agentloop state for the current or selected session
+  /cleanup [--dry-run]  Clean up stale chat sessions
+  /compact              Summarize older chat turns and keep the latest turns
+  /exit                 Exit chat mode
+
+Goals and tasks
+  /status [goal-id]     Show active goal status, or one goal when an id is provided
+  /goals                List goals
+  /tasks [goal-id]      List tasks for a goal; uses the only active goal when unambiguous
+  /task <task-id> [goal-id]
+                        Show one task; searches goals when no goal id is provided
+  /track                Promote session to Tier 2 goal pursuit (not yet implemented)
+  /tend                 Generate a goal from chat history and start autonomous daemon execution
+
+Configuration
+  /config               Show provider configuration with secrets masked
+  /model                Show the active provider/model/adapter
+  /permissions [args]   Show or update session execution policy
+  /plugins              List installed plugins when plugin metadata is available
+  /usage [scope]        Show usage summary (session, goal <id>, daemon <goal-id>, schedule [7d|24h|2w])
+
+Review and branching
+  /review               Show current diff summary and verification context
+  /fork [title]         Fork the current chat session into a new session
+  /undo                 Remove the latest chat turn from session history
+
+Deferred
+  /retry is intentionally not supported yet.`;
+// ─── Helpers ───
+function checkGitChanges(cwd) {
+    return new Promise((resolve) => {
+        execFile("git", ["diff", "HEAD", "--stat"], { cwd, timeout: 5_000 }, (err, stdout, stderr) => {
+            resolve(err ? null : (stdout + stderr).trim());
+        });
+    });
+}
+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}`;
+}
+function shouldUseDirectAnswerRoute(input) {
+    const normalized = input.trim();
+    if (!normalized)
+        return false;
+    const lowered = normalized.toLowerCase();
+    const questionSignals = [
+        /[?？]/,
+        /\b(what|why|how|when|where|who|which|is|are|can|could|would|should|tell me|explain|describe|help me understand)\b/,
+        /(教えて|説明して|教えてください|説明してください|どう思う|なんで|なぜ|どうして|いつ|どこ|だれ|誰|何|どれ|どっち)/,
+    ];
+    if (!questionSignals.some((pattern) => pattern.test(lowered))) {
+        return false;
+    }
+    const workSignals = [
+        /\b(fix|implement|change|changed|add|remove|delete|update|refactor|patch|debug|diagnose|investigate|review|write|create|build|run|execute|test|verify|confirm|check|inspect|search|open|read|edit|modify|commit|push|merge|release|deploy|start|stop|restart|resume|compare|convert|migrate|optimize|improve|configure|setup|set up)\b/,
+        /(修正|実装|変更|追加|削除|更新|リファクタ|デバッグ|調査|確認|レビュー|書いて|作って|作成|実行|走らせ|テスト|検証|調べて|開いて|読んで|編集|コミット|プッシュ|マージ|デプロイ|再起動|再開|設定)/,
+        /\b(git|repo|repository|branch|commit|diff|pull request|pr|issue|ticket|adapter|agentloop|tool|tools|code)\b|コード|src\//,
+        /\b(latest|most recent|current|today|now|recent|news|web|internet|api|docs|github|release|version)\b|最新|最新版|今日|現在|最近|今|外部|ネット/,
+        /\bwhat\s+(files?\s+)?changed\b|\bwhich\s+files?\s+(changed|were\s+(modified|edited))\b/,
+        /(\.(ts|tsx|js|jsx|json|md|yml|yaml|toml|py|go|rs|sh|sql)\b|\/[^/\s]+\.[A-Za-z0-9]+$)/,
+    ];
+    return !workSignals.some((pattern) => pattern.test(lowered));
+}
+// ─── ChatRunner ───
+export class ChatRunner {
+    deps;
+    history = null;
+    sessionCwd = null;
+    /** True when startSession() has been called — enables session persistence across execute() calls. */
+    sessionActive = false;
+    /** 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;
+    nativeAgentLoopStatePath = null;
+    runtimeControlContext = null;
+    sessionExecutionPolicy = null;
+    stateView;
+    constructor(deps) {
+        this.deps = deps;
+        this.stateView = new ChatStateService(deps.stateManager);
+    }
+    /**
+     * Initialize a persistent session for interactive (multi-turn) mode.
+     * Must be called before the first execute() to share history across turns.
+     * If not called, execute() auto-creates a new session per call (Phase 1a behavior).
+     */
+    startSession(cwd) {
+        const gitRoot = resolveGitRoot(cwd);
+        const sessionId = crypto.randomUUID();
+        this.history = new ChatHistory(this.deps.stateManager, sessionId, gitRoot);
+        this.sessionCwd = gitRoot;
+        this.sessionActive = true;
+        this.nativeAgentLoopStatePath = `chat/agentloop/${sessionId}.state.json`;
+        this.history.setAgentLoopStatePath(this.nativeAgentLoopStatePath);
+        this.sessionExecutionPolicy = null;
+    }
+    startSessionFromLoadedSession(session) {
+        const chatSession = this.loadedSessionToChatSession(session);
+        this.history = ChatHistory.fromSession(this.deps.stateManager, chatSession);
+        this.sessionCwd = session.cwd;
+        this.sessionActive = true;
+        this.nativeAgentLoopStatePath = session.agentLoopStatePath ?? `chat/agentloop/${session.id}.state.json`;
+        this.history.setAgentLoopStatePath(this.nativeAgentLoopStatePath);
+        this.sessionExecutionPolicy = null;
+    }
+    getSessionId() {
+        return this.history?.getSessionId() ?? null;
+    }
+    getCurrentSessionMessages() {
+        return this.history?.getMessages() ?? [];
+    }
+    setRuntimeControlContext(context) {
+        this.runtimeControlContext = context;
+    }
+    loadedSessionToChatSession(session) {
+        return {
+            id: session.id,
+            cwd: session.cwd,
+            createdAt: session.createdAt,
+            updatedAt: session.updatedAt,
+            messages: [...session.messages],
+            ...(session.compactionSummary ? { compactionSummary: session.compactionSummary } : {}),
+            ...(session.title ? { title: session.title } : {}),
+            ...(session.agentLoopStatePath ? { agentLoopStatePath: session.agentLoopStatePath } : {}),
+            ...(session.agentLoopStatus === "running" || session.agentLoopStatus === "completed" || session.agentLoopStatus === "failed"
+                ? { agentLoopStatus: session.agentLoopStatus }
+                : {}),
+            ...(session.agentLoopResumable ? { agentLoopResumable: true } : {}),
+            ...(session.agentLoopUpdatedAt ? { agentLoopUpdatedAt: session.agentLoopUpdatedAt } : {}),
+            ...(session.agentLoop ? { agentLoop: session.agentLoop } : {}),
+            ...(session.usage ? { usage: session.usage } : {}),
+        };
+    }
+    formatSessionsList(entries) {
+        if (entries.length === 0)
+            return "No chat sessions found.";
+        const lines = entries.map((entry) => {
+            const title = entry.title ? ` "${entry.title}"` : "";
+            const resumable = entry.agentLoopResumable ? " resumable" : "";
+            return `${entry.id}${title} - ${entry.messageCount} message(s), updated ${entry.updatedAt}, cwd ${entry.cwd}${resumable}`;
+        });
+        return `Chat sessions:\n${lines.join("\n")}`;
+    }
+    formatHistory(session) {
+        const title = session.title ? ` "${session.title}"` : "";
+        if (session.messages.length === 0) {
+            return `Session ${session.id}${title} has no messages.`;
+        }
+        const lines = session.messages.map((message) => {
+            const role = message.role === "assistant" ? "Assistant" : "User";
+            return `${role}: ${message.content}`;
+        });
+        return `Session ${session.id}${title} (${session.cwd})\n${lines.join("\n")}`;
+    }
+    async loadGoals() {
+        return this.stateView.loadGoals();
+    }
+    async listAllGoalIds() {
+        return this.stateView.listAllGoalIds();
+    }
+    activeGoals(goals) {
+        return this.stateView.activeGoals(goals);
+    }
+    formatGoalLine(goal) {
+        const dimensions = goal.dimensions.length === 0
+            ? "no dimensions"
+            : goal.dimensions
+                .slice(0, 3)
+                .map((dimension) => `${dimension.name}: ${String(dimension.current_value)} target ${JSON.stringify(dimension.threshold)}`)
+                .join("; ");
+        return `${goal.id} - ${goal.title} [${goal.status}, loop ${goal.loop_status}] ${dimensions}`;
+    }
+    async handleStatus(args, start) {
+        if (args) {
+            const goal = await this.deps.stateManager.loadGoal(args);
+            if (!goal) {
+                return { success: false, output: `Goal not found: ${args}`, elapsed_ms: Date.now() - start };
+            }
+            const lines = [
+                `Goal status: ${goal.title}`,
+                `ID: ${goal.id}`,
+                `Status: ${goal.status}`,
+                `Loop: ${goal.loop_status}`,
+                `Updated: ${goal.updated_at}`,
+                `Children: ${goal.children_ids.length}`,
+                `Dimensions:`,
+                ...goal.dimensions.map((dimension) => `- ${dimension.name}: current=${String(dimension.current_value)}, threshold=${JSON.stringify(dimension.threshold)}, confidence=${dimension.confidence}`),
+            ];
+            return { success: true, output: lines.join("\n"), elapsed_ms: Date.now() - start };
+        }
+        const goals = await this.loadGoals();
+        const active = this.activeGoals(goals);
+        if (active.length === 0) {
+            return { success: true, output: "No active goals found.", elapsed_ms: Date.now() - start };
+        }
+        return {
+            success: true,
+            output: `Active goals:\n${active.map((goal) => this.formatGoalLine(goal)).join("\n")}`,
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    async handleGoals(start) {
+        const goals = await this.loadGoals();
+        if (goals.length === 0) {
+            return { success: true, output: "No goals found.", elapsed_ms: Date.now() - start };
+        }
+        return {
+            success: true,
+            output: `Goals:\n${goals.map((goal) => this.formatGoalLine(goal)).join("\n")}`,
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    async readTasksForGoal(goalId) {
+        return this.stateView.readTasksForGoal(goalId);
+    }
+    async resolveGoalForTasks(selector) {
+        if (selector)
+            return { goalId: selector };
+        const active = this.activeGoals(await this.loadGoals());
+        if (active.length === 1)
+            return { goalId: active[0].id };
+        if (active.length === 0)
+            return { error: "No active goals found. Use /tasks <goal-id>." };
+        return { error: "Multiple active goals found. Use /tasks <goal-id>." };
+    }
+    formatTaskLine(task) {
+        const verdict = task.verification_verdict ? `, verdict ${task.verification_verdict}` : "";
+        return `${task.id} - ${task.status}${verdict}: ${task.work_description}`;
+    }
+    async handleTasks(args, start) {
+        const resolved = await this.resolveGoalForTasks(args);
+        if (resolved.error || !resolved.goalId) {
+            return { success: false, output: resolved.error ?? "Usage: /tasks <goal-id>", elapsed_ms: Date.now() - start };
+        }
+        const tasks = await this.readTasksForGoal(resolved.goalId);
+        if (tasks.length === 0) {
+            return { success: true, output: `No tasks found for goal "${resolved.goalId}".`, elapsed_ms: Date.now() - start };
+        }
+        return {
+            success: true,
+            output: `Tasks for goal ${resolved.goalId}:\n${tasks.map((task) => this.formatTaskLine(task)).join("\n")}`,
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    parseTaskArgs(args) {
+        const parts = args.split(/\s+/).filter(Boolean);
+        const goalFlagIndex = parts.indexOf("--goal");
+        if (goalFlagIndex >= 0) {
+            const goalId = parts[goalFlagIndex + 1];
+            parts.splice(goalFlagIndex, goalId ? 2 : 1);
+            return { taskId: parts[0], goalId };
+        }
+        return { taskId: parts[0], goalId: parts[1] };
+    }
+    async findTask(taskId, goalId) {
+        return this.stateView.findTask(taskId, goalId);
+    }
+    formatTask(task) {
+        const lines = [
+            `Task: ${task.id}`,
+            `Goal: ${task.goal_id}`,
+            `Status: ${task.status}`,
+            `Category: ${task.task_category}`,
+            `Created: ${task.created_at}`,
+            `Work: ${task.work_description}`,
+            `Approach: ${task.approach}`,
+        ];
+        if (task.started_at)
+            lines.push(`Started: ${task.started_at}`);
+        if (task.completed_at)
+            lines.push(`Completed: ${task.completed_at}`);
+        if (task.verification_verdict)
+            lines.push(`Verification: ${task.verification_verdict}`);
+        if (task.verification_evidence?.length)
+            lines.push(`Evidence: ${task.verification_evidence.join("; ")}`);
+        if (task.success_criteria.length > 0) {
+            lines.push("Success criteria:");
+            lines.push(...task.success_criteria.map((criterion) => `- ${criterion.description}`));
+        }
+        return lines.join("\n");
+    }
+    async handleTask(args, start) {
+        const { taskId, goalId } = this.parseTaskArgs(args);
+        if (!taskId) {
+            return { success: false, output: "Usage: /task <task-id> [goal-id]", elapsed_ms: Date.now() - start };
+        }
+        const found = await this.findTask(taskId, goalId);
+        if (found.matches.length > 1) {
+            return {
+                success: false,
+                output: `Task selector "${taskId}" matched multiple goals. Use /task ${taskId} <goal-id>.\n${found.matches.map((match) => `- ${match.goalId}`).join("\n")}`,
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        if (!found.task) {
+            const suffix = goalId ? ` for goal "${goalId}"` : "";
+            return { success: false, output: `Task not found: ${taskId}${suffix}`, elapsed_ms: Date.now() - start };
+        }
+        return { success: true, output: this.formatTask(found.task), elapsed_ms: Date.now() - start };
+    }
+    async readProviderConfigSummary() {
+        return this.stateView.readProviderConfigSummary();
+    }
+    formatConfig(config) {
+        return this.stateView.formatConfig(config);
+    }
+    async handleConfig(start) {
+        const config = await this.readProviderConfigSummary();
+        return { success: true, output: `Provider configuration:\n${this.formatConfig(config)}`, elapsed_ms: Date.now() - start };
+    }
+    async handleModel(start) {
+        const config = await this.readProviderConfigSummary();
+        return {
+            success: true,
+            output: `Model: ${config.model}\nProvider: ${config.provider}\nAdapter: ${config.adapter}`,
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    async handlePlugins(start) {
+        if (!this.deps.pluginLoader) {
+            return { success: true, output: "Plugin information is not available in this chat session.", elapsed_ms: Date.now() - start };
+        }
+        try {
+            const plugins = await this.deps.pluginLoader.loadAll();
+            if (plugins.length === 0) {
+                return { success: true, output: "No plugins found.", elapsed_ms: Date.now() - start };
+            }
+            return {
+                success: true,
+                output: `Plugins:\n${plugins.map((plugin) => `${plugin.name} - ${plugin.type ?? "unknown"} - ${plugin.enabled === false ? "disabled" : "enabled"}`).join("\n")}`,
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { success: true, output: `Plugin information is unavailable: ${message}`, elapsed_ms: Date.now() - start };
+        }
+    }
+    zeroUsageCounter() {
+        return { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+    }
+    normalizeUsageCounter(usage) {
+        const inputTokens = Number.isFinite(usage.inputTokens) ? Math.max(0, Math.floor(usage.inputTokens)) : 0;
+        const outputTokens = Number.isFinite(usage.outputTokens) ? Math.max(0, Math.floor(usage.outputTokens)) : 0;
+        const totalTokens = Number.isFinite(usage.totalTokens)
+            ? Math.max(0, Math.floor(usage.totalTokens))
+            : inputTokens + outputTokens;
+        return {
+            inputTokens,
+            outputTokens,
+            totalTokens,
+        };
+    }
+    usageFromLLMResponse(response) {
+        const inputTokens = response.usage?.input_tokens ?? 0;
+        const outputTokens = response.usage?.output_tokens ?? 0;
+        return {
+            inputTokens,
+            outputTokens,
+            totalTokens: inputTokens + outputTokens,
+        };
+    }
+    addUsageCounter(target, delta) {
+        const normalizedDelta = this.normalizeUsageCounter(delta);
+        target.inputTokens += normalizedDelta.inputTokens;
+        target.outputTokens += normalizedDelta.outputTokens;
+        target.totalTokens += normalizedDelta.totalTokens;
+    }
+    hasUsage(usage) {
+        return usage.totalTokens > 0 || usage.inputTokens > 0 || usage.outputTokens > 0;
+    }
+    formatUsageCounter(prefix, usage) {
+        return [
+            `${prefix} input tokens:  ${usage.inputTokens}`,
+            `${prefix} output tokens: ${usage.outputTokens}`,
+            `${prefix} total tokens:  ${usage.totalTokens}`,
+        ];
+    }
+    parseUsagePeriodMs(period) {
+        const match = /^(\d+)([dhw])$/i.exec(period.trim());
+        if (!match) {
+            throw new Error("period must be one of 24h, 7d, 2w");
+        }
+        const value = Number(match[1]);
+        const unit = match[2]?.toLowerCase();
+        if (!Number.isFinite(value) || value <= 0) {
+            throw new Error("period value must be positive");
+        }
+        if (unit === "h")
+            return value * 60 * 60 * 1000;
+        if (unit === "w")
+            return value * 7 * 24 * 60 * 60 * 1000;
+        return value * 24 * 60 * 60 * 1000;
+    }
+    async collectGoalUsage(goalId) {
+        const baseDir = this.deps.stateManager.getBaseDir();
+        const ledgerDir = path.join(baseDir, "tasks", goalId, "ledger");
+        let entries = [];
+        try {
+            entries = await fsp.readdir(ledgerDir);
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err;
+            return { goalId, totalTokens: 0, taskCount: 0, terminalTaskCount: 0 };
+        }
+        let totalTokens = 0;
+        let taskCount = 0;
+        let terminalTaskCount = 0;
+        for (const entry of entries) {
+            if (!entry.endsWith(".json"))
+                continue;
+            taskCount += 1;
+            try {
+                const raw = await fsp.readFile(path.join(ledgerDir, entry), "utf-8");
+                const parsed = JSON.parse(raw);
+                if (typeof parsed.summary?.tokens_used === "number") {
+                    totalTokens += parsed.summary.tokens_used;
+                }
+                if (parsed.summary?.latest_event_type === "succeeded"
+                    || parsed.summary?.latest_event_type === "failed"
+                    || parsed.summary?.latest_event_type === "abandoned") {
+                    terminalTaskCount += 1;
+                }
+            }
+            catch {
+                // Ignore malformed records.
+            }
+        }
+        return { goalId, totalTokens, taskCount, terminalTaskCount };
+    }
+    async collectScheduleUsage(period) {
+        const periodMs = this.parseUsagePeriodMs(period);
+        const since = Date.now() - periodMs;
+        const historyPath = path.join(this.deps.stateManager.getBaseDir(), "schedule-history.json");
+        let raw;
+        try {
+            raw = JSON.parse(await fsp.readFile(historyPath, "utf-8"));
+        }
+        catch (err) {
+            if (err.code === "ENOENT") {
+                return { period, runs: 0, totalTokens: 0 };
+            }
+            throw err;
+        }
+        if (!Array.isArray(raw)) {
+            return { period, runs: 0, totalTokens: 0 };
+        }
+        let runs = 0;
+        let totalTokens = 0;
+        for (const record of raw) {
+            if (!record || typeof record !== "object")
+                continue;
+            const finishedAt = record["finished_at"];
+            const firedAt = typeof finishedAt === "string" ? Date.parse(finishedAt) : Number.NaN;
+            if (!Number.isFinite(firedAt) || firedAt < since)
+                continue;
+            runs += 1;
+            const tokensUsed = record["tokens_used"];
+            if (typeof tokensUsed === "number" && Number.isFinite(tokensUsed)) {
+                totalTokens += tokensUsed;
+            }
+        }
+        return { period, runs, totalTokens };
+    }
+    async handleUsage(args, start) {
+        const tokens = args.trim().split(/\s+/).filter(Boolean);
+        const scope = tokens[0]?.toLowerCase();
+        if (!scope || scope === "session") {
+            if (!this.history) {
+                return { success: false, output: "No active chat session. Start a session and run work before /usage.", elapsed_ms: Date.now() - start };
+            }
+            const session = this.history.getSessionData();
+            const totals = this.normalizeUsageCounter(session.usage?.totals ?? this.zeroUsageCounter());
+            const lines = [
+                `Usage summary (session ${session.id})`,
+                ...this.formatUsageCounter("Session", totals),
+            ];
+            const phaseEntries = Object.entries(session.usage?.byPhase ?? {})
+                .map(([phase, usage]) => ({ phase, usage: this.normalizeUsageCounter(usage) }))
+                .filter((entry) => this.hasUsage(entry.usage))
+                .sort((left, right) => right.usage.totalTokens - left.usage.totalTokens);
+            if (phaseEntries.length > 0) {
+                lines.push("");
+                lines.push("By phase:");
+                for (const entry of phaseEntries) {
+                    lines.push(`- ${entry.phase}: ${entry.usage.totalTokens} (in=${entry.usage.inputTokens}, out=${entry.usage.outputTokens})`);
+                }
+            }
+            return { success: true, output: lines.join("\n"), elapsed_ms: Date.now() - start };
+        }
+        if (scope === "goal" || scope === "daemon") {
+            const goalId = tokens[1] ?? this.deps.goalId;
+            if (!goalId) {
+                return { success: false, output: "Usage: /usage goal <goal-id>", elapsed_ms: Date.now() - start };
+            }
+            const summary = await this.collectGoalUsage(goalId);
+            const lines = [
+                `Usage summary (${scope} scope)`,
+                `Goal: ${summary.goalId}`,
+                `Tasks observed: ${summary.taskCount}`,
+                `Terminal tasks: ${summary.terminalTaskCount}`,
+                `Total tokens: ${summary.totalTokens}`,
+            ];
+            return { success: true, output: lines.join("\n"), elapsed_ms: Date.now() - start };
+        }
+        if (scope === "schedule") {
+            const period = tokens[1] ?? "7d";
+            try {
+                const summary = await this.collectScheduleUsage(period);
+                const lines = [
+                    `Usage summary (schedule, ${summary.period})`,
+                    `Runs: ${summary.runs}`,
+                    `Total tokens: ${summary.totalTokens}`,
+                ];
+                return { success: true, output: lines.join("\n"), elapsed_ms: Date.now() - start };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return { success: false, output: `Usage: /usage schedule [24h|7d|2w]\nError: ${message}`, elapsed_ms: Date.now() - start };
+            }
+        }
+        return {
+            success: false,
+            output: "Usage: /usage [session|goal <goal-id>|daemon <goal-id>|schedule [24h|7d|2w]]",
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    deterministicChatSummary(messages) {
+        const lines = messages.map((message) => `${message.role}: ${message.content.replace(/\s+/g, " ").trim()}`);
+        return lines.join("\n").slice(0, 4_000);
+    }
+    async summarizeChatForCompaction(messages, existingSummary) {
+        const content = [
+            existingSummary ? `Previous summary:\n${existingSummary}` : "",
+            `Messages to summarize:\n${messages.map((message) => `${message.role}: ${message.content}`).join("\n")}`,
+        ].filter(Boolean).join("\n\n");
+        if (this.deps.llmClient) {
+            try {
+                const response = await this.deps.llmClient.sendMessage([
+                    { role: "user", content: `Summarize this chat history for later continuation. Preserve decisions, open tasks, constraints, and user preferences. Keep it concise.\n\n${content}` },
+                ], { max_tokens: 700, model_tier: "light" });
+                if (response.content.trim())
+                    return { summary: response.content.trim(), usedLlm: true };
+            }
+            catch {
+                // Fall back to deterministic summary below.
+            }
+        }
+        const fallback = [
+            existingSummary ? `Previous summary:\n${existingSummary}` : "",
+            "Extractive summary:",
+            this.deterministicChatSummary(messages),
+        ].filter(Boolean).join("\n\n");
+        return { summary: fallback, usedLlm: false };
+    }
+    async handleCompact(start) {
+        if (!this.history) {
+            return { success: false, output: "No active chat session to compact.", elapsed_ms: Date.now() - start };
+        }
+        const session = this.history.getSessionData();
+        if (session.messages.length <= 4) {
+            return { success: true, output: "Chat history is already compact. No messages were removed.", elapsed_ms: Date.now() - start };
+        }
+        const olderMessages = session.messages.slice(0, -4);
+        const { summary, usedLlm } = await this.summarizeChatForCompaction(olderMessages, session.compactionSummary);
+        const { before, after } = await this.history.compact(summary, 4);
+        const method = usedLlm ? "LLM summary" : "deterministic summary";
+        return {
+            success: true,
+            output: `Compacted chat history with ${method}. Persisted ${before} message(s) down to ${after}; the latest user/assistant turns were kept.`,
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    async handleCommand(input) {
+        const trimmed = input.trim();
+        if (!trimmed.startsWith("/"))
+            return null;
+        const cmd = trimmed.toLowerCase().split(/\s+/)[0];
+        const start = Date.now();
+        if (cmd === "/help") {
+            return { success: true, output: COMMAND_HELP, elapsed_ms: Date.now() - start };
+        }
+        if (cmd === "/clear") {
+            await this.history?.clear();
+            return { success: true, output: "Conversation history cleared.", elapsed_ms: Date.now() - start };
+        }
+        if (cmd === "/sessions") {
+            const catalog = new ChatSessionCatalog(this.deps.stateManager);
+            const sessions = await catalog.listSessions();
+            return { success: true, output: this.formatSessionsList(sessions), elapsed_ms: Date.now() - start };
+        }
+        if (cmd === "/history") {
+            const catalog = new ChatSessionCatalog(this.deps.stateManager);
+            const selector = trimmed.slice("/history".length).trim();
+            const session = selector
+                ? await catalog.loadSessionBySelector(selector)
+                : this.history
+                    ? await catalog.loadSession(this.history.getSessionId())
+                    : null;
+            if (!session) {
+                return { success: false, output: "No chat session history found.", elapsed_ms: Date.now() - start };
+            }
+            return { success: true, output: this.formatHistory(session), elapsed_ms: Date.now() - start };
+        }
+        if (cmd === "/title") {
+            const title = trimmed.slice("/title".length).trim();
+            if (!title) {
+                return { success: false, output: "Usage: /title <title>", elapsed_ms: Date.now() - start };
+            }
+            if (!this.history) {
+                return { success: false, output: "No active chat session to rename.", elapsed_ms: Date.now() - start };
+            }
+            const catalog = new ChatSessionCatalog(this.deps.stateManager);
+            this.history.setTitle(title);
+            await this.history.persist();
+            await catalog.renameSession(this.history.getSessionId(), title);
+            return { success: true, output: `Renamed chat session to "${title}".`, elapsed_ms: Date.now() - start };
+        }
+        if (cmd === "/cleanup") {
+            const catalog = new ChatSessionCatalog(this.deps.stateManager);
+            const dryRun = trimmed.includes("--dry-run");
+            const report = await catalog.cleanupSessions({
+                dryRun,
+                activeSessionId: this.history?.getSessionId(),
+            });
+            const verb = dryRun ? "would remove" : "removed";
+            return {
+                success: true,
+                output: `Chat session cleanup ${verb} ${report.removedSessionIds.length} session(s).`,
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        if (cmd === "/compact") {
+            return this.handleCompact(start);
+        }
+        if (cmd === "/status") {
+            return this.handleStatus(trimmed.slice("/status".length).trim(), start);
+        }
+        if (cmd === "/goals") {
+            return this.handleGoals(start);
+        }
+        if (cmd === "/tasks") {
+            return this.handleTasks(trimmed.slice("/tasks".length).trim(), start);
+        }
+        if (cmd === "/task") {
+            return this.handleTask(trimmed.slice("/task".length).trim(), start);
+        }
+        if (cmd === "/config") {
+            return this.handleConfig(start);
+        }
+        if (cmd === "/model") {
+            return this.handleModel(start);
+        }
+        if (cmd === "/permissions") {
+            return this.handlePermissions(trimmed.slice("/permissions".length).trim(), start);
+        }
+        if (cmd === "/plugins") {
+            return this.handlePlugins(start);
+        }
+        if (cmd === "/usage") {
+            return this.handleUsage(trimmed.slice("/usage".length).trim(), start);
+        }
+        if (cmd === "/review") {
+            return this.handleReview(start);
+        }
+        if (cmd === "/fork") {
+            return this.handleFork(trimmed.slice("/fork".length).trim(), start);
+        }
+        if (cmd === "/undo") {
+            return this.handleUndo(start);
+        }
+        if (cmd === "/exit") {
+            return { success: true, output: "Exiting chat mode.", elapsed_ms: Date.now() - start };
+        }
+        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.`,
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    async handleTrack(start) {
+        if (!this.deps.escalationHandler) {
+            return {
+                success: false,
+                output: "Escalation not available — missing LLM configuration",
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        if (!this.history || this.history.getMessages().length === 0) {
+            return {
+                success: false,
+                output: "No conversation to escalate. Chat first, then /track.",
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        try {
+            const result = await this.deps.escalationHandler.escalateToGoal(this.history);
+            return {
+                success: true,
+                output: `Goal created: ${result.title} (ID: ${result.goalId})\nRun: pulseed run --goal ${result.goalId} --yes`,
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                success: false,
+                output: `Escalation failed: ${message}`,
+                elapsed_ms: Date.now() - start,
+            };
+        }
+    }
+    async handlePermissions(args, start) {
+        const policy = await this.getSessionExecutionPolicy();
+        if (!args) {
+            return {
+                success: true,
+                output: this.formatExecutionPolicyOutput(summarizeExecutionPolicy(policy), "Profile", await this.getAgentLoopProfileSummary("chat", policy)),
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        const tokens = args.toLowerCase().split(/\s+/).filter(Boolean);
+        let nextPolicy = policy;
+        for (let index = 0; index < tokens.length; index++) {
+            const token = tokens[index];
+            if (token === "read-only" || token === "readonly" || token === "read_only") {
+                nextPolicy = withExecutionPolicyOverrides(nextPolicy, { sandboxMode: "read_only" });
+                continue;
+            }
+            if (token === "workspace-write" || token === "workspace_write") {
+                nextPolicy = withExecutionPolicyOverrides(nextPolicy, { sandboxMode: "workspace_write" });
+                continue;
+            }
+            if (token === "full-access" || token === "danger-full-access" || token === "danger_full_access") {
+                nextPolicy = withExecutionPolicyOverrides(nextPolicy, { sandboxMode: "danger_full_access" });
+                continue;
+            }
+            if (token === "network" && tokens[index + 1]) {
+                nextPolicy = withExecutionPolicyOverrides(nextPolicy, { networkAccess: tokens[index + 1] === "on" });
+                index += 1;
+                continue;
+            }
+            if (token === "approval" && tokens[index + 1]) {
+                const approvalPolicy = tokens[index + 1];
+                if (approvalPolicy === "never" || approvalPolicy === "on_request" || approvalPolicy === "untrusted") {
+                    nextPolicy = withExecutionPolicyOverrides(nextPolicy, { approvalPolicy });
+                    index += 1;
+                    continue;
+                }
+            }
+            return {
+                success: false,
+                output: "Usage: /permissions [read-only|workspace-write|full-access] [network on|off] [approval on_request|never|untrusted]",
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        this.sessionExecutionPolicy = nextPolicy;
+        return {
+            success: true,
+            output: this.formatExecutionPolicyOutput(summarizeExecutionPolicy(nextPolicy), "Profile", await this.getAgentLoopProfileSummary("chat", nextPolicy)),
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    async handleReview(start) {
+        const cwd = this.sessionCwd ?? process.cwd();
+        const diffStat = await checkGitChanges(cwd);
+        const reviewProfile = await this.getAgentLoopDefaultProfile("review");
+        const reviewPolicy = reviewProfile.executionPolicy ?? await this.getSessionExecutionPolicy();
+        if (this.deps.reviewAgentLoopRunner) {
+            const review = await this.deps.reviewAgentLoopRunner.execute({
+                cwd,
+                diffStat,
+                executionPolicy: reviewPolicy,
+            });
+            return { success: review.success, output: review.output, elapsed_ms: Date.now() - start };
+        }
+        const output = [
+            "Review summary",
+            diffStat ? diffStat : "No uncommitted changes detected.",
+            "",
+            "Execution policy",
+            summarizeExecutionPolicy(reviewPolicy),
+            "",
+            "Review profile",
+            formatAgentLoopResolvedProfileSummary(summarizeAgentLoopResolvedProfile(reviewProfile, reviewPolicy)),
+        ].join("\n");
+        return { success: true, output, elapsed_ms: Date.now() - start };
+    }
+    async handleFork(title, start) {
+        const cwd = this.sessionCwd ?? process.cwd();
+        const sessionId = crypto.randomUUID();
+        const baseSession = this.history?.getSessionData() ?? {
+            id: sessionId,
+            cwd,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            messages: [],
+        };
+        const now = new Date().toISOString();
+        const forkedSession = {
+            ...baseSession,
+            id: sessionId,
+            createdAt: now,
+            updatedAt: now,
+            title: title || (baseSession.title ? `${baseSession.title} (fork)` : "Forked session"),
+        };
+        this.history = ChatHistory.fromSession(this.deps.stateManager, forkedSession);
+        this.sessionCwd = cwd;
+        this.sessionActive = true;
+        this.nativeAgentLoopStatePath = `chat/agentloop/${sessionId}.state.json`;
+        this.history.setAgentLoopStatePath(this.nativeAgentLoopStatePath);
+        await this.history.persist();
+        return {
+            success: true,
+            output: `Forked chat session as ${sessionId}.`,
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    async handleUndo(start) {
+        if (!this.history) {
+            return { success: false, output: "No active chat session to undo.", elapsed_ms: Date.now() - start };
+        }
+        const removed = await this.history.removeLastTurn();
+        if (removed === 0) {
+            return { success: false, output: "No chat turn to undo.", elapsed_ms: Date.now() - start };
+        }
+        return {
+            success: true,
+            output: `Removed ${removed} message(s) from chat history. File changes were not reverted.`,
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    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.
+     *
+     * Flow:
+     *  1. Intercept slash commands before adapter dispatch
+     *  2. Resolve git root → create ChatHistory
+     *  3. Build chat context and assemble prompt
+     *  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 only after the final assistant text is complete
+     */
+    async execute(input, cwd, timeoutMs = DEFAULT_TIMEOUT_MS) {
+        const eventContext = this.createEventContext();
+        const resumeCommand = this.parseResumeCommand(input);
+        const resumeOnly = resumeCommand !== null;
+        // Intercept commands before any adapter call
+        const commandResult = resumeOnly ? null : 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 && !resumeOnly) {
+            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;
+        }
+        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;
+        }
+        if (resumeOnly && resumeCommand.selector) {
+            try {
+                const catalog = new ChatSessionCatalog(this.deps.stateManager);
+                const session = await catalog.loadSessionBySelector(resumeCommand.selector);
+                if (!session) {
+                    const elapsed_ms = 0;
+                    const output = `No chat session matched selector "${resumeCommand.selector}".`;
+                    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.startSessionFromLoadedSession(session);
+            }
+            catch (err) {
+                const elapsed_ms = 0;
+                const output = err instanceof ChatSessionSelectorError ? err.message : `Failed to load chat session: ${err instanceof Error ? err.message : String(err)}`;
+                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 };
+            }
+        }
+        // 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`;
+            this.history.setAgentLoopStatePath(this.nativeAgentLoopStatePath);
+        }
+        const gitRoot = this.sessionCwd ?? resolveGitRoot(cwd);
+        // history is always assigned by this point (either by startSession or the block above)
+        const history = this.history;
+        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 {
+                this.cachedStaticSystemPrompt = buildStaticSystemPrompt();
+            }
+            catch {
+                this.cachedStaticSystemPrompt = "";
+            }
+        }
+        // Build conversation history from prior turns (last 10), including any manual compaction summary.
+        const messages = history.getMessages();
+        const compactionSummary = history.getSessionData().compactionSummary;
+        const priorTurns = resumeOnly ? messages.slice(-10) : messages.slice(0, -1).slice(-10);
+        let historyBlock = "";
+        const historySections = [];
+        if (compactionSummary) {
+            historySections.push(`Compacted previous conversation summary:\n${compactionSummary}`);
+        }
+        if (priorTurns.length > 0) {
+            const lines = priorTurns.map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content}`).join("\n");
+            historySections.push(`Previous conversation:\n${lines}`);
+        }
+        if (historySections.length > 0) {
+            historyBlock = `${historySections.join("\n\n")}\n\nCurrent message:\n`;
+        }
+        const directAnswerRoute = !resumeOnly && !this.deps.chatAgentLoopRunner && this.deps.llmClient !== undefined && shouldUseDirectAnswerRoute(input);
+        const directPrompt = historyBlock ? `${historyBlock}${input}` : input;
+        const start = Date.now();
+        const assistantBuffer = { text: "" };
+        const turnUsage = this.zeroUsageCounter();
+        if (directAnswerRoute) {
+            try {
+                this.emitActivity("lifecycle", "Calling model...", eventContext, "lifecycle:model");
+                const directResponse = await this.sendLLMMessage(this.deps.llmClient, [{ role: "user", content: directPrompt }], {
+                    ...(this.cachedStaticSystemPrompt ? { system: this.cachedStaticSystemPrompt } : {}),
+                    model_tier: "light",
+                    max_tokens: DIRECT_ANSWER_MAX_TOKENS,
+                }, assistantBuffer, eventContext);
+                this.addUsageCounter(turnUsage, this.usageFromLLMResponse(directResponse));
+                const elapsed_ms = Date.now() - start;
+                const output = assistantBuffer.text || directResponse.content || "(no response)";
+                if (this.hasUsage(turnUsage)) {
+                    history.recordUsage("execution", turnUsage);
+                }
+                await history.appendAssistantMessage(output);
+                this.emitActivity("lifecycle", "Finalizing response...", eventContext, "lifecycle:finalizing");
+                this.emitEvent({
+                    type: "assistant_final",
+                    text: output,
+                    persisted: true,
+                    ...this.eventBase(eventContext),
+                });
+                this.emitLifecycleEndEvent("completed", elapsed_ms, eventContext, true);
+                return {
+                    success: true,
+                    output,
+                    elapsed_ms,
+                    diagnostics: {
+                        route: "direct",
+                        reason: "simple_question",
+                        modelTier: "light",
+                        maxTokens: DIRECT_ANSWER_MAX_TOKENS,
+                    },
+                };
+            }
+            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,
+                    diagnostics: {
+                        route: "direct",
+                        reason: "simple_question",
+                        modelTier: "light",
+                        maxTokens: DIRECT_ANSWER_MAX_TOKENS,
+                    },
+                };
+            }
+        }
+        let dynamicSystemPrompt = "";
+        try {
+            this.emitActivity("lifecycle", "Preparing context...", eventContext, "lifecycle:context");
+            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();
+        const agentLoopSystemPrompt = [
+            systemPrompt,
+            compactionSummary ? `## Compacted Chat Summary\n${compactionSummary}` : "",
+        ]
+            .filter((section) => section && section.trim().length > 0)
+            .join("\n\n")
+            .trim();
+        const context = resumeOnly ? "" : await buildChatContext(input, gitRoot);
+        const basePrompt = resumeOnly ? "" : (context ? `${context}\n\n${input}` : input);
+        const prompt = historyBlock ? `${historyBlock}${basePrompt}` : basePrompt;
+        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;
+                    },
+                    toolCallContext: {
+                        executionPolicy: await this.getSessionExecutionPolicy(),
+                    },
+                    ...(this.nativeAgentLoopStatePath ? { resumeStatePath: this.nativeAgentLoopStatePath } : {}),
+                    ...(resumeState ? { resumeState } : {}),
+                    ...(resumeOnly ? { resumeOnly: true } : {}),
+                    ...(agentLoopSystemPrompt ? { systemPrompt: agentLoopSystemPrompt } : {}),
+                });
+                const elapsed_ms = Date.now() - start;
+                const agentLoopUsage = this.normalizeUsageCounter(result.agentLoop?.usage ?? this.zeroUsageCounter());
+                if (this.hasUsage(agentLoopUsage)) {
+                    history.recordUsage("agentloop", agentLoopUsage);
+                }
+                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 {
+                    if (this.hasUsage(agentLoopUsage)) {
+                        await history.persist();
+                    }
+                    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,
+                };
+            }
+        }
+        // Prefer the local LLM/tool loop over the external adapter fallback whenever a client is available.
+        if (this.deps.llmClient) {
+            try {
+                const toolResult = await this.executeWithTools(prompt, eventContext, assistantBuffer, systemPrompt || undefined);
+                const elapsed_ms = Date.now() - start;
+                if (this.hasUsage(toolResult.usage)) {
+                    history.recordUsage("execution", toolResult.usage);
+                }
+                await history.appendAssistantMessage(toolResult.output);
+                this.emitActivity("lifecycle", "Finalizing response...", eventContext, "lifecycle:finalizing");
+                this.emitEvent({
+                    type: "assistant_final",
+                    text: toolResult.output,
+                    persisted: true,
+                    ...this.eventBase(eventContext),
+                });
+                this.emitLifecycleEndEvent("completed", elapsed_ms, eventContext, true);
+                return { success: true, output: toolResult.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,
+                };
+            }
+        }
+        const task = {
+            prompt,
+            timeout_ms: timeoutMs,
+            adapter_type: this.deps.adapter.adapterType,
+            cwd,
+            ...(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]);
+        // 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;
+            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)),
+            ]);
+            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")}`;
+                const retryTask = { ...task, prompt: retryPrompt };
+                result = await this.deps.adapter.execute(retryTask);
+                verification = await verifyChatAction(gitRoot, this.deps.toolExecutor);
+            }
+            if (!verification.passed) {
+                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: `${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,
+                };
+            }
+        }
+        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 {
+            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,
+            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.
+     */
+    async executeWithTools(prompt, eventContext, assistantBuffer, systemPrompt) {
+        const llmClient = this.deps.llmClient;
+        const messages = [{ role: "user", content: prompt }];
+        const toolCallContext = await this.buildToolCallContext();
+        const usage = this.zeroUsageCounter();
+        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 })
+                : [];
+            const supportsNativeToolCalling = llmClient.supportsToolCalling?.() !== false;
+            let response;
+            try {
+                this.emitActivity("lifecycle", "Calling model...", eventContext, "lifecycle:model");
+                response = await this.sendLLMMessage(llmClient, messages, {
+                    ...(supportsNativeToolCalling
+                        ? { tools, ...(systemPrompt ? { system: systemPrompt } : {}) }
+                        : { system: buildPromptedToolProtocolSystemPrompt({ systemPrompt, tools }) }),
+                }, assistantBuffer, eventContext);
+                this.addUsageCounter(usage, this.usageFromLLMResponse(response));
+            }
+            catch (err) {
+                console.error("[chat-runner] executeWithTools error:", err);
+                const hint = err instanceof Error ? `: ${err.message}` : "";
+                throw new Error(`Sorry, I encountered an error processing your request${hint}.`);
+            }
+            const toolCalls = response.tool_calls?.length
+                ? response.tool_calls
+                : supportsNativeToolCalling
+                    ? []
+                    : extractPromptedToolCalls({
+                        content: response.content,
+                        tools,
+                        createId: () => `prompted-${loop}-${crypto.randomUUID()}`,
+                    }).map((call) => ({
+                        id: call.id,
+                        type: "function",
+                        function: {
+                            name: call.name,
+                            arguments: JSON.stringify(call.input ?? {}),
+                        },
+                    }));
+            if (!supportsNativeToolCalling && toolCalls.length > 0) {
+                assistantBuffer.text = "";
+            }
+            // No tool calls — return the text content
+            if (toolCalls.length === 0) {
+                return {
+                    output: assistantBuffer.text || response.content || "(no response)",
+                    usage,
+                };
+            }
+            // Append assistant message, then process tool calls
+            messages.push({ role: "assistant", content: response.content || "" });
+            for (const tc of toolCalls) {
+                let args = {};
+                try {
+                    args = JSON.parse(tc.function.arguments || "{}");
+                }
+                catch {
+                    // ignore parse errors, use empty args
+                }
+                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}` });
+            }
+        }
+        // Max loops reached — return last assistant content or fallback
+        const lastAssistant = [...messages].reverse().find(m => m.role === "assistant");
+        return {
+            output: lastAssistant?.content || "I was unable to complete the request within the allowed tool call limit.",
+            usage,
+        };
+    }
+    /**
+     * 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
+        }
+    }
+    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 } : {};
+    }
+    parseResumeCommand(input) {
+        const trimmed = input.trim();
+        const match = /^\/resume(?:\s+(.+))?$/i.exec(trimmed);
+        if (!match)
+            return null;
+        const selector = match[1]?.trim();
+        return selector ? { selector } : {};
+    }
+    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;
+        const usageCandidate = raw.usage;
+        const usage = usageCandidate
+            ? this.normalizeUsageCounter({
+                inputTokens: typeof usageCandidate.inputTokens === "number" ? usageCandidate.inputTokens : 0,
+                outputTokens: typeof usageCandidate.outputTokens === "number" ? usageCandidate.outputTokens : 0,
+                totalTokens: typeof usageCandidate.totalTokens === "number" ? usageCandidate.totalTokens : 0,
+            })
+            : this.zeroUsageCounter();
+        return {
+            ...raw,
+            messages: [...raw.messages],
+            calledTools: [...raw.calledTools],
+            usage,
+        };
+    }
+    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,
+                    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),
+            });
+            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: "running",
+                    message: "running",
+                    ...this.eventBase(eventContext),
+                });
+                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: 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, `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);
+            }
+            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,
+                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.emitActivity("tool", formatToolActivity("Failed", name, message), eventContext, toolCallId);
+            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 {
+            runId: crypto.randomUUID(),
+            turnId: crypto.randomUUID(),
+        };
+    }
+    eventBase(context) {
+        return { ...context, createdAt: new Date().toISOString() };
+    }
+    emitEvent(event) {
+        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;
+        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. */
+    async getSessionExecutionPolicy() {
+        if (this.sessionExecutionPolicy)
+            return this.sessionExecutionPolicy;
+        const profile = await this.getAgentLoopDefaultProfile("chat");
+        if (!profile.executionPolicy) {
+            throw new Error("Chat profile did not resolve an execution policy.");
+        }
+        this.sessionExecutionPolicy = profile.executionPolicy;
+        return this.sessionExecutionPolicy;
+    }
+    async getAgentLoopDefaultProfile(surface) {
+        const config = await loadProviderConfig({ saveMigration: false });
+        return resolveAgentLoopDefaultProfile({
+            surface,
+            workspaceRoot: this.sessionCwd ?? process.cwd(),
+            security: config.agent_loop?.security,
+        });
+    }
+    async getAgentLoopProfileSummary(surface, executionPolicy) {
+        const profile = await this.getAgentLoopDefaultProfile(surface);
+        return formatAgentLoopResolvedProfileSummary(summarizeAgentLoopResolvedProfile(profile, executionPolicy));
+    }
+    formatExecutionPolicyOutput(policySummary, profileHeading, profileSummary) {
+        return [policySummary, "", profileHeading, profileSummary].join("\n");
+    }
+    async buildToolCallContext() {
+        const executionPolicy = await this.getSessionExecutionPolicy();
+        return {
+            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;
+            },
+            executionPolicy,
+        };
+    }
+}
+//# sourceMappingURL=chat-runner.js.map