lsd-pi 1.3.7 → 1.3.10

package/dist/resources/extensions/mcp-client/mcp-manager-component.js

@@ -0,0 +1,220 @@
+import { Key, SelectList, matchesKey, truncateToWidth } from "@gsd/pi-tui";
+function getSelectListTheme(theme) {
+    return {
+        selectedPrefix: (text) => theme.fg("accent", text),
+        selectedText: (text) => theme.fg("accent", text),
+        description: (text) => theme.fg("muted", text),
+        scrollInfo: (text) => theme.fg("dim", text),
+        noMatch: (text) => theme.fg("warning", text),
+    };
+}
+function serversToItems(servers) {
+    return servers.map((server) => ({
+        value: server.name,
+        label: server.name,
+        description: [
+            server.enabled ? "enabled" : "disabled",
+            server.transport,
+            server.connected ? "● connected" : "○ offline",
+            `${server.toolCount} tools`,
+            server.sourceLabel || undefined,
+        ].filter(Boolean).join("  "),
+    }));
+}
+export class McpManagerComponent {
+    theme;
+    callbacks;
+    selectList;
+    mode = "list";
+    inspectServerName = "";
+    inspectLines = [];
+    inspectScrollOffset = 0;
+    statusMessage = "";
+    busy = false;
+    statusTimeout = null;
+    constructor(callbacks, theme) {
+        this.callbacks = callbacks;
+        this.theme = theme;
+        this.selectList = new SelectList([], 8, getSelectListTheme(theme));
+        this.bindSelectList();
+        this.refreshList();
+    }
+    invalidate() {
+        this.selectList.invalidate();
+    }
+    dispose() {
+        if (this.statusTimeout) {
+            clearTimeout(this.statusTimeout);
+            this.statusTimeout = null;
+        }
+    }
+    getMode() {
+        return this.mode;
+    }
+    handleInput(data) {
+        if (this.mode === "inspect") {
+            this.handleInspectInput(data);
+            return;
+        }
+        if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
+            this.callbacks.onClose();
+            return;
+        }
+        if (data === "i") {
+            void this.handleInspect();
+            return;
+        }
+        if (data === "r") {
+            void this.handleReconnect();
+            return;
+        }
+        this.selectList.handleInput(data);
+        this.callbacks.requestRender();
+    }
+    render(width) {
+        const lines = [];
+        const add = (line = "") => lines.push(truncateToWidth(line, width));
+        const divider = this.theme.fg("border", "─".repeat(Math.max(width, 1)));
+        add(divider);
+        if (this.mode === "inspect") {
+            add(this.theme.bold(this.theme.fg("toolTitle", ` MCP Tools · ${this.inspectServerName}`)) +
+                this.theme.fg("dim", "  esc/q: back  ↑↓/pgup/pgdn/home/end: scroll"));
+            add("");
+            const bodyHeight = Math.max(8, width > 0 ? 18 : 8);
+            const maxOffset = Math.max(0, this.inspectLines.length - bodyHeight);
+            this.inspectScrollOffset = Math.max(0, Math.min(this.inspectScrollOffset, maxOffset));
+            const visibleLines = this.inspectLines.slice(this.inspectScrollOffset, this.inspectScrollOffset + bodyHeight);
+            for (const line of visibleLines)
+                add(line);
+            if (visibleLines.length === 0)
+                add(this.theme.fg("dim", "  No tool information"));
+            add("");
+            add(divider);
+            add(this.theme.fg("dim", ` ${this.inspectLines.length} lines`));
+            return lines;
+        }
+        add(this.theme.bold(this.theme.fg("toolTitle", " MCP Servers")) +
+            this.theme.fg("dim", "  ↑↓ navigate  enter: toggle  i: inspect  r: reconnect  esc: close"));
+        add("");
+        lines.push(...this.selectList.render(width));
+        add("");
+        add(divider);
+        const servers = this.callbacks.getServers();
+        const enabled = servers.filter((server) => server.enabled).length;
+        let footer = this.theme.fg("dim", ` ${servers.length} servers · ${enabled} enabled`);
+        if (this.busy)
+            footer += this.theme.fg("accent", " · working…");
+        if (this.statusMessage)
+            footer += this.theme.fg("accent", ` — ${this.statusMessage}`);
+        add(footer);
+        return lines;
+    }
+    bindSelectList() {
+        this.selectList.onSelect = () => {
+            void this.handleToggle();
+        };
+        this.selectList.onCancel = () => {
+            this.callbacks.onClose();
+        };
+    }
+    refreshList(preferredName) {
+        const currentSelected = preferredName ?? this.selectList.getSelectedItem()?.value;
+        this.selectList = new SelectList(serversToItems(this.callbacks.getServers()), 8, getSelectListTheme(this.theme));
+        this.bindSelectList();
+        if (currentSelected) {
+            const items = this.callbacks.getServers();
+            const index = items.findIndex((item) => item.name === currentSelected);
+            if (index >= 0)
+                this.selectList.setSelectedIndex(index);
+        }
+        this.callbacks.requestRender();
+    }
+    setStatus(message) {
+        this.statusMessage = message;
+        this.callbacks.requestRender();
+        if (this.statusTimeout)
+            clearTimeout(this.statusTimeout);
+        if (!message)
+            return;
+        this.statusTimeout = setTimeout(() => {
+            this.statusMessage = "";
+            this.callbacks.requestRender();
+        }, 3000);
+        this.statusTimeout.unref?.();
+    }
+    getSelectedName() {
+        return this.selectList.getSelectedItem()?.value;
+    }
+    async runBusy(task) {
+        if (this.busy)
+            return;
+        this.busy = true;
+        this.callbacks.requestRender();
+        try {
+            await task();
+        }
+        finally {
+            this.busy = false;
+            this.callbacks.requestRender();
+        }
+    }
+    async handleToggle() {
+        const name = this.getSelectedName();
+        if (!name)
+            return;
+        await this.runBusy(async () => {
+            this.setStatus(`Toggling ${name}...`);
+            const updated = await this.callbacks.onToggle(name);
+            this.refreshList(updated?.name ?? name);
+            if (updated) {
+                this.setStatus(`${updated.name}: ${updated.enabled ? "enabled" : "disabled"}`);
+            }
+        });
+    }
+    async handleInspect() {
+        const name = this.getSelectedName();
+        if (!name)
+            return;
+        await this.runBusy(async () => {
+            this.setStatus(`Loading tools for ${name}...`);
+            const text = await this.callbacks.onInspect(name);
+            this.inspectServerName = name;
+            this.inspectLines = text.split("\n");
+            this.inspectScrollOffset = 0;
+            this.mode = "inspect";
+            this.setStatus("");
+        });
+    }
+    async handleReconnect() {
+        const name = this.getSelectedName();
+        if (!name)
+            return;
+        await this.runBusy(async () => {
+            this.setStatus(`Reconnecting ${name}...`);
+            const updated = await this.callbacks.onReconnect(name);
+            this.refreshList(updated?.name ?? name);
+            this.setStatus(updated ? `${updated.name}: reconnected` : `${name}: reconnect failed`);
+        });
+    }
+    handleInspectInput(data) {
+        if (matchesKey(data, Key.escape) || data === "q") {
+            this.mode = "list";
+            this.callbacks.requestRender();
+            return;
+        }
+        const page = 12;
+        if (matchesKey(data, Key.up))
+            this.inspectScrollOffset -= 1;
+        else if (matchesKey(data, Key.down))
+            this.inspectScrollOffset += 1;
+        else if (matchesKey(data, Key.pageUp))
+            this.inspectScrollOffset -= page;
+        else if (matchesKey(data, Key.pageDown))
+            this.inspectScrollOffset += page;
+        else if (matchesKey(data, Key.home))
+            this.inspectScrollOffset = 0;
+        else if (matchesKey(data, Key.end))
+            this.inspectScrollOffset = Number.MAX_SAFE_INTEGER;
+        this.callbacks.requestRender();
+    }
+}

package/dist/resources/extensions/slash-commands/plan.js

@@ -155,7 +155,7 @@ function readAutoSwitchPlanModelSetting() {
             return false;
         const raw = readFileSync(settingsPath, "utf-8");
         const parsed = JSON.parse(raw);
-        return parsed.autoSwitchPlanModel === true;
+        return parsed.planModeAutoSwitchModel === true;
     }
     catch {
         return false;
@@ -277,7 +277,7 @@ async function setModelIfNeeded(pi, ctx, modelRef) {
     return true;
 }
 function buildExecutionKickoffMessage(options) {
-    const { permissionMode, executeWithSubagent = false } = options;
+    const { permissionMode, executeWithSubagent = false, executionNote } = options;
     const task = state.task.trim();
     if (!executeWithSubagent) {
         const details = [
@@ -287,6 +287,9 @@ function buildExecutionKickoffMessage(options) {
             details.push(`Original task: ${task}`);
         if (state.latestPlanPath)
             details.push(`Use the approved plan artifact at ${state.latestPlanPath} as the execution plan.`);
+        if (executionNote)
+            details.push(`User execution note: ${executionNote}`);
+        details.push("After implementation: guide the user through verification by presenting a concise checklist based on the plan's Acceptance Criteria and Verification Plan. Run applicable checks (build, lint, tests) and report results.");
         return details.join(" ");
     }
     const codingModel = readPlanModeCodingModel();
@@ -303,13 +306,24 @@ function buildExecutionKickoffMessage(options) {
         details.push(`Original task: ${task}`);
     if (state.latestPlanPath)
         details.push(`Primary plan artifact: ${state.latestPlanPath}`);
+    if (executionNote) {
+        details.push(`User execution note: ${executionNote}`);
+        // If the note contains a model request, surface it explicitly so the agent
+        // doesn't silently drop it. The model override will be resolved by
+        // normalizeSubagentModel when the subagent tool is invoked.
+        const modelMatch = executionNote.match(/\b(?:model|use\s+model)\s+["']?([\w.-]+(?:\/[\w.-]+)?)["']?\b/i);
+        if (modelMatch?.[1]) {
+            details.push(`The user explicitly requested model "${modelMatch[1]}". You MUST pass model="${modelMatch[1]}" in the subagent tool call. If normalizeSubagentModel cannot resolve this model, report the error to the user instead of silently falling back.`);
+        }
+    }
     details.push("Important: if the plan is large and you estimate it would exceed a single subagent's context window (~200k tokens), " +
         "split execution across multiple sequential subagents instead of one. " +
         "Use the subagent tool's chain mode: pass a \"chain\" array where each entry covers one self-contained phase or group of steps from the plan. " +
         "Each chain entry should include the agent name, a focused task description for that phase, and may reference {previous} to receive the prior phase's output as handoff context. " +
         "Only split when genuinely needed — prefer a single subagent for plans that fit comfortably.");
     details.push("After all subagents complete: (1) do a quick review of the implementation — check that the plan steps were actually carried out, spot obvious issues or missed pieces, and verify the code compiles/passes lint if applicable. " +
-        "(2) Then summarize what was done, what (if anything) needs follow-up, and flag any concerns found during review.");
+        "(2) Then guide the user through verification: present a concise checklist based on the plan's Acceptance Criteria and Verification Plan sections. Run applicable checks (build, lint, tests) and report results. " +
+        "(3) Summarize what was done, what (if anything) needs follow-up, and flag any concerns found during review.");
     return details.join(" ");
 }
 let pendingNewSession = null;
@@ -331,11 +345,11 @@ function scheduleNewSession(pi, ctx) {
     // Must use the /prefix so tryExecuteExtensionCommand parses the name correctly.
     pi.executeSlashCommand("/plan-execute-new-session");
 }
-async function approvePlan(pi, ctx, permissionMode, executeWithSubagent = false) {
-    const reasoningModel = parseQualifiedModelRef(readPlanModeReasoningModel());
-    if (reasoningModel) {
-        await setModelIfNeeded(pi, ctx, reasoningModel);
-    }
+async function approvePlan(pi, ctx, permissionMode, executeWithSubagent = false, executionNote) {
+    // Do NOT switch to reasoning model during execution.
+    // The reasoning model is only for plan-mode investigation, not execution.
+    // If a coding model is configured and we're using a subagent, the explicit
+    // model="<planModeCodingModel>" in the kickoff message will handle it.
     state = {
         ...state,
         targetPermissionMode: permissionMode,
@@ -347,7 +361,7 @@ async function approvePlan(pi, ctx, permissionMode, executeWithSubagent = false)
     // subagent tool with the default session model BEFORE it ever sees the
     // explicit model="<planModeCodingModel>" instruction. Steering ensures the
     // configured plan-mode coding model reaches the subagent invocation.
-    await pi.sendUserMessage(buildExecutionKickoffMessage({ permissionMode, executeWithSubagent }), { deliverAs: "steer" });
+    await pi.sendUserMessage(buildExecutionKickoffMessage({ permissionMode, executeWithSubagent, executionNote }), { deliverAs: "steer" });
 }
 async function cancelPlan(pi, ctx, clearTask = true) {
     const restoreMode = state.previousMode ?? "accept-on-edit";
@@ -359,10 +373,12 @@ async function cancelPlan(pi, ctx, clearTask = true) {
 function buildPlanModeSystemPrompt() {
     const details = [
         "You are currently in plan mode.",
+        "Terse output. All technical substance stays. Only fluff dies. Fragments OK.",
         "Investigate, clarify scope, and produce a persisted execution plan before making source changes.",
         "If requirements are ambiguous or constraints are missing, ask concise clarifying questions before drafting or saving a plan.",
         `Before writing or updating a plan artifact, make sure your confidence is at least ${MIN_PLAN_CONFIDENCE}/10. If confidence is lower, investigate more or ask clarifying questions first.`,
         "Include an explicit confidence line in every saved plan, for example: \"Confidence: 8/10\" or higher.",
+        "Every saved plan MUST include explicit \"Acceptance Criteria\" and \"Verification Plan\" sections. Plans missing these sections will be rejected for approval.",
         "When adjusting an existing saved plan, prefer the edit tool for targeted changes. Rewrite the whole file only when the structure changes substantially or an exact edit is impractical.",
         "Do not modify source files or run side-effect commands while plan mode is active.",
         "Persist plan artifacts under .lsd/plan/.",
@@ -411,6 +427,29 @@ function buildApprovalActionInstructions() {
 function buildApprovalDialogInstructions() {
     return buildApprovalActionInstructions();
 }
+/** Required heading patterns for plan artifacts. Matches common variants. */
+const REQUIRED_PLAN_SECTIONS = [
+    { pattern: /\b(acceptance\s*criteria|success\s*criteria|done\s*criteria)\b/i, label: "Acceptance Criteria" },
+    { pattern: /\b(verification\s*(plan|steps|strategy)|how\s+to\s+verify|testing\s*plan)\b/i, label: "Verification Plan" },
+];
+function validatePlanArtifact(markdown) {
+    const missing = [];
+    for (const section of REQUIRED_PLAN_SECTIONS) {
+        if (!section.pattern.test(markdown)) {
+            missing.push(section.label);
+        }
+    }
+    return { valid: missing.length === 0, missing };
+}
+function buildPlanValidationSteeringMessage(planPath, missing) {
+    const missingList = missing.map((m) => `- **${m}**`).join("\n");
+    return [
+        `Plan artifact saved at ${planPath}.`,
+        `The plan is missing required sections before it can be approved for implementation:`,
+        missingList,
+        `Please revise the plan to include these sections, then re-save. Do not ask for approval until all required sections are present.`,
+    ].join("\n\n");
+}
 function buildApprovalSteeringMessage(planPath) {
     return [
         `Plan artifact saved at ${planPath}.`,
@@ -621,13 +660,26 @@ export default function planCommand(pi) {
                     return;
                 }
                 const planMarkdown = readPlanArtifact(path);
-                pi.sendMessage({
-                    customType: "plan-mode-preview",
-                    content: buildPlanPreviewMessage(path, planMarkdown),
-                    display: true,
-                });
-                ctx.ui?.notify?.("/plan to show plan", "info");
-                pi.sendUserMessage(buildApprovalSteeringMessage(path), { deliverAs: "steer" });
+                if (!planMarkdown) {
+                    ctx.ui?.notify?.("Plan artifact could not be read for validation", "warning");
+                    pi.sendUserMessage(buildApprovalSteeringMessage(path), { deliverAs: "steer" });
+                }
+                else {
+                    const validation = validatePlanArtifact(planMarkdown);
+                    if (!validation.valid) {
+                        ctx.ui?.notify?.("Plan missing required sections — see guidance below", "warning");
+                        pi.sendUserMessage(buildPlanValidationSteeringMessage(path, validation.missing), { deliverAs: "steer" });
+                    }
+                    else {
+                        pi.sendMessage({
+                            customType: "plan-mode-preview",
+                            content: buildPlanPreviewMessage(path, planMarkdown),
+                            display: true,
+                        });
+                        ctx.ui?.notify?.("/plan to show plan", "info");
+                        pi.sendUserMessage(buildApprovalSteeringMessage(path), { deliverAs: "steer" });
+                    }
+                }
             }
             return;
         }
@@ -676,12 +728,13 @@ export default function planCommand(pi) {
                 permissionMode: DEFAULT_APPROVAL_PERMISSION_MODE,
                 executeWithSubagent: false,
             };
+            const permissionNote = getAnswerNote(permissionAnswer);
             state = { ...state, targetPermissionMode: executionMode.permissionMode };
             if (executionMode.executeWithSubagent) {
                 const modeLabel = executionMode.permissionMode === "danger-full-access" ? "bypass" : "auto";
                 ctx.ui?.notify?.(`Plan approved: subagent(${modeLabel})`, "info");
             }
-            await approvePlan(pi, ctx, executionMode.permissionMode, executionMode.executeWithSubagent);
+            await approvePlan(pi, ctx, executionMode.permissionMode, executionMode.executeWithSubagent, permissionNote);
             return;
         }
         // ── First question answered (action) ──────────────────────────────────
@@ -699,12 +752,13 @@ export default function planCommand(pi) {
                 permissionMode: DEFAULT_APPROVAL_PERMISSION_MODE,
                 executeWithSubagent: false,
             };
+            const actionNote = getAnswerNote(actionAnswer);
             state = { ...state, targetPermissionMode: executionMode.permissionMode };
             if (executionMode.executeWithSubagent) {
                 const modeLabel = executionMode.permissionMode === "danger-full-access" ? "bypass" : "auto";
                 ctx.ui?.notify?.(`Plan approved: subagent(${modeLabel})`, "info");
             }
-            await approvePlan(pi, ctx, executionMode.permissionMode, executionMode.executeWithSubagent);
+            await approvePlan(pi, ctx, executionMode.permissionMode, executionMode.executeWithSubagent, actionNote);
             return;
         }
         if (actionSelection.includes(REVIEW_LABEL)) {

package/dist/resources/extensions/subagent/agents.js

@@ -6,6 +6,8 @@ import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { getAgentDir, parseFrontmatter } from "@gsd/pi-coding-agent";
 const PROJECT_AGENT_DIR_CANDIDATES = [".lsd", ".gsd", ".pi"];
+/** Fixed read-only tool set for the reserved `scout` agent. */
+const SCOUT_ALLOWED_TOOLS = ["read", "lsp", "grep", "find", "ls"];
 function normalizeAgentModel(model) {
     const trimmed = model?.trim();
     if (!trimmed)
@@ -117,6 +119,11 @@ export function discoverAgents(cwd, scope) {
     else {
         addAgents(projectAgents);
     }
+    // Enforce reserved agent tool policies — scout is always read-only
+    const scout = agentMap.get("scout");
+    if (scout) {
+        scout.tools = [...SCOUT_ALLOWED_TOOLS];
+    }
     return { agents: Array.from(agentMap.values()), projectAgentsDir };
 }
 export function formatAgentList(agents, maxItems) {

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

@@ -997,11 +997,13 @@ export default function (pi) {
             const hasTasks = (params.tasks?.length ?? 0) > 0;
             const hasSingle = Boolean(params.agent && params.task);
             const modeCount = Number(hasChain) + Number(hasTasks) + Number(hasSingle);
-            const makeDetails = (mode) => (results) => ({
+            const makeDetails = (mode) => (results, opts) => ({
                 mode,
                 agentScope,
                 projectAgentsDir: discovery.projectAgentsDir,
                 results,
+                totalChainSteps: opts?.totalSteps,
+                currentChainStep: opts?.currentStep,
             });
             const trackInProcessDepth = (started, depth, ancestry) => {
                 const sessionId = started.handle.sessionId;
@@ -1090,7 +1092,8 @@ export default function (pi) {
                 for (let i = 0; i < params.chain.length; i++) {
                     const step = params.chain[i];
                     const taskWithContext = step.task.replace(/\{previous\}/g, previousOutput);
-                    // Create update callback that includes all previous results
+                    // Create update callback that includes all previous results + chain progress
+                    const chainTotalSteps = params.chain.length;
                     const chainUpdate = onUpdate
                         ? (partial) => {
                             // Combine completed results with current streaming result
@@ -1099,7 +1102,10 @@ export default function (pi) {
                                 const allResults = [...results, currentResult];
                                 onUpdate({
                                     content: partial.content,
-                                    details: makeDetails("chain")(allResults),
+                                    details: makeDetails("chain")(allResults, {
+                                        totalSteps: chainTotalSteps,
+                                        currentStep: i + 1,
+                                    }),
                                 });
                             }
                         }
@@ -1117,7 +1123,7 @@ export default function (pi) {
                         const errorMsg = result.errorMessage || result.stderr || getFinalOutput(result.messages) || "(no output)";
                         return {
                             content: [{ type: "text", text: `Chain stopped at step ${i + 1} (${step.agent}): ${errorMsg}` }],
-                            details: makeDetails("chain")(results),
+                            details: makeDetails("chain")(results, { totalSteps: params.chain.length }),
                             isError: true,
                         };
                     }
@@ -1125,7 +1131,7 @@ export default function (pi) {
                 }
                 return {
                     content: [{ type: "text", text: getFinalOutput(results[results.length - 1].messages) || "(no output)" }],
-                    details: makeDetails("chain")(results),
+                    details: makeDetails("chain")(results, { totalSteps: params.chain.length }),
                 };
             }
             if (params.tasks && params.tasks.length > 0) {
@@ -1653,13 +1659,24 @@ export default function (pi) {
             };
             if (details.mode === "chain") {
                 const successCount = details.results.filter((r) => r.exitCode === 0).length;
-                const icon = successCount === details.results.length ? theme.fg("success", "✓") : theme.fg("error", "✗");
+                const isRunning = details.currentChainStep != null;
+                const icon = !isRunning && successCount === details.results.length
+                    ? theme.fg("success", "✓")
+                    : isRunning
+                        ? theme.fg("accent", "◉")
+                        : theme.fg("error", "✗");
+                const totalLabel = details.totalChainSteps != null
+                    ? `${details.results.length}/${details.totalChainSteps} steps`
+                    : `${details.results.length} steps`;
+                const progressLabel = isRunning
+                    ? ` (step ${details.currentChainStep} running)`
+                    : "";
                 if (expanded) {
                     const container = new Container();
                     container.addChild(new Text(icon +
                         " " +
                         theme.fg("toolTitle", theme.bold("chain ")) +
-                        theme.fg("accent", `${successCount}/${details.results.length} steps`), 0, 0));
+                        theme.fg("accent", `${totalLabel}${progressLabel}`), 0, 0));
                     for (const r of details.results) {
                         const rIcon = r.exitCode === 0 ? theme.fg("success", "✓") : theme.fg("error", "✗");
                         const displayItems = getDisplayItems(r.messages);
@@ -1693,7 +1710,7 @@ export default function (pi) {
                 let text = icon +
                     " " +
                     theme.fg("toolTitle", theme.bold("chain ")) +
-                    theme.fg("accent", `${successCount}/${details.results.length} steps`);
+                    theme.fg("accent", `${totalLabel}${progressLabel}`);
                 for (const r of details.results) {
                     const rIcon = r.exitCode === 0 ? theme.fg("success", "✓") : theme.fg("error", "✗");
                     const displayItems = getDisplayItems(r.messages);

package/dist/resources/extensions/subagent/model-resolution.js

@@ -11,6 +11,7 @@ const BARE_MODEL_PROVIDER_RULES = [
         matches: (modelId) => /^(mistral-|ministral-|codestral-)/.test(modelId),
     },
     { provider: "groq", matches: (modelId) => modelId.startsWith("llama-") || modelId.startsWith("mixtral-") },
+    { provider: "zhipu", matches: (modelId) => modelId.startsWith("glm-") },
 ];
 export function inferProviderForBareModel(modelId) {
     const normalizedModelId = modelId.trim().toLowerCase();

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

@@ -231,6 +231,7 @@ function collectUsage(sessionFiles, startMs, endMs, scope, groupBy) {
         let projectLabel = basename(file);
         let headerResolved = false;
         let currentModel = "";
+        let lastUserTimestamp = 0;
         const raw = readFileSync(file, "utf-8");
         for (const line of raw.split("\n")) {
             if (!line.trim())
@@ -282,6 +283,8 @@ function collectUsage(sessionFiles, startMs, endMs, scope, groupBy) {
                     cacheWrite: 0,
                     total: 0,
                     cost: 0,
+                    totalDurationMs: 0,
+                    totalOutputForSpeed: 0,
                 };
                 existing.messages += 1;
                 existing.input += input;
@@ -290,11 +293,25 @@ function collectUsage(sessionFiles, startMs, endMs, scope, groupBy) {
                 existing.cacheWrite += cacheWrite;
                 existing.total += total;
                 existing.cost += cost;
+                // Track tok/sec: use preceding user message timestamp
+                if (output > 0 && lastUserTimestamp > 0) {
+                    const durationMs = timestamp - lastUserTimestamp;
+                    if (durationMs > 0) {
+                        existing.totalDurationMs += durationMs;
+                        existing.totalOutputForSpeed += output;
+                    }
+                }
                 rows.set(key, existing);
             }
             else if (message.role === "user") {
                 const timestamp = Number(message.timestamp ?? 0);
-                if (!timestamp || timestamp < startMs || timestamp >= endMs)
+                if (!timestamp)
+                    continue;
+                // Always track last user timestamp for tok/sec calculation,
+                // even if this user message is outside the time range
+                // (the assistant response may still be within range).
+                lastUserTimestamp = timestamp;
+                if (timestamp < startMs || timestamp >= endMs)
                     continue;
                 matchedUserPrompts++;
                 const model = currentModel;
@@ -311,6 +328,8 @@ function collectUsage(sessionFiles, startMs, endMs, scope, groupBy) {
                     cacheWrite: 0,
                     total: 0,
                     cost: 0,
+                    totalDurationMs: 0,
+                    totalOutputForSpeed: 0,
                 };
                 existing.userPrompts += 1;
                 userPromptRows.set(key, existing);
@@ -342,8 +361,10 @@ function collectUsage(sessionFiles, startMs, endMs, scope, groupBy) {
         acc.cacheWrite += row.cacheWrite;
         acc.total += row.total;
         acc.cost += row.cost;
+        acc.totalDurationMs += row.totalDurationMs;
+        acc.totalOutputForSpeed += row.totalOutputForSpeed;
         return acc;
-    }, { messages: 0, userPrompts: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0, cost: 0 });
+    }, { messages: 0, userPrompts: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0, cost: 0, totalDurationMs: 0, totalOutputForSpeed: 0 });
     return {
         label: "",
         scope,
@@ -355,6 +376,11 @@ function collectUsage(sessionFiles, startMs, endMs, scope, groupBy) {
         totals,
     };
 }
+function formatSpeed(totalDurationMs, totalOutputForSpeed) {
+    if (totalDurationMs <= 0)
+        return "—";
+    return Math.round(totalOutputForSpeed / (totalDurationMs / 1000)).toLocaleString();
+}
 function renderTable(report) {
     const firstColumnHeader = report.groupBy === "project"
         ? "project"
@@ -371,7 +397,9 @@ function renderTable(report) {
         write: formatInt(row.cacheWrite),
         total: formatInt(row.total),
         cost: formatCost(row.cost),
+        speed: formatSpeed(row.totalDurationMs, row.totalOutputForSpeed),
     }));
+    const totalsSpeed = formatSpeed(report.totals.totalDurationMs, report.totals.totalOutputForSpeed);
     const widths = {
         label: Math.max(firstColumnHeader.length, ...displayRows.map((row) => row.label.length), 5),
         userPrompts: Math.max(11, ...displayRows.map((row) => row.userPrompts.length), String(report.totals.userPrompts).length),
@@ -382,6 +410,7 @@ function renderTable(report) {
         write: Math.max(5, ...displayRows.map((row) => row.write.length), formatInt(report.totals.cacheWrite).length),
         total: Math.max(5, ...displayRows.map((row) => row.total.length), formatInt(report.totals.total).length),
         cost: Math.max(7, ...displayRows.map((row) => row.cost.length), formatCost(report.totals.cost).length),
+        speed: Math.max(5, ...displayRows.map((row) => row.speed.length), totalsSpeed.length),
     };
     const header = [
         firstColumnHeader.padEnd(widths.label),
@@ -393,6 +422,7 @@ function renderTable(report) {
         "write".padStart(widths.write),
         "total".padStart(widths.total),
         "cost".padStart(widths.cost),
+        "tok/s".padStart(widths.speed),
     ].join("  ");
     const divider = "-".repeat(header.length);
     const body = displayRows.map((row) => [
@@ -405,6 +435,7 @@ function renderTable(report) {
         row.write.padStart(widths.write),
         row.total.padStart(widths.total),
         row.cost.padStart(widths.cost),
+        row.speed.padStart(widths.speed),
     ].join("  "));
     const totalsLine = [
         "TOTAL".padEnd(widths.label),
@@ -416,6 +447,7 @@ function renderTable(report) {
         formatInt(report.totals.cacheWrite).padStart(widths.write),
         formatInt(report.totals.total).padStart(widths.total),
         formatCost(report.totals.cost).padStart(widths.cost),
+        totalsSpeed.padStart(widths.speed),
     ].join("  ");
     return [header, divider, ...body, divider, totalsLine].join("\n");
 }

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

@@ -275,6 +275,7 @@ export default function (pi) {
             activationMode,
             editorText: ctx.ui.getEditorText(),
             holdToTalkSupported: isKittyProtocolActive(),
+            isEditorFocused: ctx.ui.isEditorFocused(),
             onUnsupported: () => {
                 if (holdToTalkUnsupportedNotified)
                     return;

package/dist/resources/extensions/voice/push-to-talk.js

@@ -2,6 +2,8 @@ import { isKeyRelease, Key, matchesKey } from "@gsd/pi-tui";
 export function handlePushToTalkInput(data, state) {
     if (!matchesKey(data, Key.space))
         return undefined;
+    if (!state.isEditorFocused)
+        return undefined;
     if (isKeyRelease(data)) {
         if (state.activationMode === "push-to-talk") {
             void Promise.resolve(state.stopVoice());