@cargo-ai/cli 1.0.87 → 1.0.89

package/build/commands/ask/session.js

@@ -4,7 +4,7 @@ import { determineIfIsFetcherError } from "@cargo-ai/api";
 import { isInteractive, selectOne } from "@cargo-ai/cdk/cli";
 import { getConfig } from "../../config.js";
 import { openPromptInput } from "../../utils/prompt.js";
-import { colors, ExitCodes, failWith, handleApiCall, outputJson, pollUntilFinished, startSpinner, } from "../runHandler.js";
+import { clipToWidth, colors, ExitCodes, failWith, handleApiCall, outputJson, pollUntilFinished, startSpinner, } from "../runHandler.js";
 import { loadChatHistoryPreamble } from "./history.js";
 import { createLocalHarness, HarnessTurnStalled, HarnessTurnStuck, isBridgeClosedError, } from "./localHarness.js";
 import { streamMessageTextDeltas } from "./messageStream.js";
@@ -12,6 +12,8 @@ import { saveAskState } from "./persist.js";
 import { readAskLine } from "./prompt.js";
 import { parseSlash } from "./slash.js";
 import { ASK_STATE_VERSION } from "./state.js";
+import { pickThinkingWord } from "./thinking.js";
+import { collectTypeAhead, EMPTY_TYPE_AHEAD, } from "./typeAhead.js";
 function requireInteractive() {
     if (isInteractive() === false || process.stdout.isTTY !== true) {
         failWith("Ask needs a terminal. Re-run with --print for one JSON turn.", {
@@ -21,6 +23,18 @@ function requireInteractive() {
 }
 /** Sentinel for `/agent` → Local workspace (no agentUuid). */
 const LOCAL_WORKSPACE = "__local_workspace__";
+/**
+ * What an assistant turn is marked with, alongside `◇` for a step and `│` for
+ * the rail.
+ *
+ * A text glyph rather than an emoji, so it takes the same `marker + two
+ * spaces` as every other row and the whole tree stays on one left edge. An
+ * emoji is two columns wide and needs its own spacing rule to line up, which
+ * is one more thing to get wrong every time a line is drawn.
+ */
+const ASSISTANT_MARKER = "■";
+/** Completed tool call, so the transcript keeps what was actually run. */
+const TOOL_MARKER = "⏺";
 /**
  * How long before a proxy token's stated expiry to stop trusting it. Covers
  * the gap between deciding to reuse the harness and the first proxy call the
@@ -107,7 +121,7 @@ async function ensureChat(input) {
     }
     await handleApiCall(() => input.api.ai.chat.create({
         uuid: input.chatUuid,
-        trigger: { type: "app" },
+        trigger: { type: "cli" },
         agentUuid: input.agentUuid,
     }), { spinner: false });
 }
@@ -193,14 +207,18 @@ export async function doesChatExist(api, chatUuid) {
  */
 function treeBodyWidth() {
     const columns = process.stderr.columns === undefined ? 80 : process.stderr.columns;
-    // Marker + two spaces (`◇  `, `│  `, `◆  `).
-    return Math.max(24, columns - 3);
+    // Marker + two spaces (`◇  `, `│  `, `◆  `), and one column of margin: a
+    // line filling the last cell makes some terminals wrap on their own, and the
+    // `\n` after it then lands a row further down than the tree expects.
+    return Math.max(24, columns - 4);
 }
 /**
  * Greedy wrap on spaces. A word longer than the width keeps its own line
  * rather than being cut mid-token.
+ *
+ * Exported for tests.
  */
-function wrapLine(text, width) {
+export function wrapLine(text, width) {
     const lines = [];
     for (const word of text.split(/\s+/).filter((part) => part.length > 0)) {
         const current = lines[lines.length - 1];
@@ -248,8 +266,25 @@ function forTerminal(text) {
  *   ◇  Agent
  *   │  reply…
  */
+/**
+ * A `◇` step: the first line beside the marker, the rest continuing on the
+ * rail under it.
+ *
+ * Wrapped here rather than left to the terminal. A label long enough to reach
+ * the edge — a stall notice, an API error — soft-wraps mid-word and starts its
+ * next line at column zero, outside the tree, which is how a one-sentence
+ * notice ends up looking like the output is corrupted.
+ */
+function writeDiamondBlock(body) {
+    const lines = body === "" ? [""] : wrapLine(body, treeBodyWidth());
+    const first = lines[0] === undefined ? "" : lines[0];
+    process.stderr.write(`${colors.dim("◇")}  ${first}\n`);
+    for (const line of lines.slice(1)) {
+        writeRail(line);
+    }
+}
 function showStep(label, body) {
-    process.stderr.write(`${colors.dim("◇")}  ${label}\n`);
+    writeDiamondBlock(label);
     for (const paragraph of body.split("\n")) {
         writeRailWrapped(paragraph);
     }
@@ -270,15 +305,7 @@ function showCard(body) {
  * `◇  ask hey --continue`. No "You" label.
  */
 function showUserTurn(body) {
-    const lines = body === "" ? [""] : wrapLine(body, treeBodyWidth());
-    const first = lines.length === 0 ? "" : lines[0] === undefined ? "" : lines[0];
-    process.stderr.write(`${colors.dim("◇")}  ${first}\n`);
-    for (let index = 1; index < lines.length; index += 1) {
-        const line = lines[index];
-        if (line !== undefined) {
-            writeRail(line);
-        }
-    }
+    writeDiamondBlock(body);
 }
 /**
  * Display lines for an assistant body. First line is the brick header body;
@@ -312,9 +339,7 @@ function assistantDisplayLines(body) {
 }
 function writeAssistantLines(lines) {
     const first = lines[0] === undefined ? "" : lines[0];
-    // One space after the brick: the emoji is already two columns, so `🧱 `
-    // lines up with `◇  ` / `│  `.
-    process.stderr.write(`🧱 ${first}\n`);
+    process.stderr.write(`${ASSISTANT_MARKER}  ${first}\n`);
     for (let index = 1; index < lines.length; index += 1) {
         const line = lines[index];
         if (line !== undefined) {
@@ -328,25 +353,56 @@ function clearPaintedLines(count) {
     }
     process.stderr.write(`\x1B[${String(count)}A\r\x1B[J`);
 }
-/** Rail gap, then an empty brick line ready for deltas. */
+/** Rail gap, then an empty marker line ready for deltas. */
 function beginAssistantTurn() {
     writeRail("");
-    process.stderr.write(`🧱 \n`);
-    return { buffer: "", paintedLines: 1 };
+    process.stderr.write(`${ASSISTANT_MARKER}  \n`);
+    return { buffer: "", paintedLines: 1, footer: "" };
 }
 function appendAssistantDelta(live, delta) {
-    live.buffer += delta;
+    // A tool between two pieces of narration inserts a paragraph break, so that
+    // "Let me look." and what it found do not run together. When the tool also
+    // closed the block on screen, that break arrives as the first thing in the
+    // *next* block — and renders as an empty rail line under the marker before a
+    // word has been said. Kept in the stored answer, where the paragraphs still
+    // belong; dropped here, where the block itself is already the separation.
+    const text = live.buffer === "" ? delta.replace(/^\n+/, "") : delta;
+    if (text === "") {
+        return;
+    }
+    live.buffer += text;
+    repaintAssistantTurn(live);
+}
+/** Draw the block again from its buffer, with the typed line under it. */
+function repaintAssistantTurn(live) {
     const lines = assistantDisplayLines(live.buffer);
     clearPaintedLines(live.paintedLines);
     writeAssistantLines(lines);
     live.paintedLines = lines.length;
+    if (live.footer !== "") {
+        // Clipped for the same reason the spinner's is: it has to occupy exactly
+        // one row, or the next repaint clears from the wrong line.
+        process.stderr.write(`${colors.dim(clipToWidth(live.footer))}\n`);
+        live.paintedLines += 1;
+    }
+}
+/** Show, change or remove the question being typed over this reply. */
+function setAssistantFooter(live, footer) {
+    if (live.footer === footer) {
+        return;
+    }
+    live.footer = footer;
+    repaintAssistantTurn(live);
 }
 /** Trailing rail gap before the next user turn / ◆ prompt. */
-function endAssistantTurn(_live) {
+function endAssistantTurn(live) {
+    // The typed line belongs to whatever draws next — the spinner, or the block
+    // after this one. Left here it would be printed twice.
+    setAssistantFooter(live, "");
     writeRail("");
 }
 /**
- * Finished assistant turn — same tree as a user step, but `🧱` instead of `◇`.
+ * Finished assistant turn — same tree as a user step, with `■` instead of `◇`.
  */
 function showAssistantTurn(body) {
     const live = beginAssistantTurn();
@@ -357,11 +413,21 @@ function showAssistantTurn(body) {
  * Ctrl-C during a turn cancels the turn, not the CLI: the harness interrupts
  * Claude Code, the tree says so, and the ◆ prompt comes back. A second Ctrl-C
  * while the first is still settling exits for real.
+ *
+ * Except once the turn has reached teardown, where exiting is the one thing
+ * that must not happen: `process.exit` skips the `finally` that shuts Claude
+ * Code down, so an impatient second press — the natural reaction to a few
+ * seconds of apparently nothing — is exactly what strands the process this
+ * teardown exists to stop. Presses are ignored for the length of it, which is
+ * bounded: `close` gives up after `SESSION_DESTROY_TIMEOUT_MS` either way.
  */
 function beginCancellableTurn(onCancel) {
     const controller = new AbortController();
-    const state = { cancelled: false };
+    const state = { cancelled: false, tearingDown: false };
     const handleInterrupt = () => {
+        if (state.tearingDown === true) {
+            return;
+        }
         if (state.cancelled === true) {
             // 130 is the conventional "terminated by SIGINT" status.
             process.exit(130);
@@ -377,11 +443,57 @@ function beginCancellableTurn(onCancel) {
         abort: () => {
             controller.abort();
         },
+        beginTeardown: () => {
+            state.tearingDown = true;
+        },
+        interrupt: handleInterrupt,
         release: () => {
             process.removeListener("SIGINT", handleInterrupt);
         },
     };
 }
+/**
+ * Let the next question be typed while this one is still being answered.
+ *
+ * The collector owns the terminal for the length of the turn; the spinner
+ * shows what has been typed so far, because raw mode means the terminal is no
+ * longer echoing it.
+ *
+ * Degrades to no type-ahead rather than failing when there is no terminal to
+ * read — `--print` and the non-interactive paths never get here, but a session
+ * whose stdin went away should still finish the turn it is running.
+ */
+function beginTurnTyping(input) {
+    const terminal = openPromptInput();
+    if (terminal === undefined) {
+        return {
+            pause: async () => undefined,
+            resume: () => undefined,
+            finish: () => EMPTY_TYPE_AHEAD,
+        };
+    }
+    const collector = collectTypeAhead({
+        stream: terminal.stream,
+        initialLine: input.carriedLine,
+        onInterrupt: input.onInterrupt,
+        onChange: input.onTyped,
+    });
+    input.onTyped(input.carriedLine);
+    return {
+        pause: collector.pause,
+        resume: () => {
+            collector.resume();
+            // The prompt that borrowed the terminal drew over the line; put it back.
+            input.onTyped(collector.current());
+        },
+        finish: () => {
+            const typed = collector.stop();
+            input.onTyped("");
+            terminal.close();
+            return typed;
+        },
+    };
+}
 /**
  * Stop a remote turn the user walked away from.
  *
@@ -418,6 +530,28 @@ function describeToolActivity(toolName, summary) {
         ? `${line.slice(0, ACTIVITY_MAX_LENGTH - 1)}…`
         : line;
 }
+/**
+ * A tool that has finished, left in the transcript.
+ *
+ * The spinner shows what is running, but it is one line that is overwritten
+ * and then cleared, so once a turn is over there is no record of what it did —
+ * only the prose describing it. A turn that read four files and ran two
+ * commands should say so afterwards, the way the approval prompt does for the
+ * tools it happened to ask about.
+ *
+ * Written through the spinner's `log` when one is up, which wipes the spinner
+ * line, leaves this behind, and lets the next frame redraw underneath.
+ */
+function showToolRun(input) {
+    const marker = input.isError === true ? colors.red("✗") : colors.dim(TOOL_MARKER);
+    const label = describeToolActivity(input.toolName, input.summary);
+    const line = `${marker}  ${colors.dim(label)}`;
+    if (input.spinner !== undefined) {
+        input.spinner.log(line);
+        return;
+    }
+    process.stderr.write(`${line}\n`);
+}
 /**
  * A path inside the session directory reads better relative to it; anything
  * outside stays absolute so it is obvious the turn left the project.
@@ -484,7 +618,9 @@ async function askToolApproval(approval) {
  * and path-like tokens. Empty Enter leaves. A first message from the palette
  * is written as a finished user turn, then sent.
  */
-async function readQuestion(firstMessage, dir) {
+async function readQuestion(firstMessage, dir, 
+/** Typed while the last turn was still answering, and not sent as its own. */
+typedAhead = "") {
     if (firstMessage !== undefined) {
         showUserTurn(firstMessage);
         return firstMessage;
@@ -496,7 +632,7 @@ async function readQuestion(firstMessage, dir) {
         });
     }
     try {
-        const answer = await readAskLine(input.stream, dir);
+        const answer = await readAskLine(input.stream, dir, typedAhead);
         if (answer === undefined) {
             return undefined;
         }
@@ -507,10 +643,36 @@ async function readQuestion(firstMessage, dir) {
         input.close();
     }
 }
+/**
+ * Where the next question comes from, once type-ahead is in the picture.
+ *
+ * A line the user finished with Enter during the last reply is already their
+ * next question, so it is sent rather than parked at the prompt — the way it
+ * would have been had they waited. Anything typed after that Enter, finished
+ * or not, is carried into the turn it kicks off so it survives to the prompt
+ * after that: one question can be queued behind a reply, not a series of them.
+ * An unfinished line with no Enter simply opens the prompt with itself in
+ * place.
+ */
+async function nextQuestion(input) {
+    const { queued } = input;
+    const pending = `${input.carried}${queued.pending}`;
+    if (queued.submitted !== undefined) {
+        return {
+            question: await readQuestion(queued.submitted, input.dir),
+            carriedLine: pending,
+        };
+    }
+    return {
+        // Consumed by the prompt, so nothing is carried past it.
+        question: await readQuestion(input.firstMessage, input.dir, pending),
+        carriedLine: "",
+    };
+}
 /**
  * Same tree grammar as the palette:
  *   ◇  <your message>
- *   🧱  reply…
+ *   ■  reply…
  *   ◆
  * Empty Enter or /exit leaves to the parent palette.
  */
@@ -539,14 +701,29 @@ export async function runAskSession(options) {
     const sessionId = randomUUID();
     // "Yes to everything" lasts until the chat is reset, never on disk.
     let approveEveryTool = false;
+    // Typed while the last turn was still answering: a finished line goes
+    // straight through as the next question, an unfinished one opens the prompt
+    // with it already in place.
+    let typedAhead = EMPTY_TYPE_AHEAD;
+    // The tail of a type-ahead whose first line was submitted, waiting for the
+    // next turn's collector to pick up where it left off.
+    let carriedLine = "";
     if (options.continueChat === true && options.chatUuid !== undefined) {
         chatCreated = await doesChatExist(options.api, options.chatUuid);
     }
     try {
         for (;;) {
             const mode = modeForAgent(agent);
-            const question = await readQuestion(pendingFirst, options.dir);
+            const next = await nextQuestion({
+                queued: typedAhead,
+                carried: carriedLine,
+                firstMessage: pendingFirst,
+                dir: options.dir,
+            });
+            typedAhead = EMPTY_TYPE_AHEAD;
+            carriedLine = next.carriedLine;
             pendingFirst = undefined;
+            const { question } = next;
             if (question === undefined) {
                 return "palette";
             }
@@ -618,25 +795,39 @@ export async function runAskSession(options) {
                     local = undefined;
                 }
                 if (local === undefined) {
-                    const minted = await handleApiCall(() => options.api.ai.chat.mintHarnessProxyToken(chatUuid), { spinner: false });
-                    localTokenMintedAtMs = Date.now();
-                    localTokenTtlMs = minted.expiresInSeconds * 1000;
-                    // A new Claude Code session knows nothing of this chat, whether it
-                    // is being continued from an earlier run or was reset by /agent.
-                    const history = await loadChatHistoryPreamble({
-                        api: options.api,
-                        chatUuid,
-                    });
-                    local = await createLocalHarness({
-                        api: options.api,
-                        apiBaseUrl: config.baseUrl,
-                        dir: options.dir,
-                        chatUuid,
-                        agentUuid: agent === undefined ? undefined : agent.uuid,
-                        proxyToken: minted.token,
-                        history,
-                        turnOwnerId: sessionId,
-                    });
+                    // Nothing has been drawn since the question was echoed, and the
+                    // Claude Code that has to answer it is not running yet: on a cold
+                    // config directory that is ten to fifteen seconds of a blank tree,
+                    // which reads as the CLI having hung on the first thing it was ever
+                    // asked. Warm, this comes and goes inside a fifth of a second.
+                    //
+                    // Retired by `startSpinner` when the turn starts its own, and by the
+                    // `finally` on the path where the setup throws instead.
+                    const starting = startSpinner("Starting the coding session…");
+                    try {
+                        const minted = await handleApiCall(() => options.api.ai.chat.mintHarnessProxyToken(chatUuid), { spinner: false });
+                        localTokenMintedAtMs = Date.now();
+                        localTokenTtlMs = minted.expiresInSeconds * 1000;
+                        // A new Claude Code session knows nothing of this chat, whether it
+                        // is being continued from an earlier run or was reset by /agent.
+                        const history = await loadChatHistoryPreamble({
+                            api: options.api,
+                            chatUuid,
+                        });
+                        local = await createLocalHarness({
+                            api: options.api,
+                            apiBaseUrl: config.baseUrl,
+                            dir: options.dir,
+                            chatUuid,
+                            agentUuid: agent === undefined ? undefined : agent.uuid,
+                            proxyToken: minted.token,
+                            history,
+                            turnOwnerId: sessionId,
+                        });
+                    }
+                    finally {
+                        starting.stop();
+                    }
                 }
                 // Nothing about a local turn is visible to the server until it is
                 // ingested, so the chat reads as idle while Claude Code works and a
@@ -669,8 +860,30 @@ export async function runAskSession(options) {
                 const touchedFiles = new Set();
                 const notices = [];
                 // Reads and Cargo MCP tools are batched; the first one to finish must
-                // not wipe the spinner back to "Asking…" while siblings still run.
+                // not wipe the spinner back to a thinking word while siblings run.
                 const activeTools = [];
+                // What the user has typed into this turn so far, drawn under the
+                // spinner. It lives here rather than on the spinner because a turn
+                // stops and restarts several of those — for an approval, for each tool
+                // label — and the line has to outlive all of them.
+                let typedLine = "";
+                // Plain text: it is clipped to the terminal width, and slicing a
+                // styled string would cut an escape sequence in half.
+                //
+                // Drawn by whichever of the two owns the screen. A reply streaming in
+                // has replaced the spinner with a live block, and that is exactly when
+                // someone is most likely to be typing over it — routing this to the
+                // spinner alone leaves the keyboard working and nothing showing for it.
+                const paintTyped = () => {
+                    const footer = typedLine === "" ? "" : `◆  ${typedLine}`;
+                    if (live !== undefined) {
+                        setAssistantFooter(live, footer);
+                        return;
+                    }
+                    if (spinner !== undefined) {
+                        spinner.footer(footer);
+                    }
+                };
                 const stopSpinner = () => {
                     if (spinner !== undefined) {
                         spinner.stop();
@@ -680,18 +893,32 @@ export async function runAskSession(options) {
                 const showSpinner = (label) => {
                     if (spinner === undefined) {
                         spinner = startSpinner(label);
-                        return;
                     }
-                    spinner.update(label);
+                    else {
+                        spinner.update(label);
+                    }
+                    paintTyped();
                 };
+                // A fresh word each time the turn goes back to thinking, so a long
+                // turn visibly moves through its steps instead of sitting on one label
+                // from the first second to the last. Held between draws — the spinner
+                // is repainted on every tool start and finish, and re-rolling there
+                // would make the word flicker rather than mark progress.
+                let thinkingWord = pickThinkingWord();
+                let wasRunningTool = false;
                 // The most recent tool labels the spinner. Nothing running means the
                 // turn is thinking rather than working.
                 const showActiveToolSpinner = () => {
                     const current = activeTools[activeTools.length - 1];
                     if (current === undefined) {
-                        showSpinner("Asking…");
+                        if (wasRunningTool === true) {
+                            thinkingWord = pickThinkingWord(thinkingWord);
+                            wasRunningTool = false;
+                        }
+                        showSpinner(thinkingWord);
                         return;
                     }
+                    wasRunningTool = true;
                     showSpinner(describeToolActivity(current.toolName, current.summary));
                 };
                 // A tool is announced twice — once when its name arrives, again with a
@@ -718,7 +945,16 @@ export async function runAskSession(options) {
                 // clack's spinner is already stopped when its own handler fires —
                 // otherwise Ctrl-C prints its cancel line under ours.
                 const cancellation = beginCancellableTurn(stopSpinner);
-                spinner = startSpinner("Asking…");
+                spinner = startSpinner(thinkingWord);
+                const typing = beginTurnTyping({
+                    carriedLine,
+                    onInterrupt: () => cancellation.interrupt(),
+                    onTyped: (text) => {
+                        typedLine = text;
+                        paintTyped();
+                    },
+                });
+                carriedLine = "";
                 try {
                     await local.streamPrompt(question, {
                         abortSignal: cancellation.signal,
@@ -729,6 +965,8 @@ export async function runAskSession(options) {
                             if (live === undefined) {
                                 stopSpinner();
                                 live = beginAssistantTurn();
+                                // The spinner was carrying the typed line; it goes with it.
+                                paintTyped();
                             }
                             saidSomething = true;
                             appendAssistantDelta(live, delta);
@@ -739,10 +977,24 @@ export async function runAskSession(options) {
                             // so a tool usually starts with live text on screen: close that
                             // block first, and the next delta opens a new one.
                             //
-                            // "dropped" is a tool the harness announced and then abandoned,
-                            // so it has no result coming. Same handling as a finish: forget
-                            // it, or the label outlives the work.
-                            if (activity.kind === "end" || activity.kind === "dropped") {
+                            // "dropped" is a tool the harness announced and then abandoned.
+                            // It has no result coming and it never ran, so it is forgotten
+                            // without a line — the transcript should hold what happened, not
+                            // what was briefly considered.
+                            if (activity.kind === "dropped") {
+                                forgetTool(activity.toolCallId);
+                                return;
+                            }
+                            if (activity.kind === "end") {
+                                // Read back before forgetting: only the remembered call knows
+                                // the input, and `end` carries the name and the outcome alone.
+                                const finished = activeTools.find((active) => active.toolCallId === activity.toolCallId);
+                                showToolRun({
+                                    spinner,
+                                    toolName: activity.toolName,
+                                    summary: finished === undefined ? "" : finished.summary,
+                                    isError: activity.isError,
+                                });
                                 forgetTool(activity.toolCallId);
                                 return;
                             }
@@ -769,9 +1021,25 @@ export async function runAskSession(options) {
                                 live = undefined;
                             }
                             stopSpinner();
-                            const decision = approveEveryTool === true
-                                ? "always"
-                                : await askToolApproval(approval);
+                            let decision;
+                            if (approveEveryTool === true) {
+                                decision = "always";
+                            }
+                            else {
+                                // The picker reads the keyboard itself, so the type-ahead
+                                // collector has to let go of it — otherwise it swallows the
+                                // arrow keys and the approval can never be answered. Awaited,
+                                // because letting go settles first: the picker appears under
+                                // whatever the user is already typing and defaults to Yes, so
+                                // a keystroke in flight must not be able to answer it.
+                                await typing.pause();
+                                try {
+                                    decision = await askToolApproval(approval);
+                                }
+                                finally {
+                                    typing.resume();
+                                }
+                            }
                             if (decision === "always") {
                                 approveEveryTool = true;
                             }
@@ -780,7 +1048,7 @@ export async function runAskSession(options) {
                                 return false;
                             }
                             // The call was announced before the prompt; keep its label up
-                            // while it runs instead of falling back to a blank "Asking…".
+                            // while it runs instead of falling back to a thinking word.
                             rememberTool({
                                 toolCallId: approval.toolCallId,
                                 toolName: approval.toolName,
@@ -804,7 +1072,35 @@ export async function runAskSession(options) {
                     if (live !== undefined) {
                         endAssistantTurn(live);
                     }
+                    // The turn is over, whichever way it went: every branch below either
+                    // replaces the Claude Code session or unwinds the command. So a
+                    // Ctrl-C from here cannot stop anything the user would want stopped
+                    // — all it can do is skip the teardown, since `process.exit` runs no
+                    // `finally` and the `finally` blocks are what stop Claude Code.
+                    //
+                    // Marked for the whole unwind rather than the cancel branch alone. A
+                    // stall waits on the same `close` with the collector still holding
+                    // the terminal, and it is the likelier press of the two: minutes of
+                    // spinner is what makes someone reach for Ctrl-C in the first place.
+                    //
+                    // It also freezes the flag the branch below reads, so a press
+                    // landing here cannot make a stall look like a user cancel.
+                    cancellation.beginTeardown();
                     if (cancellation.wasCancelled() === true) {
+                        // Ctrl-C aborts the harness stream, and what it leaves behind is a
+                        // session that answers nothing: the next question opens a stream
+                        // that yields its `start` part and then goes silent until the
+                        // stall watchdog gives up on it two minutes later. The harness
+                        // does not report it as an unfinished turn, so there is nothing to
+                        // drain and no way to tell from the outside — the only cure is a
+                        // new Claude Code process.
+                        //
+                        // Paid here rather than on the next question so the wait belongs
+                        // to the interrupt the user just pressed. The chat, its history
+                        // and the working copy all survive; the next turn replays the
+                        // history into a fresh session.
+                        await local.close();
+                        local = undefined;
                         showTouchedFiles(touchedFiles, options.dir);
                         showNotices(notices);
                         showCard("Cancelled.");
@@ -832,6 +1128,10 @@ export async function runAskSession(options) {
                     throw error;
                 }
                 finally {
+                    // Before `cancellation.release()`: while the collector still owns
+                    // the terminal, Ctrl-C is a keypress it turns into an interrupt, and
+                    // dropping the handler first would leave a window with neither.
+                    typedAhead = typing.finish();
                     cancellation.release();
                     await releaseChatTurn(options.api, chatUuid, sessionId);
                 }
@@ -869,7 +1169,9 @@ export async function runAskSession(options) {
             // Registered before the spinner so our handler runs before clack's own
             // — same ordering as the local turn.
             const cancellation = beginCancellableTurn(stopRemoteSpinner);
-            spinner = startSpinner("Asking…");
+            // A remote turn is one stream with no tool steps of its own to mark, so
+            // it gets the one word rather than a sequence of them.
+            spinner = startSpinner(pickThinkingWord());
             let assistantMessageUuid;
             try {
                 const deltas = streamMessageTextDeltas({