@markusylisiurunen/tau 0.2.102 → 0.2.104

package/dist/tui/chat_controller.js

@@ -1,8 +1,8 @@
 import { randomUUID } from "node:crypto";
-import { realpathSync, statSync } from "node:fs";
+import { statSync } from "node:fs";
 import { mkdtemp, readFile, unlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { dirname, join, relative, resolve, sep } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { z } from "zod";
 import { formatCodexAuthError } from "../core/auth/auth_messages.js";
 import { getAuthPath } from "../core/auth/auth_paths.js";
@@ -19,11 +19,10 @@ import { buildBashUiText, formatBashUserMessageText, getBashOutputPolicy, prepar
 import { ToolCatalog } from "../core/tools/catalog.js";
 import { createLocalToolExecutionBackend } from "../core/tools/execution_backend.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 { formatCwdChangeNotice, formatProjectContextChangeNotice, formatRiskLevelChangeNotice, } from "../core/utils/context.js";
 import { formatAdaptiveNumber, formatCwd, formatPathForDisplay, formatTokenWindow, } from "../core/utils/format.js";
-import { getGitRoot } from "../core/utils/git.js";
+import { generateGeminiSpeech } from "../core/utils/gemini_speech.js";
 import { extractAllFencedCodeBlocks, extractAssistantText } from "../core/utils/messages.js";
 import { transcribeMistralAudio } from "../core/utils/mistral_transcription.js";
 import { streamModel } from "../core/utils/model_stream.js";
@@ -55,9 +54,11 @@ const RELOAD_PLANS = {
     },
 };
 const ALLOWED_RISK_LEVELS = ["read-only", "read-write"];
+const LISTEN_TEMP_FILE_TEMPLATE = "/tmp/tau-listen.XXXXXX";
 const SPEAK_TEMP_FILE_TEMPLATE = "/tmp/tau-speak.XXXXXX";
-const SPEAK_RECORDING_MIN_BYTES = 1024;
-const SPEAK_RECORDING_MAX_DURATION_MS = 5 * 60 * 1000;
+const LISTEN_RECORDING_MIN_BYTES = 1024;
+const LISTEN_RECORDING_MAX_DURATION_MS = 5 * 60 * 1000;
+const SPEAK_PLAYBACK_RATE = 1.4;
 const CAFFEINATE_COMMAND = "/usr/bin/caffeinate";
 const SmartPruneResponseSchema = z.object({
     prune: z.array(z.string().trim().min(1)),
@@ -76,9 +77,7 @@ export class ChatController {
     activeThemeId;
     credentialResolver;
     authPath;
-    sandboxEnabled;
     caffeinated;
-    sandboxRootReal;
     agentCwd;
     includeAgentContext;
     runtime;
@@ -86,7 +85,6 @@ export class ChatController {
     commandRegistry;
     commandHandlers;
     toolBackend;
-    toolBackendDispose;
     deps;
     eventUnsubscribe;
     isStreaming = false;
@@ -100,6 +98,7 @@ export class ChatController {
     showThinking = false;
     compactToolUi = true;
     commandHint;
+    speechStatusHint;
     riskLevel = "read-only";
     projectContextBlock;
     projectFiles = [];
@@ -118,9 +117,10 @@ export class ChatController {
     lastTurnDurationMs = 0;
     turnTimer;
     lastEmptySubmitAt;
-    speakRecording;
-    isTranscribingSpeak = false;
-    speakTransition;
+    listenRecording;
+    isTranscribingListen = false;
+    listenTransition;
+    speakTask;
     turnCaffeinate;
     disableCaffeinateForSession = false;
     constructor(options) {
@@ -139,9 +139,7 @@ export class ChatController {
         this.initialUserMessage = options.initialUserMessage;
         this.config = options.config ?? {};
         this.defaultDiffTool = options.defaultDiffTool;
-        this.sandboxEnabled = options.sandboxEnabled;
         this.caffeinated = options.caffeinated ?? false;
-        this.sandboxRootReal = this.sandboxEnabled ? this.resolveSandboxRoot(cwd) : undefined;
         this.activeThemeId = this.config.defaultTheme;
         this.authPath = getAuthPath(this.deps.env.home());
         const authStorage = new AuthStorage(this.authPath);
@@ -153,7 +151,6 @@ export class ChatController {
         const queuedUserMessages = options.queuedUserMessages ?? [];
         this.queuedMessageBuffer = new QueuedUserMessages(queuedUserMessages);
         this.interruptLifecycle = new InterruptLifecycle();
-        this.toolBackendDispose = options.toolBackendDispose;
         this.includeAgentContext = !options.noAgentContextFiles;
         const initialPersona = (options.initialPersonaId &&
             this.personas.find((p) => p.id.toLowerCase() === options.initialPersonaId.toLowerCase())) ||
@@ -175,10 +172,6 @@ export class ChatController {
             cwd,
             home,
             includeAgentContext: this.includeAgentContext,
-            sandboxEnabled: this.sandboxEnabled,
-            sandboxConfig: this.config.sandbox,
-            sandboxHostRoot: this.sandboxRootReal,
-            sandboxEnvironmentInfo: this.config.sandbox?.environmentInfo,
             readFile: this.deps.fs.readFile,
         });
         this.agentCwd = startupBootstrap.promptContext.cwd;
@@ -194,9 +187,6 @@ export class ChatController {
                     spawn: this.deps.spawn,
                     env: this.deps.env,
                 });
-        if (this.sandboxEnabled && this.toolBackend.kind !== "sandbox") {
-            throw new Error("sandbox enabled but tool backend is not sandboxed.");
-        }
         const toolRegistry = ToolCatalog.createRegistry(this.toolBackend);
         this.runtime = ChatRuntime.create({
             persona: this.currentPersona,
@@ -249,7 +239,8 @@ export class ChatController {
             pruneLargest: (extra) => this.pruneToolResults("largest", extra),
             pruneSmart: (extra) => this.pruneToolResultsSmart(extra),
             reload: () => this.reloadContent(),
-            speak: () => this.toggleSpeakCapture(),
+            listen: () => this.startListenCaptureFromCommand(),
+            speak: () => this.speakLastAssistantMessage(),
             risk: (level) => this.setRiskLevel(level),
             persona: (id) => this.switchPersona(id),
             prompt: (id) => this.insertPrompt(id),
@@ -296,7 +287,7 @@ export class ChatController {
             onCtrlR: () => this.cycleRiskLevel(),
             onCtrlP: () => this.cyclePersonality(),
             onCtrlS: () => void this.stashEditorToClipboard(),
-            onCtrlY: () => void this.toggleSpeakCapture(),
+            onCtrlY: () => void this.toggleListenCapture(),
             onEscape: () => this.onInterrupt(),
             onCtrlF: () => {
                 this.expandFileMentions().catch((err) => {
@@ -318,23 +309,31 @@ export class ChatController {
     }
     async dispose() {
         this.eventUnsubscribe?.();
-        if (this.speakTransition) {
-            await this.speakTransition;
+        if (this.listenTransition) {
+            await this.listenTransition;
+        }
+        if (this.speakTask) {
+            this.speakTask.abortController.abort();
+            await this.speakTask.completion;
         }
         await this.cancelDiffReview();
-        await this.cancelSpeakCapture();
+        await this.cancelListenCapture();
         await this.stopTurnCaffeinate();
-        if (!this.toolBackendDispose)
-            return;
-        await this.toolBackendDispose();
     }
     // Mode Adapter ---------------------------------------------------------------------------------
     async onUserInput(text) {
         await this.handleSubmit(text);
     }
     onInterrupt() {
-        if (this.speakRecording) {
-            void this.runSpeakTransition(() => this.stopSpeakCapture());
+        if (this.listenRecording) {
+            void this.runListenTransition(() => this.stopListenCapture());
+            return;
+        }
+        if (this.speakTask) {
+            if (!this.speakTask.abortController.signal.aborted) {
+                this.speakTask.abortController.abort();
+                this.view.addSystemMessage("interrupted", "error");
+            }
             return;
         }
         this.interruptActiveTask();
@@ -491,7 +490,6 @@ export class ChatController {
                 sessionCost,
                 duration,
                 riskLevel: this.riskLevel,
-                sandboxed: this.sandboxEnabled,
                 commandHint: this.getActiveCommandHint(),
             },
             editor: {
@@ -504,7 +502,7 @@ export class ChatController {
         });
     }
     getInputMode() {
-        if (this.speakRecording)
+        if (this.listenRecording)
             return "recording";
         if (this.isBashIncognito)
             return "bash_incognito";
@@ -515,7 +513,7 @@ export class ChatController {
         return "normal";
     }
     getActiveCommandHint() {
-        return this.diffReviewService.getCommandHint(this.commandHint);
+        return this.diffReviewService.getCommandHint(this.speechStatusHint ?? this.commandHint);
     }
     // Context & Cost Tracking -----------------------------------------------------------------------
     getContextUsageString() {
@@ -674,10 +672,6 @@ export class ChatController {
         const resolved = resolvePersonaSkillsForPromptContext({
             persona,
             discoveredSkills: this.skills,
-            cwd: this.deps.env.cwd(),
-            sandboxEnabled: this.sandboxEnabled,
-            sandboxConfig: this.config.sandbox,
-            sandboxHostRoot: this.sandboxRootReal,
         });
         return { skillsBlock: resolved.skillsBlock, unknown: resolved.unknown };
     }
@@ -724,10 +718,6 @@ export class ChatController {
             this.view.addSystemMessage(`not a directory: ${normalized}`, "error");
             return;
         }
-        if (this.sandboxEnabled && !this.isPathWithinSandboxRoot(resolved)) {
-            this.view.addSystemMessage(`directory is outside the sandbox mount: ${normalized}`, "error");
-            return;
-        }
         try {
             process.chdir(resolved);
         }
@@ -738,18 +728,7 @@ export class ChatController {
         const nextCwd = this.deps.env.cwd();
         const previousAgentCwd = this.agentCwd;
         const previousProjectContextBlock = this.projectContextBlock;
-        this.agentCwd =
-            this.sandboxEnabled && this.sandboxRootReal
-                ? resolveSandboxPath({
-                    hostPath: nextCwd,
-                    cwd: this.sandboxRootReal,
-                    sandboxConfig: this.config.sandbox,
-                })
-                : resolveAgentCwd({
-                    cwd: nextCwd,
-                    sandboxEnabled: this.sandboxEnabled,
-                    sandboxConfig: this.config.sandbox,
-                });
+        this.agentCwd = nextCwd;
         this.refreshProjectContext(nextCwd);
         this.updatePendingProjectContextChange(previousProjectContextBlock, this.projectContextBlock);
         this.projectFiles = [];
@@ -784,36 +763,11 @@ export class ChatController {
             return join(home, input.slice(2));
         return resolve(cwd, input);
     }
-    resolveSandboxRoot(cwd) {
-        try {
-            const root = getGitRoot(cwd) ?? cwd;
-            return realpathSync(root);
-        }
-        catch {
-            return undefined;
-        }
-    }
-    isPathWithinSandboxRoot(targetPath) {
-        if (!this.sandboxRootReal)
-            return true;
-        let resolved = targetPath;
-        try {
-            resolved = realpathSync(targetPath);
-        }
-        catch {
-            // fall back to provided path
-        }
-        const rel = relative(this.sandboxRootReal, resolved);
-        return !(rel === ".." || rel.startsWith(`..${sep}`));
-    }
     refreshProjectContext(cwd) {
         const projectContext = resolveProjectContextForPromptContext({
             cwd,
             home: this.deps.env.home(),
             includeAgentContext: this.includeAgentContext,
-            sandboxEnabled: this.sandboxEnabled,
-            sandboxConfig: this.config.sandbox,
-            sandboxHostRoot: this.sandboxRootReal,
             readFile: this.deps.fs.readFile,
         });
         this.agentsFiles = projectContext.agentsFiles;
@@ -880,7 +834,7 @@ export class ChatController {
     }
     // Input Handling --------------------------------------------------------------------------------
     beforeSubmit(text) {
-        if (this.speakRecording)
+        if (this.listenRecording)
             return false;
         if (!this.isStreaming)
             return true;
@@ -970,8 +924,10 @@ 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 "listen":
+                return "start microphone recording and transcribe to editor (macOS only)";
             case "speak":
-                return "toggle microphone recording and transcribe to editor (macOS only)";
+                return "speak the last assistant message aloud (macOS only)";
             case "risk":
                 return "set risk level: /risk:read-only or /risk:read-write";
             case "bash":
@@ -1212,16 +1168,27 @@ export class ChatController {
         this.view.addMessage({ type: "user", text: trimmed }, historyEntryId);
         await this.runAssistantTurn();
     }
-    async toggleSpeakCapture() {
-        if (this.speakTransition) {
+    async toggleListenCapture() {
+        if (this.listenTransition) {
+            this.view.addSystemMessage("speech recording state change already in progress", "warn");
+            return;
+        }
+        if (this.listenRecording) {
+            await this.runListenTransition(() => this.stopListenCapture());
+            return;
+        }
+        await this.startListenCaptureFromCommand();
+    }
+    async startListenCaptureFromCommand() {
+        if (this.listenTransition) {
             this.view.addSystemMessage("speech recording state change already in progress", "warn");
             return;
         }
-        if (this.speakRecording) {
-            await this.runSpeakTransition(() => this.stopSpeakCapture());
+        if (this.listenRecording) {
+            this.view.addSystemMessage("speech recording already in progress", "warn");
             return;
         }
-        if (this.isTranscribingSpeak) {
+        if (this.isTranscribingListen) {
             this.view.addSystemMessage("speech transcription already in progress", "warn");
             return;
         }
@@ -1229,36 +1196,36 @@ export class ChatController {
             this.view.addSystemMessage("wait for the assistant to finish before recording", "warn");
             return;
         }
-        await this.runSpeakTransition(() => this.startSpeakCapture());
+        await this.runListenTransition(() => this.startListenCapture());
     }
-    async runSpeakTransition(task) {
-        if (this.speakTransition) {
+    async runListenTransition(task) {
+        if (this.listenTransition) {
             return;
         }
         const transition = task();
-        this.speakTransition = transition;
+        this.listenTransition = transition;
         try {
             await transition;
         }
         finally {
-            if (this.speakTransition === transition) {
-                this.speakTransition = undefined;
+            if (this.listenTransition === transition) {
+                this.listenTransition = undefined;
             }
         }
     }
-    async startSpeakCapture() {
+    async startListenCapture() {
         if (this.deps.env.platform() !== "darwin") {
-            this.view.addSystemMessage("/speak is currently supported only on macOS.", "warn");
+            this.view.addSystemMessage("/listen is currently supported only on macOS.", "warn");
             return;
         }
         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");
+            this.view.addSystemMessage("set MISTRAL_API_KEY or apiKeys.mistral to use /listen", "error");
             return;
         }
         let audioPath;
         try {
-            audioPath = await this.createSpeakTempFilePath();
+            audioPath = await this.createTempFilePath(LISTEN_TEMP_FILE_TEMPLATE);
             const abortController = new AbortController();
             const completion = this.deps.spawn("ffmpeg", [
                 "-hide_banner",
@@ -1292,29 +1259,29 @@ export class ChatController {
                 completion,
             };
             recording.maxDurationTimeout = setTimeout(() => {
-                if (this.speakRecording !== recording || this.speakTransition)
+                if (this.listenRecording !== recording || this.listenTransition)
                     return;
-                void this.runSpeakTransition(() => this.stopSpeakCapture());
-            }, SPEAK_RECORDING_MAX_DURATION_MS);
-            this.speakRecording = recording;
+                void this.runListenTransition(() => this.stopListenCapture());
+            }, LISTEN_RECORDING_MAX_DURATION_MS);
+            this.listenRecording = recording;
             this.view.setEditorInputEnabled(false);
             this.refreshStatus();
-            void this.watchSpeakRecording(recording);
+            void this.watchListenRecording(recording);
         }
         catch (err) {
             if (audioPath) {
-                await this.cleanupSpeakTempFile(audioPath);
+                await this.cleanupTempFile(audioPath);
             }
             this.view.addSystemMessage(`failed to start recording: ${err.message}`, "error");
         }
     }
-    async stopSpeakCapture() {
-        const recording = this.speakRecording;
+    async stopListenCapture() {
+        const recording = this.listenRecording;
         if (!recording)
             return;
         recording.stopRequested = true;
-        this.clearSpeakRecordingMaxDurationTimeout(recording);
-        this.speakRecording = undefined;
+        this.clearListenRecordingMaxDurationTimeout(recording);
+        this.listenRecording = undefined;
         this.view.setEditorInputEnabled(true);
         this.refreshStatus();
         recording.abortController.abort();
@@ -1323,17 +1290,17 @@ export class ChatController {
         }
         catch (err) {
             this.view.addSystemMessage(`recording failed: ${err.message}`, "error");
-            await this.cleanupSpeakTempFile(recording.audioPath);
+            await this.cleanupTempFile(recording.audioPath);
             return;
         }
-        this.isTranscribingSpeak = true;
+        this.isTranscribingListen = true;
         try {
             const audio = await readFile(recording.audioPath);
-            if (audio.byteLength < SPEAK_RECORDING_MIN_BYTES) {
+            if (audio.byteLength < LISTEN_RECORDING_MIN_BYTES) {
                 this.view.addSystemMessage("recording too short, try again", "warn");
                 return;
             }
-            const transcript = await this.transcribeSpeakAudio(audio);
+            const transcript = await this.transcribeListenAudio(audio);
             const text = transcript.trim();
             if (!text) {
                 return;
@@ -1344,17 +1311,17 @@ export class ChatController {
             this.view.addSystemMessage(`speech transcription failed: ${err.message}`, "error");
         }
         finally {
-            this.isTranscribingSpeak = false;
-            await this.cleanupSpeakTempFile(recording.audioPath);
+            this.isTranscribingListen = false;
+            await this.cleanupTempFile(recording.audioPath);
         }
     }
-    async cancelSpeakCapture() {
-        const recording = this.speakRecording;
+    async cancelListenCapture() {
+        const recording = this.listenRecording;
         if (!recording)
             return;
         recording.stopRequested = true;
-        this.clearSpeakRecordingMaxDurationTimeout(recording);
-        this.speakRecording = undefined;
+        this.clearListenRecordingMaxDurationTimeout(recording);
+        this.listenRecording = undefined;
         this.view.setEditorInputEnabled(true);
         this.refreshStatus();
         recording.abortController.abort();
@@ -1364,15 +1331,15 @@ export class ChatController {
         catch {
             // ignore disposal errors
         }
-        await this.cleanupSpeakTempFile(recording.audioPath);
+        await this.cleanupTempFile(recording.audioPath);
     }
-    async watchSpeakRecording(recording) {
+    async watchListenRecording(recording) {
         try {
             const result = await recording.completion;
-            this.clearSpeakRecordingMaxDurationTimeout(recording);
-            if (this.speakRecording !== recording || recording.stopRequested)
+            this.clearListenRecordingMaxDurationTimeout(recording);
+            if (this.listenRecording !== recording || recording.stopRequested)
                 return;
-            this.speakRecording = undefined;
+            this.listenRecording = undefined;
             this.view.setEditorInputEnabled(true);
             this.refreshStatus();
             const detail = result.exitCode !== null
@@ -1381,13 +1348,13 @@ export class ChatController {
                     ? `ffmpeg terminated by signal ${result.closeSignal}`
                     : "ffmpeg exited";
             this.view.addSystemMessage(`recording stopped unexpectedly (${detail})`, "error");
-            await this.cleanupSpeakTempFile(recording.audioPath);
+            await this.cleanupTempFile(recording.audioPath);
         }
         catch (err) {
-            this.clearSpeakRecordingMaxDurationTimeout(recording);
-            if (this.speakRecording !== recording || recording.stopRequested)
+            this.clearListenRecordingMaxDurationTimeout(recording);
+            if (this.listenRecording !== recording || recording.stopRequested)
                 return;
-            this.speakRecording = undefined;
+            this.listenRecording = undefined;
             this.view.setEditorInputEnabled(true);
             this.refreshStatus();
             const error = err;
@@ -1397,17 +1364,17 @@ export class ChatController {
             else {
                 this.view.addSystemMessage(`recording failed: ${error.message}`, "error");
             }
-            await this.cleanupSpeakTempFile(recording.audioPath);
+            await this.cleanupTempFile(recording.audioPath);
         }
     }
-    clearSpeakRecordingMaxDurationTimeout(recording) {
+    clearListenRecordingMaxDurationTimeout(recording) {
         if (!recording.maxDurationTimeout)
             return;
         clearTimeout(recording.maxDurationTimeout);
         recording.maxDurationTimeout = undefined;
     }
-    async createSpeakTempFilePath() {
-        const result = await this.deps.spawn("mktemp", [SPEAK_TEMP_FILE_TEMPLATE]);
+    async createTempFilePath(template) {
+        const result = await this.deps.spawn("mktemp", [template]);
         if (result.exitCode !== 0) {
             const message = result.stderr.trim() || result.stdout.trim() || "mktemp failed";
             throw new Error(message);
@@ -1418,7 +1385,7 @@ export class ChatController {
         }
         return path;
     }
-    async transcribeSpeakAudio(audio) {
+    async transcribeListenAudio(audio) {
         const apiKey = getMistralApiKey(this.config, this.deps.env.env());
         if (!apiKey) {
             throw new Error("missing MISTRAL_API_KEY or apiKeys.mistral");
@@ -1431,7 +1398,7 @@ export class ChatController {
             language: "en",
         });
     }
-    async cleanupSpeakTempFile(path) {
+    async cleanupTempFile(path) {
         try {
             await unlink(path);
         }
@@ -1439,18 +1406,138 @@ export class ChatController {
             // best-effort cleanup
         }
     }
+    async speakLastAssistantMessage() {
+        if (this.speakTask) {
+            this.view.addSystemMessage("speech playback already in progress", "warn");
+            return;
+        }
+        if (this.isStreaming) {
+            this.view.addSystemMessage("wait for the assistant to finish before speaking", "warn");
+            return;
+        }
+        if (this.deps.env.platform() !== "darwin") {
+            this.view.addSystemMessage("/speak is currently supported only on macOS.", "warn");
+            return;
+        }
+        const lastAssistant = this.getLastAssistantMessage();
+        if (!lastAssistant) {
+            this.view.addSystemMessage("no assistant message to speak yet.", "warn");
+            return;
+        }
+        const sourceText = extractAssistantText(lastAssistant).trim();
+        if (!sourceText) {
+            this.view.addSystemMessage("last assistant message was empty.", "warn");
+            return;
+        }
+        const apiKey = await this.credentialResolver.getApiKey("google");
+        if (!apiKey) {
+            this.view.addSystemMessage("set GEMINI_API_KEY or apiKeys.google to use /speak", "error");
+            return;
+        }
+        this.isStreaming = true;
+        this.speechStatusHint = "rewriting for speech...";
+        this.refreshStatus();
+        this.view.startWorkingIcon();
+        const abortController = new AbortController();
+        const completion = this.runSpeakTask({
+            apiKey,
+            sourceText,
+            signal: abortController.signal,
+        });
+        const task = { abortController, completion };
+        this.speakTask = task;
+        try {
+            await completion;
+        }
+        catch (err) {
+            if (abortController.signal.aborted) {
+                return;
+            }
+            this.view.addSystemMessage(`speech synthesis failed: ${err.message}`, "error");
+        }
+        finally {
+            const wasAborted = abortController.signal.aborted;
+            if (this.speakTask === task) {
+                this.speakTask = undefined;
+            }
+            this.speechStatusHint = undefined;
+            this.view.stopWorkingIcon();
+            this.isStreaming = false;
+            this.refreshStatus();
+            this.view.requestRender();
+            if (wasAborted) {
+                this.dequeueQueuedUserMessagesIntoEditor();
+            }
+            else {
+                void this.drainQueuedUserMessages();
+            }
+        }
+    }
+    async runSpeakTask(args) {
+        let audioPath;
+        try {
+            const result = await generateGeminiSpeech({
+                apiKey: args.apiKey,
+                sourceText: args.sourceText,
+                signal: args.signal,
+                onStageChange: () => { },
+                onChunkProgress: ({ ready, total }) => {
+                    this.speechStatusHint = this.formatSpeechChunkProgressMessage(ready, total);
+                    this.refreshStatus();
+                },
+            });
+            if (args.signal.aborted) {
+                return;
+            }
+            audioPath = await this.createTempFilePath(SPEAK_TEMP_FILE_TEMPLATE);
+            await writeFile(audioPath, result.audio);
+            this.speechStatusHint = "playing speech...";
+            this.refreshStatus();
+            const playback = await this.deps.spawn("afplay", ["-r", String(SPEAK_PLAYBACK_RATE), audioPath], {
+                detached: true,
+                killProcessGroup: true,
+                signal: args.signal,
+                stdio: ["ignore", "ignore", "ignore"],
+            });
+            if (args.signal.aborted || playback.aborted) {
+                return;
+            }
+            if (playback.exitCode !== 0) {
+                const detail = playback.exitCode !== null
+                    ? `afplay exited with code ${playback.exitCode}`
+                    : playback.closeSignal
+                        ? `afplay terminated by signal ${playback.closeSignal}`
+                        : "afplay exited";
+                throw new Error(detail);
+            }
+        }
+        catch (err) {
+            if (args.signal.aborted) {
+                return;
+            }
+            const error = err;
+            if (error.name === "AbortError") {
+                return;
+            }
+            if (error.code === "ENOENT") {
+                throw new Error("afplay not found.");
+            }
+            throw err;
+        }
+        finally {
+            if (audioPath) {
+                await this.cleanupTempFile(audioPath);
+            }
+        }
+    }
+    formatSpeechChunkProgressMessage(ready, total) {
+        return `generating speech chunks (${ready} out of ${total} ready)...`;
+    }
     getMemoryModeFilePath() {
         const cwd = this.deps.env.cwd();
         const home = this.deps.env.home();
         const nearestAgentsFiles = findAgentsFilesFromCwdToHome(cwd, home);
         const hostPath = nearestAgentsFiles.length > 0 ? nearestAgentsFiles[0] : resolve(join(cwd, "AGENTS.md"));
-        if (this.sandboxEnabled) {
-            return resolveSandboxPath({
-                hostPath,
-                cwd,
-                sandboxConfig: this.config.sandbox,
-            });
-        }
         return hostPath;
     }
     formatMemoryModeUserMessage(agentsFilePath, request) {
@@ -1629,9 +1716,10 @@ export class ChatController {
     }
     isDiffReviewIdle() {
         return (!this.isStreaming &&
-            !this.speakRecording &&
-            !this.speakTransition &&
-            !this.isTranscribingSpeak &&
+            !this.listenRecording &&
+            !this.listenTransition &&
+            !this.isTranscribingListen &&
+            !this.speakTask &&
             !this.diffReviewService.isActive());
     }
     resolveDiffToolConfig() {
@@ -1742,12 +1830,9 @@ export class ChatController {
     syncRuntimePromptContext() {
         this.runtime.updatePromptContext({
             cwd: this.agentCwd,
-            hostCwd: this.deps.env.cwd(),
             home: this.deps.env.home(),
             includeAgentContext: this.includeAgentContext,
             projectContextBlock: this.projectContextBlock,
-            sandboxEnabled: this.sandboxEnabled,
-            sandboxEnvironmentInfo: this.config.sandbox?.environmentInfo,
         });
     }
     rebuildSystemPrompt(skillsBlock) {
@@ -1933,12 +2018,7 @@ export class ChatController {
             this.view.addSystemMessage(`unknown bash command '${id}'.`, "error");
             return;
         }
-        const baseCwd = saved.cwd ?? this.deps.env.cwd();
-        const cwd = resolveAgentCwd({
-            cwd: baseCwd,
-            sandboxEnabled: this.sandboxEnabled,
-            sandboxConfig: this.config.sandbox,
-        });
+        const cwd = saved.cwd ?? this.deps.env.cwd();
         await this.runBashCommand(saved.cmd, { cwd });
     }
     async refreshReloadableContent(scope) {