@cargo-ai/cli 1.0.94 → 1.0.96

package/build/commands/ask/session/run.js

@@ -0,0 +1,846 @@
+import { determineIfIsFetcherError } from "@cargo-ai/api";
+import { isInteractive, selectOne } from "@cargo-ai/cdk/cli";
+import { v4 as uuidv4 } from "uuid";
+import { getConfig } from "../../../config.js";
+import { openPromptInput } from "../../../utils/prompt.js";
+import { ExitCodes, failWith, handleApiCall, outputJson, startSpinner, } from "../../runHandler.js";
+import { createLocalHarness, HarnessTurnStalled, HarnessTurnStuck, isBridgeClosedError, } from "../harness/index.js";
+import { readAskLine } from "../input/prompt.js";
+import { parseSlash } from "../input/slash.js";
+import { collectTypeAhead, EMPTY_TYPE_AHEAD, } from "../input/typeAhead.js";
+import { loadChatHistoryPreamble } from "../persist/history.js";
+import { saveAskState } from "../persist/persist.js";
+import { ASK_STATE_VERSION } from "../persist/state.js";
+import { claimChatTurn, proxyTokenDeadlineMs, releaseChatTurn, reportApiFailure, } from "./claim.js";
+import { pickThinkingWord } from "./thinking.js";
+import { appendAssistantDelta, askToolApproval, askUserQuestions, beginAssistantTurn, describeToolActivity, endAssistantTurn, setAssistantFooter, showAssistantTurn, showCard, showNotices, showToolRun, showTouchedFiles, showUserTurn, } from "./tree.js";
+function requireInteractive() {
+    if (isInteractive() === false || process.stdout.isTTY !== true) {
+        failWith("Ask needs a terminal. Re-run with --print for one JSON turn.", {
+            code: ExitCodes.InvalidUsage,
+        });
+    }
+}
+/** Sentinel for `/agent` → Local workspace (no agentUuid). */
+const LOCAL_WORKSPACE = "__local_workspace__";
+async function loadAgent(api, agentUuid) {
+    const result = await handleApiCall(() => api.ai.agent.get(agentUuid));
+    return result.agent;
+}
+async function loadDeployedRelease(api, agent) {
+    if (agent === undefined) {
+        return undefined;
+    }
+    if (agent.deployedRelease === undefined) {
+        return undefined;
+    }
+    const { release } = await handleApiCall(() => api.ai.release.getDeployed({
+        agentUuid: agent.uuid,
+    }), { spinner: false });
+    return release;
+}
+/**
+ * Pick a workspace agent, or Local workspace (clears the agent).
+ * Returns undefined when the user chooses the local default.
+ */
+async function pickAgent(api, currentUuid) {
+    const { agents } = await handleApiCall(() => api.ai.agent.all());
+    const chosen = await selectOne({
+        message: "Agent for the next question",
+        recommended: currentUuid !== undefined ? currentUuid : LOCAL_WORKSPACE,
+        choices: [
+            {
+                value: LOCAL_WORKSPACE,
+                label: "Local workspace",
+                hint: "Claude Code on this machine (default)",
+                fallback: true,
+            },
+            ...agents.map((agent) => ({
+                value: agent.uuid,
+                label: agent.name,
+                hint: agent.uuid,
+            })),
+        ],
+    });
+    if (chosen === LOCAL_WORKSPACE) {
+        return undefined;
+    }
+    return chosen;
+}
+/**
+ * cargo ask always runs in local Claude Code, including after `/agent`, so
+ * the chat is stamped claudeCode for ingest.
+ */
+async function ensureChat(input) {
+    if (input.created === true) {
+        return;
+    }
+    await handleApiCall(() => input.api.ai.chat.create({
+        uuid: input.chatUuid,
+        trigger: { type: "cli" },
+        agentUuid: input.agentUuid,
+        harnessSlug: "claudeCode",
+    }), { spinner: false });
+}
+function persistAskState(input) {
+    saveAskState({
+        version: ASK_STATE_VERSION,
+        chatUuid: input.chatUuid,
+        agentUuid: input.agentUuid,
+        updatedAt: new Date().toISOString(),
+    });
+}
+/**
+ * True when the chat is already on the server. A saved `--continue` uuid can
+ * point at nothing (Esc before the first turn, wiped local DB, different API),
+ * and that must become a create — not chatNotFound on the first message.
+ *
+ * Careful with the false case: it means "not readable", which covers a chat
+ * that was deleted as well as one that never existed. Deletion is soft, so
+ * the row keeps the uuid and creating it again fails on the primary key —
+ * see where `--continue` resolves its uuid.
+ */
+export async function doesChatExist(api, chatUuid) {
+    try {
+        await api.ai.chat.get(chatUuid);
+        return true;
+    }
+    catch (error) {
+        if (determineIfIsFetcherError(error) === true &&
+            error.status === 404) {
+            return false;
+        }
+        await handleApiCall(async () => {
+            throw error;
+        }, { spinner: false });
+        return false;
+    }
+}
+/**
+ * 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, tearingDown: false };
+    const handleInterrupt = () => {
+        if (state.tearingDown === true) {
+            return;
+        }
+        if (state.cancelled === true) {
+            // 130 is the conventional "terminated by SIGINT" status.
+            process.exit(130);
+        }
+        state.cancelled = true;
+        onCancel();
+        controller.abort();
+    };
+    process.on("SIGINT", handleInterrupt);
+    return {
+        signal: controller.signal,
+        wasCancelled: () => state.cancelled,
+        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;
+        },
+    };
+}
+/**
+ * Live prompt: `◆  ` with an as-you-type suggestion menu for `/…` commands
+ * 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, 
+/** Typed while the last turn was still answering, and not sent as its own. */
+typedAhead = "") {
+    if (firstMessage !== undefined) {
+        showUserTurn(firstMessage);
+        return firstMessage;
+    }
+    const input = openPromptInput();
+    if (input === undefined) {
+        failWith("Ask needs a terminal. Re-run with --print for one JSON turn.", {
+            code: ExitCodes.InvalidUsage,
+        });
+    }
+    try {
+        const answer = await readAskLine(input.stream, dir, typedAhead);
+        if (answer === undefined) {
+            return undefined;
+        }
+        showUserTurn(answer);
+        return answer;
+    }
+    finally {
+        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…
+ *   ◆
+ * Empty Enter or /exit leaves to the parent palette.
+ */
+export async function runAskSession(options) {
+    requireInteractive();
+    const config = getConfig();
+    // An API token from CARGO_API_TOKEN is workspace-bound on the server, so
+    // config.workspaceUuid can be unset — same as whoami / every other command.
+    if (config.getAccessToken === undefined) {
+        failWith("Not authenticated. Run 'cargo-ai login --email <email>' or 'cargo-ai login --oauth'.", { code: ExitCodes.NotAuthenticated });
+    }
+    let agent;
+    if (options.agentUuid !== undefined) {
+        agent = await loadAgent(options.api, options.agentUuid);
+        if (agent.deployedRelease === undefined) {
+            failWith(`${agent.name} has no deployed release, so Ask cannot load its prompt and tools.`, { code: ExitCodes.GenericError });
+        }
+    }
+    let chatUuid = options.chatUuid !== undefined ? options.chatUuid : uuidv4();
+    let chatCreated = false;
+    let pendingFirst = options.message;
+    let harness;
+    // The proxy token is fixed in the Claude Code process env at spawn, so the
+    // only way to refresh it is to rebuild the harness. These two say when that
+    // becomes necessary; see `proxyTokenDeadlineMs`.
+    let proxyTokenMintedAtMs = 0;
+    let proxyTokenTtlMs = 0;
+    // Identifies this process to the server's per-chat turn claim, so our own
+    // next turn renews it rather than colliding with it.
+    const sessionId = uuidv4();
+    // "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 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";
+            }
+            const slash = parseSlash(question);
+            if (slash !== undefined) {
+                if (slash.kind === "card") {
+                    showCard(slash.text);
+                    continue;
+                }
+                if (slash.action === "exit") {
+                    return "palette";
+                }
+                if (slash.action === "cancel") {
+                    showCard("Nothing is running — this prompt only appears between turns. Press Ctrl-C while a turn is in flight to stop it.");
+                    continue;
+                }
+                if (slash.action === "new" || slash.action === "clear") {
+                    if (harness !== undefined) {
+                        await harness.close();
+                        harness = undefined;
+                    }
+                    // Fresh session returns to the local default (no agent).
+                    agent = undefined;
+                    chatUuid = uuidv4();
+                    chatCreated = false;
+                    approveEveryTool = false;
+                    showCard("Started a fresh chat.");
+                    continue;
+                }
+                if (slash.action === "pick-agent") {
+                    const nextUuid = await pickAgent(options.api, agent === undefined ? undefined : agent.uuid);
+                    if (nextUuid === undefined) {
+                        if (harness !== undefined) {
+                            await harness.close();
+                            harness = undefined;
+                        }
+                        agent = undefined;
+                        approveEveryTool = false;
+                        continue;
+                    }
+                    const nextAgent = await loadAgent(options.api, nextUuid);
+                    if (nextAgent.deployedRelease === undefined) {
+                        showCard(`${nextAgent.name} has no deployed release, so Ask cannot load its prompt and tools.`);
+                        continue;
+                    }
+                    if (harness !== undefined) {
+                        await harness.close();
+                        harness = undefined;
+                    }
+                    agent = nextAgent;
+                    // A blanket "yes" was given to one agent's local session, not to
+                    // whatever the next one wants to run.
+                    approveEveryTool = false;
+                    continue;
+                }
+            }
+            if (chatCreated === false) {
+                await ensureChat({
+                    api: options.api,
+                    chatUuid,
+                    agentUuid: agent === undefined ? undefined : agent.uuid,
+                    created: false,
+                });
+                chatCreated = true;
+            }
+            // A session left at the prompt long enough for its token to lapse
+            // would send the next turn with a dead key, which surfaces as an
+            // authentication failure from the proxy rather than anything the user
+            // can act on. Rebuilding costs a cold start and a history replay, so
+            // it happens only once the token really is past saving.
+            if (harness !== undefined) {
+                const deadlineMs = proxyTokenDeadlineMs({
+                    mintedAtMs: proxyTokenMintedAtMs,
+                    lastUsedAtMs: harness.proxyLastUsedAtMs(),
+                    ttlMs: proxyTokenTtlMs,
+                });
+                if (Date.now() >= deadlineMs) {
+                    await harness.close();
+                    harness = undefined;
+                }
+            }
+            if (harness === undefined) {
+                // 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.proxy.mintToken(chatUuid), { spinner: false });
+                    proxyTokenMintedAtMs = Date.now();
+                    proxyTokenTtlMs = 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,
+                    });
+                    harness = await createLocalHarness({
+                        api: options.api,
+                        apiBaseUrl: config.baseUrl,
+                        dir: options.dir,
+                        chatUuid,
+                        agentUuid: agent === undefined ? undefined : agent.uuid,
+                        release: await loadDeployedRelease(options.api, agent),
+                        proxyToken: minted.token,
+                        connectorUuid: minted.connectorUuid,
+                        integrationSlug: minted.integrationSlug,
+                        languageModelSlug: minted.languageModelSlug,
+                        history,
+                        turnOwnerId: sessionId,
+                        allowWorkspaceMutations: true,
+                    });
+                }
+                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
+            // second session resuming it would spend alongside this one.
+            //
+            // Taken here rather than before the setup above: the claim is only
+            // released by a finished turn, so holding it across a mint or a
+            // harness build that then fails would block the chat for the whole
+            // TTL. Nothing in the setup needs protecting — mint hands back the
+            // token already in play rather than replacing it.
+            const claim = await claimChatTurn(options.api, chatUuid, sessionId);
+            if (claim.outcome === "busy") {
+                showCard("Another session is already running a turn in this chat. Wait for it to finish, or /new to start a fresh one.");
+                continue;
+            }
+            if (claim.outcome === "unavailable") {
+                // Reporting this ends the process, and the harness is already
+                // running — shut it down here, because `process.exit` skips the
+                // `finally` below that would otherwise have done it. Left assigned
+                // so the `finally` still closes it on the one path that unwinds
+                // instead of exiting; closing twice is harmless.
+                await harness.close();
+                await reportApiFailure(claim.error);
+            }
+            let spinner;
+            let live;
+            // A tool interrupting the narration closes the live block, so `live`
+            // alone cannot tell whether the turn ever said anything.
+            let saidSomething = false;
+            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 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();
+                    spinner = undefined;
+                }
+            };
+            const showSpinner = (label) => {
+                if (spinner === undefined) {
+                    spinner = startSpinner(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) {
+                    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
+            // summary once its input is known — so the second has to overwrite the
+            // first rather than stack a duplicate label.
+            const rememberTool = (tool) => {
+                const at = activeTools.findIndex((active) => active.toolCallId === tool.toolCallId);
+                if (at === -1) {
+                    activeTools.push(tool);
+                }
+                else {
+                    activeTools[at] = tool;
+                }
+                showActiveToolSpinner();
+            };
+            const forgetTool = (toolCallId) => {
+                const at = activeTools.findIndex((active) => active.toolCallId === toolCallId);
+                if (at !== -1) {
+                    activeTools.splice(at, 1);
+                }
+                showActiveToolSpinner();
+            };
+            // Registered before the spinner so our SIGINT handler runs first and
+            // 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(thinkingWord);
+            const typing = beginTurnTyping({
+                carriedLine,
+                onInterrupt: () => cancellation.interrupt(),
+                onTyped: (text) => {
+                    typedLine = text;
+                    paintTyped();
+                },
+            });
+            carriedLine = "";
+            try {
+                await harness.streamPrompt(question, {
+                    abortSignal: cancellation.signal,
+                    onStall: () => {
+                        cancellation.abort();
+                    },
+                    onTextDelta: (delta) => {
+                        if (live === undefined) {
+                            stopSpinner();
+                            live = beginAssistantTurn();
+                            // The spinner was carrying the typed line; it goes with it.
+                            paintTyped();
+                        }
+                        saidSomething = true;
+                        appendAssistantDelta(live, delta);
+                    },
+                    onActivity: (activity) => {
+                        // Tool work replaces the spinner text so a long Bash step is
+                        // not an unexplained pause. Claude Code narrates before it acts,
+                        // 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.
+                        // 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;
+                        }
+                        if (live !== undefined) {
+                            endAssistantTurn(live);
+                            live = undefined;
+                        }
+                        rememberTool({
+                            toolCallId: activity.toolCallId,
+                            toolName: activity.toolName,
+                            summary: activity.summary,
+                        });
+                    },
+                    onFileTouched: (path) => {
+                        touchedFiles.add(path);
+                    },
+                    onNotice: (message) => {
+                        notices.push(message);
+                    },
+                    onApproval: async (approval) => {
+                        // Close whatever is on screen: the prompt owns the line next.
+                        if (live !== undefined) {
+                            endAssistantTurn(live);
+                            live = undefined;
+                        }
+                        stopSpinner();
+                        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;
+                        }
+                        if (decision === "no") {
+                            forgetTool(approval.toolCallId);
+                            return false;
+                        }
+                        // The call was announced before the prompt; keep its label up
+                        // while it runs instead of falling back to a thinking word.
+                        rememberTool({
+                            toolCallId: approval.toolCallId,
+                            toolName: approval.toolName,
+                            summary: approval.summary,
+                        });
+                        return true;
+                    },
+                    onUserQuestion: async (input) => {
+                        if (live !== undefined) {
+                            endAssistantTurn(live);
+                            live = undefined;
+                        }
+                        stopSpinner();
+                        await typing.pause();
+                        try {
+                            return await askUserQuestions(input);
+                        }
+                        finally {
+                            typing.resume();
+                        }
+                    },
+                });
+                stopSpinner();
+                if (live !== undefined) {
+                    endAssistantTurn(live);
+                }
+                else if (saidSomething === false) {
+                    showAssistantTurn("");
+                }
+                showTouchedFiles(touchedFiles, options.dir);
+                showNotices(notices);
+            }
+            catch (error) {
+                stopSpinner();
+                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 harness.close();
+                    harness = undefined;
+                    showTouchedFiles(touchedFiles, options.dir);
+                    showNotices(notices);
+                    showCard("Cancelled.");
+                    persistAskState({
+                        chatUuid,
+                        agentUuid: agent === undefined ? undefined : agent.uuid,
+                    });
+                    continue;
+                }
+                showNotices(notices);
+                // The runtime could not be wound down, went silent, or the bridge
+                // dropped — this session will refuse every question from here.
+                // Replace it rather than exiting Ask: the chat, its history and the
+                // working copy all survive; only the Claude Code process is new.
+                if (error instanceof HarnessTurnStuck ||
+                    error instanceof HarnessTurnStalled ||
+                    isBridgeClosedError(error) === true) {
+                    await harness.close();
+                    harness = undefined;
+                    showCard(error instanceof HarnessTurnStalled
+                        ? `${error.message} The coding session has been replaced — ask again, or try smaller steps.`
+                        : "That coding session stopped responding, so it has been replaced. Ask again — the chat is unchanged.");
+                    continue;
+                }
+                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);
+            }
+            persistAskState({
+                chatUuid,
+                agentUuid: agent === undefined ? undefined : agent.uuid,
+            });
+            continue;
+        }
+    }
+    finally {
+        if (harness !== undefined) {
+            await harness.close();
+        }
+    }
+}
+export async function runAskPrint(input) {
+    const config = getConfig();
+    if (config.getAccessToken === undefined) {
+        failWith("Not authenticated. Run 'cargo-ai login --email <email>' or 'cargo-ai login --oauth'.", { code: ExitCodes.NotAuthenticated });
+    }
+    const agent = input.agentUuid !== undefined
+        ? await loadAgent(input.api, input.agentUuid)
+        : undefined;
+    if (agent !== undefined && agent.deployedRelease === undefined) {
+        failWith(`${agent.name} has no deployed release, so Ask cannot load its prompt and tools.`, { code: ExitCodes.GenericError });
+    }
+    const chatUuid = input.chatUuid !== undefined ? input.chatUuid : uuidv4();
+    // Same lifecycle as the interactive session: a caller-supplied uuid may
+    // already be on the server (--chat-uuid, or --continue reopening the last
+    // thread), in which case creating it again would fail; a fresh one has to
+    // be created before the first message.
+    const chatCreated = input.chatUuid !== undefined
+        ? await doesChatExist(input.api, input.chatUuid)
+        : false;
+    await ensureChat({
+        api: input.api,
+        chatUuid,
+        agentUuid: agent === undefined ? undefined : agent.uuid,
+        created: chatCreated,
+    });
+    const minted = await handleApiCall(() => input.api.ai.chat.proxy.mintToken(chatUuid), { spinner: false });
+    const history = await loadChatHistoryPreamble({
+        api: input.api,
+        chatUuid,
+    });
+    const ownerId = uuidv4();
+    // Before the harness is built, because both exits below end the process
+    // and `process.exit` does not run `finally` blocks — either one below a
+    // live harness would leave Claude Code and its bridge running.
+    const claim = await claimChatTurn(input.api, chatUuid, ownerId);
+    if (claim.outcome === "busy") {
+        failWith("Another session is already running a turn in this chat. Wait for it to finish, or pass --chat-uuid for a different one.", { code: ExitCodes.GenericError });
+    }
+    if (claim.outcome === "unavailable") {
+        await reportApiFailure(claim.error);
+    }
+    let harness;
+    try {
+        harness = await createLocalHarness({
+            api: input.api,
+            apiBaseUrl: config.baseUrl,
+            dir: input.dir,
+            chatUuid,
+            agentUuid: agent === undefined ? undefined : agent.uuid,
+            release: await loadDeployedRelease(input.api, agent),
+            proxyToken: minted.token,
+            connectorUuid: minted.connectorUuid,
+            integrationSlug: minted.integrationSlug,
+            languageModelSlug: minted.languageModelSlug,
+            history,
+            turnOwnerId: ownerId,
+            allowWorkspaceMutations: false,
+        });
+        const text = await harness.streamPrompt(input.message);
+        persistAskState({
+            chatUuid,
+            agentUuid: agent === undefined ? undefined : agent.uuid,
+        });
+        outputJson({ chatUuid, text });
+    }
+    finally {
+        // Covers the build as well as the turn: a turn that errored spent
+        // nothing and so recorded nothing, and a build that failed never got as
+        // far as a turn. Either would leave the chat claimed until the TTL.
+        await releaseChatTurn(input.api, chatUuid, ownerId);
+        if (harness !== undefined) {
+            await harness.close();
+        }
+    }
+}