pulseed 0.5.2 → 0.5.4

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

@@ -2,81 +2,36 @@
 //
 // 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 { getPulseedDirPath } from "../../base/utils/paths.js";
 import { getSelfIdentityResponseForBaseDir } from "../../base/config/identity-loader.js";
-import { loadProviderConfig } from "../../base/llm/provider-config.js";
-import { TaskSchema } from "../../base/types/task.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 { buildChatAgentLoopSystemPrompt, buildStaticSystemPrompt, createChatGroundingGateway } 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 { resolveExecutionPolicy, summarizeExecutionPolicy, withExecutionPolicyOverrides, } from "../../orchestrator/execution/agent-loop/execution-policy.js";
-import { buildStandaloneIngressMessage, createIngressRouter, } from "./ingress-router.js";
+import { createIngressRouter, } from "./ingress-router.js";
+import { classifyInterruptRedirect, collectGitDiffArtifact, previewActivityText } from "./chat-runner-support.js";
+import { COMMAND_HELP, ChatRunnerCommandHandler, } from "./chat-runner-commands.js";
+import { ChatRunnerEventBridge } from "./chat-runner-event-bridge.js";
+import { buildRuntimeControlContextFromIngress, buildStandaloneIngressMessageFromContext, formatRoute, getRouteCapabilities, loadedSessionToChatSession, resolveChatResumeSelector, } from "./chat-runner-runtime.js";
+import { executeAdapterRoute, executeAgentLoopRoute, executeRuntimeControlRoute, executeToolLoopRoute, resolveSessionExecutionPolicy, } from "./chat-runner-routes.js";
 const DEFAULT_TIMEOUT_MS = 120_000;
-const MAX_VERIFY_RETRIES = 2;
-const MAX_TOOL_LOOPS = 5;
-const ACTIVITY_PREVIEW_CHARS = 40;
-const standaloneIngressRouter = createIngressRouter();
-// ─── 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 normalizePinnedReplyTarget(replyTarget) {
+    if (!replyTarget)
+        return null;
+    const channel = replyTarget.channel ?? replyTarget.surface;
+    if (!channel)
+        return null;
+    return {
+        channel,
+        target_id: replyTarget.conversation_id ?? replyTarget.identity_key ?? replyTarget.response_channel ?? null,
+        thread_id: replyTarget.message_id ?? null,
+        metadata: {
+            ...replyTarget,
+            ...(replyTarget.metadata ?? {}),
+        },
+    };
 }
+const standaloneIngressRouter = createIngressRouter();
 function resolveSelfIdentityResponse(input, baseDir) {
     const normalized = input.trim().toLowerCase().replace(/\s+/g, "");
     if (!normalized)
@@ -91,43 +46,52 @@ function resolveSelfIdentityResponse(input, baseDir) {
         return null;
     return getSelfIdentityResponseForBaseDir(baseDir, isEnglishIdentityQuestion ? "en" : "ja");
 }
-// ─── ChatRunner ───
 export class ChatRunner {
     deps;
     groundingGateway;
+    eventBridge;
+    commandHandler;
     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;
+    lastSelectedRoute = null;
     constructor(deps) {
         this.deps = deps;
         this.groundingGateway = createChatGroundingGateway({
             stateManager: deps.stateManager,
             pluginLoader: deps.pluginLoader,
         });
+        this.eventBridge = new ChatRunnerEventBridge(() => this.onEvent ?? this.deps.onEvent);
+        this.commandHandler = new ChatRunnerCommandHandler({
+            deps: this.deps,
+            onNotification: this.onNotification,
+            getHistory: () => this.history,
+            setHistory: (history) => { this.history = history; },
+            getSessionCwd: () => this.sessionCwd,
+            setSessionCwd: (cwd) => { this.sessionCwd = cwd; },
+            setSessionActive: (active) => { this.sessionActive = active; },
+            getNativeAgentLoopStatePath: () => this.nativeAgentLoopStatePath,
+            setNativeAgentLoopStatePath: (path) => { this.nativeAgentLoopStatePath = path; },
+            getRuntimeControlContext: () => this.runtimeControlContext,
+            getPendingTend: () => this.pendingTend,
+            setPendingTend: (value) => { this.pendingTend = value; },
+            getLastSelectedRoute: () => this.lastSelectedRoute,
+            getSessionExecutionPolicy: () => this.getSessionExecutionPolicy(),
+            emitEvent: (event) => this.eventBridge.emitEvent(event),
+            getActiveSubscribers: () => this.activeSubscribers,
+            setSessionExecutionPolicy: (policy) => { this.sessionExecutionPolicy = policy; },
+            resetSessionExecutionPolicy: () => { this.sessionExecutionPolicy = null; },
+        });
     }
-    /**
-     * 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();
@@ -135,13 +99,13 @@ export class ChatRunner {
         this.sessionCwd = gitRoot;
         this.sessionActive = true;
         this.nativeAgentLoopStatePath = `chat/agentloop/${sessionId}.state.json`;
-        this.history.setAgentLoopStatePath(this.nativeAgentLoopStatePath);
+        this.history.resetAgentLoopState(this.nativeAgentLoopStatePath);
         this.sessionExecutionPolicy = null;
     }
     startSessionFromLoadedSession(session) {
-        const chatSession = this.loadedSessionToChatSession(session);
+        const chatSession = loadedSessionToChatSession(session);
         this.history = ChatHistory.fromSession(this.deps.stateManager, chatSession);
-        this.sessionCwd = session.cwd;
+        this.sessionCwd = resolveGitRoot(session.cwd);
         this.sessionActive = true;
         this.nativeAgentLoopStatePath = session.agentLoopStatePath ?? `chat/agentloop/${session.id}.state.json`;
         this.history.setAgentLoopStatePath(this.nativeAgentLoopStatePath);
@@ -153,6 +117,65 @@ export class ChatRunner {
     getCurrentSessionMessages() {
         return this.history?.getMessages() ?? [];
     }
+    hasActiveTurn() {
+        return this.eventBridge.hasActiveTurn();
+    }
+    async interruptAndRedirect(input, cwd, timeoutMs = DEFAULT_TIMEOUT_MS) {
+        const activeTurn = this.eventBridge.getActiveTurn();
+        if (!activeTurn) {
+            return this.execute(input, cwd, timeoutMs);
+        }
+        const start = Date.now();
+        const redirect = classifyInterruptRedirect(input);
+        if (redirect === "background") {
+            return this.eventBridge.emitEphemeralAssistantResult(input, [
+                "Continuing this same turn in the background is not available yet.",
+                "",
+                "The active turn is still running in the foreground.",
+                "Use /tend for daemon-backed work, or send a narrower follow-up request.",
+            ].join("\n"), true, start);
+        }
+        activeTurn.interruptRequested = true;
+        if (!activeTurn.abortController.signal.aborted) {
+            activeTurn.abortController.abort();
+        }
+        this.eventBridge.emitCheckpoint("Interrupt requested", `Redirect: ${previewActivityText(input, 120)}`, activeTurn.context, "interrupt");
+        const stopped = await this.eventBridge.waitForActiveTurn(activeTurn, 2_000);
+        if (!stopped) {
+            return this.eventBridge.emitEphemeralAssistantResult(input, "Interrupt requested. The active turn will stop at the next safe point.", false, start);
+        }
+        let output;
+        if (redirect === "diff") {
+            const diff = await collectGitDiffArtifact(activeTurn.cwd);
+            if (diff) {
+                const context = this.eventBridge.createEventContext();
+                this.eventBridge.emitDiffArtifact(diff, context);
+                output = "Interrupted the active turn. Current diff is shown above.";
+            }
+            else {
+                output = "Interrupted the active turn. No working-tree changes were detected.";
+            }
+        }
+        else if (redirect === "review") {
+            const review = await this.commandHandler.handleCommand("/review", activeTurn.cwd);
+            output = `Interrupted the active turn and switched to review-only mode.\n\n${review?.output ?? "Review unavailable."}`;
+        }
+        else {
+            output = [
+                "Interrupted the active turn.",
+                "",
+                "Recent activity",
+                ...(activeTurn.recentEvents.length > 0
+                    ? activeTurn.recentEvents.slice(-6).map((event) => `- ${event}`)
+                    : ["- No activity was captured before the interrupt."]),
+                "",
+                "Next actions",
+                "- Ask for the exact continuation you want.",
+                "- Ask to show diff or switch to review if files may have changed.",
+            ].join("\n");
+        }
+        return this.eventBridge.emitEphemeralAssistantResult(input, output, true, start);
+    }
     setRuntimeControlContext(context) {
         this.runtimeControlContext = context;
     }
@@ -160,1142 +183,77 @@ export class ChatRunner {
         if (!selectedRoute) {
             throw new Error("executeIngressMessage requires selectedRoute; use CrossPlatformChatSessionManager for ingress route selection.");
         }
-        const runtimeControlContext = this.buildRuntimeControlContextFromIngress(ingress);
+        const runtimeControlContext = buildRuntimeControlContextFromIngress(ingress, this.runtimeControlContext, this.deps);
         return this.execute(ingress.text, cwd, timeoutMs, {
             selectedRoute,
             runtimeControlContext,
             goalId: ingress.goal_id,
         });
     }
-    resolveRouteFromIngress(ingress) {
-        return standaloneIngressRouter.selectRoute(ingress, this.getRouteCapabilities());
-    }
-    resolveRouteFromInput(input, runtimeControlContext) {
-        return this.resolveRouteFromIngress(this.buildStandaloneIngressMessage(input, runtimeControlContext));
-    }
-    getRouteCapabilities() {
-        return {
-            hasLightweightLlm: this.deps.llmClient !== undefined,
-            hasAgentLoop: this.deps.chatAgentLoopRunner !== undefined,
-            hasToolLoop: this.deps.llmClient !== undefined,
-            hasRuntimeControlService: this.deps.runtimeControlService !== undefined,
-        };
-    }
-    buildStandaloneIngressMessage(input, runtimeControlContext) {
-        const channel = runtimeControlContext?.replyTarget?.surface === "tui"
-            ? "tui"
-            : runtimeControlContext?.replyTarget?.surface === "cli"
-                ? "cli"
-                : runtimeControlContext?.replyTarget?.surface === "gateway"
-                    ? "plugin_gateway"
-                    : "cli";
-        const runtimeApprovalFn = runtimeControlContext?.approvalFn
-            ?? this.deps.runtimeControlApprovalFn
-            ?? this.deps.approvalFn;
-        const replyTarget = runtimeControlContext?.replyTarget ?? this.deps.runtimeReplyTarget;
-        const replyTargetInput = replyTarget
-            ? {
-                ...(replyTarget.surface ? { surface: replyTarget.surface } : {}),
-                channel,
-                ...(replyTarget.platform ? { platform: replyTarget.platform } : {}),
-                ...(replyTarget.conversation_id ? { conversation_id: replyTarget.conversation_id } : {}),
-                ...(replyTarget.message_id ? { message_id: replyTarget.message_id } : {}),
-                ...(replyTarget.response_channel ? { response_channel: replyTarget.response_channel } : {}),
-                ...(replyTarget.outbox_topic ? { outbox_topic: replyTarget.outbox_topic } : {}),
-                ...(replyTarget.identity_key ? { identity_key: replyTarget.identity_key } : {}),
-                ...(replyTarget.user_id ? { user_id: replyTarget.user_id } : {}),
-                ...(replyTarget.deliveryMode === "reply" || replyTarget.deliveryMode === "notify" || replyTarget.deliveryMode === "thread_reply"
-                    ? { deliveryMode: replyTarget.deliveryMode }
-                    : {}),
-                ...(replyTarget.metadata ? { metadata: replyTarget.metadata } : {}),
-            }
-            : undefined;
-        return buildStandaloneIngressMessage({
-            text: input,
-            channel,
-            platform: runtimeControlContext?.replyTarget?.platform ?? this.deps.runtimeReplyTarget?.platform,
-            identity_key: runtimeControlContext?.replyTarget?.identity_key ?? this.deps.runtimeReplyTarget?.identity_key,
-            conversation_id: runtimeControlContext?.replyTarget?.conversation_id ?? this.deps.runtimeReplyTarget?.conversation_id,
-            user_id: runtimeControlContext?.replyTarget?.user_id ?? this.deps.runtimeReplyTarget?.user_id,
-            actor: runtimeControlContext?.actor ?? this.deps.runtimeControlActor,
-            replyTarget: replyTargetInput,
-            runtimeControl: {
-                allowed: true,
-                approvalMode: "interactive",
-            },
-        });
-    }
-    buildRuntimeControlContextFromIngress(ingress) {
-        if (!ingress.actor && !ingress.replyTarget)
-            return null;
-        const interactiveApproval = this.runtimeControlContext?.approvalFn
-            ?? this.deps.runtimeControlApprovalFn
-            ?? this.deps.approvalFn;
-        return {
-            actor: ingress.actor,
-            replyTarget: ingress.replyTarget,
-            approvalFn: ingress.runtimeControl.approvalMode === "preapproved"
-                ? async () => true
-                : ingress.runtimeControl.approvalMode === "interactive"
-                    ? interactiveApproval
-                    : undefined,
-        };
-    }
-    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 } : {}),
-        };
-    }
-    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() {
-        const goalIds = await this.deps.stateManager.listGoalIds();
-        const goals = await Promise.all(goalIds.map((id) => this.deps.stateManager.loadGoal(id)));
-        return goals.filter((goal) => goal !== null);
-    }
-    async listAllGoalIds() {
-        const activeIds = await this.deps.stateManager.listGoalIds();
-        const archivedIds = await this.deps.stateManager.listArchivedGoals();
-        const recoverableArchivedIds = await this.listRecoverableArchivedGoalIds();
-        return [...new Set([...activeIds, ...archivedIds, ...recoverableArchivedIds])];
-    }
-    resolveStatePath(baseDir, ...segments) {
-        const base = path.resolve(baseDir);
-        const resolved = path.resolve(base, ...segments);
-        if (!resolved.startsWith(base + path.sep))
-            return null;
-        return resolved;
-    }
-    async listRecoverableArchivedGoalIds() {
-        const stateManager = this.deps.stateManager;
-        if (typeof stateManager.getBaseDir !== "function")
-            return [];
-        const archiveDir = this.resolveStatePath(stateManager.getBaseDir(), "archive");
-        if (archiveDir === null)
-            return [];
-        let entries = [];
-        try {
-            entries = await fsp.readdir(archiveDir, { withFileTypes: true });
-        }
-        catch {
-            return [];
-        }
-        const goalIds = [];
-        for (const entry of entries) {
-            if (!entry.isDirectory() || entry.name === ".staging")
-                continue;
-            try {
-                await fsp.access(path.join(archiveDir, entry.name, "goal", "goal.json"));
-                goalIds.push(entry.name);
-            }
-            catch {
-                continue;
-            }
-        }
-        return goalIds;
-    }
-    activeGoals(goals) {
-        return goals.filter((goal) => goal.status === "active" || goal.status === "waiting" || goal.loop_status === "running");
-    }
-    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 readTasksFromDir(tasksDir) {
-        let entries = [];
-        try {
-            entries = await fsp.readdir(tasksDir);
-        }
-        catch {
-            return [];
-        }
-        const tasks = [];
-        for (const entry of entries) {
-            if (!entry.endsWith(".json") || entry === "task-history.json" || entry === "last-failure-context.json")
-                continue;
-            let raw;
-            try {
-                raw = JSON.parse(await fsp.readFile(path.join(tasksDir, entry), "utf-8"));
-            }
-            catch {
-                continue;
-            }
-            const parsed = TaskSchema.safeParse(raw);
-            if (parsed.success)
-                tasks.push(parsed.data);
-        }
-        return tasks.sort((a, b) => (a.created_at < b.created_at ? 1 : -1));
-    }
-    async readTasksForGoal(goalId) {
-        const stateManager = this.deps.stateManager;
-        if (typeof stateManager.getBaseDir !== "function")
-            return [];
-        const baseDir = stateManager.getBaseDir();
-        const activeTasksDir = this.resolveStatePath(baseDir, "tasks", goalId);
-        const archiveTasksDir = this.resolveStatePath(baseDir, "archive", goalId, "tasks");
-        if (activeTasksDir === null || archiveTasksDir === null)
-            return [];
-        const activeTasks = await this.readTasksFromDir(activeTasksDir);
-        if (activeTasks.length > 0)
-            return activeTasks;
-        return this.readTasksFromDir(archiveTasksDir);
-    }
-    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) {
-        const goalIds = goalId ? [goalId] : await this.listAllGoalIds();
-        const matches = [];
-        for (const candidateGoalId of goalIds) {
-            let raw = null;
-            try {
-                raw = await this.deps.stateManager.readRaw(`tasks/${candidateGoalId}/${taskId}.json`);
-            }
-            catch {
-                raw = null;
-            }
-            if (!raw) {
-                const tasks = await this.readTasksForGoal(candidateGoalId);
-                const matched = tasks.find((task) => task.id === taskId || task.id.startsWith(taskId));
-                if (matched)
-                    matches.push({ goalId: candidateGoalId, task: matched });
-                continue;
-            }
-            const parsed = TaskSchema.safeParse(raw);
-            if (parsed.success)
-                matches.push({ goalId: candidateGoalId, task: parsed.data });
-        }
-        return { task: matches.length === 1 ? matches[0].task : undefined, matches };
-    }
-    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 };
-    }
-    providerConfigBaseDir() {
-        const stateManager = this.deps.stateManager;
-        return typeof stateManager.getBaseDir === "function" ? stateManager.getBaseDir() : getPulseedDirPath();
-    }
-    async readProviderConfigSummary() {
-        const config = await loadProviderConfig({
-            baseDir: this.providerConfigBaseDir(),
-            saveMigration: false,
-        });
-        return {
-            provider: config.provider,
-            model: config.model,
-            adapter: config.adapter,
-            light_model: config.light_model,
-            base_url: config.base_url,
-            codex_cli_path: config.codex_cli_path,
-            has_api_key: Boolean(config.api_key),
-        };
-    }
-    formatConfig(config) {
-        return Object.entries(config)
-            .filter(([, value]) => value !== undefined)
-            .map(([key, value]) => `${key}: ${typeof value === "string" && /key|token|secret/i.test(key) ? "[masked]" : String(value)}`)
-            .join("\n");
-    }
-    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: summarizeExecutionPolicy(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: summarizeExecutionPolicy(nextPolicy),
-            elapsed_ms: Date.now() - start,
-        };
-    }
-    async handleReview(start) {
-        const cwd = this.sessionCwd ?? process.cwd();
-        const diffStat = await checkGitChanges(cwd);
-        const reviewPolicy = withExecutionPolicyOverrides(await this.getSessionExecutionPolicy(), {
-            sandboxMode: "read_only",
-            approvalPolicy: "never",
-        });
-        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),
-        ].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,
-            };
-        }
-        const { goalId, maxIterations } = pending;
-        let subscriber = null;
-        if (this.deps.daemonBaseUrl && !this.activeSubscribers.has(goalId)) {
-            subscriber = new EventSubscriber(this.deps.daemonBaseUrl, goalId, "normal");
-            this.activeSubscribers.set(goalId, subscriber);
-            subscriber.on("notification", (notification) => {
-                const n = notification;
-                this.deps.onNotification?.(n.message);
-                this.onNotification?.(n.message);
-            });
-            subscriber.on("chat_event", (event) => {
-                this.emitEvent(event);
-            });
-            try {
-                await subscriber.subscribeReady();
-            }
-            catch (err) {
-                subscriber.unsubscribe();
-                this.activeSubscribers.delete(goalId);
-                const msg = err instanceof Error ? err.message : String(err);
-                return {
-                    success: false,
-                    output: `Daemon event stream unavailable: ${msg}. Goal was not started.`,
-                    elapsed_ms: Date.now() - start,
-                };
-            }
-        }
-        try {
-            await this.deps.daemonClient.startGoal(goalId);
-        }
-        catch (err) {
-            if (subscriber) {
-                subscriber.unsubscribe();
-                this.activeSubscribers.delete(goalId);
-            }
-            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,
-            };
-        }
-        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, options = {}) {
-        const eventContext = this.createEventContext();
-        const resumeCommand = this.parseResumeCommand(input);
+        const eventContext = this.eventBridge.createEventContext();
+        const resolvedCwd = resolveGitRoot(cwd);
+        const activeTurn = this.eventBridge.beginActiveTurn(eventContext, resolvedCwd);
+        const resumeCommand = this.commandHandler.parseResumeCommand(input);
         const resumeOnly = resumeCommand !== null;
         const runtimeControlContext = options.runtimeControlContext ?? this.runtimeControlContext;
         const executionGoalId = options.goalId ?? this.deps.goalId;
-        // Intercept commands before any adapter call
-        const commandResult = resumeOnly ? null : await this.handleCommand(input);
+        const commandResult = resumeOnly ? null : await this.commandHandler.handleCommand(input, resolvedCwd);
         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;
+            return this.finalizeNonPersistentResult(commandResult, eventContext);
         }
-        // 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 confirmationResult = await this.commandHandler.handleTendConfirmation(input.trim(), Date.now());
+            return this.finalizeNonPersistentResult(confirmationResult, eventContext);
         }
         if (resumeOnly && resumeCommand.selector) {
             try {
+                const selectorResolution = await resolveChatResumeSelector(resumeCommand.selector, this.deps);
+                if (selectorResolution.nonResumableMessage) {
+                    return this.finalizeNonPersistentResult({
+                        success: false,
+                        output: selectorResolution.nonResumableMessage,
+                        elapsed_ms: 0,
+                    }, eventContext);
+                }
                 const catalog = new ChatSessionCatalog(this.deps.stateManager);
-                const session = await catalog.loadSessionBySelector(resumeCommand.selector);
+                const session = await catalog.loadSessionBySelector(selectorResolution.chatSelector);
                 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 };
+                    return this.finalizeNonPersistentResult({
+                        success: false,
+                        output: `No chat session matched selector "${selectorResolution.chatSelector}".`,
+                        elapsed_ms: 0,
+                    }, eventContext);
                 }
                 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 };
+                return this.finalizeNonPersistentResult({ success: false, output, elapsed_ms: 0 }, eventContext);
             }
         }
-        // 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.history = new ChatHistory(this.deps.stateManager, sessionId, resolvedCwd);
             this.nativeAgentLoopStatePath = `chat/agentloop/${sessionId}.state.json`;
-            this.history.setAgentLoopStatePath(this.nativeAgentLoopStatePath);
+            this.history.resetAgentLoopState(this.nativeAgentLoopStatePath);
         }
-        const executionCwd = this.sessionCwd ?? cwd;
-        const gitRoot = this.sessionCwd ?? resolveGitRoot(cwd);
-        // history is always assigned by this point (either by startSession or the block above)
+        const executionCwd = this.sessionCwd ?? resolvedCwd;
+        const gitRoot = this.sessionCwd ?? resolvedCwd;
+        activeTurn.cwd = gitRoot;
         const history = this.history;
-        this.emitEvent({
+        const pinnedReplyTarget = normalizePinnedReplyTarget(runtimeControlContext?.replyTarget ?? this.deps.runtimeReplyTarget ?? null);
+        if (pinnedReplyTarget) {
+            history.setNotificationReplyTarget(pinnedReplyTarget);
+        }
+        this.eventBridge.emitEvent({
             type: "lifecycle_start",
             input,
-            ...this.eventBase(eventContext),
+            ...this.eventBridge.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(this.providerConfigBaseDir());
@@ -1304,11 +262,9 @@ export class ChatRunner {
                 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}`);
@@ -1317,28 +273,26 @@ export class ChatRunner {
             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 historyBlock = historySections.length > 0 ? `${historySections.join("\n\n")}\n\nCurrent message:\n` : "";
         const selectedRoute = resumeOnly
             ? null
             : (options.selectedRoute ?? this.resolveRouteFromInput(input, runtimeControlContext));
-        const directPrompt = historyBlock ? `${historyBlock}${input}` : input;
+        this.lastSelectedRoute = selectedRoute;
+        this.eventBridge.emitIntent(input, selectedRoute, eventContext);
         const start = Date.now();
         const assistantBuffer = { text: "" };
-        const turnUsage = this.zeroUsageCounter();
         const identityResponse = resumeOnly ? null : resolveSelfIdentityResponse(input, this.providerConfigBaseDir());
         if (identityResponse !== null) {
             const elapsed_ms = Date.now() - start;
             await history.appendAssistantMessage(identityResponse);
-            this.emitActivity("lifecycle", "Finalizing response...", eventContext, "lifecycle:finalizing");
-            this.emitEvent({
+            this.eventBridge.emitActivity("lifecycle", "Finalizing response...", eventContext, "lifecycle:finalizing");
+            this.eventBridge.emitEvent({
                 type: "assistant_final",
                 text: identityResponse,
                 persisted: true,
-                ...this.eventBase(eventContext),
+                ...this.eventBridge.eventBase(eventContext),
             });
-            this.emitLifecycleEndEvent("completed", elapsed_ms, eventContext, true);
+            this.eventBridge.emitLifecycleEndEvent("completed", elapsed_ms, eventContext, true);
             return {
                 success: true,
                 output: identityResponse,
@@ -1346,78 +300,26 @@ export class ChatRunner {
             };
         }
         if (selectedRoute?.kind === "runtime_control") {
-            const runtimeControlResult = await this.executeRuntimeControlRoute(selectedRoute, runtimeControlContext, executionCwd, start);
+            this.eventBridge.emitCheckpoint("Runtime control selected", `${selectedRoute.intent.kind} request recognized.`, eventContext, "route");
+            const runtimeControlResult = await executeRuntimeControlRoute(this.routeHost(), selectedRoute, runtimeControlContext, executionCwd, start);
             if (runtimeControlResult.success) {
                 await history.appendAssistantMessage(runtimeControlResult.output);
-                this.emitActivity("lifecycle", "Finalizing response...", eventContext, "lifecycle:finalizing");
-                this.emitEvent({
+                this.eventBridge.emitCheckpoint("Runtime control completed", "The runtime-control operation produced a result.", eventContext, "complete");
+                this.eventBridge.emitActivity("lifecycle", "Finalizing response...", eventContext, "lifecycle:finalizing");
+                this.eventBridge.emitEvent({
                     type: "assistant_final",
                     text: runtimeControlResult.output,
                     persisted: true,
-                    ...this.eventBase(eventContext),
+                    ...this.eventBridge.eventBase(eventContext),
                 });
-                this.emitLifecycleEndEvent("completed", runtimeControlResult.elapsed_ms, eventContext, true);
+                this.eventBridge.emitLifecycleEndEvent("completed", runtimeControlResult.elapsed_ms, eventContext, true);
             }
             else {
-                this.emitLifecycleErrorEvent(runtimeControlResult.output, assistantBuffer.text, eventContext);
-                this.emitLifecycleEndEvent("error", runtimeControlResult.elapsed_ms, eventContext, false);
+                runtimeControlResult.output = this.eventBridge.emitLifecycleErrorEvent(runtimeControlResult.output, assistantBuffer.text, eventContext);
+                this.eventBridge.emitLifecycleEndEvent("error", runtimeControlResult.elapsed_ms, eventContext, false);
             }
             return runtimeControlResult;
         }
-        if (selectedRoute?.kind === "direct_answer") {
-            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: selectedRoute.modelTier,
-                    max_tokens: selectedRoute.maxTokens,
-                }, 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: selectedRoute.reason,
-                        modelTier: selectedRoute.modelTier,
-                        maxTokens: selectedRoute.maxTokens,
-                    },
-                };
-            }
-            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: selectedRoute.reason,
-                        modelTier: selectedRoute.modelTier,
-                        maxTokens: selectedRoute.maxTokens,
-                    },
-                };
-            }
-        }
         const usesNativeAgentLoop = resumeOnly || selectedRoute?.kind === "agent_loop";
         const groundingWorkspaceContext = !resumeOnly && usesNativeAgentLoop
             ? await buildChatContext(input, executionCwd)
@@ -1425,7 +327,7 @@ export class ChatRunner {
         let systemPrompt = this.cachedStaticSystemPrompt ?? "";
         if (!resumeOnly) {
             try {
-                this.emitActivity("lifecycle", "Preparing context...", eventContext, "lifecycle:context");
+                this.eventBridge.emitActivity("lifecycle", "Preparing context...", eventContext, "lifecycle:context");
                 if (usesNativeAgentLoop) {
                     systemPrompt = await buildChatAgentLoopSystemPrompt({
                         stateManager: this.deps.stateManager,
@@ -1453,6 +355,9 @@ export class ChatRunner {
             catch {
                 systemPrompt = this.cachedStaticSystemPrompt ?? "";
             }
+            this.eventBridge.emitCheckpoint("Context gathered", usesNativeAgentLoop
+                ? "Workspace and agent-loop grounding are ready."
+                : "Workspace grounding is ready.", eventContext, "context");
         }
         const agentLoopSystemPrompt = [
             systemPrompt,
@@ -1466,745 +371,108 @@ export class ChatRunner {
         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,
-            };
+            const output = this.eventBridge.emitLifecycleErrorEvent("Resume requires the native chat agentloop runtime.", assistantBuffer.text, eventContext);
+            this.eventBridge.emitLifecycleEndEvent("error", elapsed_ms, eventContext, false);
+            return { success: false, output, elapsed_ms };
         }
-        const chatAgentLoopRunner = this.deps.chatAgentLoopRunner;
         if (resumeOnly || selectedRoute?.kind === "agent_loop") {
-            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 chatAgentLoopRunner.execute({
-                    message: basePrompt,
-                    cwd: executionCwd,
-                    goalId: executionGoalId,
-                    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 = result.agentLoop?.usage
-                    ? 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 {
-                    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,
-                };
-            }
+            return executeAgentLoopRoute(this.routeHost(), {
+                resumeOnly,
+                executionCwd,
+                executionGoalId,
+                basePrompt,
+                priorTurns,
+                agentLoopSystemPrompt,
+                assistantBuffer,
+                eventContext,
+                history,
+                gitRoot,
+                activeAbortSignal: activeTurn.abortController.signal,
+                start,
+            });
         }
-        // Prefer the local LLM/tool loop over the external adapter fallback whenever a client is available.
         if (selectedRoute?.kind === "tool_loop") {
-            try {
-                const toolResult = await this.executeWithTools(prompt, eventContext, assistantBuffer, systemPrompt || undefined, executionGoalId);
-                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,
-                };
-            }
+            return executeToolLoopRoute(this.routeHost(), {
+                prompt,
+                eventContext,
+                assistantBuffer,
+                systemPrompt: systemPrompt || undefined,
+                executionGoalId,
+                history,
+                gitRoot,
+                start,
+            });
         }
         if (!resumeOnly && selectedRoute && selectedRoute.kind !== "adapter") {
             const elapsed_ms = Date.now() - start;
-            const output = `Unsupported chat route: ${selectedRoute.kind}`;
-            this.emitLifecycleErrorEvent(output, assistantBuffer.text, eventContext);
-            this.emitLifecycleEndEvent("error", elapsed_ms, eventContext, false);
-            return {
-                success: false,
-                output,
-                elapsed_ms,
-            };
+            const output = this.eventBridge.emitLifecycleErrorEvent(`Unsupported chat route: ${selectedRoute.kind}`, assistantBuffer.text, eventContext);
+            this.eventBridge.emitLifecycleEndEvent("error", elapsed_ms, eventContext, false);
+            return { success: false, output, elapsed_ms };
         }
-        const task = {
+        return executeAdapterRoute(this.routeHost(), {
             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 executeRuntimeControlRoute(route, runtimeControlContext, cwd, start) {
-        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 = runtimeControlContext?.replyTarget ?? this.deps.runtimeReplyTarget;
-        const actor = runtimeControlContext?.actor ?? this.deps.runtimeControlActor;
-        const result = await this.deps.runtimeControlService.request({
-            intent: route.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: runtimeControlContext?.approvalFn
-                ?? this.deps.runtimeControlApprovalFn
-                ?? this.deps.approvalFn,
+            timeoutMs,
+            systemPrompt: systemPrompt || undefined,
+            eventContext,
+            assistantBuffer,
+            gitRoot,
+            start,
+            history,
         });
-        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, goalId) {
-        const llmClient = this.deps.llmClient;
-        const messages = [{ role: "user", content: prompt }];
-        const toolCallContext = await this.buildToolCallContext(goalId);
-        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);
-            }
-            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}.`);
-            }
-            this.addUsageCounter(usage, this.usageFromLLMResponse(response));
-            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),
-                    });
-                }
-            },
-        };
+    getSessionCwd() {
+        return this.sessionCwd;
     }
-    parseAgentLoopPreview(preview) {
-        try {
-            const parsed = JSON.parse(preview);
-            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-                return parsed;
-            }
-        }
-        catch {
-            // fall through
-        }
-        return preview ? { preview } : {};
+    getNativeAgentLoopStatePath() {
+        return this.nativeAgentLoopStatePath;
     }
-    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 } : {};
+    setSessionExecutionPolicy(policy) {
+        this.sessionExecutionPolicy = policy;
     }
-    async loadResumableAgentLoopState() {
-        if (!this.nativeAgentLoopStatePath)
-            return null;
-        const raw = await this.deps.stateManager.readRaw(this.nativeAgentLoopStatePath);
-        if (!this.isAgentLoopSessionState(raw))
-            return null;
-        if (raw.status === "completed")
-            return null;
-        return {
-            ...raw,
-            messages: [...raw.messages],
-            calledTools: [...raw.calledTools],
-        };
+    async getSessionExecutionPolicy() {
+        const policy = await resolveSessionExecutionPolicy(this.sessionExecutionPolicy, this.sessionCwd);
+        this.sessionExecutionPolicy = policy;
+        return policy;
     }
-    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";
+    resolveRouteFromIngress(ingress) {
+        return standaloneIngressRouter.selectRoute(ingress, getRouteCapabilities(this.deps));
     }
-    /** 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}` });
-        }
+    resolveRouteFromInput(input, runtimeControlContext) {
+        return this.resolveRouteFromIngress(buildStandaloneIngressMessageFromContext(input, runtimeControlContext, this.deps));
     }
-    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;
+    loadedSessionToChatSession(session) {
+        return loadedSessionToChatSession(session);
     }
-    createEventContext() {
+    routeHost() {
         return {
-            runId: crypto.randomUUID(),
-            turnId: crypto.randomUUID(),
+            deps: this.deps,
+            eventBridge: this.eventBridge,
+            activatedTools: this.activatedTools,
+            getConversationSessionId: () => this.history?.getSessionId() ?? null,
+            getSessionCwd: () => this.sessionCwd,
+            getNativeAgentLoopStatePath: () => this.nativeAgentLoopStatePath,
+            getSessionExecutionPolicy: () => this.getSessionExecutionPolicy(),
+            setSessionExecutionPolicy: (policy) => { this.sessionExecutionPolicy = policy; },
         };
     }
-    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 config = await loadProviderConfig({ saveMigration: false });
-        this.sessionExecutionPolicy = resolveExecutionPolicy({
-            workspaceRoot: this.sessionCwd ?? process.cwd(),
-            security: config.agent_loop?.security,
-        });
-        return this.sessionExecutionPolicy;
+    providerConfigBaseDir() {
+        const stateManager = this.deps.stateManager;
+        return typeof stateManager.getBaseDir === "function" ? stateManager.getBaseDir() : getPulseedDirPath();
     }
-    async buildToolCallContext(goalId = this.deps.goalId) {
-        const executionPolicy = await this.getSessionExecutionPolicy();
-        return {
-            cwd: this.sessionCwd ?? process.cwd(),
-            goalId: goalId ?? "",
-            trustBalance: 0,
-            preApproved: false,
-            approvalFn: async (req) => {
-                if (this.deps.approvalFn) {
-                    return this.deps.approvalFn(req.reason);
-                }
-                return false;
-            },
-            executionPolicy,
-        };
+    finalizeNonPersistentResult(result, eventContext) {
+        if (result.output) {
+            this.eventBridge.emitEvent({
+                type: "assistant_final",
+                text: result.output,
+                persisted: false,
+                ...this.eventBridge.eventBase(eventContext),
+            });
+        }
+        this.eventBridge.emitLifecycleEndEvent(result.success ? "completed" : "error", result.elapsed_ms, eventContext, false);
+        return result;
     }
 }
+void COMMAND_HELP;
+void formatRoute;
 //# sourceMappingURL=chat-runner.js.map