commandmate 0.43.0 → 0.44.1

package/dist/server/src/lib/session/claude-session.js

@@ -4,7 +4,7 @@
  * Manages Claude CLI sessions within tmux for each worktree
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CLAUDE_PROMPT_POLL_INTERVAL = exports.CLAUDE_SEND_PROMPT_WAIT_TIMEOUT = exports.CLAUDE_PROMPT_WAIT_TIMEOUT = exports.CLAUDE_POST_PROMPT_DELAY = exports.CLAUDE_INIT_POLL_INTERVAL = exports.CLAUDE_INIT_TIMEOUT = void 0;
+exports.CLAUDE_PROMPT_POLL_INTERVAL = exports.CLAUDE_SEND_PROMPT_WAIT_TIMEOUT = exports.CLAUDE_PROMPT_WAIT_TIMEOUT = exports.CLAUDE_TRUST_DIALOG_EXITED = exports.CLAUDE_TRUST_DIALOG_CURSOR_STUCK = exports.CLAUDE_POST_PROMPT_DELAY = exports.CLAUDE_INIT_POLL_INTERVAL = exports.CLAUDE_INIT_TIMEOUT = void 0;
 exports.clearCachedClaudePath = clearCachedClaudePath;
 exports.isSessionHealthy = isSessionHealthy;
 exports.getSessionName = getSessionName;
@@ -36,6 +36,7 @@ const cmate_cli_tool_parser_1 = require("../../lib/cmate-cli-tool-parser");
 const agent_session_lifecycle_1 = require("../../lib/session/agent-session-lifecycle");
 const agent_event_state_1 = require("../../lib/session/agent-event-state");
 const session_start_error_1 = require("../../lib/session/session-start-error");
+const launch_screen_1 = require("../../lib/session/launch-screen");
 const logger = (0, logger_1.createLogger)('claude-session');
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 // ----- Helper Functions -----
@@ -130,6 +131,122 @@ exports.CLAUDE_INIT_POLL_INTERVAL = 300;
  * @see Issue #152 - First message not being sent after session start
  */
 exports.CLAUDE_POST_PROMPT_DELAY = 500;
+/**
+ * Polls (of CLAUDE_INIT_POLL_INTERVAL) a still-open trust dialog is given to
+ * close after being answered before it is answered again (Issue #3078). The
+ * measured close is ~950 ms (Issue #1637), so 10 polls = 3 s is not a race.
+ */
+const TRUST_DIALOG_REANSWER_POLLS = 10;
+/** Upper bound on trust dialog answers per session start (Issue #3078). */
+const TRUST_DIALOG_MAX_ANSWERS = 3;
+/**
+ * Polls a cursor move is given to show up on screen before the next one is
+ * sent (Issue #3089). 3 polls = ~900 ms: a TUI that is not taking keys yet
+ * swallows the move, and the next one goes in once the screen still shows the
+ * cursor off `Yes`.
+ */
+const TRUST_DIALOG_MOVE_SETTLE_POLLS = 3;
+/**
+ * Upper bound on single cursor moves per session start (Issue #3089). 20 moves
+ * at TRUST_DIALOG_MOVE_SETTLE_POLLS apart is ~18 s of a TUI that will not move its
+ * cursor; past that the start fails without ever pressing Enter.
+ */
+const TRUST_DIALOG_MAX_MOVES = 20;
+/** Reported when the cursor never reached `Yes` (Issue #3089). A fixed string, never captured output. */
+exports.CLAUDE_TRUST_DIALOG_CURSOR_STUCK = 'trust dialog: cursor did not reach "Yes, I trust this folder"';
+/** Reported when Claude Code quit from the trust dialog (Issue #3089). A fixed string, never captured output. */
+exports.CLAUDE_TRUST_DIALOG_EXITED = 'trust dialog: Claude Code exited to the shell';
+/**
+ * One poll's answer to the folder-trust dialog (Issue #201 / #3078 / #3089).
+ *
+ * Enter confirms whichever option the cursor is on, and since 2.1.259 that is
+ * `No, exit` by default (which quits Claude Code). So Enter is sent only when
+ * THIS screen shows the cursor on `Yes, I trust this folder`. Otherwise one
+ * move key goes in, and the screen is read again on a later poll: sending
+ * `Down Enter` together lost the `Down` to a TUI that was not taking keys yet
+ * and confirmed `No, exit` (Issue #3089). Both are bounded: Enter is repeated
+ * TRUST_DIALOG_REANSWER_POLLS apart up to TRUST_DIALOG_MAX_ANSWERS times for a
+ * dialog that outlives it, and a cursor that has not reached Yes after
+ * TRUST_DIALOG_MAX_MOVES moves fails the start without Enter.
+ *
+ * @param sessionName - tmux session name
+ * @param dialogScreen - ANSI-stripped pane output when the dialog is open, else null
+ * @param state - Mutated in place
+ * @throws {SessionStartFailedError} When the move budget is spent
+ */
+async function answerTrustDialog(sessionName, dialogScreen, state) {
+    if (state.pollsSinceAnswer !== null)
+        state.pollsSinceAnswer++;
+    if (state.pollsSinceMove !== null)
+        state.pollsSinceMove++;
+    if (dialogScreen === null)
+        return;
+    if (!state.seen) {
+        state.seen = true;
+        state.shellTellsExit = await paneCommandIsAgent(sessionName);
+    }
+    const keys = (0, cli_patterns_1.resolveClaudeTrustDialogKeys)(dialogScreen);
+    if (keys === null)
+        return;
+    if (keys.length === 1) {
+        // Cursor on Yes, on this very screen: the Issue #201 Enter.
+        const due = state.pollsSinceAnswer === null ||
+            (state.pollsSinceAnswer >= TRUST_DIALOG_REANSWER_POLLS && state.answers < TRUST_DIALOG_MAX_ANSWERS);
+        if (!due)
+            return;
+        try {
+            await (0, tmux_1.sendKeys)(sessionName, '', true);
+            state.pollsSinceAnswer = 0;
+            state.answers++;
+            logger.info('trust-dialog-detected', { keys: 'Enter', attempt: state.answers });
+        }
+        catch {
+            // Left unhandled so a later poll answers the dialog again
+        }
+        return;
+    }
+    // Cursor off Yes: one move, then look again before anything else.
+    if (state.pollsSinceMove !== null && state.pollsSinceMove < TRUST_DIALOG_MOVE_SETTLE_POLLS)
+        return;
+    if (state.moves >= TRUST_DIALOG_MAX_MOVES) {
+        throw new session_start_error_1.SessionStartFailedError('Claude Code', sessionName, exports.CLAUDE_TRUST_DIALOG_CURSOR_STUCK);
+    }
+    try {
+        await (0, tmux_1.sendSpecialKeys)(sessionName, [keys[0]]);
+        state.pollsSinceMove = 0;
+        state.moves++;
+        logger.info('trust-dialog-cursor-move', { key: keys[0], attempt: state.moves });
+    }
+    catch {
+        // Left unhandled so a later poll moves the cursor again
+    }
+}
+/**
+ * Whether the pane's foreground process is a shell again (Issue #3089). A
+ * pane tmux cannot describe is not called exited; the start budget still
+ * bounds that case. Only asked when {@link TrustDialogState.shellTellsExit}.
+ *
+ * @param sessionName - tmux session name
+ */
+async function hasReturnedToShell(sessionName) {
+    const command = await readPaneCommand(sessionName);
+    return command !== null && (0, cli_patterns_1.isShellPaneCommand)(command);
+}
+/** Whether the pane's foreground command is known and is not a shell (Issue #3089). */
+async function paneCommandIsAgent(sessionName) {
+    const command = await readPaneCommand(sessionName);
+    return command !== null && !(0, cli_patterns_1.isShellPaneCommand)(command);
+}
+/** `#{pane_current_command}`, or null when it cannot be read. */
+async function readPaneCommand(sessionName) {
+    try {
+        const command = await (0, tmux_1.getPaneCurrentCommand)(sessionName);
+        return typeof command === 'string' ? command : null;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Prompt wait timeout before message send (milliseconds)
  *
@@ -313,6 +430,11 @@ function findSessionErrorPattern(cleanOutput) {
  * reading as a zsh prompt. What changed is that six other tools can now be
  * asked the same question; see `lib/cli-tools/liveness-spec`.
  *
+ * Issue #3191: a `user@host …` prompt of 40 characters or more is now read as
+ * the shell too (claude's spec takes `SHELL_PROMPT_LINE_PATTERNS`), so a claude
+ * that was `/exit`ed into a long zsh / bash prompt is reported unhealthy and
+ * relaunched instead of timing out the next send.
+ *
  * @param sessionName - tmux session name
  * @returns HealthCheckResult with healthy status and optional reason
  */
@@ -558,14 +680,15 @@ async function startClaudeSession(options) {
         // and the operator's `~/.claude/settings.json` (measured on 2.1.278).
         const launchCommand = model === undefined ? baseLaunchCommand : `${baseLaunchCommand} --model ${(0, hook_settings_generator_1.shellQuote)(model)}`;
         // Start Claude CLI in interactive mode using dynamically resolved path
-        await (0, tmux_1.sendKeys)(sessionName, launchCommand, true);
+        await (0, tmux_1.sendKeys)(sessionName, (0, launch_screen_1.withLaunchScreenCleared)(launchCommand), true);
         // Wait for Claude to initialize with dynamic detection (OCP-001)
         // Use constants instead of hardcoded values
         const maxWaitTime = exports.CLAUDE_INIT_TIMEOUT;
         const pollInterval = exports.CLAUDE_INIT_POLL_INTERVAL;
         const startTime = Date.now();
         let initialized = false;
-        let trustDialogHandled = false;
+        // Issue #3078 / #3089: the trust dialog's progress this start.
+        const trust = { pollsSinceAnswer: null, pollsSinceMove: null, answers: 0, moves: 0, seen: false, shellTellsExit: false };
         while (Date.now() - startTime < maxWaitTime) {
             await new Promise((resolve) => setTimeout(resolve, pollInterval));
             // SF-001: Use getCleanPaneOutput helper (DRY)
@@ -579,28 +702,27 @@ async function startClaudeSession(options) {
             if (cleanOutput === null) {
                 continue;
             }
+            // Issue #201 / #3078 / #3089: answer the folder-trust dialog. Checked
+            // BEFORE the prompt: the dialog's cursor row (`❯ No, exit`) wears the
+            // prompt glyph, so an open dialog is never read as a ready prompt.
+            const trustDialogOpen = (0, cli_patterns_1.isClaudeTrustDialogOpen)(cleanOutput);
+            await answerTrustDialog(sessionName, trustDialogOpen ? cleanOutput : null, trust);
             // Claude is ready when we see the prompt (DRY-001)
             // Use CLAUDE_PROMPT_PATTERN from cli-patterns.ts for consistency
             // Note: CLAUDE_SEPARATOR_PATTERN was removed from initialization check (Issue #187, P1-1)
-            if (cli_patterns_1.CLAUDE_PROMPT_PATTERN.test(cleanOutput)) {
+            if (!trustDialogOpen && cli_patterns_1.CLAUDE_PROMPT_PATTERN.test(cleanOutput)) {
                 // Wait for stability after prompt detection (CONS-007, DOC-001)
                 await new Promise((resolve) => setTimeout(resolve, exports.CLAUDE_POST_PROMPT_DELAY));
                 logger.info('claude-initialized-in');
                 initialized = true;
                 break;
             }
-            // Issue #201: Detect trust dialog and auto-respond with Enter
-            // Condition order: CLAUDE_PROMPT_PATTERN (above) is checked first for shortest path
-            if (!trustDialogHandled && cli_patterns_1.CLAUDE_TRUST_DIALOG_PATTERN.test(cleanOutput)) {
-                try {
-                    await (0, tmux_1.sendKeys)(sessionName, '', true);
-                    trustDialogHandled = true;
-                    logger.info('trust-dialog-detected');
-                }
-                catch {
-                    // Left unhandled so the next poll answers the dialog again
-                }
-                // Continue polling to wait for prompt detection
+            // Issue #3089: the dialog is gone and no prompt came up. If the pane is
+            // back at its shell, Claude Code quit (an Enter that landed on
+            // `No, exit`); nothing will ever draw a prompt, so fail now instead of
+            // spending the rest of the budget (and answering the shell).
+            if (!trustDialogOpen && trust.shellTellsExit && (await hasReturnedToShell(sessionName))) {
+                throw new session_start_error_1.SessionStartFailedError('Claude Code', sessionName, exports.CLAUDE_TRUST_DIALOG_EXITED);
             }
             // Issue #1637: fail fast on a start that cannot succeed. The budget is
             // 60s of patience for a *slow* start; a session already showing a

package/dist/server/src/lib/session/current-output-builder.js

@@ -55,6 +55,7 @@ const db_1 = require("../../lib/db");
 // when this instance was last handed a prompt.
 const chat_db_1 = require("../../lib/db/chat-db");
 const unclassified_frame_tracker_1 = require("../../lib/detection/unclassified-frame-tracker");
+const session_starting_state_1 = require("../../lib/session/session-starting-state");
 const composer_text_1 = require("../../lib/detection/composer-text");
 const upstream_faults_1 = require("../../lib/detection/upstream-faults");
 const opencode_pane_obstruction_1 = require("../../lib/detection/opencode-pane-obstruction");
@@ -608,7 +609,8 @@ async function buildCurrentOutput(db, worktreeId, cliToolId, instanceId, resolut
     // surface is actually being watched at, which is exactly the property the
     // terminal snapshot already has. Gated on the merged verdict (`'running'`, not
     // the tmux-session-exists `isRunning`) so an idle pane reads no transcript.
-    if (payload.isRunning && payload.sessionStatus === 'running') {
+    // Issue #3179: not during a launch — there is no turn to publish yet.
+    if (payload.isRunning && payload.sessionStatus === 'running' && payload.startingSince == null) {
         // Issue #2248 made this an `await`, and it buys less than it looks like: the
         // expensive half — the transcript read and the broadcast — is detached
         // inside, so what is waited for is a worktree row and a Map lookup. What it
@@ -750,6 +752,10 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
         (0, status_evidence_1.forgetLastKnownStatus)((0, auto_yes_manager_1.buildCompositeKey)(worktreeId, cliToolId, instanceId));
         return {
             isRunning: false,
+            // Issue #3179: `beginAgentSession` runs before the pane is created, so a
+            // launch can be in progress with no tmux session yet. Read-only here —
+            // there is no frame to judge a dialog on.
+            startingSince: (0, session_starting_state_1.getSessionStartingSince)(worktreeId, cliToolId, instanceId),
             sessionName,
             content: '',
             lineCount: 0,
@@ -828,7 +834,17 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
     const compositeKey = (0, auto_yes_manager_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
     const lastServerResponseTimestamp = (0, auto_yes_manager_1.getLastServerResponseTimestamp)(compositeKey);
     const lastOutputTimestamp = lastServerResponseTimestamp ? new Date(lastServerResponseTimestamp) : undefined;
-    const statusResult = (0, status_detector_1.detectSessionStatus)(output, cliToolId, lastOutputTimestamp);
+    const rawStatusResult = (0, status_detector_1.detectSessionStatus)(output, cliToolId, lastOutputTimestamp);
+    // Issue #3179: a launch in progress. The frame is a shell prompt and the
+    // launch line, or a dialog the launch is about to answer, and none of the
+    // flags below may be read off it: the floor verdict raised the Navigate pad,
+    // the trust dialog raised the selection list / prompt sheet. A dialog that
+    // outstays the launch's own answer releases the record (a login, an unknown
+    // dialog), and from then on this is the ordinary verdict again.
+    const startingSince = (0, session_starting_state_1.observeSessionStartingFrame)(worktreeId, cliToolId, instanceId, rawStatusResult.status === 'waiting' || rawStatusResult.hasActivePrompt);
+    const statusResult = startingSince === null
+        ? rawStatusResult
+        : (0, session_starting_state_1.startingStatusResult)(rawStatusResult);
     // Issue #1912: every `running` reason that means "the agent is producing
     // output", not just `thinking_indicator`. opencode answers
     // `opencode_processing_indicator` for its `esc interrupt` footer, which is
@@ -946,7 +962,9 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
     // the guard cannot disagree about whether a prompt is open. What they are
     // still allowed to differ on is what to DO about it — see `blocksSend`, which
     // bounds the structured layer's veto over sends and leaves this flag alone.
-    const isPromptWaiting = promptResolution.waiting;
+    // Issue #3179: not while a launch is in progress. The scraper half is already
+    // neutralised above; this also drops a structured wait the launch inherited.
+    const isPromptWaiting = startingSince === null && promptResolution.waiting;
     // Issue #1726: the agent's own account of what it asked. It contributes only
     // where some other layer has already established that a dialog is on screen —
     // this record decides no status of its own, because Claude emits nothing at
@@ -1033,13 +1051,15 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
             // instead of by coincidence.)
             patterns: decisionOptions !== null ? promptWaiting.patterns : null,
         };
-    const promptData = scraperPromptWaiting
-        ? correctedPromptData ??
-            scraperPromptData ??
-            (structuredFacts ? (0, structured_prompt_1.buildStructuredPromptData)(worktreeId, structuredFacts) : null)
-        : structuredFacts
-            ? (0, structured_prompt_1.buildStructuredPromptData)(worktreeId, structuredFacts)
-            : null;
+    const promptData = startingSince !== null
+        ? null
+        : scraperPromptWaiting
+            ? correctedPromptData ??
+                scraperPromptData ??
+                (structuredFacts ? (0, structured_prompt_1.buildStructuredPromptData)(worktreeId, structuredFacts) : null)
+            : structuredFacts
+                ? (0, structured_prompt_1.buildStructuredPromptData)(worktreeId, structuredFacts)
+                : null;
     // Issue #2870: whether `/prompt-response` would answer the prompt published
     // above, read by the SAME function it re-verifies with. In #2868 `promptData`
     // came off the generic parser alone, the route refused it, and the UI's Send
@@ -1111,7 +1131,9 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
     // and the 60 seconds — start afresh if the frame is still unreadable once the
     // decision is gone (answered, expired, or the source dropped).
     const answerableOverAgentApi = (0, structured_prompt_1.hasApiAnswerableDecision)(eventSource.capabilities.eventIdentity, structuredEvents.pendingDecisions ?? []);
-    const unclassifiedVerdict = (0, unclassified_frame_tracker_1.observeUnclassifiedFrame)(compositeKey, merged.isUnclassifiedActive && !answerableOverAgentApi);
+    // Issue #3179: a launch in progress is not a detection failure — its frame is
+    // the shell and the launch line — so no row, and the run starts afresh after.
+    const unclassifiedVerdict = (0, unclassified_frame_tracker_1.observeUnclassifiedFrame)(compositeKey, merged.isUnclassifiedActive && !answerableOverAgentApi && startingSince === null);
     if (unclassifiedVerdict.shouldRecord) {
         recordUnclassifiedFrame(db, {
             worktreeId,
@@ -1197,29 +1219,34 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
     // `sessionStatus` it sat next to one poll earlier. Observed before it is read
     // so a positive poll reports itself, which is what keeps the field from
     // looking stale on a healthy session.
+    // Issue #3179: the structured layer cannot override a launch in progress
+    // either — a `waiting` it inherited would put the answer sheet back.
+    const published = startingSince === null
+        ? merged
+        : { ...merged, status: 'running', reason: status_detector_1.STATUS_REASON.STARTING, thinking: false };
     (0, status_evidence_1.observeStatusEvidence)(compositeKey, {
-        status: merged.status,
-        reason: merged.reason,
-        evidence: merged.evidence,
+        status: published.status,
+        reason: published.reason,
+        evidence: published.evidence,
     });
     const lastKnown = (0, status_evidence_1.getLastKnownStatus)(compositeKey);
     return {
         isRunning: true,
         sessionName,
         cliToolId,
-        sessionStatus: merged.status,
-        sessionStatusReason: merged.reason,
+        sessionStatus: published.status,
+        sessionStatusReason: published.reason,
         content: newContent,
         fullOutput: output,
         realtimeSnippet,
         lineCount: totalLines,
         lastCapturedLine,
         isComplete: isPromptWaiting,
-        isGenerating: merged.thinking,
-        thinking: merged.thinking,
+        isGenerating: published.thinking,
+        thinking: published.thinking,
         // Issue #2607: named after the tool actually running. A fixed "Claude" was
         // published for every agent, and `capture --json` readers took it at its word.
-        thinkingMessage: merged.thinking ? `${(0, types_2.getCliToolDisplayName)(cliToolId)} is thinking...` : null,
+        thinkingMessage: published.thinking ? `${(0, types_2.getCliToolDisplayName)(cliToolId)} is thinking...` : null,
         isPromptWaiting,
         promptData,
         ...(promptAnswerable !== undefined ? { promptAnswerable } : {}),
@@ -1235,11 +1262,12 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
         isSelectionListActive,
         isPagerActive,
         isDismissablePanelActive,
-        isUnclassifiedActive: merged.isUnclassifiedActive,
+        isUnclassifiedActive: startingSince === null && merged.isUnclassifiedActive,
+        startingSince,
         // Issue #1926: the same fact `isUnclassifiedActive` carries, named the way
         // §4 D1 names it. Published from the merged verdict so the two cannot
         // disagree on the wire.
-        statusEvidence: merged.evidence,
+        statusEvidence: published.evidence,
         lastKnownStatus: lastKnown?.status ?? null,
         lastKnownStatusAt: lastKnown?.at ?? null,
         lastServerResponseTimestamp,

package/dist/server/src/lib/session/launch-screen.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Keep the launch line off the pane (Issue #3180).
+ *
+ * Every `startSession` types its launch line into the pane's login shell —
+ * `CM_HOOK_URL='…' CM_PERMISSION_HOOK_URL='…' CM_PORT='3000' 'agy'` — and the
+ * shell echoes it. A tool that repaints the whole screen hides the echo once it
+ * draws; agy and codex draw inline, so the line, with its internal URL, port
+ * and worktree ID, stayed in the scrollback for the life of the session.
+ *
+ * `clear` runs in the same shell, before the agent, so the echo is wiped before
+ * the agent paints. The shell stays the agent's parent exactly as before, which
+ * is what keeps exit detection (`judgeToolLiveness`, `relaunchIfToolExited`)
+ * unchanged: when the agent quits, the pane falls back to the same shell prompt.
+ *
+ * `clear` alone only empties the visible screen. tmux 3.4+ defaults to
+ * `scroll-on-clear on`, which moves what `clear` wiped INTO the scrollback, and
+ * CommandMate's capture reads the scrollback: in the 2026-10-04 UAT (tmux 3.5a)
+ * codex, antigravity, Command Code and gemini still had the launch line twice in
+ * `tmux capture-pane -p -J -S -` (two `CM_HOOK_URL` hits), and it surfaced in the
+ * UI terminal and in codex's trust-dialog sheet. So `printf '\033[3J'` follows
+ * `clear`: ESC [3J (Erase Saved Lines) drops the scrollback, the echo included.
+ * `tmux clear-history` would also work but depends on the pane having a tmux
+ * binary and `TMUX` set, so it is not used. `printf` is a builtin in zsh, bash,
+ * dash and fish, and each reads `\033` in the format as octal ESC; the single
+ * quotes keep the backslash for printf in all of them.
+ *
+ * Joined with `;`, not `&&`, and with `clear`'s stderr dropped: a pane whose
+ * `clear` is missing or fails (unknown `TERM`, no ncurses), or whose `printf`
+ * fails, must still start the agent — a launch line left on screen is a
+ * cosmetic leak, a session that never starts is not — and must not print the
+ * failure in the line's place.
+ *
+ * Applied at the `sendKeys` call site, AFTER any flags a tool appends
+ * (`--model`, `-s <id>`, Command Code's launch flags): `buildAgentLaunchCommandLine`
+ * stays `NAME='value' … command`, and an appended flag lands on the agent, not
+ * on `clear`.
+ *
+ * Deliberately not in a module the session suites mock wholesale
+ * (`agent-session-lifecycle`, `tmux`), so those suites see the real prefix.
+ *
+ * @module lib/session/launch-screen
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LAUNCH_SCREEN_CLEAR_PREFIX = void 0;
+exports.withLaunchScreenCleared = withLaunchScreenCleared;
+/** The prefix every launch line is typed with. */
+exports.LAUNCH_SCREEN_CLEAR_PREFIX = "clear 2>/dev/null; printf '\\033[3J'; ";
+/**
+ * The line to type into the pane: clear the screen and the scrollback, then launch.
+ *
+ * @param launchCommand - The rendered launch line, flags included
+ * @returns `clear 2>/dev/null; printf '\033[3J'; <launchCommand>`
+ */
+function withLaunchScreenCleared(launchCommand) {
+    return `${exports.LAUNCH_SCREEN_CLEAR_PREFIX}${launchCommand}`;
+}

package/dist/server/src/lib/session/session-start-error.js

@@ -30,6 +30,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionStartUnavailableError = exports.SessionStartFailedError = exports.SessionStartTimeoutError = exports.SESSION_START_UNAVAILABLE_CODE = exports.SESSION_START_FAILED_CODE = exports.SESSION_STARTING_CODE = void 0;
+exports.buildSessionExitedToShellMessage = buildSessionExitedToShellMessage;
 exports.isSessionStartTimeoutError = isSessionStartTimeoutError;
 exports.isSafeSessionStartError = isSafeSessionStartError;
 exports.isSessionStartUnavailableError = isSessionStartUnavailableError;
@@ -81,6 +82,25 @@ class SessionStartTimeoutError extends Error {
     }
 }
 exports.SessionStartTimeoutError = SessionStartTimeoutError;
+/**
+ * The message for a start timeout whose pane is back at a shell (Issue #3093).
+ *
+ * {@link SessionStartTimeoutError} says "the process is still running, so this
+ * is a slow start … nothing needs repairing" — true for a slow cold start, and
+ * exactly wrong when the agent quit during startup (e.g. a trust dialog that
+ * was answered with "No, exit"): the reader was told to wait for a process that
+ * no longer exists. Built from the tool's display name and the session name
+ * only, for the same SEC-SF-002 reason as the classes in this module.
+ *
+ * @param toolName - Display name of the CLI tool (e.g. `Claude Code`)
+ * @param sessionName - tmux session whose pane is back at a shell
+ */
+function buildSessionExitedToShellMessage(toolName, sessionName) {
+    return (`${toolName} exited before reaching its input prompt: the tmux session '${sessionName}' ` +
+        'is back at a shell, so this is not a slow start and waiting will not help. The message ' +
+        'was not delivered. Run `commandmate capture <worktree-id>` to see why it exited (for ' +
+        'example a startup dialog answered with exit, or a missing login), fix that, then send again.');
+}
 /**
  * The CLI tool printed an error that startup cannot recover from.
  *