lsd-pi 1.3.2 → 1.3.6

package/dist/resources/extensions/subagent/legacy-runner.js

@@ -0,0 +1,503 @@
+import { spawn, execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { getAgentDir } from "@gsd/pi-coding-agent";
+import { buildSubagentProcessArgs, getBundledExtensionPathsFromEnv } from "./launch-helpers.js";
+import { handleSubagentPermissionRequest, isSubagentPermissionRequest } from "./approval-proxy.js";
+import { resolveConfiguredSubagentModel } from "./configured-model.js";
+import { normalizeSubagentModel, resolveSubagentModel } from "./model-resolution.js";
+import { loadEffectivePreferences } from "../shared/preferences.js";
+const liveSubagentProcesses = new Set();
+export function readBudgetSubagentModelFromSettings() {
+    try {
+        const settingsPath = path.join(getAgentDir(), "settings.json");
+        if (!fs.existsSync(settingsPath))
+            return undefined;
+        const raw = fs.readFileSync(settingsPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed.budgetSubagentModel === "string"
+            ? normalizeSubagentModel(parsed.budgetSubagentModel)
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function stopLegacySubagents() {
+    const active = Array.from(liveSubagentProcesses);
+    if (active.length === 0)
+        return;
+    for (const proc of active) {
+        try {
+            proc.kill("SIGTERM");
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    await Promise.all(active.map((proc) => new Promise((resolve) => {
+        const done = () => resolve();
+        const timer = setTimeout(done, 500);
+        proc.once("exit", () => {
+            clearTimeout(timer);
+            resolve();
+        });
+    })));
+    for (const proc of active) {
+        if (proc.exitCode === null) {
+            try {
+                proc.kill("SIGKILL");
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+}
+function listSessionFiles(sessionDir) {
+    if (!fs.existsSync(sessionDir))
+        return [];
+    try {
+        return fs
+            .readdirSync(sessionDir)
+            .filter((name) => name.endsWith(".jsonl"))
+            .map((name) => path.join(sessionDir, name));
+    }
+    catch {
+        return [];
+    }
+}
+function detectNewSubagentSessionFile(sessionDir, before, startedAt) {
+    const after = listSessionFiles(sessionDir);
+    const created = after.filter((file) => !before.has(file));
+    const candidates = created.length > 0 ? created : after;
+    const ranked = candidates
+        .map((file) => {
+        let mtime = 0;
+        try {
+            mtime = fs.statSync(file).mtimeMs;
+        }
+        catch {
+            mtime = 0;
+        }
+        return { file, mtime };
+    })
+        .filter((entry) => entry.mtime >= startedAt - 5000)
+        .sort((a, b) => b.mtime - a.mtime);
+    return ranked[0]?.file;
+}
+function resolveSubagentCliPath(defaultCwd) {
+    const candidates = [process.env.GSD_BIN_PATH, process.env.LSD_BIN_PATH, process.argv[1]]
+        .map((value) => value?.trim())
+        .filter((value) => Boolean(value && value !== "undefined"));
+    for (const candidate of candidates) {
+        if (path.isAbsolute(candidate) && fs.existsSync(candidate))
+            return candidate;
+    }
+    const cwdCandidates = [path.join(defaultCwd, "dist", "loader.js"), path.join(defaultCwd, "scripts", "dev-cli.js")];
+    for (const candidate of cwdCandidates) {
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    for (const binName of ["lsd", "gsd"]) {
+        try {
+            const resolved = execFileSync("which", [binName], { encoding: "utf-8" }).trim();
+            if (resolved)
+                return resolved;
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return null;
+}
+function processSubagentEventLine(line, currentResult, emitUpdate, proc, onSessionInfo, onEventType, onParsedEvent) {
+    if (!line.trim())
+        return false;
+    let event;
+    try {
+        event = JSON.parse(line);
+    }
+    catch {
+        return false;
+    }
+    const eventType = typeof event.type === "string" ? event.type : "unknown";
+    onEventType?.(eventType);
+    onParsedEvent?.(event);
+    if (event.type === "subagent_session_info") {
+        let changed = false;
+        if (typeof event.sessionFile === "string" && event.sessionFile) {
+            if (currentResult.sessionFile !== event.sessionFile)
+                changed = true;
+            currentResult.sessionFile = event.sessionFile;
+        }
+        if (typeof event.parentSessionFile === "string" && event.parentSessionFile) {
+            if (currentResult.parentSessionFile !== event.parentSessionFile)
+                changed = true;
+            currentResult.parentSessionFile = event.parentSessionFile;
+        }
+        if (changed) {
+            onSessionInfo?.({
+                sessionFile: currentResult.sessionFile,
+                parentSessionFile: currentResult.parentSessionFile,
+            });
+        }
+        return false;
+    }
+    if (proc && isSubagentPermissionRequest(event)) {
+        void handleSubagentPermissionRequest(event, proc);
+        return false;
+    }
+    if ((event.type === "message_end" || event.type === "turn_end") && event.message) {
+        const msg = event.message;
+        currentResult.messages.push(msg);
+        if (msg.role === "assistant") {
+            currentResult.usage.turns++;
+            const usage = msg.usage;
+            if (usage) {
+                currentResult.usage.input += usage.input || 0;
+                currentResult.usage.output += usage.output || 0;
+                currentResult.usage.cacheRead += usage.cacheRead || 0;
+                currentResult.usage.cacheWrite += usage.cacheWrite || 0;
+                currentResult.usage.cost += usage.cost?.total || 0;
+                currentResult.usage.contextTokens = usage.totalTokens || 0;
+            }
+            if (msg.model && (!currentResult.model || msg.model.includes("/")))
+                currentResult.model = msg.model;
+            if (msg.stopReason)
+                currentResult.stopReason = msg.stopReason;
+            if (msg.errorMessage)
+                currentResult.errorMessage = msg.errorMessage;
+        }
+        emitUpdate();
+    }
+    if (event.type === "tool_result_end" && event.message) {
+        currentResult.messages.push(event.message);
+        emitUpdate();
+    }
+    return event.type === "agent_end";
+}
+function writePromptToTempFile(agentName, prompt) {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-"));
+    const safeName = agentName.replace(/[^\w.-]+/g, "_");
+    const filePath = path.join(tmpDir, `prompt-${safeName}.md`);
+    fs.writeFileSync(filePath, prompt, { encoding: "utf-8", mode: 0o600 });
+    return { dir: tmpDir, filePath };
+}
+function getFinalOutput(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.role === "assistant") {
+            for (const part of msg.content) {
+                if (part.type === "text")
+                    return part.text;
+            }
+        }
+    }
+    return "";
+}
+export async function runLegacySingleAgent(defaultCwd, agents, agentName, task, cwd, step, modelOverride, parentModel, signal, onUpdate, makeDetails, parentSessionFile, attachableSession, onSessionInfo, onSubagentEvent, foregroundHooks) {
+    const agent = agents.find((a) => a.name === agentName);
+    if (!agent) {
+        const available = agents.map((a) => `"${a.name}"`).join(", ") || "none";
+        return {
+            agent: agentName,
+            agentSource: "unknown",
+            task,
+            exitCode: 1,
+            messages: [],
+            stderr: `Unknown agent: "${agentName}". Available agents: ${available}.`,
+            usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+            step,
+        };
+    }
+    let tmpPromptDir = null;
+    let tmpPromptPath = null;
+    const preferences = loadEffectivePreferences()?.preferences;
+    const settingsBudgetModel = readBudgetSubagentModelFromSettings();
+    const resolvedModel = resolveConfiguredSubagentModel(agent, preferences, settingsBudgetModel);
+    const inferredModel = resolveSubagentModel({ name: agent.name, model: resolvedModel }, { overrideModel: modelOverride, parentModel });
+    const currentResult = {
+        agent: agentName,
+        agentSource: agent.source,
+        task,
+        exitCode: 0,
+        messages: [],
+        stderr: "",
+        usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+        model: inferredModel,
+        step,
+        parentSessionFile,
+    };
+    const emitUpdate = () => {
+        if (onUpdate) {
+            onUpdate({
+                content: [{ type: "text", text: getFinalOutput(currentResult.messages) || "(running...)" }],
+                details: makeDetails([currentResult]),
+            });
+        }
+    };
+    let wasAborted = false;
+    let deferTempPromptCleanup = false;
+    let tempPromptCleanupDone = false;
+    const cleanupTempPromptFiles = () => {
+        if (tempPromptCleanupDone)
+            return;
+        tempPromptCleanupDone = true;
+        if (tmpPromptPath)
+            try {
+                fs.unlinkSync(tmpPromptPath);
+            }
+            catch {
+                /* ignore */
+            }
+        if (tmpPromptDir)
+            try {
+                fs.rmdirSync(tmpPromptDir);
+            }
+            catch {
+                /* ignore */
+            }
+    };
+    try {
+        if (agent.systemPrompt.trim()) {
+            const tmp = writePromptToTempFile(agent.name, agent.systemPrompt);
+            tmpPromptDir = tmp.dir;
+            tmpPromptPath = tmp.filePath;
+        }
+        const effectiveCwd = cwd ?? defaultCwd;
+        const subagentSessionDir = parentSessionFile ? path.dirname(parentSessionFile) : undefined;
+        const sessionFilesBefore = attachableSession && subagentSessionDir
+            ? new Set(listSessionFiles(subagentSessionDir))
+            : undefined;
+        const launchStartedAt = Date.now();
+        const args = buildSubagentProcessArgs(agent, task, tmpPromptPath, inferredModel, {
+            noSession: !attachableSession,
+            parentSessionFile: parentSessionFile,
+            mode: attachableSession ? "rpc" : "json",
+        });
+        const exitCode = await new Promise((resolve) => {
+            const bundledPaths = getBundledExtensionPathsFromEnv();
+            const extensionArgs = bundledPaths.flatMap((p) => ["--extension", p]);
+            const cliPath = resolveSubagentCliPath(effectiveCwd);
+            if (!cliPath) {
+                currentResult.stderr += "Unable to resolve LSD/GSD CLI path for subagent launch.";
+                resolve(1);
+                return;
+            }
+            const proc = spawn(process.execPath, [cliPath, ...extensionArgs, ...args], { cwd: effectiveCwd, shell: false, stdio: ["pipe", "pipe", "pipe"] });
+            liveSubagentProcesses.add(proc);
+            let buffer = "";
+            let completionSeen = false;
+            let resolved = false;
+            let foregroundReleased = false;
+            let isBusy = false;
+            let commandSeq = 0;
+            const pendingCommandResponses = new Map();
+            const procAbortController = new AbortController();
+            let resolveBackgroundResult;
+            let rejectBackgroundResult;
+            const backgroundResultPromise = new Promise((resolveBg, rejectBg) => {
+                resolveBackgroundResult = resolveBg;
+                rejectBackgroundResult = rejectBg;
+            });
+            const sendRpcCommand = async (command) => {
+                const id = `sa_cmd_${++commandSeq}`;
+                if (!proc.stdin)
+                    throw new Error("Subagent RPC stdin is not available.");
+                return new Promise((resolveCmd, rejectCmd) => {
+                    pendingCommandResponses.set(id, { resolve: resolveCmd, reject: rejectCmd });
+                    proc.stdin.write(JSON.stringify({ id, ...command }) + "\n");
+                });
+            };
+            const finishForeground = (code) => {
+                if (resolved)
+                    return;
+                resolved = true;
+                resolve(code);
+            };
+            const adoptToBackground = (jobId) => {
+                if (resolved || foregroundReleased)
+                    return false;
+                foregroundReleased = true;
+                deferTempPromptCleanup = true;
+                currentResult.backgroundJobId = jobId;
+                finishForeground(0);
+                return true;
+            };
+            backgroundResultPromise.finally(() => {
+                if (deferTempPromptCleanup)
+                    cleanupTempPromptFiles();
+            });
+            foregroundHooks?.onStart?.({
+                agentName,
+                task,
+                cwd: cwd ?? defaultCwd,
+                parentSessionFile,
+                abortController: procAbortController,
+                resultPromise: backgroundResultPromise,
+                adoptToBackground,
+                sendPrompt: attachableSession
+                    ? async (text, images) => {
+                        await sendRpcCommand({ type: "prompt", message: text, images });
+                    }
+                    : undefined,
+                sendSteer: attachableSession
+                    ? async (text, images) => {
+                        await sendRpcCommand({ type: "steer", message: text, images });
+                    }
+                    : undefined,
+                sendFollowUp: attachableSession
+                    ? async (text, images) => {
+                        await sendRpcCommand({ type: "follow_up", message: text, images });
+                    }
+                    : undefined,
+                isBusy: attachableSession ? () => isBusy : undefined,
+            });
+            proc.stdout.on("data", (data) => {
+                buffer += data.toString();
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        continue;
+                    if (attachableSession) {
+                        try {
+                            const parsed = JSON.parse(trimmed);
+                            if (parsed?.type === "response" && typeof parsed.id === "string" && pendingCommandResponses.has(parsed.id)) {
+                                const pending = pendingCommandResponses.get(parsed.id);
+                                pendingCommandResponses.delete(parsed.id);
+                                if (parsed.success === false) {
+                                    pending.reject(new Error(typeof parsed.error === "string" ? parsed.error : "Subagent RPC command failed."));
+                                }
+                                else {
+                                    pending.resolve(parsed.data);
+                                }
+                                continue;
+                            }
+                        }
+                        catch {
+                            // Fall through to generic event processing.
+                        }
+                    }
+                    if (processSubagentEventLine(trimmed, currentResult, emitUpdate, proc, onSessionInfo, (eventType) => {
+                        if (eventType === "agent_start")
+                            isBusy = true;
+                        if (eventType === "agent_end")
+                            isBusy = false;
+                    }, (event) => onSubagentEvent?.(event, currentResult))) {
+                        completionSeen = true;
+                        try {
+                            proc.kill("SIGTERM");
+                        }
+                        catch {
+                            /* ignore */
+                        }
+                    }
+                }
+            });
+            proc.stderr.on("data", (data) => {
+                currentResult.stderr += data.toString();
+            });
+            proc.on("close", (code) => {
+                liveSubagentProcesses.delete(proc);
+                if (buffer.trim()) {
+                    const completedOnFlush = processSubagentEventLine(buffer, currentResult, emitUpdate, proc, onSessionInfo, (eventType) => {
+                        if (eventType === "agent_start")
+                            isBusy = true;
+                        if (eventType === "agent_end")
+                            isBusy = false;
+                    }, (event) => onSubagentEvent?.(event, currentResult));
+                    completionSeen = completionSeen || completedOnFlush;
+                }
+                isBusy = false;
+                for (const pending of pendingCommandResponses.values()) {
+                    pending.reject(new Error("Subagent process closed before command response."));
+                }
+                pendingCommandResponses.clear();
+                const finalExitCode = completionSeen && (code === null || code === 143 || code === 15) ? 0 : (code ?? 0);
+                currentResult.exitCode = finalExitCode;
+                if (attachableSession && sessionFilesBefore && subagentSessionDir && !currentResult.sessionFile) {
+                    const detected = detectNewSubagentSessionFile(subagentSessionDir, sessionFilesBefore, launchStartedAt);
+                    if (detected)
+                        currentResult.sessionFile = detected;
+                }
+                resolveBackgroundResult?.({
+                    summary: getFinalOutput(currentResult.messages),
+                    stderr: currentResult.stderr,
+                    exitCode: finalExitCode,
+                    model: currentResult.model,
+                    sessionFile: currentResult.sessionFile,
+                    parentSessionFile: currentResult.parentSessionFile,
+                });
+                foregroundHooks?.onFinish?.();
+                finishForeground(finalExitCode);
+            });
+            proc.on("error", (error) => {
+                liveSubagentProcesses.delete(proc);
+                isBusy = false;
+                for (const pending of pendingCommandResponses.values()) {
+                    pending.reject(error instanceof Error ? error : new Error(String(error)));
+                }
+                pendingCommandResponses.clear();
+                rejectBackgroundResult?.(error);
+                foregroundHooks?.onFinish?.();
+                finishForeground(1);
+            });
+            if (attachableSession) {
+                void sendRpcCommand({ type: "prompt", message: task }).catch((error) => {
+                    currentResult.stderr += error instanceof Error ? error.message : String(error);
+                    try {
+                        proc.kill("SIGTERM");
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                });
+            }
+            const killProc = () => {
+                wasAborted = true;
+                procAbortController.abort();
+                proc.kill("SIGTERM");
+                setTimeout(() => {
+                    if (!proc.killed)
+                        proc.kill("SIGKILL");
+                }, 5000);
+            };
+            if (signal) {
+                if (signal.aborted)
+                    killProc();
+                else
+                    signal.addEventListener("abort", killProc, { once: true });
+            }
+            if (procAbortController.signal.aborted) {
+                killProc();
+            }
+            else {
+                procAbortController.signal.addEventListener("abort", () => {
+                    proc.kill("SIGTERM");
+                    setTimeout(() => {
+                        if (!proc.killed)
+                            proc.kill("SIGKILL");
+                    }, 5000);
+                }, { once: true });
+            }
+        });
+        currentResult.exitCode = exitCode;
+        if (attachableSession && sessionFilesBefore && subagentSessionDir) {
+            const detected = detectNewSubagentSessionFile(subagentSessionDir, sessionFilesBefore, launchStartedAt);
+            if (detected) {
+                currentResult.sessionFile = detected;
+            }
+        }
+        if (wasAborted)
+            throw new Error("Subagent was aborted");
+        return currentResult;
+    }
+    finally {
+        if (!deferTempPromptCleanup)
+            cleanupTempPromptFiles();
+    }
+}

package/dist/resources/extensions/voice/index.js

@@ -1,10 +1,11 @@
 import { shortcutDesc } from "../shared/mod.js";
-import { isKeyRelease, Key, matchesKey, truncateToWidth, visibleWidth } from "@gsd/pi-tui";
+import { isKeyRelease, isKittyProtocolActive, Key, matchesKey, truncateToWidth, visibleWidth } from "@gsd/pi-tui";
 import { spawn, execFileSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as readline from "node:readline";
 import { linuxPython, diagnoseSounddeviceError, ensureVoiceVenv } from "./linux-ready.js";
+import { handlePushToTalkInput } from "./push-to-talk.js";
 const __extensionDir = import.meta.dirname;
 const SWIFT_SRC = path.join(__extensionDir, "speech-recognizer.swift");
 const RECOGNIZER_BIN = path.join(__extensionDir, "speech-recognizer");
@@ -76,10 +77,14 @@ export default function (pi) {
     if (!IS_DARWIN && !IS_LINUX)
         return;
     let active = false;
+    let activationMode = null;
     let recognizerProcess = null;
     let flashOn = true;
     let flashTimer = null;
     let footerTui = null;
+    let closeVoiceOverlay = null;
+    let voiceSessionPromise = null;
+    let holdToTalkUnsupportedNotified = false;
     function setVoiceFooter(ctx, on) {
         if (!on) {
             stopFlash();
@@ -153,41 +158,59 @@ export default function (pi) {
         }
         footerTui = null;
     }
-    async function toggleVoice(ctx) {
-        if (active) {
-            killRecognizer();
-            active = false;
-            setVoiceFooter(ctx, false);
-            return;
+    function killRecognizer() {
+        if (recognizerProcess) {
+            recognizerProcess.kill("SIGTERM");
+            recognizerProcess = null;
         }
+    }
+    function prepareVoice(ctx) {
         if (IS_DARWIN) {
             if (!ensureBinary()) {
                 ctx.ui.notify("Voice: failed to compile speech recognizer (need Xcode CLI tools)", "error");
-                return;
+                return false;
             }
         }
         else if (IS_LINUX) {
             if (!ensureLinuxReady(ctx)) {
-                return;
+                return false;
             }
         }
+        return true;
+    }
+    async function startVoice(ctx, mode) {
+        if (active)
+            return false;
+        if (!prepareVoice(ctx))
+            return false;
         active = true;
+        activationMode = mode;
         setVoiceFooter(ctx, true);
-        await runVoiceSession(ctx);
+        voiceSessionPromise = runVoiceSession(ctx).finally(() => {
+            if (voiceSessionPromise) {
+                voiceSessionPromise = null;
+            }
+        });
+        return true;
     }
-    pi.registerCommand("voice", {
-        description: "Toggle voice mode",
-        handler: async (_args, ctx) => toggleVoice(ctx),
-    });
-    pi.registerShortcut("ctrl+alt+v", {
-        description: shortcutDesc("Toggle voice mode", "/voice"),
-        handler: async (ctx) => toggleVoice(ctx),
-    });
-    function killRecognizer() {
-        if (recognizerProcess) {
-            recognizerProcess.kill("SIGTERM");
-            recognizerProcess = null;
+    async function stopVoice(ctx) {
+        if (!active && !closeVoiceOverlay && !recognizerProcess)
+            return;
+        killRecognizer();
+        active = false;
+        activationMode = null;
+        setVoiceFooter(ctx, false);
+        const close = closeVoiceOverlay;
+        closeVoiceOverlay = null;
+        close?.();
+        await voiceSessionPromise;
+    }
+    async function toggleVoice(ctx) {
+        if (active) {
+            await stopVoice(ctx);
+            return;
         }
+        await startVoice(ctx, "toggle");
     }
     function startRecognizer(onPartial, onFinal, onError, onReady) {
         if (IS_LINUX) {
@@ -224,20 +247,57 @@ export default function (pi) {
             }, (text) => {
                 ctx.ui.setEditorText(text);
             }, (msg) => ctx.ui.notify(`Voice: ${msg}`, "error"), () => { });
-            ctx.ui.custom((_tui, _theme, _kb, done) => ({
-                render() { return []; },
-                handleInput(data) {
-                    if (isKeyRelease(data))
-                        return;
-                    if (matchesKey(data, Key.escape) || matchesKey(data, Key.enter)) {
-                        killRecognizer();
-                        active = false;
-                        setVoiceFooter(ctx, false);
-                        done();
-                    }
-                },
-                invalidate() { },
-            }), { overlay: true, overlayOptions: { anchor: "bottom-center", width: "100%" } }).then(() => resolve());
+            ctx.ui.custom((_tui, _theme, _kb, done) => {
+                const close = () => done();
+                closeVoiceOverlay = close;
+                return {
+                    render() { return []; },
+                    handleInput(data) {
+                        if (isKeyRelease(data))
+                            return;
+                        if (matchesKey(data, Key.escape) || matchesKey(data, Key.enter)) {
+                            void stopVoice(ctx);
+                        }
+                    },
+                    invalidate() { },
+                    dispose() {
+                        if (closeVoiceOverlay === close) {
+                            closeVoiceOverlay = null;
+                        }
+                    },
+                };
+            }, { overlay: true, overlayOptions: { anchor: "bottom-center", width: "100%" } }).then(() => resolve());
         });
     }
+    pi.on("session_start", async (_event, ctx) => {
+        ctx.ui.onTerminalInput((data) => handlePushToTalkInput(data, {
+            active,
+            activationMode,
+            editorText: ctx.ui.getEditorText(),
+            holdToTalkSupported: isKittyProtocolActive(),
+            onUnsupported: () => {
+                if (holdToTalkUnsupportedNotified)
+                    return;
+                holdToTalkUnsupportedNotified = true;
+                ctx.ui.notify("Voice: hold Space requires Kitty key-release support in this terminal — use /voice or Ctrl+Alt+V", "warning");
+            },
+            startPushToTalk: async () => {
+                await startVoice(ctx, "push-to-talk");
+            },
+            stopVoice: async () => {
+                await stopVoice(ctx);
+            },
+        }));
+    });
+    pi.on("session_shutdown", async (_event, ctx) => {
+        await stopVoice(ctx);
+    });
+    pi.registerCommand("voice", {
+        description: "Toggle voice mode",
+        handler: async (_args, ctx) => toggleVoice(ctx),
+    });
+    pi.registerShortcut("ctrl+alt+v", {
+        description: shortcutDesc("Toggle voice mode", "/voice"),
+        handler: async (ctx) => toggleVoice(ctx),
+    });
 }