@cargo-ai/cli 1.0.92 → 1.0.95

package/build/commands/ask/session.js

@@ -1,1328 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { isAbsolute, relative } from "node:path";
-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 { 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";
-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.", {
-            code: ExitCodes.InvalidUsage,
-        });
-    }
-}
-/** 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
- * turn makes.
- */
-const TOKEN_REFRESH_MARGIN_MS = 5 * 60_000;
-/**
- * When the proxy token baked into the running harness stops being safe to
- * reuse.
- *
- * The server re-arms the token on every proxy call, so the clock runs from
- * the last turn that reached Anthropic rather than from when it was minted.
- * Anchoring it to mint time instead would tear down a conversation that is
- * still going — a cold start, a replayed history preamble and the loss of
- * Claude Code's in-session memory, for a token that had not expired.
- *
- * Exported for tests.
- */
-export function proxyTokenDeadlineMs(input) {
-    const armedAtMs = input.lastUsedAtMs === undefined ? input.mintedAtMs : input.lastUsedAtMs;
-    return armedAtMs + input.ttlMs - TOKEN_REFRESH_MARGIN_MS;
-}
-const PRINT_POLL_INTERVAL_MS = 5_000;
-/**
- * How long `--print` waits for a remote turn. Generous, because a multi-step
- * agent legitimately runs for a while — but bounded, because `--print` is the
- * path used by pipes and CI, where nobody is there to notice a wait that
- * never ends.
- */
-const PRINT_POLL_TIMEOUT_MS = 30 * 60_000;
-async function loadAgent(api, agentUuid) {
-    const result = await handleApiCall(() => api.ai.agent.get(agentUuid));
-    return result.agent;
-}
-/**
- * No agent → local Claude Code on the host. Any agent streams remotely, like
- * the webapp chat: what it runs — a tool loop or a harness against its bound
- * repo — follows from its deployed release, which the API resolves itself.
- *
- * Exported for tests.
- */
-export function modeForAgent(agent) {
-    return agent === undefined ? { kind: "local" } : { kind: "remote" };
-}
-/**
- * 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;
-}
-/**
- * `harnessSlug` is deliberately not sent. On the API it is a chat-level
- * override that outranks the agent's release for the life of the chat, so a
- * chat stamped here would keep routing to a harness even after `/agent` picks
- * something else — and a local chat's harness runs on this machine, where the
- * API could not reach it anyway. Letting the release speak for itself keeps the
- * chat reusable by any agent.
- */
-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,
-    }), { spinner: false });
-}
-function persistAskState(input) {
-    saveAskState({
-        version: ASK_STATE_VERSION,
-        chatUuid: input.chatUuid,
-        agentUuid: input.agentUuid,
-        updatedAt: new Date().toISOString(),
-    });
-}
-/**
- * Take the chat for one local turn.
- *
- * Exported for tests.
- */
-export async function claimChatTurn(api, chatUuid, ownerId) {
-    try {
-        await api.ai.chat.claimTurn(chatUuid, { ownerId });
-        return { outcome: "claimed" };
-    }
-    catch (error) {
-        if (determineIfIsFetcherError(error) === true &&
-            error.status === 409) {
-            return { outcome: "busy" };
-        }
-        // Handed back rather than reported from here. Reporting an API failure
-        // ends the process, and the interactive session has a Claude Code process
-        // to shut down first — `process.exit` does not run the `finally` that
-        // would have done it.
-        return { outcome: "unavailable", error };
-    }
-}
-/**
- * Report an API failure the way every other call in the CLI does, and exit.
- * Never returns: `handleApiCall` exits on a recognised API error, and anything
- * else is rethrown for the top-level handler.
- */
-async function reportApiFailure(error) {
-    await handleApiCall(async () => {
-        throw error;
-    }, { spinner: false });
-    throw error;
-}
-/**
- * Hand the chat back after a turn.
- *
- * Recording the turn already does this, but a turn that spent nothing has
- * nothing to record — a stall, an expired token, a workspace out of credits —
- * and the claim would sit there until it expired, telling the next process the
- * chat was busy.
- *
- * Best effort: the TTL is the backstop, and a reply the user has already read
- * must not fail on the way out.
- */
-async function releaseChatTurn(api, chatUuid, ownerId) {
-    try {
-        await api.ai.chat.releaseTurn(chatUuid, { ownerId });
-    }
-    catch {
-        // Nothing useful to say to the user about this one.
-    }
-}
-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;
-    }
-}
-/**
- * Body width under `◇  ` / `│  ` / `◆  `. Soft wrap without this drops the
- * rail mid-line and the tree looks broken.
- */
-function treeBodyWidth() {
-    const columns = process.stderr.columns === undefined ? 80 : process.stderr.columns;
-    // 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.
- */
-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];
-        if (current === undefined || `${current} ${word}`.length > width) {
-            lines.push(word);
-            continue;
-        }
-        lines[lines.length - 1] = `${current} ${word}`;
-    }
-    return lines;
-}
-/** One line under the current ◆/◇, with the │ rail (same indent as clack). */
-function writeRail(body) {
-    process.stderr.write(`${colors.dim("│")}  ${body}\n`);
-}
-/** Word-wrap onto the │ rail so the terminal never soft-wraps mid-line. */
-function writeRailWrapped(body) {
-    // Keep the rail on blank paragraphs so the tree does not break mid-reply.
-    if (body === "") {
-        writeRail("");
-        return;
-    }
-    const lines = wrapLine(body, treeBodyWidth());
-    if (lines.length === 0) {
-        writeRail("");
-        return;
-    }
-    for (const line of lines) {
-        writeRail(line);
-    }
-}
-/**
- * Light cleanup so model markdown does not fight the tree. Keeps the words;
- * drops heading marks, bold markers, and horizontal rules.
- */
-function forTerminal(text) {
-    return text
-        .replace(/^#{1,6}\s+/gm, "")
-        .replace(/\*\*([^*]+)\*\*/g, "$1")
-        .replace(/^---+$/gm, "");
-}
-/**
- * One finished step: label on the diamond, body on the rail.
- *
- *   ◇  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) {
-    writeDiamondBlock(label);
-    for (const paragraph of body.split("\n")) {
-        writeRailWrapped(paragraph);
-    }
-}
-/**
- * Slash help / notes — finished step like the palette:
- *   ◇  /help
- *   │  …
- */
-function showCard(body) {
-    const paragraphs = body.split("\n");
-    const title = paragraphs[0] === undefined ? "" : paragraphs[0];
-    const rest = paragraphs.slice(1).join("\n");
-    showStep(title, rest);
-}
-/**
- * Finished user turn — message on the diamond, like the palette's
- * `◇  ask hey --continue`. No "You" label.
- */
-function showUserTurn(body) {
-    writeDiamondBlock(body);
-}
-/**
- * Display lines for an assistant body. First line is the brick header body;
- * later lines sit on the │ rail. Blank paragraphs keep an empty rail.
- */
-function assistantDisplayLines(body) {
-    const paragraphs = forTerminal(body).split("\n");
-    const lines = [];
-    for (let index = 0; index < paragraphs.length; index += 1) {
-        const paragraph = paragraphs[index];
-        if (paragraph === undefined) {
-            continue;
-        }
-        if (paragraph === "") {
-            lines.push("");
-            continue;
-        }
-        const wrapped = wrapLine(paragraph, treeBodyWidth());
-        if (wrapped.length === 0) {
-            lines.push("");
-            continue;
-        }
-        for (const line of wrapped) {
-            lines.push(line);
-        }
-    }
-    if (lines.length === 0) {
-        return [""];
-    }
-    return lines;
-}
-function writeAssistantLines(lines) {
-    const first = lines[0] === undefined ? "" : lines[0];
-    process.stderr.write(`${ASSISTANT_MARKER}  ${first}\n`);
-    for (let index = 1; index < lines.length; index += 1) {
-        const line = lines[index];
-        if (line !== undefined) {
-            writeRail(line);
-        }
-    }
-}
-function clearPaintedLines(count) {
-    if (count <= 0 || process.stderr.isTTY !== true) {
-        return;
-    }
-    process.stderr.write(`\x1B[${String(count)}A\r\x1B[J`);
-}
-/** Rail gap, then an empty marker line ready for deltas. */
-function beginAssistantTurn() {
-    writeRail("");
-    process.stderr.write(`${ASSISTANT_MARKER}  \n`);
-    return { buffer: "", paintedLines: 1, footer: "" };
-}
-function appendAssistantDelta(live, 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) {
-    // 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, with `■` instead of `◇`.
- */
-function showAssistantTurn(body) {
-    const live = beginAssistantTurn();
-    appendAssistantDelta(live, body);
-    endAssistantTurn(live);
-}
-/**
- * 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;
-        },
-    };
-}
-/**
- * Stop a remote turn the user walked away from.
- *
- * Best effort: the uuid is only known once the server has announced the
- * message, and a failed cancel must not take the chat session down with it —
- * the next turn reports `lastMessageNotFinished` if this did not land.
- */
-async function cancelRemoteMessage(api, messageUuid) {
-    if (messageUuid === undefined) {
-        return;
-    }
-    try {
-        await api.ai.message.cancel({ uuids: [messageUuid] });
-    }
-    catch {
-        // Nothing useful to do here; surfacing it would bury the "Cancelled." card.
-    }
-}
-/** Common tool names arrive lowercase (`bash`); natives keep their case. */
-function toolLabel(toolName) {
-    if (toolName.length === 0) {
-        return "tool";
-    }
-    return `${toolName.slice(0, 1).toUpperCase()}${toolName.slice(1)}`;
-}
-const ACTIVITY_MAX_LENGTH = 72;
-function describeToolActivity(toolName, summary) {
-    const label = toolLabel(toolName);
-    if (summary === "") {
-        return label;
-    }
-    const line = `${label}: ${summary}`;
-    return line.length > ACTIVITY_MAX_LENGTH
-        ? `${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.
- *
- * Exported for tests.
- */
-export function displayPath(path, dir) {
-    const relativePath = relative(dir, path);
-    return relativePath === "" ||
-        relativePath.startsWith("..") === true ||
-        isAbsolute(relativePath) === true
-        ? path
-        : relativePath;
-}
-/**
- * Closing step for a turn that edited the working copy, so a reply that says
- * "done" is backed by the list of files it touched.
- */
-function showTouchedFiles(paths, dir) {
-    if (paths.size === 0) {
-        return;
-    }
-    const listed = [...paths].map((path) => displayPath(path, dir)).sort();
-    showStep(`${String(listed.length)} file${listed.length === 1 ? "" : "s"} changed`, listed.join("\n"));
-}
-/**
- * Side notes from a turn — a chat-history save that failed, say. They are not
- * part of the reply, so they land after it rather than inside it.
- */
-function showNotices(notices) {
-    while (notices.length > 0) {
-        const notice = notices.shift();
-        if (notice !== undefined) {
-            showCard(notice);
-        }
-    }
-}
-/**
- * Local Claude Code runs against the user's own working copy, so anything
- * beyond a read is confirmed before it happens:
- *
- *   ◆  Run Bash: npm test?
- *   │  ● Yes …
- */
-async function askToolApproval(approval) {
-    const decision = await selectOne({
-        message: approval.summary === ""
-            ? `Run ${approval.toolName}?`
-            : `Run ${approval.toolName}: ${approval.summary}?`,
-        recommended: "yes",
-        // Escape here means "not that tool", not "leave the chat" — the turn
-        // continues and the model reports what it could not do.
-        cancelValue: "no",
-        choices: [
-            { value: "yes", label: "Yes", hint: "just this once" },
-            { value: "always", label: "Yes to everything", hint: "for this chat" },
-            { value: "no", label: "No", hint: "tell the model to skip it" },
-        ],
-    });
-    return decision === "always" ? "always" : decision === "no" ? "no" : "yes";
-}
-/**
- * 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 = options.agentUuid !== undefined
-        ? await loadAgent(options.api, options.agentUuid)
-        : undefined;
-    let chatUuid = options.chatUuid !== undefined ? options.chatUuid : randomUUID();
-    let chatCreated = false;
-    let pendingFirst = options.message;
-    let local;
-    // 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 localTokenMintedAtMs = 0;
-    let localTokenTtlMs = 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 = 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 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 (local !== undefined) {
-                        await local.close();
-                        local = undefined;
-                    }
-                    // Fresh session returns to the local default (no agent).
-                    agent = undefined;
-                    chatUuid = randomUUID();
-                    chatCreated = false;
-                    approveEveryTool = false;
-                    showCard("Started a fresh chat.");
-                    continue;
-                }
-                if (slash.action === "pick-agent") {
-                    if (local !== undefined) {
-                        await local.close();
-                        local = undefined;
-                    }
-                    const nextUuid = await pickAgent(options.api, agent === undefined ? undefined : agent.uuid);
-                    agent =
-                        nextUuid === undefined
-                            ? undefined
-                            : await loadAgent(options.api, nextUuid);
-                    // A blanket "yes" was given to one agent's local session, not to
-                    // whatever the next one wants to run.
-                    approveEveryTool = false;
-                    continue;
-                }
-            }
-            if (mode.kind === "local") {
-                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 (local !== undefined &&
-                    Date.now() >=
-                        proxyTokenDeadlineMs({
-                            mintedAtMs: localTokenMintedAtMs,
-                            lastUsedAtMs: local.proxyLastUsedAtMs(),
-                            ttlMs: localTokenTtlMs,
-                        })) {
-                    await local.close();
-                    local = undefined;
-                }
-                if (local === 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.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
-                // 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 local.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 local.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;
-                        },
-                    });
-                    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 local.close();
-                        local = 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 local.close();
-                        local = 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;
-            }
-            if (agent === undefined) {
-                failWith("Ask remote stream needs an agent.", {
-                    code: ExitCodes.GenericError,
-                });
-            }
-            if (chatCreated === false) {
-                await ensureChat({
-                    api: options.api,
-                    chatUuid,
-                    agentUuid: agent.uuid,
-                    created: false,
-                });
-                chatCreated = true;
-            }
-            if (config.getAccessToken === undefined) {
-                failWith("Not authenticated. Run 'cargo-ai login --email <email>' or 'cargo-ai login --oauth'.", { code: ExitCodes.NotAuthenticated });
-            }
-            let live;
-            let spinner;
-            const stopRemoteSpinner = () => {
-                if (spinner !== undefined) {
-                    spinner.stop();
-                    spinner = undefined;
-                }
-            };
-            // Registered before the spinner so our handler runs before clack's own
-            // — same ordering as the local turn.
-            const cancellation = beginCancellableTurn(stopRemoteSpinner);
-            // 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({
-                    baseUrl: config.baseUrl,
-                    getAccessToken: config.getAccessToken,
-                    workspaceUuid: config.workspaceUuid,
-                    chatUuid,
-                    messageUuid: randomUUID(),
-                    parts: [{ type: "text", text: question }],
-                    agentUuid: agent.uuid,
-                    onAssistantMessageUuid: (uuid) => {
-                        assistantMessageUuid = uuid;
-                    },
-                    abortSignal: cancellation.signal,
-                });
-                for await (const delta of deltas) {
-                    if (live === undefined) {
-                        stopRemoteSpinner();
-                        live = beginAssistantTurn();
-                    }
-                    appendAssistantDelta(live, delta);
-                }
-                if (live === undefined) {
-                    stopRemoteSpinner();
-                    showAssistantTurn("");
-                }
-                else {
-                    endAssistantTurn(live);
-                }
-            }
-            catch (error) {
-                stopRemoteSpinner();
-                if (live !== undefined) {
-                    endAssistantTurn(live);
-                }
-                // Ctrl-C only stops the CLI reading the stream, so the message has to
-                // be cancelled server-side too — an unfinished one makes the next
-                // question in this chat fail with lastMessageNotFinished.
-                if (cancellation.wasCancelled() === true) {
-                    await cancelRemoteMessage(options.api, assistantMessageUuid);
-                    showCard("Cancelled.");
-                    persistAskState({ chatUuid, agentUuid: agent.uuid });
-                    continue;
-                }
-                if (error instanceof Error) {
-                    failWith(error.message, { code: ExitCodes.GenericError });
-                }
-                throw error;
-            }
-            finally {
-                cancellation.release();
-            }
-            persistAskState({
-                chatUuid,
-                agentUuid: agent.uuid,
-            });
-        }
-    }
-    finally {
-        if (local !== undefined) {
-            await local.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;
-    const mode = modeForAgent(agent);
-    const chatUuid = input.chatUuid !== undefined ? input.chatUuid : randomUUID();
-    // 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;
-    if (mode.kind === "local") {
-        await ensureChat({
-            api: input.api,
-            chatUuid,
-            agentUuid: agent === undefined ? undefined : agent.uuid,
-            created: chatCreated,
-        });
-        const minted = await handleApiCall(() => input.api.ai.chat.mintHarnessProxyToken(chatUuid), { spinner: false });
-        const history = await loadChatHistoryPreamble({
-            api: input.api,
-            chatUuid,
-        });
-        const ownerId = randomUUID();
-        // 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 local;
-        try {
-            local = await createLocalHarness({
-                api: input.api,
-                apiBaseUrl: config.baseUrl,
-                dir: input.dir,
-                chatUuid,
-                agentUuid: agent === undefined ? undefined : agent.uuid,
-                proxyToken: minted.token,
-                history,
-                turnOwnerId: ownerId,
-            });
-            const text = await local.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 (local !== undefined) {
-                await local.close();
-            }
-        }
-        return;
-    }
-    if (agent === undefined) {
-        failWith("Ask remote print needs an agent.", {
-            code: ExitCodes.GenericError,
-        });
-    }
-    await ensureChat({
-        api: input.api,
-        chatUuid,
-        agentUuid: agent.uuid,
-        created: chatCreated,
-    });
-    const result = await handleApiCall(() => input.api.ai.message.create({
-        chatUuid,
-        agentUuid: agent.uuid,
-        parts: [{ type: "text", text: input.message }],
-    }));
-    const finalResult = await pollUntilFinished(() => input.api.ai.message.get(result.assistantMessage.uuid), (row) => row.message.finishedAt, PRINT_POLL_INTERVAL_MS, PRINT_POLL_TIMEOUT_MS);
-    persistAskState({ chatUuid, agentUuid: agent.uuid });
-    outputJson(finalResult);
-}