commandmate 0.39.0 → 0.40.0

package/dist/server/src/lib/prompt-answer-sender.js

@@ -7,17 +7,35 @@
  * the promptType/defaultOptionNumber fallback introduced in Bug1).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FreeTextAtChoiceOnlyPromptError = exports.FreeTextAnswerRejectedError = exports.FREE_TEXT_AT_MENU_ROW_REASON = exports.PromptAnswerRejectedError = exports.ANSWER_MODE_KEYS_REASON = void 0;
+exports.MultiSelectAnswerRejectedError = exports.MULTI_SELECT_NOT_COMMITTED_REASON = exports.FreeTextAtChoiceOnlyPromptError = exports.FreeTextAnswerRejectedError = exports.FREE_TEXT_AT_MENU_ROW_REASON = exports.PromptAnswerRejectedError = exports.ANSWER_MODE_KEYS_REASON = void 0;
 exports.sendPromptAnswer = sendPromptAnswer;
 const tmux_1 = require("./tmux/tmux");
 const frame_1 = require("../lib/detection/tools/frame");
 const registry_1 = require("../lib/detection/tools/registry");
 const prompt_detect_multiple_choice_1 = require("../lib/detection/prompt-detect-multiple-choice");
+const dialog_1 = require("../lib/detection/tools/command-code/dialog");
+const selection_shape_1 = require("../lib/detection/selection-shape");
 const models_1 = require("../types/models");
 const tmux_capture_cache_1 = require("./tmux/tmux-capture-cache");
 const cli_tool_timing_config_1 = require("../config/cli-tool-timing-config");
 /** Regex pattern to detect checkbox-style multi-select options */
 const CHECKBOX_OPTION_PATTERN = /^\[[ x]\] /;
+/**
+ * A validated SELECTION SET, as opposed to free text (Issue #2755).
+ *
+ * `"1,3"` does not match `/^\d+$/`, which is the shape every guard in this
+ * module asks "is this a number?" with — so without this the answer for a
+ * checkbox question would be judged, and refused, as free text aimed at a menu
+ * row (#2573 / #2583 / #2584). The set is recognised BEFORE those guards run
+ * and takes its own arm; none of them is loosened, and every other answer still
+ * meets them exactly as it did.
+ *
+ * Deliberately strict: digits and single commas, no spaces, no empty members.
+ * `/prompt-response` normalises what it accepts into this spelling and refuses
+ * anything else with nothing sent, so a string reaching here is one the route
+ * has already range-checked against the option list on the FRESH frame.
+ */
+const SELECTION_SET_PATTERN = /^\d+(?:,\d+)*$/;
 /**
  * The reason code a caller gets back when a digit meets a `keys`-mode dialog
  * (Issue #2033).
@@ -498,6 +516,229 @@ function assertFreeTextCursorIsOnTheField(params) {
         return;
     throw new FreeTextAnswerRejectedError(params.cliToolId, fields.map((option) => option.number), { kind: 'cursor_elsewhere', cursorOptionNumber: cursor.number });
 }
+/**
+ * The reason code every Command Code multi-select refusal carries
+ * (Issue #2755).
+ *
+ * Shares the shape of {@link ANSWER_MODE_KEYS_REASON} and
+ * {@link FREE_TEXT_AT_MENU_ROW_REASON} — a machine-readable code the API and
+ * `respond` branch on — and means one thing: **the question was not
+ * committed.** What varies is how far the arm got, which
+ * {@link MultiSelectAnswerRejectedError.stage} says.
+ */
+exports.MULTI_SELECT_NOT_COMMITTED_REASON = 'multi_select_not_committed';
+/**
+ * A Command Code checkbox answer that did not reach the agent (Issue #2755).
+ *
+ * The sibling of {@link PromptAnswerRejectedError} for the two-stage confirm.
+ * Unlike that one it does NOT always promise an untouched pane — ticking boxes
+ * is the first half of this answer and it may already have happened — so
+ * {@link keysSent} says which of the two the caller is looking at. What it does
+ * promise in every case is that the question was **not submitted**: the arm
+ * stops before the confirm row whenever the screen it re-read is not the one it
+ * was asked to answer.
+ *
+ * Fixed text, a tool id and option numbers only (SEC-003, as in
+ * `prompt-answer-semantic`): `/prompt-response` returns this message verbatim.
+ */
+class MultiSelectAnswerRejectedError extends Error {
+    /** Machine-readable code, always {@link MULTI_SELECT_NOT_COMMITTED_REASON}. */
+    reason;
+    stage;
+    /** Whether any key reached the pane before the refusal. */
+    keysSent;
+    /** The set the caller asked for, ascending. */
+    wanted;
+    constructor(stage, keysSent, wanted) {
+        super(`The question was not submitted (${stage}). `
+            + (keysSent
+                ? 'Some boxes may have been ticked, but the confirm row was not pressed, so the '
+                    + 'question is still on screen exactly as the pane shows it. '
+                : 'No key was sent. ')
+            + `Requested selection: ${wanted.join(', ')}. Check the terminal and answer it there, or `
+            + 'retry once the screen has settled.');
+        this.name = 'MultiSelectAnswerRejectedError';
+        this.reason = exports.MULTI_SELECT_NOT_COMMITTED_REASON;
+        this.stage = stage;
+        this.keysSent = keysSent;
+        this.wanted = wanted;
+    }
+}
+exports.MultiSelectAnswerRejectedError = MultiSelectAnswerRejectedError;
+/**
+ * Is this request a Command Code checkbox answer? (Issue #2755)
+ *
+ * Three conditions, all of them about the FRESH reading rather than about the
+ * caller's claim: the tool, the payload's own `multiSelect` and the shape of
+ * the answer. `promptData` here is what `/prompt-response` re-verified against
+ * the pane a moment ago, which is why this arm may act on `option.checked`
+ * without taking a capture of its own first.
+ *
+ * A bare `"2"` counts. On a `multiSelect: true` payload the digit is a TOGGLE,
+ * so "the answer is 2" is not an available reading of it — which is the half of
+ * 確定仕様 5 this function owns; the other half, telling a one-item checkbox
+ * answer apart from a single-select one, is a request-shape question and lives
+ * in the route.
+ */
+function readMultiSelectRequest(params) {
+    if (params.cliToolId !== 'command-code')
+        return null;
+    const { promptData } = params;
+    if (promptData?.type !== 'multiple_choice')
+        return null;
+    if (promptData.multiSelect !== true)
+        return null;
+    if (!SELECTION_SET_PATTERN.test(params.answer))
+        return null;
+    const wanted = [...new Set(params.answer.split(',').map(Number))].sort((a, b) => a - b);
+    return { promptData, wanted };
+}
+/** `Down` this many times, as {@link sendSpecialKeys} names the key. */
+function downKeys(count) {
+    return Array.from({ length: Math.max(0, count) }, () => 'Down');
+}
+/** The ticked option numbers of a reading, ascending. */
+function tickedNumbers(promptData) {
+    return promptData.options.filter((o) => o.checked === true).map((o) => o.number);
+}
+function sameNumbers(a, b) {
+    return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+/**
+ * Re-read the pane after a keystroke, or null when it cannot be read.
+ *
+ * `capturePane` here rather than the caller's `frame`: the whole point of the
+ * read is that the screen has moved since. {@link TUI_MESSAGE_PROCESSED_WAIT_MS}
+ * is the settle the rest of this file already uses for a TUI that has just been
+ * typed at.
+ */
+async function recaptureAfterKeys(sessionName) {
+    await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.TUI_MESSAGE_PROCESSED_WAIT_MS));
+    try {
+        return await (0, tmux_1.capturePane)(sessionName, GUARD_CAPTURE_LINES);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Answer Command Code's checkbox `AskUserQuestion` (Issue #2755 §6 / §7).
+ *
+ * ## What the keys mean, measured
+ *
+ * Every line below is from #2754's twenty-six live captures
+ * (`docs/design/command-code-1541-askuserquestion.md` §4), taken one keystroke
+ * at a time with a capture on each side:
+ *
+ * | key | on this screen |
+ * |---|---|
+ * | `1`–`9` | **toggles** that box. The cursor does not move. Dead while the `❯` is off the list |
+ * | `Enter` on an option row | toggles that row. It is NOT a confirm |
+ * | `Enter` on `Submit` / `Next` | opens the **Review page**, or advances to the next question. Still not a send |
+ * | `Enter` on the Review page's `❯ 1. Submit` | **this** is where the answer is sent |
+ * | `Space` | works, but from `Submit` it ticked a row the cursor was nowhere near. Not sent |
+ * | `Esc` / `c` / `d` / `n` | cancel, send-as-chat, finish, mode switch. One keystroke each, no confirmation. Not sent |
+ *
+ * So the sequence is: **toggle the symmetric difference → walk down to the
+ * confirm row → Enter → confirm on the Review page.** The confirm is two stages
+ * and an implementation that stopped at the first one would report an answer
+ * the agent never received.
+ *
+ * ## Why a symmetric difference and not "press the numbers"
+ *
+ * The answer is the SET the operator wants ticked, not a list of toggles. A row
+ * the human already ticked in the terminal is `[✔]` on the frame, and pressing
+ * its number would turn it OFF; a row they want off but that is already on has
+ * to be pressed even though it is not in the answer. `current` comes from
+ * `option.checked` on the payload `/prompt-response` verified against the pane
+ * moments earlier, so both halves are read rather than assumed.
+ *
+ * ## Why it re-reads before the confirm
+ *
+ * Because a toggle is only measured to work while the cursor is in the list,
+ * and nothing on the frame proves the tool accepted the keystroke. Confirming a
+ * set nobody verified is the failure this whole Issue is about, one screen
+ * later. If the re-read does not equal the request, the confirm is not pressed
+ * and the operator gets the pane back exactly as it is.
+ *
+ * @throws {MultiSelectAnswerRejectedError} whenever the question was not
+ *   committed; `keysSent` says whether the pane was touched.
+ */
+async function sendCommandCodeMultiSelectAnswer(sessionName, promptData, wanted) {
+    const cursor = promptData.options.find((option) => option.isDefault === true);
+    if (cursor === undefined) {
+        throw new MultiSelectAnswerRejectedError('cursor-unknown', false, wanted);
+    }
+    // 1. The symmetric difference, ascending, one digit per press. An empty one
+    //    sends nothing at all — the set on screen is already the set asked for,
+    //    and the only thing left to do is commit it.
+    const current = tickedNumbers(promptData);
+    const toggles = [
+        ...wanted.filter((n) => !current.includes(n)),
+        ...current.filter((n) => !wanted.includes(n)),
+    ].sort((a, b) => a - b);
+    if (toggles.length > 0) {
+        await (0, tmux_1.sendSpecialKeys)(sessionName, toggles.map(String));
+    }
+    const keysSent = toggles.length > 0;
+    // 2. Read the screen back and refuse unless it is the same question with
+    //    exactly the requested boxes ticked.
+    const afterToggle = await recaptureAfterKeys(sessionName);
+    if (afterToggle === null) {
+        throw new MultiSelectAnswerRejectedError('recapture-failed', keysSent, wanted);
+    }
+    const reading = (0, dialog_1.readCommandCodeQuestionDialog)(afterToggle);
+    if (reading.kind !== 'prompt' ||
+        reading.prompt.promptData?.type !== 'multiple_choice' ||
+        reading.prompt.promptData.multiSelect !== true ||
+        reading.prompt.promptData.question !== promptData.question ||
+        reading.prompt.promptData.options.length !== promptData.options.length) {
+        throw new MultiSelectAnswerRejectedError('screen-changed', keysSent, wanted);
+    }
+    const verified = reading.prompt.promptData;
+    if (!sameNumbers(tickedNumbers(verified), [...wanted])) {
+        throw new MultiSelectAnswerRejectedError('toggle-mismatch', keysSent, wanted);
+    }
+    // 3. Walk to the confirm row and open it. `Down` is the only movement key
+    //    measured to be deterministic here: it steps one row at a time through
+    //    the options, then the free-text row, then stops on `Submit` / `Next`.
+    //    (`Up` from option 1 goes to two different rows depending on whether the
+    //    list has ever reported a highlight — invisible on the frame.) The cursor
+    //    is re-read rather than reused, because the request is allowed to have
+    //    been built from a slightly older frame.
+    const cursorNow = verified.options.find((option) => option.isDefault === true);
+    if (cursorNow === undefined) {
+        throw new MultiSelectAnswerRejectedError('cursor-unknown', keysSent, wanted);
+    }
+    await (0, tmux_1.sendSpecialKeys)(sessionName, [
+        ...downKeys(verified.options.length - cursorNow.number + 1),
+        'Enter',
+    ]);
+    // 4. The second stage. `Submit` opens the Review page and the answer is sent
+    //    from there; `Next` advances to the following question, which IS the
+    //    commit for this one (its tab turns `✔`).
+    const afterConfirm = await recaptureAfterKeys(sessionName);
+    if (afterConfirm === null) {
+        throw new MultiSelectAnswerRejectedError('recapture-failed', true, wanted);
+    }
+    const review = (0, selection_shape_1.readCommandCodeReviewPage)(afterConfirm);
+    if (review !== null) {
+        // Reached with answers still missing — the `d` shape. Confirming it would
+        // send `No answer` for questions nobody has been shown (Issue #2755 §7).
+        if (review.hasUnansweredWarning) {
+            throw new MultiSelectAnswerRejectedError('review-unanswered', true, wanted);
+        }
+        await (0, tmux_1.sendSpecialKeys)(sessionName, ['Enter']);
+        return;
+    }
+    const next = (0, dialog_1.readCommandCodeQuestionDialog)(afterConfirm);
+    const advanced = next.kind === 'prompt' &&
+        next.prompt.promptData?.type === 'multiple_choice' &&
+        next.prompt.promptData.question !== promptData.question;
+    if (!advanced) {
+        throw new MultiSelectAnswerRejectedError('not-committed', true, wanted);
+    }
+}
 /**
  * Send an answer to a tmux session, using cursor-key navigation for
  * Claude Code / Antigravity multiple-choice prompts and text input for
@@ -509,6 +750,19 @@ function assertFreeTextCursorIsOnTheField(params) {
  */
 async function sendPromptAnswer(params) {
     const { sessionName, answer, cliToolId, promptData, fallbackPromptType, fallbackDefaultOptionNumber } = params;
+    // Issue #2755: Command Code's checkbox question, before every guard below.
+    // Its answer is a SET (`"1,3"`), which none of them can read — `/^\d+$/` is
+    // how all three ask "is this a number?", so a set would be judged as free
+    // text and refused as text aimed at a menu row. The arm is entered only on a
+    // reading that says `multiSelect: true`, so nothing else's path moves, and it
+    // returns rather than falling through: what this screen needs is toggles and
+    // a two-stage confirm, not a digit and an Enter.
+    const multiSelect = readMultiSelectRequest(params);
+    if (multiSelect !== null) {
+        await sendCommandCodeMultiSelectAnswer(sessionName, multiSelect.promptData, multiSelect.wanted);
+        (0, tmux_capture_cache_1.invalidateCache)(sessionName);
+        return;
+    }
     // Issue #2033: before ANY key is chosen, let the tool's own dialog rules
     // refuse a digit its dialog cannot take. Placed above the branch rather than
     // inside the text arm because the number->offset arithmetic the cursor arm

package/dist/server/src/lib/realtime-snippet.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * The rows `CurrentOutputPayload.realtimeSnippet` publishes (Issue #2768).
+ *
+ * The snippet has always been "the last 100 rows of the capture". CommandMate
+ * pins agent panes to 200x1000, and an inline tool (codex, antigravity, Command
+ * Code, gemini, vibe-local) paints from the TOP of that canvas: until a session
+ * has scrolled a thousand rows, everything it has drawn sits in rows 1..N and
+ * rows N+1..1000 are blank. The last 100 rows of such a capture are 100 empty
+ * strings — measured on a live Command Code pane whose content ended at row 173.
+ *
+ * So the window is anchored to the last row that carries content, but ONLY when
+ * the plain tail window is entirely blank. Any frame whose last 100 rows hold so
+ * much as one glyph is returned exactly as before, which is every bottom-anchored
+ * (alternate-screen) tool and every inline session that has filled its canvas.
+ *
+ * Browser-safe on purpose: the server builds the payload with it and
+ * `useTerminalPanePolling` rebuilds the same field from a pushed snapshot, and
+ * the two must not be able to disagree about one frame.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REALTIME_SNIPPET_ROW_COUNT = void 0;
+exports.selectRealtimeSnippetRows = selectRealtimeSnippetRows;
+exports.buildRealtimeSnippet = buildRealtimeSnippet;
+const ansi_1 = require("../lib/detection/ansi");
+/** Rows in the snippet. The 100 that Issue #1839 / #2095 read their verdicts off. */
+exports.REALTIME_SNIPPET_ROW_COUNT = 100;
+function isBlankRow(row) {
+    return (0, ansi_1.stripAnsi)(row).trim() === '';
+}
+/**
+ * Pick the snippet rows out of a capture already split on `\n`.
+ *
+ * @param lines - every row of the capture, in order
+ * @returns at most {@link REALTIME_SNIPPET_ROW_COUNT} rows
+ */
+function selectRealtimeSnippetRows(lines) {
+    const tail = lines.slice(-exports.REALTIME_SNIPPET_ROW_COUNT);
+    if (tail.some((row) => !isBlankRow(row)))
+        return tail;
+    let last = lines.length - 1;
+    while (last >= 0 && isBlankRow(lines[last]))
+        last -= 1;
+    // Nothing on the pane at all: the old answer (a run of blank rows) is as good
+    // as any, and keeping it means an empty pane is reported exactly as before.
+    if (last < 0)
+        return tail;
+    return lines.slice(Math.max(0, last + 1 - exports.REALTIME_SNIPPET_ROW_COUNT), last + 1);
+}
+/** {@link selectRealtimeSnippetRows}, joined the way the payload carries it. */
+function buildRealtimeSnippet(output) {
+    return selectRealtimeSnippetRows(output.split('\n')).join('\n');
+}

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

@@ -30,6 +30,8 @@ const logger_1 = require("../../lib/logger");
 const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
 const types_1 = require("../../lib/cli-tools/types");
 const sources_1 = require("../../lib/hooks/sources");
+const hook_settings_generator_1 = require("../../lib/hooks/hook-settings-generator");
+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");
@@ -465,7 +467,16 @@ async function waitForPrompt(sessionName, timeout = exports.CLAUDE_PROMPT_WAIT_T
  * ```
  */
 async function startClaudeSession(options) {
-    const { worktreeId, worktreePath, instanceId } = options;
+    const { worktreeId, worktreePath, instanceId, model } = options;
+    // Issue #2771: the model is about to be typed into a shell. The route and the
+    // CLI have both validated it already; this is the copy that cannot be
+    // forgotten by a future caller, and it runs before anything is created.
+    if (model !== undefined) {
+        const modelValidation = (0, cmate_cli_tool_parser_1.validateClaudeModelName)(model);
+        if (!modelValidation.valid) {
+            throw new Error(`Invalid Claude model name: ${modelValidation.reason}`);
+        }
+    }
     // Check if Claude is installed
     const claudeAvailable = await isClaudeInstalled();
     if (!claudeAvailable) {
@@ -532,11 +543,17 @@ async function startClaudeSession(options) {
         // Issue #1759: which config file gets written, and whether one is written
         // at all, belongs to the tool's `AgentEventSource` (S3/S4). Claude's
         // delegates to `buildClaudeLaunchCommand`, unchanged.
-        const launchCommand = (0, agent_session_lifecycle_1.buildAgentLaunchCommandLine)({
+        const baseLaunchCommand = (0, agent_session_lifecycle_1.buildAgentLaunchCommandLine)({
             target: { worktreeId, cliToolId: sources_1.CLAUDE_CLI_TOOL_ID, instanceId },
             executablePath: claudePath,
             worktreePath,
         });
+        // Issue #2771: `--model` goes AFTER the rendered line, the shape
+        // `AntigravityTool` uses, so the env assignments stay in front of the
+        // executable. Single-quoted because `opus[1m]` is a glob to the pane's zsh.
+        // The flag outranks a `model` in the worktree's `.claude/settings.local.json`
+        // 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);
         // Wait for Claude to initialize with dynamic detection (OCP-001)

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

@@ -79,6 +79,7 @@ const auto_yes_suppression_state_1 = require("../../lib/polling/auto-yes-suppres
 const prompt_dedup_state_1 = require("../../lib/polling/prompt-dedup-state");
 const status_capture_config_1 = require("../../config/status-capture-config");
 const tmux_capture_cache_1 = require("../../lib/tmux/tmux-capture-cache");
+const realtime_snippet_1 = require("../../lib/realtime-snippet");
 const agent_event_state_1 = require("../../lib/session/agent-event-state");
 const prompt_waiting_composition_1 = require("../../lib/session/prompt-waiting-composition");
 const provisional_turn_1 = require("../../lib/session/provisional-turn");
@@ -1052,7 +1053,9 @@ async function buildPayload(db, worktreeId, cliToolId, instanceId) {
     // once, here, above the first reader. The 100 rows are also what the payload
     // publishes, which is the property both fields rest on: what they claim can be
     // checked against the rows printed next to them in `capture --json`.
-    const realtimeSnippet = lines.slice(-100).join('\n');
+    // Issue #2768: still "the 100 rows this payload publishes" — but anchored to
+    // the last content row when the plain tail is entirely blank (top-anchored panes).
+    const realtimeSnippet = (0, realtime_snippet_1.selectRealtimeSnippetRows)(lines).join('\n');
     // Issue #2095: gated on the tool because the anchors are opencode's own box
     // drawing. Every other CLI's detection is untouched by construction — nothing
     // here even looks at its frame. Computed before the unclassified-frame writer

package/dist/server/src/lib/session/status-mapping.js

@@ -29,6 +29,10 @@
  *     -> deriveCliStatus()                      (this module)
  *     -> BranchStatus                           (sidebar / header / tab dots)
  *
+ * An unclassified frame (Issue #2775) takes the same chain with no activity
+ * flag raised, and `isUnclassifiedCliStatus()` is how a surface tells its
+ * `ready` apart from a real one.
+ *
  * `deriveSessionStatus()` is the reverse edge of that chain: the worktrees API
  * folds the boolean triple back into a `SessionStatus` for its JSON payload.
  *
@@ -48,6 +52,7 @@ exports.HOOK_STATUS_REASON = void 0;
 exports.agentEventToSessionStatus = agentEventToSessionStatus;
 exports.sessionStatusToActivityFlags = sessionStatusToActivityFlags;
 exports.deriveCliStatus = deriveCliStatus;
+exports.isUnclassifiedCliStatus = isUnclassifiedCliStatus;
 exports.deriveSessionStatus = deriveSessionStatus;
 exports.deriveBranchStatus = deriveBranchStatus;
 /**
@@ -173,19 +178,40 @@ function agentEventToSessionStatus(event, detail) {
  * existence (plus the Claude health check), which is independent of what the
  * terminal output says.
  *
- * | SessionStatus | isWaitingForResponse | isProcessing |
- * |---------------|----------------------|--------------|
- * | `idle`        | false                | false        |
- * | `ready`       | false                | false        |
- * | `running`     | false                | true         |
- * | `waiting`     | true                 | false        |
+ * | SessionStatus | unclassified | isWaitingForResponse | isProcessing |
+ * |---------------|--------------|----------------------|--------------|
+ * | `idle`        | (ignored)    | false                | false        |
+ * | `ready`       | (ignored)    | false                | false        |
+ * | `running`     | false        | false                | true         |
+ * | `running`     | true         | false                | false        |
+ * | `waiting`     | (ignored)    | true                 | false        |
+ *
+ * ## The `running` + unclassified row (Issue #2775)
+ *
+ * The detector's floors (`default` / `unknown_frame` / `no_recent_output`)
+ * answer `running`, and `running` keeps meaning what it means there — the
+ * detector is not touched. What changes is only this projection: `isProcessing`
+ * is what the sidebar, the header, `commandmate ls` and `peers` read as "it is
+ * working", and "no rule could read the frame" is not an observation that it
+ * is. So an unclassified `running` raises no activity flag at all, and the
+ * caller publishes the fact itself (`isUnclassified`) for the surfaces that
+ * draw it.
+ *
+ * `unclassified` is the caller's `isUnclassifiedFrame(status, reason)`, passed
+ * in rather than recomputed: that function is the single producer of the fact,
+ * and this module stays free of the server-side imports it would need to call
+ * it. It is ignored for every status but `running`, which is the only status it
+ * can be true for.
+ *
+ * @param status - The detector's verdict
+ * @param unclassified - `isUnclassifiedFrame(status, reason)` for the same frame
  */
-function sessionStatusToActivityFlags(status) {
+function sessionStatusToActivityFlags(status, unclassified = false) {
     switch (status) {
         case 'waiting':
             return { isWaitingForResponse: true, isProcessing: false };
         case 'running':
-            return { isWaitingForResponse: false, isProcessing: true };
+            return { isWaitingForResponse: false, isProcessing: !unclassified };
         case 'idle':
         case 'ready':
             return { isWaitingForResponse: false, isProcessing: false };
@@ -220,6 +246,30 @@ function deriveCliStatus(toolStatus) {
         return 'ready';
     return 'idle';
 }
+/**
+ * Whether one session should be drawn as "cannot tell" rather than as the
+ * `BranchStatus` {@link deriveCliStatus} names for it (Issue #2775).
+ *
+ * True exactly when the server flagged the frame unclassified AND nothing more
+ * significant is known, i.e. {@link deriveCliStatus} lands on `ready`. The
+ * second half is not decoration:
+ *
+ *  - an unclassified session raises no activity flag of its own (see
+ *    {@link sessionStatusToActivityFlags}), so on its own it derives `ready` —
+ *    the one `BranchStatus` that would otherwise claim "you can send now";
+ *  - a `waiting` the agent's own events reported, or a `running` from another
+ *    instance folded into the same per-tool aggregate, is a reading, and a
+ *    reading outranks "cannot tell". Those keep their dot.
+ *
+ * Which also means a `running` with positive evidence can never be redrawn by
+ * this: it has no `isUnclassified`, and even if it had, it derives `running`.
+ *
+ * Reads the published flag, never `(status, reason)`: the classification itself
+ * has one producer, `isUnclassifiedFrame` in `status-evidence.ts`.
+ */
+function isUnclassifiedCliStatus(toolStatus) {
+    return toolStatus?.isUnclassified === true && deriveCliStatus(toolStatus) === 'ready';
+}
 /**
  * Fold a worktree-level boolean triple back into a `SessionStatus` for the
  * worktrees API payload — the reverse edge of `sessionStatusToActivityFlags`.

package/dist/server/src/lib/tmux/key-sequence.js

@@ -56,10 +56,33 @@
  * @module lib/tmux/key-sequence
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeTrailingSemicolon = escapeTrailingSemicolon;
 exports.keySequenceArgs = keySequenceArgs;
 exports.runKeySequence = runKeySequence;
 exports.describeKeySequence = describeKeySequence;
 const cli_tool_contracts_1 = require("../../types/cli-tool-contracts");
+/**
+ * Make `text` survive tmux's own reading of a `send-keys` argument (Issue #2769).
+ *
+ * tmux treats a `;` at the END of an argument as its command separator — even
+ * under `-l`, even after `--`, even though `execFile` never involved a shell —
+ * and drops it; `\;` is how it is told the semicolon is text. Measured on
+ * tmux 3.5a against a raw pty:
+ *
+ *     'a;'   -> a      (the `;` is gone, rc 0)      ';'   -> nothing at all
+ *     'a\;'  -> a;     (one backslash consumed)     'a;;' -> a;
+ *     'a;b'  -> a;b    (only a TRAILING `;` counts)
+ *
+ * One rule covers every case: when the text ends in `;`, put one backslash in
+ * front of that last `;`. tmux removes exactly that backslash, so `a;` arrives
+ * as `a;` and a body that really ends in `\;` arrives as `\;` too.
+ *
+ * @param text - Text about to be placed in a `send-keys` argv entry
+ * @returns The same text, escaped only if its last character is `;`
+ */
+function escapeTrailingSemicolon(text) {
+    return text.endsWith(';') ? `${text.slice(0, -1)}\\;` : text;
+}
 /**
  * The `tmux` arguments that send one step to a pane.
  *
@@ -74,7 +97,10 @@ function keySequenceArgs(target, step) {
         // `-l` stops the key-table lookup; `--` stops the getopt parse. Both are
         // required: without `-l` a body of `Escape` is the ESC key, and without
         // `--` a body of `-l` is consumed as a flag and nothing is sent at all.
-        return ['send-keys', '-t', target, '-l', '--', step.text];
+        //
+        // Neither protects a TRAILING `;`, which tmux takes for its command
+        // separator and drops — see {@link escapeTrailingSemicolon}.
+        return ['send-keys', '-t', target, '-l', '--', escapeTrailingSemicolon(step.text)];
     }
     if (!(0, cli_tool_contracts_1.isKeySequenceKeyName)(step.name)) {
         throw new Error(`Invalid key sequence key name: ${step.name}`);

package/dist/server/src/lib/tmux/tmux-control-client.js

@@ -1,12 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TmuxControlClient = void 0;
+exports.TmuxControlClient = exports.CONTROL_SEND_KEYS_CHUNK_BYTES = void 0;
 const child_process_1 = require("child_process");
 const logger_1 = require("../../lib/logger");
 const tmux_control_parser_1 = require("./tmux-control-parser");
 const tmux_1 = require("./tmux");
 const logger = (0, logger_1.createLogger)('tmux-control-client');
 const DEFAULT_CONTROL_CLIENT_IDLE_TIMEOUT_MS = 30_000;
+/**
+ * Bytes of user input per `send-keys -H` command (Issue #2767).
+ *
+ * A control-mode client's stdin is a stream of tmux COMMANDS, one per line — it
+ * is not the pane's keyboard. Input is therefore delivered as `send-keys -H`
+ * followed by the bytes in hex, and a long paste is split so no single command
+ * line grows without bound (256 bytes is 767 characters of hex).
+ */
+exports.CONTROL_SEND_KEYS_CHUNK_BYTES = 256;
 /**
  * Thin wrapper around a tmux control mode child process.
  *
@@ -70,12 +79,26 @@ class TmuxControlClient {
             this.handlers.delete(handler);
         };
     }
+    /**
+     * Deliver user input to the pane (Issue #2767).
+     *
+     * A control-mode client's stdin is where tmux COMMANDS are written, not the
+     * pane's keyboard. Before #2767 the raw input was written straight through, so
+     * a line typed in the browser terminal ran as a tmux command (`kill-server` +
+     * Enter took down every session) and never reached the pane. The input is now
+     * wrapped in `send-keys -H` with the bytes in hex: not one character of the
+     * input appears in the line that is written, so it cannot be parsed as a command.
+     */
     sendInput(input) {
-        if (!this.child?.stdin.writable) {
+        if (!this.child?.stdin.writable || this.sessionName === null) {
             throw new Error('Tmux control client is not writable');
         }
         this.touch();
-        this.child.stdin.write(input);
+        const bytes = Buffer.from(input, 'utf8');
+        for (let offset = 0; offset < bytes.length; offset += exports.CONTROL_SEND_KEYS_CHUNK_BYTES) {
+            const hex = Array.from(bytes.subarray(offset, offset + exports.CONTROL_SEND_KEYS_CHUNK_BYTES), (byte) => byte.toString(16).padStart(2, '0')).join(' ');
+            this.child.stdin.write(`send-keys -t ${(0, tmux_1.exactTarget)(this.sessionName)} -H ${hex}\n`);
+        }
     }
     resize(cols, rows) {
         if (!this.child?.stdin.writable) {