@cuna_labs/cli 0.1.0 → 0.1.1

package/dist/cli/recorded-launch-prompt.js

@@ -0,0 +1,80 @@
+/**
+ * THE ONE QUESTION THE CLI ASKS MID-JOURNEY, AND WHAT THE SCREEN OWES THE
+ * PERSON THE MOMENT THEY ANSWER IT.
+ *
+ * WHY THIS IS A MODULE AND NOT FOUR LINES IN `run.ts`. Measured 2026-09-22
+ * (`prds/cuna-cli-latency-before-20260922.md` § 3, finding 1): after this
+ * answer was accepted, the terminal went BYTE-silent — no output at all, not a
+ * repeating spinner — for 2 317 ms, 3 864 ms and 18 314 ms in three of five
+ * runs. The screen froze on the person's own keystroke, which is the worst
+ * shape a stall can take, because the last thing they did is the thing that
+ * appears to have broken it.
+ *
+ * The cause was structural: the question gave the progress row up in order to
+ * be readable, and nothing took the row back until the next remote step
+ * happened to report. Whatever that step cost was silence. So the repair is not
+ * "make the next step faster" — it is that the answer itself is an event worth
+ * rendering, and it is rendered from the branch that was actually taken rather
+ * than from the question that was asked.
+ *
+ * Keeping it here rather than inline is what makes that assertable: `run.ts`
+ * reaches this code only through a real TTY, a real `process.stdin` and a
+ * 90 ms paint timer, none of which can express the defect, which was entirely
+ * about WHEN a line appears relative to an answer.
+ */
+/**
+ * Asked verbatim, and quoted verbatim in the measurement, so the two can be
+ * compared without guessing which build produced a transcript.
+ */
+export const RECORDED_LAUNCH_QUESTION = "A previous launch is recorded. Create another session? [y/N; No resumes the recorded launch] ";
+/**
+ * How long the screen may stay unchanged after the answer is accepted.
+ *
+ * DERIVATION. Not a tuning knob: it is the bound this module exists to hold,
+ * and it is deliberately far below the 2 000 ms threshold the measurement used
+ * to call a stall a stall, because a stall that begins on the person's own
+ * keypress reads as a crash rather than as waiting. The measured worst case was
+ * 18 314 ms, which is 36 times this.
+ */
+export const RECORDED_LAUNCH_ACKNOWLEDGEMENT_BUDGET_MS = 500;
+/**
+ * What answers the recorded-launch question for a folder journey.
+ * `--new-session` is that answer already given on the command line, so it is
+ * not asked again: asking let a No, or a slow answer, override the flag (qa6
+ * witness 2026-09-22). Without the flag the person is asked.
+ */
+export function recordedLaunchConfirmation(newSessionFlag, ask) {
+    return newSessionFlag ? async () => true : ask;
+}
+/** Only an explicit yes creates; anything else, including empty, resumes. */
+export function recordedLaunchWantsNewSession(answer) {
+    return /^y(?:es)?$/iu.test(answer.trim());
+}
+/**
+ * What the screen says next, named for the branch that was taken rather than
+ * for the question that was asked.
+ *
+ * `No` resumes a launch that already exists, and calling that "Creating" would
+ * be the CLI announcing work it is not about to do — which is the same defect
+ * as the silence, one layer up: a screen that does not describe what is
+ * happening.
+ */
+export function recordedLaunchAcknowledgement(wantsNewSession, createLabel) {
+    return wantsNewSession ? createLabel : "Resuming the recorded launch";
+}
+/**
+ * Ask the recorded-launch question and answer the screen at once.
+ *
+ * THE BOUND THIS GIVES, STATED EXACTLY. `acknowledge` is called synchronously
+ * between the answer arriving and this function resolving, so no remote work
+ * can be dispatched in between — not because a timer says so, but because
+ * there is nowhere for it to go. The caller therefore cannot reintroduce the
+ * measured silence by being slow; it can only reintroduce it by writing
+ * nothing, which is what `acknowledge` exists to prevent.
+ */
+export async function askRecordedLaunch(input) {
+    const wantsNewSession = recordedLaunchWantsNewSession(await input.ask(RECORDED_LAUNCH_QUESTION));
+    input.acknowledge(recordedLaunchAcknowledgement(wantsNewSession, input.createLabel));
+    return wantsNewSession;
+}
+//# sourceMappingURL=recorded-launch-prompt.js.map

package/dist/cli/recorded-launch-prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recorded-launch-prompt.js","sourceRoot":"","sources":["../../src/cli/recorded-launch-prompt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,wBAAwB,GACnC,+FAA+F,CAAC;AAElG;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,yCAAyC,GAAG,GAAG,CAAC;AAE7D;;;;;GAKG;AACH,MAAM,UAAU,0BAA0B,CACxC,cAAuB,EACvB,GAAoC;IAEpC,OAAO,cAAc,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC;AACjD,CAAC;AAED,6EAA6E;AAC7E,MAAM,UAAU,6BAA6B,CAAC,MAAc;IAC1D,OAAO,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,6BAA6B,CAAC,eAAwB,EAAE,WAAmB;IACzF,OAAO,eAAe,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,8BAA8B,CAAC;AACxE,CAAC;AAgBD;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,KAAgC;IACtE,MAAM,eAAe,GAAG,6BAA6B,CAAC,MAAM,KAAK,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC,CAAC;IACjG,KAAK,CAAC,WAAW,CAAC,6BAA6B,CAAC,eAAe,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC;IACrF,OAAO,eAAe,CAAC;AACzB,CAAC"}

package/dist/cli/run.d.ts

@@ -10,6 +10,7 @@ import { type ExitCode } from "../core/errors.js";
 import type { SecureCredentialBackend } from "../credentials/contracts.js";
 import { CredentialVault } from "../credentials/vault.js";
 import { type AgentJourneyEffects, type ReconciledAgentJourneyIntent } from "../journey/index.js";
+import { type FirstLine } from "./first-line.js";
 import { type RootJourneyRunner } from "../journey/root-entry.js";
 import { type PlatformAdapter } from "../platform/adapter.js";
 import { type RuntimeFeatureGate } from "../runtime/contracts.js";
@@ -50,6 +51,24 @@ export interface RunCliDependencies {
     readonly managedWorkspaceMachineId?: string;
     /** Test seam for the folder a command resolves its workspace binding from. */
     readonly workspaceRoot?: string;
+    /**
+     * Test seam for the stream a mid-journey question reads its answer from.
+     * Production always leaves this absent and uses the real `process.stdin`.
+     *
+     * It exists because the recorded-launch question is the one place the CLI
+     * stops and waits for a person mid-journey, and the measured defect there was
+     * entirely about WHEN the next line appears relative to the answer
+     * (`prds/cuna-cli-latency-before-20260922.md` § 3, finding 1). Without a seam
+     * that ordering is only assertable through a real TTY, and the live evidence
+     * for the repair is n=0: none of the nine runs of § 8.2 met the question.
+     */
+    readonly promptInput?: NodeJS.ReadableStream;
+    /**
+     * The row `bin/cuna.ts` painted before this module loaded, if it painted one.
+     * The paint site that would have drawn the same row claims it instead of
+     * drawing it again; see `cli/first-line.ts`.
+     */
+    readonly firstLine?: FirstLine;
     readonly automaticJourneyEffectsFactory?: (input: {
         readonly client: CunaApiClient;
         readonly intent: ReconciledAgentJourneyIntent;

package/dist/cli/run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/cli/run.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/cli/run.ts"],"names":[],"mappings":"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"}

package/dist/cli/run.js

@@ -5,8 +5,9 @@ import { runOwnerGrantsScreen } from "../runtime/owner-grants-screen.js";
 import { ownerGrantOperationStore } from "../runtime/owner-grant-operations.js";
 import { runProviderScreen } from "../machines/provider-screen.js";
 import { Writable } from "node:stream";
-import { terminalCellWidth, truncateTerminalLine } from "../terminal/cell-width.js";
+import { terminalCellWidth } from "../terminal/cell-width.js";
 import { createInterface } from "node:readline/promises";
+import { setTimeout as delay } from "node:timers/promises";
 import { mkdir } from "node:fs/promises";
 import { createHash } from "node:crypto";
 import { launchRemoteWorkspaceSession } from "../journey/remote-workspace.js";
@@ -26,8 +27,12 @@ import { integerArgument } from "../core/validation.js";
 import { CredentialBoundaryError } from "../credentials/errors.js";
 import { CredentialVault } from "../credentials/vault.js";
 import { LocalEncryptedSessionBackend, localEncryptedSessionPaths } from "../credentials/local-session.js";
-import { conservativeFilesystemCapabilities, createApiAgentJourneyEffects, createWorkspaceJourneyEffects, orchestrateAgentJourney, preflightAgentJourneyInvocation, } from "../journey/index.js";
-import { rootJourneyArgv, runNodeRootJourney, } from "../journey/root-entry.js";
+import { conservativeFilesystemCapabilities, createApiAgentJourneyEffects, createWorkspaceJourneyEffects, journeyWaitLine, orchestrateAgentJourney, preflightAgentJourneyInvocation, readAccountIdentityWithin, } from "../journey/index.js";
+import { agentSessionDispositionLine, composeInlineProgressLine, inlineProgressColumns, renderInlineProgressFrame, } from "./progress-line.js";
+import { agentDisplayName, journeyPreparationLabel, ROOT_FIRST_LINE_LABEL, } from "./first-line.js";
+import { askRecordedLaunch, recordedLaunchConfirmation } from "./recorded-launch-prompt.js";
+import { settledAgentSessionDisposition } from "../journey/session-disposition.js";
+import { agentJourneyCommand, rootJourneyArgv, runNodeRootJourney, } from "../journey/root-entry.js";
 import { createPlatformAdapter } from "../platform/adapter.js";
 import { CLI_VERSION, OUTPUT_SCHEMA_VERSION } from "../version.js";
 import { runtimeFeatureGates } from "../runtime/contracts.js";
@@ -421,12 +426,6 @@ function managedWorkspaceScope(intent, machineId) {
     }
     return `${intent.agent}-${intent.machine.kind}`;
 }
-function agentDisplayName(agent) {
-    return agent === "claude-code" ? "Claude Code"
-        : agent === "codex" ? "Codex"
-            : agent === "opencode" ? "OpenCode"
-                : "OpenClaw";
-}
 /**
  * `doctor` must distinguish two independent facts: whether this host can
  * protect a durable login-code envelope, and whether the selected deployment
@@ -620,51 +619,58 @@ function writeTerminalSupervisorReadiness(stream, color, state, sessionIds) {
             : "After the stopped-machine supervisor update, open this same AgentSession again.\n");
     }
 }
-function inlineProgressColumns(stream) {
-    const tty = stream;
-    // Node 24 on Windows can retain stale public columns after ConPTY resize.
-    // Read this stream's native TTY observation without changing its prototype
-    // or cached fields. This guarded private API depends on the supported Node
-    // engine; absent/failed/malformed observations retain the ordinary fallback.
-    if (process.platform === "win32" && typeof tty._handle?.getWindowSize === "function") {
-        try {
-            const size = [];
-            if (tty._handle.getWindowSize(size) === 0 && size.length === 2 &&
-                Number.isSafeInteger(size[0]) && size[0] >= 2 && size[0] <= 4096 &&
-                Number.isSafeInteger(size[1]) && size[1] >= 1 && size[1] <= 4096)
-                return size[0];
-        }
-        catch { /* An unavailable native observation does not break progress. */ }
-    }
-    return Number.isSafeInteger(tty.columns) && tty.columns >= 2 && tty.columns <= 4096 ? tty.columns : 80;
-}
-function startInlineProgress(stream, color, initialLabel = "Loading machines") {
-    const frames = ["◐", "◓", "◑", "◒"];
-    const bars = ["━╺━━━━", "━━╺━━━", "━━━╺━━", "━━━━╺━", "━━━━━╺", "━━━━╸━", "━━━╸━━", "━━╸━━━"];
-    const startedAt = Date.now();
-    let frame = 0;
+/**
+ * Start the one inline progress row, or continue a row `cli/first-line.ts`
+ * already painted before this module loaded (`adopted`). An adopted row is not
+ * painted again: its frame 0 is on screen, so the loop starts at frame 1 and its
+ * clocks start when that row appeared, not when this code got to run.
+ */
+function startInlineProgress(stream, color, initialLabel = "Loading machines", adopted) {
+    const startedAt = adopted?.paintedAt ?? Date.now();
+    let frame = adopted === undefined ? 0 : 1;
     let label = initialLabel;
+    // When THIS label started, not when the spinner did. The measured defect was
+    // label dwell — 61 259 ms on one unchanging sentence
+    // (`prds/cuna-cli-latency-before-20260922.md` § 3) — so the number a person
+    // needs is how long the current step has been running, not the command.
+    let labelStartedAt = startedAt;
+    let waiting;
     let stopped = false;
-    let lastColumns = 0;
-    let lastCells = 0;
+    let lastColumns = adopted?.columns ?? 0;
+    let lastCells = adopted?.cells ?? 0;
     const paint = () => {
         const columns = inlineProgressColumns(stream);
-        const elapsed = Date.now() - startedAt;
+        const now = Date.now();
         // A spinner alone is too easy to mistake for a frozen cursor on slower
-        // Windows terminals. Keep the phase honest, then add a small, actionable
-        // acknowledgement while an authenticated read is still in flight.
-        const slowHint = elapsed >= 12_000
-            ? " · still working — Ctrl-C cancels"
-            : elapsed >= 4_000
-                ? " · still working"
-                : "";
-        const text = `◆ CUNA  ${frames[frame % frames.length]} ${label}${slowHint}  ${bars[frame % bars.length]}`;
-        const fitted = truncateTerminalLine(text, columns - 1);
-        const styled = color && fitted === text
-            ? `\u001b[38;5;202m\u001b[1m◆ CUNA\u001b[0m  \u001b[38;5;202m${frames[frame % frames.length]}\u001b[0m \u001b[38;5;255m\u001b[1m${label}\u001b[0m\u001b[38;5;245m${slowHint}\u001b[0m  \u001b[38;5;208m${bars[frame % bars.length]}\u001b[0m`
-            : color ? `\u001b[38;5;255m${fitted}\u001b[0m` : fitted;
+        // Windows terminals, and `· still working` — the whole escalation this
+        // replaces — said nothing a second repaint had not already said. The
+        // sentence and its thresholds live in `progress-line.ts`, where they can
+        // be asserted without a clock or a TTY.
+        const { headline, trailer } = composeInlineProgressLine({
+            label,
+            ...(waiting === undefined ? {} : {
+                waiting: {
+                    waitingFor: waiting.notice.waitingFor,
+                    // Re-derived per repaint: the reporter speaks once per poll, up to
+                    // 1 600 ms apart, and a number that only moves when the poll does
+                    // reproduces the dwell it is meant to cure.
+                    elapsedMs: waiting.notice.elapsedMs + (now - waiting.observedAt),
+                    deadlineMs: waiting.notice.deadlineMs,
+                },
+            }),
+            labelElapsedMs: now - labelStartedAt,
+            totalElapsedMs: now - startedAt,
+        });
+        const { styled, fitted } = renderInlineProgressFrame({ headline, trailer, frame, columns, color });
         if (lastColumns > columns && lastCells >= columns) {
             // A terminal resize can reflow our previously single row before repaint.
+            // HAZARD, unrepaired: this assumes the terminal reflowed. One that
+            // truncated instead still has a single row here, so the walk clears
+            // whatever is above it — on this path, the durable `note()` line naming
+            // the AgentSession. @xterm/headless truncates, which is why
+            // `test/cli.test.mjs` asserts the progress row is never BELOW the durable
+            // rows rather than exactly at row 0. Distinguishing the two needs
+            // terminal feedback the CLI does not have.
             for (let row = 0; row < Math.floor(lastCells / columns); row += 1)
                 stream.write("\r\u001b[2K\u001b[1A");
         }
@@ -673,14 +679,33 @@ function startInlineProgress(stream, color, initialLabel = "Loading machines") {
         lastCells = terminalCellWidth(fitted);
         frame += 1;
     };
-    paint();
+    if (adopted === undefined)
+        paint();
     const timer = setInterval(paint, 90);
     timer.unref();
     return Object.freeze({
         update(nextLabel) {
-            if (stopped || nextLabel === label)
+            if (stopped)
                 return;
-            label = nextLabel;
+            // A repeat of the same label must not restart the dwell clock, but it
+            // MUST still end a wait: the phase resuming is exactly the state change
+            // the wait line was standing in for, and an early return on the label
+            // alone would leave the stale wait on screen forever.
+            if (nextLabel === label && waiting === undefined)
+                return;
+            waiting = undefined;
+            if (nextLabel !== label) {
+                label = nextLabel;
+                labelStartedAt = Date.now();
+            }
+            paint();
+        },
+        wait(notice) {
+            if (stopped)
+                return;
+            waiting = notice === undefined ? undefined : Object.freeze({ notice, observedAt: Date.now() });
+            if (notice === undefined)
+                labelStartedAt = Date.now();
             paint();
         },
         note(line) {
@@ -812,11 +837,6 @@ function journeyPhaseLabel(phase, agent) {
             : `Opening ${display}`;
     }
 }
-function journeyPreparationLabel(agent) {
-    return agent === "opencode"
-        ? "Preparing OpenCode — use /connect in its terminal"
-        : `Preparing ${agentDisplayName(agent)}`;
-}
 function foregroundAttachLabel(agent) {
     return agent === "opencode"
         ? "Opening OpenCode terminal — use /connect there"
@@ -841,9 +861,21 @@ export async function runCli(argv, dependencies = {}) {
     let interactiveCloseUi = false;
     let interactiveCloseColor = false;
     let terminalSessionIds = [];
+    // Known once configuration is read; every attach happens after that.
+    let terminalClients;
     const runForeground = async (input) => {
         terminalSessionIds = [...input.agentSessionIds];
-        await (dependencies.foregroundTerminalRunner ?? runNodeForegroundSessions)(input);
+        await (dependencies.foregroundTerminalRunner ?? runNodeForegroundSessions)({
+            ...(terminalClients === undefined ? {} : { terminalClients }),
+            onNotice: (line) => {
+                const row = inlineJourneyProgress ?? inlineRootProgress;
+                if (row !== undefined)
+                    row.note(line);
+                else
+                    streams.stderr.write(`${line}\n`);
+            },
+            ...input,
+        });
     };
     try {
         const parsed = parseArgv(argv);
@@ -950,7 +982,7 @@ export async function runCli(argv, dependencies = {}) {
             interactiveCloseUi = true;
             interactiveCloseColor = color;
             if (streams.stderrIsTTY === true) {
-                inlineRootProgress = startInlineProgress(streams.stderr, color, "Starting Cuna");
+                inlineRootProgress = startInlineProgress(streams.stderr, color, ROOT_FIRST_LINE_LABEL, dependencies.firstLine?.claim({ kind: "root", label: ROOT_FIRST_LINE_LABEL, color, stream: streams.stderr }));
             }
             else {
                 streams.stderr.write("Cuna: starting...\n");
@@ -1001,8 +1033,9 @@ export async function runCli(argv, dependencies = {}) {
             // tells the truth immediately without claiming that attach has begun.
             const preparation = journeyPreparationLabel(journeyIntent.agent);
             const color = !booleanOption(parsed, "no-color") && !Object.hasOwn(effectiveEnvironment, "NO_COLOR");
-            if (streams.stderrIsTTY === true)
-                inlineJourneyProgress = startInlineProgress(streams.stderr, color, preparation);
+            if (streams.stderrIsTTY === true) {
+                inlineJourneyProgress = startInlineProgress(streams.stderr, color, preparation, dependencies.firstLine?.claim({ kind: "journey", label: preparation, color, stream: streams.stderr }));
+            }
             else
                 streams.stderr.write(`Cuna: ${preparation.charAt(0).toLowerCase()}${preparation.slice(1)}...\n`);
         }
@@ -1046,6 +1079,7 @@ export async function runCli(argv, dependencies = {}) {
             },
             ...(creatingProfile ? { allowMissingProfile: true } : {}),
         });
+        terminalClients = Object.freeze({ platform, profile: config.profile });
         if (interactiveRoot) {
             inlineRootProgress?.update(config.apiKey === undefined ? "Checking your Cuna sign-in" : "Checking Cuna access");
         }
@@ -1488,6 +1522,80 @@ export async function runCli(argv, dependencies = {}) {
                 throw unsupportedError("openclaw", "provider_route_unavailable");
             }
             const journeyAgent = journeyIntent.agent;
+            const journeyColor = () => !booleanOption(parsed, "no-color") && !Object.hasOwn(effectiveEnvironment, "NO_COLOR");
+            const resumeJourneyProgress = () => {
+                if (streams.stderrIsTTY === true) {
+                    return startInlineProgress(streams.stderr, journeyColor(), journeyPhaseLabel("create-agent-session", journeyAgent));
+                }
+                return undefined;
+            };
+            // Both launch paths render these two the same way, so they are written
+            // once: a declared wait takes the spinner row and gives it back, while a
+            // settled AgentSession is a durable note that stays above it. Without the
+            // row, each becomes a plain line on stderr.
+            const renderJourneyWait = (notice) => {
+                if (inlineJourneyProgress !== undefined)
+                    inlineJourneyProgress.wait(notice);
+                else
+                    streams.stderr.write(`${journeyWaitLine(notice)}\n`);
+            };
+            const renderAgentSession = (event) => {
+                const line = agentSessionDispositionLine(event);
+                if (inlineJourneyProgress !== undefined)
+                    inlineJourneyProgress.note(line);
+                else
+                    streams.stderr.write(`${line}\n`);
+            };
+            /**
+             * True once the recorded-launch question has been answered No, on either
+             * launch path. It is what separates a new launch from a resumed one; see
+             * `journey/session-disposition.ts` for why nothing else on the path can.
+             */
+            let recordedLaunchResumed = false;
+            /**
+             * Ask the one recorded-launch question, and answer the screen at once.
+             *
+             * ONE HELPER BECAUSE THERE WAS ONE QUESTION AND TWO BEHAVIOURS. The
+             * journey copy stopped the spinner to ask and never took the row back;
+             * the remote-menu copy left the spinner running, so its 90 ms repaint
+             * erased the question before it could be read. Measured 2026-09-22
+             * (`prds/cuna-cli-latency-before-20260922.md` § 3, finding 1): the
+             * terminal went BYTE-silent for up to 18 314 ms in 3 of 5 runs, always
+             * immediately after this answer was accepted — the screen froze on the
+             * person's own keystroke. What is said, and that it is said before this
+             * returns, live in `recorded-launch-prompt.ts`, which can be asserted
+             * without a TTY; this closure owns only the readline and the row.
+             */
+            const askCreateAnotherSession = async (signal) => {
+                inlineJourneyProgress?.stop();
+                inlineJourneyProgress = undefined;
+                const another = await askRecordedLaunch({
+                    // The readline is opened and closed inside `ask`, so it has released
+                    // the cursor before the acknowledgement is painted onto the same row.
+                    ask: async (question) => {
+                        const prompt = createInterface({ input: dependencies.promptInput ?? process.stdin, output: streams.stderr });
+                        try {
+                            return signal === undefined
+                                ? await prompt.question(question)
+                                : await prompt.question(question, { signal });
+                        }
+                        finally {
+                            prompt.close();
+                        }
+                    },
+                    acknowledge: (line) => {
+                        if (streams.stderrIsTTY === true) {
+                            inlineJourneyProgress = startInlineProgress(streams.stderr, journeyColor(), line);
+                        }
+                        else {
+                            streams.stderr.write(`${line}\n`);
+                        }
+                    },
+                    createLabel: journeyPhaseLabel("create-agent-session", journeyAgent),
+                });
+                recordedLaunchResumed = recordedLaunchResumed || !another;
+                return another;
+            };
             if (credentialMode === undefined) {
                 throw new CunaError({
                     code: "cuna.auth.required",
@@ -1501,7 +1609,30 @@ export async function runCli(argv, dependencies = {}) {
             // Read before the effects branch, not inside it: the principal and the
             // workspace are half of the machine-create request identity, so every
             // journey needs them, including the one built from injected effects.
-            const identity = await client.getIdentity(dependencies.signal);
+            //
+            // Under the journey's own wait policy rather than under the per-request
+            // budget alone. Being first is exactly why this read needed it: it sits
+            // outside `journey/api-effects.ts` and `journey/remote-workspace.ts`, so
+            // the re-issue repair reached neither of the two places it runs, and one
+            // elapsed 15 000 ms budget still ended the whole command — measured
+            // 2026-09-22 (`prds/cuna-cli-latency-before-20260922.md` § 8.3, runs `a5`
+            // and the `--timeout-ms 800` control `slow1`, both exit 5 on `GET /v1/me`).
+            // `journey/account-identity.ts` holds the deadline and its derivation.
+            let accountWaitShown = false;
+            const identity = await readAccountIdentityWithin({
+                read: () => client.getIdentity(dependencies.signal),
+                signal: dependencies.signal ?? new AbortController().signal,
+                sleep: async (milliseconds, signal) => { await delay(milliseconds, undefined, { signal }); },
+                now: dependencies.now ?? Date.now,
+                onWait: (notice) => {
+                    accountWaitShown = true;
+                    renderJourneyWait(notice);
+                },
+            });
+            // The account answered, so the row stops counting a wait that is over.
+            // Nothing else ends it: the next phase label can be several steps away.
+            if (accountWaitShown)
+                inlineJourneyProgress?.wait(undefined);
             const workspaceId = identity.workspaceId;
             if (workspaceId === undefined) {
                 throw new CunaError({
@@ -1518,22 +1649,25 @@ export async function runCli(argv, dependencies = {}) {
                 const preset = await (dependencies.providerScreenRunner ?? runProviderScreen)(client, { kind: "preset", agent: journeyAgent }, undefined, dependencies.signal);
                 if (preset === undefined)
                     return EXIT_CODES.success;
+                inlineJourneyProgress = resumeJourneyProgress();
                 const agentSessionId = await launchRemoteWorkspaceSession({
                     preset,
                     providerLaunchState: { stateDirectory: platform.paths.stateDirectory, ownerId: identity.id },
-                    confirmNew: async () => { const prompt = createInterface({ input: process.stdin, output: streams.stderr }); try {
-                        return /^y(?:es)?$/iu.test((await prompt.question("A previous launch is recorded. Create another session? [y/N; No resumes the recorded launch] ", { signal: dependencies.signal })).trim());
-                    }
-                    finally {
-                        prompt.close();
-                    } },
+                    confirmNew: () => askCreateAnotherSession(dependencies.signal),
                     client, machineId: dependencies.managedWorkspaceMachineId, workspaceId, agent: journeyAgent,
                     onProgress: (label) => inlineJourneyProgress?.update(label),
+                    onWait: renderJourneyWait,
+                    onAgentSession: renderAgentSession,
                     ...(dependencies.signal === undefined ? {} : { signal: dependencies.signal }),
                     ...(dependencies.now === undefined ? {} : { now: dependencies.now }),
                 });
+                inlineJourneyProgress?.stop();
+                inlineJourneyProgress = undefined;
                 return await runCli([
-                    journeyAgent,
+                    // The COMMAND, not the agent identifier. `claude-code` is not a
+                    // command, and passing it here ended this path at `Unknown command
+                    // claude-code` right after the AgentSession was created.
+                    agentJourneyCommand(journeyAgent),
                     "--agent-session", agentSessionId,
                     ...(booleanOption(parsed, "no-color") ? ["--no-color"] : []),
                 ], { ...dependencies, ...(humanAuth === undefined ? {} : { humanAuth }) });
@@ -1584,15 +1718,17 @@ export async function runCli(argv, dependencies = {}) {
                 effects = createApiAgentJourneyEffects({
                     client,
                     requestedAgent: journeyAgent,
-                    confirmNewProviderLaunch: async (signal) => { inlineJourneyProgress?.stop(); inlineJourneyProgress = undefined; const prompt = createInterface({ input: process.stdin, output: streams.stderr }); try {
-                        return /^y(?:es)?$/iu.test((await prompt.question("A previous launch is recorded. Create another session? [y/N; No resumes the recorded launch] ", { signal })).trim());
-                    }
-                    finally {
-                        prompt.close();
-                    } },
+                    confirmNewProviderLaunch: recordedLaunchConfirmation(journeyIntent.newSession, askCreateAnotherSession),
                     providerLaunchState: { stateDirectory: platform.paths.stateDirectory, ownerId: identity.id, workspaceId },
-                    selectProviderPreset: async (signal) => { inlineJourneyProgress?.stop(); inlineJourneyProgress = undefined; const preset = await (dependencies.providerScreenRunner ?? runProviderScreen)(client, { kind: "preset", agent: journeyAgent }, undefined, signal); if (!preset)
-                        throw new CunaError({ code: "cuna.provider.selection_cancelled", message: "Provider selection cancelled. The synchronized Workspace is preserved.", exitCode: EXIT_CODES.usage }); return preset; },
+                    selectProviderPreset: async (signal) => {
+                        inlineJourneyProgress?.stop();
+                        inlineJourneyProgress = undefined;
+                        const preset = await (dependencies.providerScreenRunner ?? runProviderScreen)(client, { kind: "preset", agent: journeyAgent }, undefined, signal);
+                        if (!preset)
+                            throw new CunaError({ code: "cuna.provider.selection_cancelled", message: "Provider selection cancelled. The synchronized Workspace is preserved.", exitCode: EXIT_CODES.usage });
+                        inlineJourneyProgress = resumeJourneyProgress();
+                        return preset;
+                    },
                     inspectWorkspace: workspace.inspectWorkspace,
                     synchronizeWorkspace: workspace.synchronizeWorkspace,
                     // The spinner and the prompt write to the same row of the same
@@ -1638,6 +1774,7 @@ export async function runCli(argv, dependencies = {}) {
                             signal,
                         });
                     },
+                    onWait: renderJourneyWait,
                     ...(dependencies.now === undefined ? {} : { now: dependencies.now }),
                 });
             }
@@ -1648,6 +1785,23 @@ export async function runCli(argv, dependencies = {}) {
                     baseEffects.onPhase?.(phase);
                     inlineJourneyProgress?.update(journeyPhaseLabel(phase, journeyAgent));
                 },
+                onAgentSession(event) {
+                    baseEffects.onAgentSession?.(event);
+                    // The orchestrator reads its disposition from the selection plan,
+                    // which cannot see the answer to the recorded-launch question asked
+                    // inside the create. On No, the create carries the recorded operation
+                    // id and returns the row that launch already produced, so the plan
+                    // still says `create-required` while the screen has just said
+                    // `Resuming the recorded launch`. This closure owns that question, so
+                    // it is the only place that can reconcile the two.
+                    renderAgentSession({
+                        ...event,
+                        disposition: settledAgentSessionDisposition({
+                            planned: event.disposition,
+                            resumedRecordedLaunch: recordedLaunchResumed,
+                        }),
+                    });
+                },
                 async attach(input) {
                     inlineJourneyProgress?.update(`Attaching to ${agentDisplayName(journeyAgent)}`);
                     try {
@@ -1913,6 +2067,10 @@ export async function runCli(argv, dependencies = {}) {
         return EXIT_CODES.success;
     }
     catch (unknownError) {
+        // A first line painted before this module loaded, and refused before any
+        // progress row took it over, is cleared here, before the error is written
+        // after it on the same row.
+        dependencies.firstLine?.release();
         inlineMachinesProgress?.stop();
         inlineJourneyProgress?.stop();
         inlineRootProgress?.stop();