@markusylisiurunen/tau 0.2.35 → 0.2.37

package/dist/tui/chat_controller.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { realpathSync, statSync } from "node:fs";
-import { mkdtemp, writeFile } from "node:fs/promises";
+import { mkdtemp, readFile, unlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, relative, resolve, sep } from "node:path";
 import { formatCodexAuthError } from "../core/auth/auth_messages.js";
@@ -8,11 +8,10 @@ import { getAuthPath } from "../core/auth/auth_paths.js";
 import { AuthStorage } from "../core/auth/auth_storage.js";
 import { createCredentialResolver, } from "../core/auth/credential_resolver.js";
 import { createCommandRegistry, getRiskLevelDescription, } from "../core/commands/index.js";
-import { createDefaultConfigDeps, loadRuntimeConfig, } from "../core/config/index.js";
+import { createDefaultConfigDeps, getMistralApiKey, loadRuntimeConfig, } from "../core/config/index.js";
+import { ChatRuntime } from "../core/runtime/chat_runtime.js";
 import { createDefaultCoreDeps } from "../core/runtime/deps.js";
 import { createCheckpoint } from "../core/session/checkpoint.js";
-import { CoreSession } from "../core/session/core_session.js";
-import { formatSubagentsForPrompt, getSubagentBasePrompt } from "../core/subagents/registry.js";
 import { buildBashUiText, formatBashUserMessageText, getBashOutputPolicy, prepareBashOutput, } from "../core/tools/bash.js";
 import { ToolCatalog } from "../core/tools/catalog.js";
 import { createLocalToolExecutionBackend } from "../core/tools/execution_backend.js";
@@ -20,7 +19,7 @@ import { TOOL_NAME_BASH, TOOL_NAME_EDIT } from "../core/tools/tool_names.js";
 import { REASONING_LEVELS, } from "../core/types.js";
 import { resolveAgentCwd, resolveSandboxPath } from "../core/utils/agent_environment.js";
 import { findAgentsFilesFromCwdToHome } from "../core/utils/agents_files.js";
-import { buildBaseSystemPrompt, buildEnvironmentTag, buildProjectContextBlock, buildSandboxInfoBlock, buildSkillsIndexBlock, findAgentsFilesInScopeDetailed, formatCwdChangeNotice, formatRiskLevelChangeNotice, } from "../core/utils/context.js";
+import { buildProjectContextBlock, buildSkillsIndexBlock, findAgentsFilesInScopeDetailed, formatCwdChangeNotice, formatRiskLevelChangeNotice, } from "../core/utils/context.js";
 import { formatAdaptiveNumber, formatCwd, formatTokenWindow } from "../core/utils/format.js";
 import { getGitRoot } from "../core/utils/git.js";
 import { buildLineDiff, collapseLongUnchangedDiffRuns } from "../core/utils/line_diff.js";
@@ -59,6 +58,11 @@ const PRUNED_EDIT_ARGUMENT_MARKER = "[content pruned]";
 const PRUNE_EDIT_UNCHANGED_CONTEXT_LINES = 4;
 const PRUNE_PREVIEW_MAX_TOKENS = 512;
 const PRUNE_MAX_OVERAGE_RATIO = 0.1;
+const SPEAK_TEMP_FILE_TEMPLATE = "/tmp/tau-speak.XXXXXX";
+const SPEAK_MISTRAL_TRANSCRIBE_MODEL = "voxtral-mini-latest";
+const SPEAK_RECORDING_MIN_BYTES = 1024;
+const SPEAK_RECORDING_MAX_DURATION_MS = 5 * 60 * 1000;
+const CAFFEINATE_COMMAND = "/usr/bin/caffeinate";
 export class ChatController {
     view;
     personas;
@@ -73,9 +77,11 @@ export class ChatController {
     credentialResolver;
     authPath;
     sandboxEnabled;
+    caffeinated;
     sandboxRootReal;
     agentCwd;
     includeAgentContext;
+    runtime;
     engine;
     commandRegistry;
     commandHandlers;
@@ -93,9 +99,9 @@ export class ChatController {
     showThinking = false;
     compactToolUi = true;
     commandHint;
+    assistantTurnInterruptRequested = false;
     currentTurnAbort;
     riskLevel = "read-only";
-    environmentTag = "";
     projectContextBlock;
     projectFiles = [];
     projectFilesCwd;
@@ -103,8 +109,6 @@ export class ChatController {
     isInFileAutocomplete = false;
     agentsFiles;
     agentsConfigErrors;
-    baseSystemPrompt = "";
-    subagentPrompts = {};
     pendingRiskLevelChange;
     pendingCwdChange;
     expandedFilesInCurrentPrompt = new Set();
@@ -114,6 +118,11 @@ export class ChatController {
     lastTurnDurationMs = 0;
     turnTimer;
     lastEmptySubmitAt;
+    speakRecording;
+    isTranscribingSpeak = false;
+    speakTransition;
+    turnCaffeinate;
+    disableCaffeinateForSession = false;
     constructor(options) {
         this.view = options.view;
         this.deps = options.deps ?? createDefaultCoreDeps();
@@ -129,7 +138,8 @@ export class ChatController {
         this.bashCommands = options.bashCommands ?? [];
         this.initialUserMessage = options.initialUserMessage;
         this.config = options.config ?? {};
-        this.sandboxEnabled = options.sandboxEnabled ?? false;
+        this.sandboxEnabled = options.sandboxEnabled;
+        this.caffeinated = options.caffeinated ?? false;
         this.sandboxRootReal = this.sandboxEnabled ? this.resolveSandboxRoot(cwd) : undefined;
         this.agentCwd = resolveAgentCwd({
             cwd,
@@ -175,7 +185,6 @@ export class ChatController {
             this.riskLevel = options.initialRiskLevel;
         }
         const skillsContext = this.getSkillsIndexBlockForPersona(this.currentPersona);
-        this.updateSystemPrompts(skillsContext.skillsBlock);
         this.toolBackend =
             options.toolBackend ??
                 createLocalToolExecutionBackend({
@@ -186,15 +195,26 @@ export class ChatController {
             throw new Error("sandbox enabled but tool backend is not sandboxed.");
         }
         const toolRegistry = ToolCatalog.createRegistry(this.toolBackend);
-        this.engine = new CoreSession({
+        this.runtime = ChatRuntime.create({
             persona: this.currentPersona,
-            systemPrompt: this.baseSystemPrompt,
-            subagentPrompts: this.subagentPrompts,
             riskLevel: this.riskLevel,
             toolRegistry,
+            promptContext: {
+                cwd: this.agentCwd,
+                projectContextBlock: this.projectContextBlock,
+                sandboxEnabled: this.sandboxEnabled,
+                sandboxEnvironmentInfo: this.config.sandbox?.environmentInfo,
+                skillsBlock: skillsContext.skillsBlock,
+            },
+            environment: {
+                now: () => this.deps.clock.now(),
+                platform: () => this.deps.env.platform(),
+                nodeVersion: () => this.deps.env.nodeVersion(),
+            },
             config: this.config,
             deps: this.deps,
         });
+        this.engine = this.runtime.session;
         this.subagentUnsubscribe = this.engine.onSubagentEvent((event) => this.onEvent(event));
         this.commandRegistry = createCommandRegistry();
         this.commandHandlers = {
@@ -211,6 +231,7 @@ export class ChatController {
             pruneLargest: (extra) => this.pruneToolResults("largest", extra),
             pruneSmart: (extra) => this.pruneToolResultsSmart(extra),
             reload: () => this.reloadContent(),
+            speak: () => this.toggleSpeakCapture(),
             risk: (level) => this.setRiskLevel(level),
             persona: (id) => this.switchPersona(id),
             prompt: (id) => this.insertPrompt(id),
@@ -263,6 +284,7 @@ export class ChatController {
             onCtrlR: () => this.cycleRiskLevel(),
             onCtrlP: () => this.cyclePersonality(),
             onCtrlS: () => void this.stashEditorToClipboard(),
+            onCtrlY: () => void this.toggleSpeakCapture(),
             onEscape: () => this.onInterrupt(),
             onCtrlF: () => {
                 this.expandFileMentions().catch((err) => {
@@ -284,6 +306,11 @@ export class ChatController {
     }
     async dispose() {
         this.subagentUnsubscribe?.();
+        if (this.speakTransition) {
+            await this.speakTransition;
+        }
+        await this.cancelSpeakCapture();
+        await this.stopTurnCaffeinate();
         if (!this.toolBackendDispose)
             return;
         await this.toolBackendDispose();
@@ -293,6 +320,10 @@ export class ChatController {
         await this.handleSubmit(text);
     }
     onInterrupt() {
+        if (this.speakRecording) {
+            void this.runSpeakTransition(() => this.stopSpeakCapture());
+            return;
+        }
         this.interruptAssistantTurn();
     }
     onEvent(event) {
@@ -444,6 +475,8 @@ export class ChatController {
         });
     }
     getInputMode() {
+        if (this.speakRecording)
+            return "recording";
         if (this.isBashIncognito)
             return "bash_incognito";
         if (this.isBashMode)
@@ -760,13 +793,25 @@ export class ChatController {
         });
     }
     interruptAssistantTurn() {
-        if (!this.isStreaming || this.currentTurnAbort?.signal.aborted)
+        if (!this.isStreaming)
+            return;
+        if (this.runtime.isTurnRunning) {
+            if (this.assistantTurnInterruptRequested)
+                return;
+            this.assistantTurnInterruptRequested = true;
+            this.runtime.interruptTurn();
+            this.view.addSystemMessage("interrupted", "error");
+            return;
+        }
+        if (this.currentTurnAbort?.signal.aborted)
             return;
         this.currentTurnAbort?.abort();
         this.view.addSystemMessage("interrupted", "error");
     }
     // Input Handling --------------------------------------------------------------------------------
     beforeSubmit(text) {
+        if (this.speakRecording)
+            return false;
         if (!this.isStreaming)
             return true;
         const trimmed = text.trimStart();
@@ -853,6 +898,8 @@ export class ChatController {
                 return "prune smart-selected tool results and compact edit calls, optional fraction and guidance";
             case "reload":
                 return "reload prompts, skills, themes, bash commands, and AGENTS.md";
+            case "speak":
+                return "toggle microphone recording and transcribe to editor";
             case "risk":
                 return "set risk level: /risk:read-only or /risk:read-write";
             case "bash":
@@ -1089,6 +1136,258 @@ export class ChatController {
         this.view.addMessage({ type: "user", text: trimmed }, historyEntryId);
         await this.runAssistantTurn();
     }
+    async toggleSpeakCapture() {
+        if (this.speakTransition) {
+            this.view.addSystemMessage("speech recording state change already in progress", "warn");
+            return;
+        }
+        if (this.speakRecording) {
+            await this.runSpeakTransition(() => this.stopSpeakCapture());
+            return;
+        }
+        if (this.isTranscribingSpeak) {
+            this.view.addSystemMessage("speech transcription already in progress", "warn");
+            return;
+        }
+        if (this.isStreaming) {
+            this.view.addSystemMessage("wait for the assistant to finish before recording", "warn");
+            return;
+        }
+        await this.runSpeakTransition(() => this.startSpeakCapture());
+    }
+    async runSpeakTransition(task) {
+        if (this.speakTransition) {
+            return;
+        }
+        const transition = task();
+        this.speakTransition = transition;
+        try {
+            await transition;
+        }
+        finally {
+            if (this.speakTransition === transition) {
+                this.speakTransition = undefined;
+            }
+        }
+    }
+    async startSpeakCapture() {
+        const apiKey = getMistralApiKey(this.config, this.deps.env.env());
+        if (!apiKey) {
+            this.view.addSystemMessage("set MISTRAL_API_KEY or apiKeys.mistral to use /speak", "error");
+            return;
+        }
+        let audioPath;
+        try {
+            audioPath = await this.createSpeakTempFilePath();
+            const abortController = new AbortController();
+            const completion = this.deps.spawn("ffmpeg", [
+                "-hide_banner",
+                "-loglevel",
+                "error",
+                "-nostdin",
+                "-f",
+                "avfoundation",
+                "-i",
+                ":0",
+                "-ac",
+                "1",
+                "-ar",
+                "16000",
+                "-c:a",
+                "pcm_s16le",
+                "-f",
+                "wav",
+                "-y",
+                audioPath,
+            ], {
+                detached: true,
+                killProcessGroup: true,
+                signal: abortController.signal,
+                stdio: ["ignore", "ignore", "ignore"],
+            });
+            const recording = {
+                audioPath,
+                stopRequested: false,
+                abortController,
+                completion,
+            };
+            recording.maxDurationTimeout = setTimeout(() => {
+                if (this.speakRecording !== recording || this.speakTransition)
+                    return;
+                void this.runSpeakTransition(() => this.stopSpeakCapture());
+            }, SPEAK_RECORDING_MAX_DURATION_MS);
+            this.speakRecording = recording;
+            this.view.setEditorInputEnabled(false);
+            this.refreshStatus();
+            void this.watchSpeakRecording(recording);
+        }
+        catch (err) {
+            if (audioPath) {
+                await this.cleanupSpeakTempFile(audioPath);
+            }
+            this.view.addSystemMessage(`failed to start recording: ${err.message}`, "error");
+        }
+    }
+    async stopSpeakCapture() {
+        const recording = this.speakRecording;
+        if (!recording)
+            return;
+        recording.stopRequested = true;
+        this.clearSpeakRecordingMaxDurationTimeout(recording);
+        this.speakRecording = undefined;
+        this.view.setEditorInputEnabled(true);
+        this.refreshStatus();
+        recording.abortController.abort();
+        try {
+            await recording.completion;
+        }
+        catch (err) {
+            this.view.addSystemMessage(`recording failed: ${err.message}`, "error");
+            await this.cleanupSpeakTempFile(recording.audioPath);
+            return;
+        }
+        this.isTranscribingSpeak = true;
+        try {
+            const audio = await readFile(recording.audioPath);
+            if (audio.byteLength < SPEAK_RECORDING_MIN_BYTES) {
+                this.view.addSystemMessage("recording too short, try again", "warn");
+                return;
+            }
+            const transcript = await this.transcribeSpeakAudio(audio);
+            const text = transcript.trim();
+            if (!text) {
+                return;
+            }
+            this.view.insertEditorTextAtCursor(text);
+        }
+        catch (err) {
+            this.view.addSystemMessage(`speech transcription failed: ${err.message}`, "error");
+        }
+        finally {
+            this.isTranscribingSpeak = false;
+            await this.cleanupSpeakTempFile(recording.audioPath);
+        }
+    }
+    async cancelSpeakCapture() {
+        const recording = this.speakRecording;
+        if (!recording)
+            return;
+        recording.stopRequested = true;
+        this.clearSpeakRecordingMaxDurationTimeout(recording);
+        this.speakRecording = undefined;
+        this.view.setEditorInputEnabled(true);
+        this.refreshStatus();
+        recording.abortController.abort();
+        try {
+            await recording.completion;
+        }
+        catch {
+            // ignore disposal errors
+        }
+        await this.cleanupSpeakTempFile(recording.audioPath);
+    }
+    async watchSpeakRecording(recording) {
+        try {
+            const result = await recording.completion;
+            this.clearSpeakRecordingMaxDurationTimeout(recording);
+            if (this.speakRecording !== recording || recording.stopRequested)
+                return;
+            this.speakRecording = undefined;
+            this.view.setEditorInputEnabled(true);
+            this.refreshStatus();
+            const detail = result.exitCode !== null
+                ? `ffmpeg exited with code ${result.exitCode}`
+                : result.closeSignal
+                    ? `ffmpeg terminated by signal ${result.closeSignal}`
+                    : "ffmpeg exited";
+            this.view.addSystemMessage(`recording stopped unexpectedly (${detail})`, "error");
+            await this.cleanupSpeakTempFile(recording.audioPath);
+        }
+        catch (err) {
+            this.clearSpeakRecordingMaxDurationTimeout(recording);
+            if (this.speakRecording !== recording || recording.stopRequested)
+                return;
+            this.speakRecording = undefined;
+            this.view.setEditorInputEnabled(true);
+            this.refreshStatus();
+            const error = err;
+            if (error.code === "ENOENT") {
+                this.view.addSystemMessage("ffmpeg not found. install it with: brew install ffmpeg", "error");
+            }
+            else {
+                this.view.addSystemMessage(`recording failed: ${error.message}`, "error");
+            }
+            await this.cleanupSpeakTempFile(recording.audioPath);
+        }
+    }
+    clearSpeakRecordingMaxDurationTimeout(recording) {
+        if (!recording.maxDurationTimeout)
+            return;
+        clearTimeout(recording.maxDurationTimeout);
+        recording.maxDurationTimeout = undefined;
+    }
+    async createSpeakTempFilePath() {
+        const result = await this.deps.spawn("mktemp", [SPEAK_TEMP_FILE_TEMPLATE]);
+        if (result.exitCode !== 0) {
+            const message = result.stderr.trim() || result.stdout.trim() || "mktemp failed";
+            throw new Error(message);
+        }
+        const path = result.stdout.trim().split(/\r?\n/, 1)[0]?.trim();
+        if (!path) {
+            throw new Error("mktemp returned an empty path");
+        }
+        return path;
+    }
+    async transcribeSpeakAudio(audio) {
+        const apiKey = getMistralApiKey(this.config, this.deps.env.env());
+        if (!apiKey) {
+            throw new Error("missing MISTRAL_API_KEY or apiKeys.mistral");
+        }
+        const formData = new FormData();
+        formData.append("model", SPEAK_MISTRAL_TRANSCRIBE_MODEL);
+        formData.append("file", new Blob([audio], { type: "audio/wav" }), "speech.wav");
+        formData.append("language", "en");
+        const response = await fetch("https://api.mistral.ai/v1/audio/transcriptions", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: formData,
+        });
+        let payload;
+        const responseText = await response.text();
+        if (responseText) {
+            try {
+                payload = JSON.parse(responseText);
+            }
+            catch {
+                payload = undefined;
+            }
+        }
+        if (!response.ok) {
+            const fromObject = payload && typeof payload === "object" && "message" in payload
+                ? payload.message
+                : undefined;
+            const fromString = typeof fromObject === "string" ? fromObject : undefined;
+            const fallback = responseText.trim() || `HTTP ${response.status}`;
+            throw new Error(fromString || fallback);
+        }
+        const text = payload && typeof payload === "object" && "text" in payload
+            ? payload.text
+            : undefined;
+        if (typeof text !== "string") {
+            return "";
+        }
+        return text;
+    }
+    async cleanupSpeakTempFile(path) {
+        try {
+            await unlink(path);
+        }
+        catch {
+            // best-effort cleanup
+        }
+    }
     getMemoryModeFilePath() {
         const cwd = this.deps.env.cwd();
         const home = this.deps.env.home();
@@ -1280,86 +1579,23 @@ export class ChatController {
     escapeXmlAttribute(text) {
         return this.escapeXml(text).replace(/"/g, "&quot;").replace(/'/g, "&apos;");
     }
-    updateSystemPrompts(skillsBlock) {
-        const timestamp = new Date(this.deps.clock.now()).toISOString();
-        this.environmentTag = buildEnvironmentTag({
-            riskLevel: this.riskLevel,
+    syncRuntimePromptContext() {
+        this.runtime.updatePromptContext({
             cwd: this.agentCwd,
-            datetime: timestamp,
-            platform: this.deps.env.platform(),
-            nodeVersion: this.deps.env.nodeVersion(),
-        });
-        const resolvedSkillsBlock = skillsBlock ?? this.getSkillsIndexBlockForPersona(this.currentPersona).skillsBlock;
-        this.baseSystemPrompt = this.buildSystemPrompt({
-            persona: this.currentPersona,
-            skillsBlock: resolvedSkillsBlock,
-        });
-        this.subagentPrompts = this.buildSubagentPromptMap({
-            persona: this.currentPersona,
-            skillsBlock: resolvedSkillsBlock,
-            timestamp,
-        });
-    }
-    updateSubagentPrompts(skillsBlock) {
-        const timestamp = new Date(this.deps.clock.now()).toISOString();
-        const resolvedSkillsBlock = skillsBlock ?? this.getSkillsIndexBlockForPersona(this.currentPersona).skillsBlock;
-        this.subagentPrompts = this.buildSubagentPromptMap({
-            persona: this.currentPersona,
-            skillsBlock: resolvedSkillsBlock,
-            timestamp,
+            projectContextBlock: this.projectContextBlock,
+            sandboxEnabled: this.sandboxEnabled,
+            sandboxEnvironmentInfo: this.config.sandbox?.environmentInfo,
         });
     }
     rebuildSystemPrompt(skillsBlock) {
-        this.updateSystemPrompts(skillsBlock);
-        this.engine.setPersona(this.currentPersona, this.baseSystemPrompt, this.subagentPrompts);
+        const resolvedSkillsBlock = skillsBlock ?? this.getSkillsIndexBlockForPersona(this.currentPersona).skillsBlock;
+        this.syncRuntimePromptContext();
+        this.runtime.setPersona(this.currentPersona, { skillsBlock: resolvedSkillsBlock });
     }
     rebuildSubagentPrompts(skillsBlock) {
-        this.updateSubagentPrompts(skillsBlock);
-        this.engine.setPersona(this.currentPersona, this.baseSystemPrompt, this.subagentPrompts);
-    }
-    buildSystemPrompt(args) {
-        return buildBaseSystemPrompt({
-            personaSystemPrompt: args.persona.systemPrompt,
-            skillsBlock: args.skillsBlock,
-            projectContextBlock: this.projectContextBlock,
-            sandboxInfoBlock: this.sandboxEnabled
-                ? buildSandboxInfoBlock(this.config.sandbox?.environmentInfo)
-                : undefined,
-            environmentTag: this.environmentTag,
-            subagentsBlock: formatSubagentsForPrompt(args.persona),
-        });
-    }
-    buildSubagentPromptMap(args) {
-        const subagents = args.persona.subagents;
-        if (!subagents || Object.keys(subagents).length === 0) {
-            return {};
-        }
-        const sandboxInfoBlock = this.sandboxEnabled
-            ? buildSandboxInfoBlock(this.config.sandbox?.environmentInfo)
-            : undefined;
-        const prompts = {};
-        for (const [name, cfg] of Object.entries(subagents)) {
-            if (!cfg)
-                continue;
-            const basePrompt = getSubagentBasePrompt(name, cfg);
-            if (!basePrompt)
-                continue;
-            const environmentTag = buildEnvironmentTag({
-                riskLevel: cfg.riskLevel ?? this.riskLevel,
-                cwd: this.agentCwd,
-                datetime: args.timestamp,
-                platform: this.deps.env.platform(),
-                nodeVersion: this.deps.env.nodeVersion(),
-            });
-            prompts[name] = buildBaseSystemPrompt({
-                personaSystemPrompt: basePrompt,
-                skillsBlock: args.skillsBlock,
-                projectContextBlock: this.projectContextBlock,
-                sandboxInfoBlock,
-                environmentTag,
-            });
-        }
-        return prompts;
+        const resolvedSkillsBlock = skillsBlock ?? this.getSkillsIndexBlockForPersona(this.currentPersona).skillsBlock;
+        this.syncRuntimePromptContext();
+        this.runtime.rebuildSubagentPrompts({ skillsBlock: resolvedSkillsBlock });
     }
     applyCompactedHistoryUi(compactionMessage) {
         this.view.resetToolUiSession();
@@ -2181,10 +2417,10 @@ export class ChatController {
     setRiskLevel(level, options) {
         const previous = this.riskLevel;
         this.riskLevel = level;
-        this.engine.setRiskLevel(level);
+        this.syncRuntimePromptContext();
+        this.runtime.setRiskLevel(level);
         this.refreshStatus();
         if (previous !== level) {
-            this.rebuildSubagentPrompts();
             const from = this.pendingRiskLevelChange?.from ?? previous;
             if (from === level) {
                 this.pendingRiskLevelChange = undefined;
@@ -2271,7 +2507,7 @@ export class ChatController {
         const previousThemeId = this.activeThemeId ?? this.config.defaultTheme;
         const messages = [];
         this.config = runtime.config;
-        this.engine.setConfig(this.config);
+        this.runtime.setConfig(this.config);
         if (plan.bashCommands) {
             this.bashCommands = runtime.bashCommands;
         }
@@ -2390,36 +2626,77 @@ export class ChatController {
             this.view.addSystemMessage(`reload failed: ${err.message}`, "error");
         }
     }
+    startTurnCaffeinate() {
+        if (!this.caffeinated || this.disableCaffeinateForSession || this.turnCaffeinate) {
+            return;
+        }
+        if (this.deps.env.platform() !== "darwin") {
+            this.disableCaffeinateForSession = true;
+            this.view.addSystemMessage("--caffeinated is only supported on macOS.", "warn");
+            return;
+        }
+        const abortController = new AbortController();
+        const completion = this.deps.spawn(CAFFEINATE_COMMAND, ["-i"], {
+            detached: true,
+            killProcessGroup: true,
+            signal: abortController.signal,
+            stdio: ["ignore", "ignore", "ignore"],
+        });
+        completion.catch(() => { });
+        this.turnCaffeinate = {
+            abortController,
+            completion,
+        };
+    }
+    async stopTurnCaffeinate() {
+        const session = this.turnCaffeinate;
+        if (!session)
+            return;
+        this.turnCaffeinate = undefined;
+        if (!session.abortController.signal.aborted) {
+            session.abortController.abort();
+        }
+        try {
+            await session.completion;
+        }
+        catch (err) {
+            if (this.disableCaffeinateForSession) {
+                return;
+            }
+            this.disableCaffeinateForSession = true;
+            const error = err;
+            const details = error.message || "unknown error";
+            this.view.addSystemMessage(`failed to run caffeinate: ${details}`, "warn");
+        }
+    }
     // Assistant Turn --------------------------------------------------------------------------------
     async runAssistantTurn() {
         this.isStreaming = true;
-        this.currentTurnAbort = new AbortController();
         this.view.startWorkingIcon();
         this.startTurnTimer();
         this.assistantState = undefined;
+        this.assistantTurnInterruptRequested = false;
+        this.startTurnCaffeinate();
+        let runResult = { aborted: false };
         try {
-            for await (const event of this.engine.events(this.currentTurnAbort.signal)) {
-                if (this.currentTurnAbort.signal.aborted)
-                    break;
-                this.onEvent(event);
-            }
+            runResult = await this.runtime.runTurn((event) => this.onEvent(event));
         }
         catch (err) {
             const message = err.message || "request failed";
             this.view.addSystemMessage(message, "error");
         }
         finally {
-            const wasAborted = this.currentTurnAbort?.signal.aborted ?? false;
-            const reason = wasAborted ? "aborted" : "interrupted";
+            await this.stopTurnCaffeinate();
+            const reason = runResult.aborted ? "aborted" : "interrupted";
             this.view.finalizeToolUiPending(reason);
             this.view.stopWorkingIcon();
             this.stopTurnTimer();
             this.isStreaming = false;
-            this.currentTurnAbort = undefined;
+            this.assistantTurnInterruptRequested = false;
             this.view.clearToolUiTransientState();
             this.pendingIdleNotification = true;
             this.view.requestRender();
-            if (wasAborted) {
+            if (runResult.aborted) {
                 this.dequeueQueuedUserMessagesIntoEditor();
             }
             else {