@cargo-ai/cli 1.0.86 → 1.0.88

package/build/commands/ask/thinking.d.ts

@@ -0,0 +1,21 @@
+/**
+ * What the spinner says while a turn is thinking rather than running a tool.
+ *
+ * One fixed word for every wait in every turn reads as a progress bar that is
+ * not moving — the same three syllables whether the answer took a second or a
+ * minute, and no way to tell a turn that is working from one that is stuck.
+ * A word that changes as the turn moves through its steps says the session is
+ * alive, which is the only thing a spinner can honestly report.
+ *
+ * Short, gerunds, and unambiguous about the fact that nothing is being done to
+ * anything yet. A few are freighted on purpose.
+ */
+export declare const ASK_THINKING_WORDS: readonly string[];
+/**
+ * A word for the next wait, never the one just used.
+ *
+ * Repeating straight after itself is the one draw that looks like the spinner
+ * is stuck rather than moving on, which is the whole thing this avoids.
+ */
+export declare function pickThinkingWord(previous?: string): string;
+//# sourceMappingURL=thinking.d.ts.map

package/build/commands/ask/thinking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking.d.ts","sourceRoot":"","sources":["../../../src/commands/ask/thinking.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB,EAAE,SAAS,MAAM,EAyB/C,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAc1D"}

package/build/commands/ask/thinking.js

@@ -0,0 +1,57 @@
+/**
+ * What the spinner says while a turn is thinking rather than running a tool.
+ *
+ * One fixed word for every wait in every turn reads as a progress bar that is
+ * not moving — the same three syllables whether the answer took a second or a
+ * minute, and no way to tell a turn that is working from one that is stuck.
+ * A word that changes as the turn moves through its steps says the session is
+ * alive, which is the only thing a spinner can honestly report.
+ *
+ * Short, gerunds, and unambiguous about the fact that nothing is being done to
+ * anything yet. A few are freighted on purpose.
+ */
+export const ASK_THINKING_WORDS = [
+    "Thinking",
+    "Pondering",
+    "Mulling",
+    "Musing",
+    "Noodling",
+    "Percolating",
+    "Ruminating",
+    "Puzzling",
+    "Deliberating",
+    "Considering",
+    "Weighing",
+    "Untangling",
+    "Wrangling",
+    "Churning",
+    "Brewing",
+    "Digging",
+    "Rummaging",
+    "Scheming",
+    "Plotting",
+    "Marshalling",
+    "Manifesting",
+    "Stowing",
+    "Loading",
+    "Hauling",
+];
+/**
+ * A word for the next wait, never the one just used.
+ *
+ * Repeating straight after itself is the one draw that looks like the spinner
+ * is stuck rather than moving on, which is the whole thing this avoids.
+ */
+export function pickThinkingWord(previous) {
+    // Callers hand back what the spinner was showing, ellipsis and all, while
+    // the list holds bare words. Comparing the two as they come never matches,
+    // and the word repeats as often as chance allows.
+    const last = previous === undefined ? undefined : previous.replace(/…$/, "");
+    const choices = last === undefined
+        ? ASK_THINKING_WORDS
+        : ASK_THINKING_WORDS.filter((word) => word !== last);
+    const pool = choices.length === 0 ? ASK_THINKING_WORDS : choices;
+    const index = Math.floor(Math.random() * pool.length);
+    const word = pool[index];
+    return `${word === undefined ? "Thinking" : word}…`;
+}

package/build/commands/ask/typeAhead.d.ts

@@ -0,0 +1,67 @@
+/// <reference types="node" resolution-mode="require"/>
+/**
+ * What the user typed while a turn was running.
+ *
+ * `submitted` is a line they finished with Enter, meant to be sent as the next
+ * question without stopping at the prompt. `pending` is everything typed
+ * behind it — a line they were still in the middle of, or a second one they
+ * did finish, which is one question too many to queue — and prefills the
+ * prompt instead.
+ */
+export type TypeAhead = {
+    submitted: string | undefined;
+    pending: string;
+};
+export declare const EMPTY_TYPE_AHEAD: TypeAhead;
+export type TypeAheadCollector = {
+    /**
+     * Hand stdin back, so a prompt inside the turn can read it itself.
+     *
+     * Resolves after a short settle during which keystrokes are read and thrown
+     * away, rather than releasing the terminal on the spot. A tool approval
+     * appears without warning under whatever the user is already typing, and it
+     * defaults to Yes — so an Enter meant to send the queued question would
+     * otherwise land on the picker and approve a shell command nobody read.
+     * Anything typed during the settle is discarded, which is the right reading
+     * of a keystroke aimed at a prompt that was not on screen yet.
+     */
+    pause: () => Promise<void>;
+    /** Take it back once that prompt is done. */
+    resume: () => void;
+    /** What has been typed so far, for the caller to draw under the spinner. */
+    current: () => string;
+    /** Stop collecting and report what was typed. */
+    stop: () => TypeAhead;
+};
+/**
+ * Collect keystrokes while a turn is running, instead of letting the terminal
+ * queue them and then lose them.
+ *
+ * Left alone, the tty stays in canonical mode through a turn: it echoes what
+ * is typed, buffers the line, and whether any of it survives the switch to raw
+ * mode when the Ask prompt reopens is a race — sometimes the line arrived,
+ * sometimes it vanished after being echoed, which is the worst of both. Owning
+ * the stream for the whole turn makes it deterministic, and lets a question
+ * typed during a reply be waiting when the reply ends.
+ *
+ * Raw mode is also what makes Ctrl-C reliable here. In canonical mode the
+ * terminal turns it into a SIGINT for the whole foreground process group,
+ * which is delivered to whatever child happens to own the terminal — during a
+ * Claude Code start that is Claude Code, which dies without this process ever
+ * hearing about it. As a keypress it always arrives, and `onInterrupt` can
+ * unwind the turn properly.
+ */
+export declare function collectTypeAhead(input: {
+    stream: NodeJS.ReadableStream;
+    /** Ctrl-C. Called on the keypress; the caller decides what it means. */
+    onInterrupt: () => void;
+    /** Called whenever the typed text changes, so it can be redrawn. */
+    onChange?: (text: string) => void;
+    /**
+     * The tail of an earlier type-ahead whose first line was already submitted.
+     * Starting from it keeps what was typed behind that question alive across
+     * the turn its own Enter kicked off.
+     */
+    initialLine?: string;
+}): TypeAheadCollector;
+//# sourceMappingURL=typeAhead.d.ts.map

package/build/commands/ask/typeAhead.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeAhead.d.ts","sourceRoot":"","sources":["../../../src/commands/ask/typeAhead.ts"],"names":[],"mappings":";AAGA;;;;;;;;GAQG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,SAG9B,CAAC;AA4BF,MAAM,MAAM,kBAAkB,GAAG;IAC/B;;;;;;;;;;OAUG;IACH,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,6CAA6C;IAC7C,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,4EAA4E;IAC5E,OAAO,EAAE,MAAM,MAAM,CAAC;IACtB,iDAAiD;IACjD,IAAI,EAAE,MAAM,SAAS,CAAC;CACvB,CAAC;AAgBF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE;IACtC,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;IAC9B,wEAAwE;IACxE,WAAW,EAAE,MAAM,IAAI,CAAC;IACxB,oEAAoE;IACpE,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,GAAG,kBAAkB,CAqJrB"}

package/build/commands/ask/typeAhead.js

@@ -0,0 +1,169 @@
+import * as readline from "node:readline";
+export const EMPTY_TYPE_AHEAD = {
+    submitted: undefined,
+    pending: "",
+};
+/**
+ * How long keystrokes are swallowed before a prompt inside a turn takes the
+ * keyboard.
+ *
+ * Long enough to catch the key already travelling when the prompt was decided
+ * on, short enough that nobody waiting for the question notices. The whole
+ * budget is spent before a human could have read what they are being asked, so
+ * nothing legitimate is lost.
+ *
+ * `CARGO_ASK_APPROVAL_SETTLE_MS` widens it for the end-to-end test that has to
+ * type into the window on purpose.
+ */
+const APPROVAL_SETTLE_MS = readSettleMs();
+function readSettleMs() {
+    const raw = process.env["CARGO_ASK_APPROVAL_SETTLE_MS"];
+    if (raw === undefined) {
+        return 250;
+    }
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 250;
+}
+function isTTYStream(stream) {
+    return (typeof stream.setRawMode === "function" &&
+        stream.isTTY === true);
+}
+/**
+ * Collect keystrokes while a turn is running, instead of letting the terminal
+ * queue them and then lose them.
+ *
+ * Left alone, the tty stays in canonical mode through a turn: it echoes what
+ * is typed, buffers the line, and whether any of it survives the switch to raw
+ * mode when the Ask prompt reopens is a race — sometimes the line arrived,
+ * sometimes it vanished after being echoed, which is the worst of both. Owning
+ * the stream for the whole turn makes it deterministic, and lets a question
+ * typed during a reply be waiting when the reply ends.
+ *
+ * Raw mode is also what makes Ctrl-C reliable here. In canonical mode the
+ * terminal turns it into a SIGINT for the whole foreground process group,
+ * which is delivered to whatever child happens to own the terminal — during a
+ * Claude Code start that is Claude Code, which dies without this process ever
+ * hearing about it. As a keypress it always arrives, and `onInterrupt` can
+ * unwind the turn properly.
+ */
+export function collectTypeAhead(input) {
+    const { stream } = input;
+    let line = input.initialLine === undefined ? "" : input.initialLine;
+    let submitted;
+    let stopped = false;
+    let listening = false;
+    let discarding = false;
+    const wasRaw = isTTYStream(stream) ? stream.isRaw === true : false;
+    const onKeypress = (str, key) => {
+        if (stopped === true) {
+            return;
+        }
+        // Mid-settle: the terminal is about to belong to a prompt that is not up
+        // yet, so nothing typed now is aimed at anything. Ctrl-C included — the
+        // prompt taking over has its own, and cancelling the turn out from under
+        // a question already being asked is not what the press meant either.
+        if (discarding === true) {
+            return;
+        }
+        if (key.ctrl === true && key.name === "c") {
+            input.onInterrupt();
+            return;
+        }
+        if (key.name === "return" || key.name === "enter") {
+            // Only the first finished line is carried forward as a question. A
+            // second Enter would mean two turns queued behind one reply, which is
+            // more than the user can be shown before it happens.
+            //
+            // Left alone rather than swallowed, though: the line behind a submitted
+            // question is the tail that prefills the next prompt, and it is drawn
+            // under a ◆ like any other, so Enter is the obvious way to finish it.
+            // Clearing it here destroyed the one thing that is meant to survive the
+            // turn its own Enter started.
+            if (submitted !== undefined) {
+                return;
+            }
+            const trimmed = line.trim();
+            if (trimmed.length > 0) {
+                submitted = trimmed;
+            }
+            line = "";
+            report();
+            return;
+        }
+        if (key.name === "backspace") {
+            if (line.length > 0) {
+                line = line.slice(0, -1);
+                report();
+            }
+            return;
+        }
+        if (str === undefined || str.length === 0) {
+            return;
+        }
+        if (key.ctrl === true || key.meta === true) {
+            return;
+        }
+        const code = str.codePointAt(0);
+        if (code === undefined || code < 32 || code === 127) {
+            return;
+        }
+        line = `${line}${str}`;
+        report();
+    };
+    function report() {
+        if (input.onChange !== undefined) {
+            input.onChange(line);
+        }
+    }
+    function listen() {
+        if (listening === true || stopped === true) {
+            return;
+        }
+        if (isTTYStream(stream) === true) {
+            stream.setRawMode(true);
+        }
+        // An interface closed by a prompt earlier in the turn leaves the stream
+        // paused, and a paused stream does not start flowing again just because a
+        // listener was added.
+        stream.resume();
+        readline.emitKeypressEvents(stream);
+        stream.on("keypress", onKeypress);
+        listening = true;
+    }
+    function unlisten() {
+        if (listening === false) {
+            return;
+        }
+        stream.off("keypress", onKeypress);
+        if (isTTYStream(stream) === true) {
+            stream.setRawMode(wasRaw);
+        }
+        listening = false;
+    }
+    listen();
+    return {
+        pause: async () => {
+            // Keeps reading throughout, so the keystroke already on its way in when
+            // the prompt was decided on is swallowed here rather than queued in the
+            // terminal for whatever reads next.
+            discarding = true;
+            await new Promise((resolve) => {
+                setTimeout(resolve, APPROVAL_SETTLE_MS);
+            });
+            unlisten();
+        },
+        resume: () => {
+            discarding = false;
+            listen();
+        },
+        current: () => line,
+        stop: () => {
+            if (stopped === true) {
+                return { submitted, pending: line };
+            }
+            stopped = true;
+            unlisten();
+            return { submitted, pending: line };
+        },
+    };
+}

package/build/commands/runHandler.d.ts

@@ -24,9 +24,16 @@ type FailWithOpts = {
     extra?: Record<string, unknown>;
 };
 export declare function failWith(message: string, opts?: FailWithOpts): never;
+/**
+ * Cut a plain line down to one screen row, with an ellipsis where it was cut.
+ *
+ * Exported for tests.
+ */
+export declare function clipToWidth(text: string, columns?: number): string;
 export type Spinner = {
     update: (message: string) => void;
     log: (line: string) => void;
+    footer: (text: string) => void;
     stop: () => void;
 };
 export declare function startSpinner(message: string): Spinner;

package/build/commands/runHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runHandler.d.ts","sourceRoot":"","sources":["../../src/commands/runHandler.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS;;;;;;;CAOZ,CAAC;AAEX,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAclE,eAAO,MAAM,MAAM;aACR,MAAM,KAAG,MAAM;eACb,MAAM,KAAG,MAAM;gBACd,MAAM,KAAG,MAAM;cACjB,MAAM,KAAG,MAAM;aAChB,MAAM,KAAG,MAAM;cACd,MAAM,KAAG,MAAM;CAC1B,CAAC;AAEF,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAM/C;AAED,wBAAgB,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE1C;AAED,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE7C;AAID,wBAAsB,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAUhE;AAED,KAAK,YAAY,GAAG;IAClB,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC,CAAC;AAEF,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,YAAY,GAAG,KAAK,CAgCpE;AAKD,MAAM,MAAM,OAAO,GAAG;IAEpB,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAGlC,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,IAAI,EAAE,MAAM,IAAI,CAAC;CAClB,CAAC;AAIF,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAuBrD;AAkDD,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,GAAG,CAQhE;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAQ1E;AAED,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,OAAO,EAAE,CAAC,EAAE,EACZ,KAAK,EAAE,MAAM,GACZ;IAAE,OAAO,EAAE,CAAC,EAAE,CAAC;IAAC,YAAY,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CASxD;AAKD,KAAK,iBAAiB,GAAG;IACvB,OAAO,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACzB;;;OAGG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF,wBAAsB,aAAa,CAAC,CAAC,EACnC,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,IAAI,CAAC,EAAE,iBAAiB,GACvB,OAAO,CAAC,CAAC,CAAC,CAgEZ;AA0ED,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,CAAC,EACvC,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAC3B,aAAa,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,EAC9D,UAAU,EAAE,MAAM,EAClB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,CAAC,CAAC,CAyBZ"}
+{"version":3,"file":"runHandler.d.ts","sourceRoot":"","sources":["../../src/commands/runHandler.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS;;;;;;;CAOZ,CAAC;AAEX,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAclE,eAAO,MAAM,MAAM;aACR,MAAM,KAAG,MAAM;eACb,MAAM,KAAG,MAAM;gBACd,MAAM,KAAG,MAAM;cACjB,MAAM,KAAG,MAAM;aAChB,MAAM,KAAG,MAAM;cACd,MAAM,KAAG,MAAM;CAC1B,CAAC;AAEF,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAM/C;AAED,wBAAgB,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE1C;AAED,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE7C;AAID,wBAAsB,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAUhE;AAED,KAAK,YAAY,GAAG;IAClB,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC,CAAC;AAEF,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,YAAY,GAAG,KAAK,CAgCpE;AAQD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAiBlE;AAED,MAAM,MAAM,OAAO,GAAG;IAEpB,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAGlC,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAU5B,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,IAAI,EAAE,MAAM,IAAI,CAAC;CAClB,CAAC;AAIF,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAwBrD;AAgED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,GAAG,CAQhE;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAQ1E;AAED,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,OAAO,EAAE,CAAC,EAAE,EACZ,KAAK,EAAE,MAAM,GACZ;IAAE,OAAO,EAAE,CAAC,EAAE,CAAC;IAAC,YAAY,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CASxD;AAKD,KAAK,iBAAiB,GAAG;IACvB,OAAO,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACzB;;;OAGG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF,wBAAsB,aAAa,CAAC,CAAC,EACnC,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,IAAI,CAAC,EAAE,iBAAiB,GACvB,OAAO,CAAC,CAAC,CAAC,CAgEZ;AA0ED,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,CAAC,EACvC,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAC3B,aAAa,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,EAC9D,UAAU,EAAE,MAAM,EAClB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,CAAC,CAAC,CAyBZ"}

package/build/commands/runHandler.js

@@ -83,6 +83,27 @@ export function failWith(message, opts) {
 }
 const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 const SPINNER_INTERVAL_MS = 80;
+/** Assumed width when the terminal will not say — the conventional default. */
+const FALLBACK_COLUMNS = 80;
+/**
+ * Cut a plain line down to one screen row, with an ellipsis where it was cut.
+ *
+ * Exported for tests.
+ */
+export function clipToWidth(text, columns) {
+    const width = columns !== undefined
+        ? columns
+        : typeof process.stderr.columns === "number" && process.stderr.columns > 0
+            ? process.stderr.columns
+            : FALLBACK_COLUMNS;
+    // One column short of the edge: writing into the last cell makes some
+    // terminals wrap to the next row, which is the thing being avoided.
+    const limit = width - 1;
+    if (limit <= 1 || text.length <= limit) {
+        return text;
+    }
+    return `${text.slice(0, limit - 1)}…`;
+}
 let activeSpinner;
 export function startSpinner(message) {
     // Only one spinner can own the line, so retire any predecessor: otherwise its
@@ -94,6 +115,7 @@ export function startSpinner(message) {
     const tracked = {
         update: spinner.update,
         log: spinner.log,
+        footer: spinner.footer,
         stop: () => {
             if (activeSpinner === tracked) {
                 activeSpinner = undefined;
@@ -112,17 +134,27 @@ function createSpinner(message) {
         return {
             update: (m) => process.stderr.write(`${m}\n`),
             log: (line) => process.stderr.write(`${line}\n`),
+            // Nothing is being redrawn, so there is no line to keep in step.
+            footer: () => undefined,
             stop: () => undefined,
         };
     }
     process.stderr.write("\x1B[?25l");
     let current = message;
     let frame = 0;
+    let footerLine = "";
     const render = () => {
         const ch = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
         if (ch !== undefined) {
-            // \x1B[K clears any stale characters when the message shrinks.
-            process.stderr.write(`\r\x1B[K${colors.cyan(ch)} ${colors.dim(current)}`);
+            // \x1B[J clears the spinner line *and* any footer under it, so a footer
+            // that just shrank or went away leaves nothing behind.
+            process.stderr.write(`\r\x1B[J${colors.cyan(ch)} ${colors.dim(current)}`);
+            // Drawn below, then the cursor comes back up: the next frame's \r has to
+            // land on the spinner line, not the footer. Clipped first, because that
+            // \x1B[1A is only right while the footer fits on one row.
+            if (footerLine !== "") {
+                process.stderr.write(`\n${colors.dim(clipToWidth(footerLine))}\x1B[1A`);
+            }
         }
         frame += 1;
     };
@@ -135,7 +167,10 @@ function createSpinner(message) {
         log: (line) => {
             // Wipe the spinner line, drop a permanent line, let the next frame redraw
             // the spinner beneath it.
-            process.stderr.write(`\r\x1B[K${line}\n`);
+            process.stderr.write(`\r\x1B[J${line}\n`);
+        },
+        footer: (line) => {
+            footerLine = line;
         },
         stop: () => {
             if (stopped) {
@@ -143,7 +178,7 @@ function createSpinner(message) {
             }
             stopped = true;
             clearInterval(id);
-            process.stderr.write("\r\x1B[K\x1B[?25h");
+            process.stderr.write("\r\x1B[J\x1B[?25h");
         },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cargo-ai/cli",
-  "version": "1.0.86",
+  "version": "1.0.88",
   "private": false,
   "license": "UNLICENSED",
   "homepage": "https://getcargo.ai",
@@ -55,8 +55,9 @@
     "build": "tsc --build",
     "dev": "tsx watch src/index.ts",
     "start": "node build/index.js",
-    "test": "npm run build && node --test \"test/**/*.test.mjs\"",
-    "test:watch": "node --test --watch \"test/**/*.test.mjs\"",
+    "test": "npm run build && node --test \"test/*.test.mjs\"",
+    "test:watch": "node --test --watch \"test/*.test.mjs\"",
+    "test:e2e": "npm run build && node --test --test-concurrency=1 \"test/e2e/*.e2e.mjs\"",
     "type:check": "tsc --noEmit",
     "lint": "eslint ./ --fix",
     "lint:check": "eslint ./ --max-warnings=0",
@@ -68,7 +69,7 @@
     "@ai-sdk/harness-claude-code": "^1.0.99",
     "@cargo-ai/api": "^1.0.76",
     "@cargo-ai/app-sdk": "^1.0.10",
-    "@cargo-ai/cdk": "^1.0.70",
+    "@cargo-ai/cdk": "^1.0.71",
     "@cargo-ai/types": "^1.0.73",
     "@cargo-ai/utils": "^1.0.28",
     "@cargo-ai/worker-sdk": "^1.0.17",
@@ -85,6 +86,7 @@
     "@cargo-ai/ts-config": "*",
     "@types/node": "^20.10.8",
     "eslint": "9.26.0",
+    "node-pty": "^1.0.0",
     "prettier": "3.3.3",
     "typescript": "5.3.2"
   }