commandmate 0.26.0 → 0.27.0

package/dist/server/src/config/detection-evidence-config.js

@@ -0,0 +1,129 @@
+"use strict";
+/**
+ * Per-tool rollout of the D1 idle-evidence rule, and its kill switch
+ * (Issue #1927, 方針書 §4 D1 決定 1 / §13.1 DR3-016).
+ *
+ * §4 D1 forbids declaring a turn finished on the absence of a busy marker. The
+ * fix has to land **one tool at a time**: a tool whose idle rule is not yet
+ * measured must keep the pre-#1927 reading, because flipping it early publishes
+ * `evidence: 'none'` for ordinary idle frames (DR2-002).
+ *
+ * Issue #2011 is the incident this warning predicted, and it also narrowed what
+ * an early flip actually costs. `TerminalEscapeHatch` and `wait`'s completion
+ * rule are gated on `isUnclassifiedActive`, which #1927 had derived from
+ * `evidence` — so an early flip took both of them out. #2011 gave the flag its
+ * own expression again (`isUnclassifiedFrame`, in `status-evidence.ts`), so a
+ * premature `enforce` now degrades only what `statusEvidence` itself feeds:
+ * §7's "last confirmed status" row and the `unclassified_frames` tally that
+ * measures the rollout. That is a smaller blast radius, not a licence to skip
+ * the `observe` step below.
+ *
+ * That makes three things necessary, and all three live here:
+ *
+ *  - **a table**, so "which tools have a measured rule" is one list rather than
+ *    a property scattered across seven modules;
+ *  - **a kill switch**, so an operator who sees the rollout misfire in
+ *    production can put one tool back to the old reading without a redeploy;
+ *  - **an observe mode**, so the rollout can be measured BEFORE it is turned on
+ *    — §11's live row makes "`unclassified_frames` の記録件数が倒す前後で有意に
+ *    増えない" an acceptance condition, and you cannot check that without a run
+ *    that computes the new verdict while still publishing the old one.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IDLE_EVIDENCE_ENV_VAR = exports.IDLE_EVIDENCE_DEFAULT_MODE = exports.IDLE_EVIDENCE_MODES = void 0;
+exports.resolveIdleEvidenceMode = resolveIdleEvidenceMode;
+/** Every accepted value of {@link IdleEvidenceMode}, for parsing and tests. */
+exports.IDLE_EVIDENCE_MODES = ['enforce', 'observe', 'legacy'];
+/**
+ * The rollout state each tool ships in.
+ *
+ * `enforce` is set only for a tool whose rule was measured from its own live
+ * frames at production pane geometry, with a positive fixture and a mutation
+ * fixture each, AND whose `observe` run has shown that enforcing it does not
+ * move the `unclassified_frames` rate (§11's live row):
+ *
+ * | tool     | rule                                                        | Issue |
+ * |----------|-------------------------------------------------------------|-------|
+ * | claude   | turn-completion marker `✻ <Verb> for <N>s` at the transcript tail, or the startup banner with no user turn under it | #1927 |
+ * | copilot  | the pane's bottom status bar reads idle (`readCopilotStatusBar`) | #1885 |
+ * | opencode | the gutter-anchored idle composer, or `▣ … · <duration>`     | #1883 / #1893 |
+ *
+ * **claude is `observe`, not `enforce` (Issue #2011).** It shipped straight to
+ * `enforce` in #1927 without the measurement above, and the live rate was
+ * measured afterwards instead: on 2026-08-24, 7 of 8 idle Claude panes answered
+ * `'none'`. The rule is not wrong about those frames — a `/model` result row, a
+ * `⎿ Tip:` row, `✔ Update installed` and `new task? /clear to save …` really do
+ * carry no completion marker — it is simply not yet complete enough to be the
+ * authority, because a legitimately idle Claude pane has no marker at all after
+ * `/model`, after `/clear`, at startup, or after an Esc interrupt. Building the
+ * rule that covers those is deliberately a separate Issue; what `observe` buys
+ * meanwhile is the tally that says when it is done.
+ *
+ * The rest are `legacy` because no rule has been read off their frames yet, and
+ * D1 決定 1 says in as many words that a tool without a rule must not be
+ * flipped. Giving them `enforce` here would not tighten anything either — their
+ * modules declare no `readIdleEvidence`, so the chain answers `'positive'`
+ * regardless. The row is kept so the table states the rollout rather than
+ * hiding it in an omission.
+ */
+exports.IDLE_EVIDENCE_DEFAULT_MODE = {
+    claude: 'observe',
+    copilot: 'enforce',
+    opencode: 'enforce',
+    codex: 'legacy',
+    gemini: 'legacy',
+    antigravity: 'legacy',
+    'vibe-local': 'legacy',
+};
+/**
+ * The kill switch.
+ *
+ * A comma-separated list of `<tool>=<mode>` pairs, with `*` for "every tool":
+ *
+ * ```
+ * CM_DETECTION_IDLE_EVIDENCE=claude=legacy            # one tool back to the old reading
+ * CM_DETECTION_IDLE_EVIDENCE=*=observe                # measure the whole rollout first
+ * CM_DETECTION_IDLE_EVIDENCE=*=observe,opencode=enforce
+ * ```
+ *
+ * Read on every call rather than at module load: the value has to be flippable
+ * without a rebuild, and a cached read would make the switch a restart away
+ * from the incident it exists for.
+ */
+exports.IDLE_EVIDENCE_ENV_VAR = 'CM_DETECTION_IDLE_EVIDENCE';
+function isMode(value) {
+    return exports.IDLE_EVIDENCE_MODES.includes(value);
+}
+/**
+ * Resolve one tool's rollout mode.
+ *
+ * Later entries win over earlier ones, and a tool-specific entry wins over `*`
+ * whatever the order — so `*=observe,claude=enforce` and
+ * `claude=enforce,*=observe` mean the same thing. An unparseable entry is
+ * ignored rather than throwing: this is read on the status polling path, and a
+ * typo in an env var must not take the detector down.
+ *
+ * @param tool - CLI tool to resolve for
+ * @param env - Environment to read; injectable for tests
+ */
+function resolveIdleEvidenceMode(tool, env = process.env) {
+    const raw = env[exports.IDLE_EVIDENCE_ENV_VAR];
+    let wildcard = null;
+    let specific = null;
+    if (typeof raw === 'string' && raw.trim() !== '') {
+        for (const entry of raw.split(',')) {
+            const [rawKey, rawValue] = entry.split('=');
+            if (rawValue === undefined)
+                continue;
+            const key = rawKey.trim();
+            const value = rawValue.trim();
+            if (!isMode(value))
+                continue;
+            if (key === '*')
+                wildcard = value;
+            else if (key === tool)
+                specific = value;
+        }
+    }
+    return specific ?? wildcard ?? exports.IDLE_EVIDENCE_DEFAULT_MODE[tool] ?? 'legacy';
+}

package/dist/server/src/config/schedule-config.js

@@ -10,7 +10,7 @@
  * [S4-014] UUID v4 format validation
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UUID_V4_PATTERN = exports.DEFAULT_PERMISSIONS = exports.VIBE_LOCAL_PERMISSIONS = exports.GEMINI_PERMISSIONS = exports.ANTIGRAVITY_PERMISSIONS = exports.COPILOT_PERMISSIONS = exports.CODEX_SANDBOXES = exports.CLAUDE_PERMISSIONS = exports.MAX_SCHEDULE_CRON_LENGTH = exports.MAX_SCHEDULE_MESSAGE_LENGTH = exports.MAX_SCHEDULE_NAME_LENGTH = void 0;
+exports.UUID_V4_PATTERN = exports.DEFAULT_PERMISSIONS = exports.NO_PERMISSION_FLAGS = exports.OPENCODE_PERMISSIONS = exports.VIBE_LOCAL_PERMISSIONS = exports.GEMINI_PERMISSIONS = exports.ANTIGRAVITY_PERMISSIONS = exports.COPILOT_PERMISSIONS = exports.CODEX_SANDBOXES = exports.CLAUDE_PERMISSIONS = exports.MAX_SCHEDULE_CRON_LENGTH = exports.MAX_SCHEDULE_MESSAGE_LENGTH = exports.MAX_SCHEDULE_NAME_LENGTH = void 0;
 exports.getPermissionOptionsForTool = getPermissionOptionsForTool;
 exports.isValidUuidV4 = isValidUuidV4;
 // =============================================================================
@@ -42,12 +42,46 @@ exports.ANTIGRAVITY_PERMISSIONS = [
 exports.GEMINI_PERMISSIONS = [];
 /** Allowed permission values for vibe-local CLI (no permission flags) */
 exports.VIBE_LOCAL_PERMISSIONS = [];
-/** Default permission per CLI tool */
+/**
+ * Allowed permission values for opencode CLI (Issue #1914).
+ *
+ * Empty, like gemini's and vibe-local's, but a **separate** constant on purpose:
+ * before this Issue `getPermissionOptionsForTool('opencode')` resolved through
+ * `default: return GEMINI_PERMISSIONS`, so the value was right for a reason that
+ * was not. Object identity is what lets a test tell "opencode has its own case"
+ * apart from "opencode falls through to gemini's".
+ *
+ * opencode has no permission *level* to choose from. `opencode run` does carry a
+ * single boolean `--auto` ("auto-approve permissions that are not explicitly
+ * denied", measured on 1.18.21), but that is a different axis from the
+ * `--permission-mode` / `--sandbox` vocabularies this list models, and
+ * CommandMate does not pass it. Wiring it up is a separate decision.
+ */
+exports.OPENCODE_PERMISSIONS = [];
+/**
+ * What a CLI tool with no permission flag at all resolves to (Issue #1914).
+ *
+ * The `default:` branch of {@link getPermissionOptionsForTool} returns this
+ * rather than any one tool's constant. A tool added to `CLI_TOOL_IDS` without a
+ * case below then inherits "no flags", which is the safe answer — inheriting
+ * Claude's `--permission-mode` vocabulary is what let `acceptEdits` through on
+ * an opencode schedule (`cmate-parser.ts` / `cmate-validator.ts` carry the same
+ * decision).
+ */
+exports.NO_PERMISSION_FLAGS = [];
+/**
+ * Default permission per CLI tool.
+ *
+ * Issue #1914 added the `opencode` entry: it was the one id in `CLI_TOOL_IDS`
+ * with no key here, so every reader fell back to its own `?? ''` and the
+ * omission read as an oversight rather than as "this tool takes no flag".
+ */
 exports.DEFAULT_PERMISSIONS = {
     claude: 'acceptEdits',
     codex: 'workspace-write',
     gemini: '',
     'vibe-local': '',
+    opencode: '',
     copilot: 'allow-all-tools',
     antigravity: '--dangerously-skip-permissions',
 };
@@ -59,24 +93,39 @@ exports.DEFAULT_PERMISSIONS = {
  * cmate-parser.ts / cmate-validator.ts enforce on read, so any value the dialog
  * writes round-trips through the parser without being silently discarded.
  *
- * Tools not listed (gemini, vibe-local, opencode) have no permission flags, so
- * the dialog hides the Permission field and an empty permission is written.
+ * gemini, vibe-local and opencode have no permission flags, so the dialog hides
+ * the Permission field and an empty permission is written.
+ *
+ * Issue #1914: every id in `CLI_TOOL_IDS` now has its own `case`, and `default:`
+ * returns {@link NO_PERMISSION_FLAGS} instead of `GEMINI_PERMISSIONS`. The
+ * returned *value* is unchanged for every tool that exists today — all three
+ * empty lists are `[]` — but the old spelling said "a tool I do not recognise
+ * gets gemini's rules", which is not a sentence anyone meant. It is also the
+ * shape that hid the real bug in the two switches this function mirrors, where
+ * the same fallback resolved to CLAUDE_PERMISSIONS and let `acceptEdits` onto an
+ * opencode schedule.
  *
  * @param cliToolId - CLI tool identifier
  * @returns Readonly array of allowed permission values (empty = no permission flags)
  */
 function getPermissionOptionsForTool(cliToolId) {
     switch (cliToolId) {
+        case 'claude':
+            return exports.CLAUDE_PERMISSIONS;
         case 'codex':
             return exports.CODEX_SANDBOXES;
         case 'copilot':
             return exports.COPILOT_PERMISSIONS;
         case 'antigravity':
             return exports.ANTIGRAVITY_PERMISSIONS;
-        case 'claude':
-            return exports.CLAUDE_PERMISSIONS;
-        default:
+        case 'gemini':
             return exports.GEMINI_PERMISSIONS;
+        case 'vibe-local':
+            return exports.VIBE_LOCAL_PERMISSIONS;
+        case 'opencode':
+            return exports.OPENCODE_PERMISSIONS;
+        default:
+            return exports.NO_PERMISSION_FLAGS;
     }
 }
 // =============================================================================

package/dist/server/src/config/tmux-pane-config.js

@@ -17,11 +17,28 @@
  * so `capture-pane` cost / render load stays reasonable.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TMUX_HISTORY_LIMIT = exports.TUI_PANE_WIDTH = exports.TUI_PANE_HEIGHT = void 0;
+exports.TMUX_HISTORY_LIMIT = exports.OPENCODE_PANE_HEIGHT = exports.TUI_PANE_WIDTH = exports.TUI_PANE_HEIGHT = void 0;
 /** Fixed pane height (rows) for TUI sessions. Large enough to retain useful history. */
 exports.TUI_PANE_HEIGHT = 1000;
 /** Fixed pane width (columns) for TUI sessions. Matches the historical default. */
 exports.TUI_PANE_WIDTH = 200;
+/**
+ * OpenCode tmux pane height (rows).
+ *
+ * Set to 200 to expand the TUI content area (~190 visible lines), allowing most
+ * responses to be captured in a single tmux capture-pane. OpenCode runs in
+ * alternate screen mode with no scrollback buffer, so only visible rows are
+ * capturable — which makes this both the session's height and the most a
+ * `capture-pane` can ever return for it.
+ *
+ * Issue #1906 moved it here from `lib/cli-tools/opencode.ts` (which re-exports
+ * it, so every existing importer is unchanged). `submit-verified-sender.ts` now
+ * needs the number to size its read-back window, and it is imported BY
+ * `opencode.ts` — taking the constant from there would have created an import
+ * cycle and pulled opencode's `child_process` use into every consumer of the
+ * sender. This module has no imports at all, so it costs nothing to depend on.
+ */
+exports.OPENCODE_PANE_HEIGHT = 200;
 /**
  * Scrollback lines retained per pane (`history-limit`), Issue #1624.
  *

package/dist/server/src/lib/auto-yes-poller.js

@@ -63,6 +63,7 @@ const prompt_detector_1 = require("./detection/prompt-detector");
 const auto_yes_resolver_1 = require("./polling/auto-yes-resolver");
 const auto_yes_policy_1 = require("./polling/auto-yes-policy");
 const auto_yes_suppression_state_1 = require("./polling/auto-yes-suppression-state");
+const auto_yes_dialog_gate_1 = require("./polling/auto-yes-dialog-gate");
 const task_transition_service_1 = require("./tasks/task-transition-service");
 const db_instance_1 = require("./db/db-instance");
 const chat_db_1 = require("./db/chat-db");
@@ -332,6 +333,41 @@ async function detectAndRespondToPrompt(worktreeId, pollerState, cliToolId, clea
             });
             return 'no_answer';
         }
+        // 3.5. Issue #1928 (§4 D1 decision 4): the generic numbered-list inference is
+        // not enough to send an answer. `detectPrompt` above judges the ROWS, and the
+        // rows of an agent's own reply can be indistinguishable from a dialog's --
+        // opencode 1.18 answering "list three options and ask which one" is the
+        // reported case (#1896), and the `1` this poller sent in reply was not
+        // answering anything, it was SENT AS A USER UTTERANCE. What separates the two
+        // is position and chrome, which only the tool's own module knows, so the
+        // decision is delegated to `detectDialog` (the seam #1927 declared).
+        //
+        // Per tool, and only for tools whose dialogs were measured from their own
+        // live captures -- see AUTO_YES_DIALOG_GATE_DEFAULT_MODE. An ungated tool
+        // reaches `allowed: true` without being judged, which is the pre-#1928
+        // behaviour and the right one where nobody has measured anything.
+        //
+        // Recorded through the #1684 channel with the reason code #1924 landed for
+        // exactly this position, so `capture --json` and `cmate wait` can name the
+        // gap instead of showing a worker that silently went quiet.
+        const dialogGate = (0, auto_yes_dialog_gate_1.evaluateAutoYesDialogGate)(cliToolId, promptDetection.promptData.type, cleanOutput);
+        if (!dialogGate.allowed) {
+            (0, auto_yes_suppression_state_1.recordPolicySuppression)(worktreeId, cliToolId, instanceId, {
+                reason: 'unclassified-frame',
+                mode: null,
+                promptType: promptDetection.promptData.type,
+            });
+            logger.warn('poller:auto-yes-skipped-unclassified-frame', {
+                worktreeId,
+                cliToolId,
+                instanceId,
+                promptType: promptDetection.promptData.type,
+                dialogKind: dialogGate.dialog?.kind ?? null,
+                answerMode: dialogGate.dialog?.answerMode ?? null,
+                gateMode: dialogGate.mode,
+            });
+            return 'no_answer';
+        }
         // 4. Resolve auto answer under the execution contract's policy (Issue #1547).
         // Auto-Yes calls detectPrompt directly instead of going through
         // status-detector, so this is the only place the policy can gate an

package/dist/server/src/lib/cli-tools/antigravity.js

@@ -20,6 +20,7 @@ const sources_1 = require("../../lib/hooks/sources");
 const agent_session_lifecycle_1 = require("../../lib/session/agent-session-lifecycle");
 const logger_1 = require("../../lib/logger");
 const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
+const session_start_error_1 = require("../session/session-start-error");
 const logger = (0, logger_1.createLogger)('cli-tools/antigravity');
 /**
  * Extract error message from unknown error type (DRY).
@@ -104,11 +105,11 @@ class AntigravityTool extends base_1.BaseCLITool {
      *   when starting a brand-new session; the caller must not pass a model
      *   for a session that is already running.
      */
-    async startSession(worktreeId, worktreePath, instanceId, model) {
+    async launchSession(worktreeId, worktreePath, instanceId, model) {
         // Check if agy is installed
         const available = await this.isInstalled();
         if (!available) {
-            throw new Error('Antigravity CLI (agy) is not installed or not in PATH');
+            throw new session_start_error_1.SessionStartUnavailableError(this.name, 'Antigravity CLI (agy) is not installed or not in PATH');
         }
         const sessionName = this.getSessionName(worktreeId, instanceId);
         // Check if session already exists
@@ -245,6 +246,7 @@ class AntigravityTool extends base_1.BaseCLITool {
                 sessionName,
                 message,
                 cliToolId: 'antigravity',
+                composer: this.describeComposer(),
             });
             // Invalidate cache after sending message (required so the poller re-reads)
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);

package/dist/server/src/lib/cli-tools/base.js

@@ -3,13 +3,48 @@
  * Base implementation for CLI tools
  * Provides common functionality for all CLI tool implementations
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseCLITool = void 0;
 const child_process_1 = require("child_process");
 const util_1 = require("util");
-const types_1 = require("./types");
-const validation_1 = require("./validation");
+const session_name_1 = require("./session-name");
 const tmux_1 = require("../tmux/tmux");
+const composer_spec_1 = require("./composer-spec");
+const capture_spec_1 = require("./capture-spec");
+const graceful_exit_1 = require("./graceful-exit");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 /**
  * Abstract base class for CLI tools
@@ -39,21 +74,71 @@ class BaseCLITool {
      *
      * T2.3: Added validation to prevent command injection (MF4-001)
      *
+     * Issue #1984: 規則の本体は `./session-name` に移した。名前だけが欲しい呼び出し側
+     * （`ws-server.ts` など）が、7 ツールの実装グラフごと import せずに済むようにするため。
+     * ここは委譲だけを行い、規則は 1 箇所に保つ。
+     *
      * @param worktreeId - Worktree ID
      * @param instanceId - Agent instance ID (defaults to the primary instance)
      * @returns Session name
      * @throws Error if the resulting session name is invalid
      */
     getSessionName(worktreeId, instanceId) {
-        const base = `mcbd-${this.id}-${worktreeId}`;
-        if (!instanceId || instanceId === this.id) {
-            (0, validation_1.validateSessionName)(base);
-            return base;
+        return (0, session_name_1.resolveSessionName)(this.id, worktreeId, instanceId);
+    }
+    /**
+     * Start this tool's session, reporting a failure exactly once (Issue #2009).
+     *
+     * ## Why the seam is here and not at the seven throw sites
+     *
+     * #2000 made "the session refused to start" reach a phone, and wired it at the
+     * single place that established the fact: `claude-session`'s
+     * `SessionStartFailedError`. Measured on this tree that was also the ONLY
+     * place — the other six tools detect their own start failures and throw a bare
+     * `Error`, so six of seven agents failed silently. Copying the #2000 call into
+     * the other six would have made the eighth tool a new silent one, which is the
+     * failure mode the Issue names ("片方だけ直る改修").
+     *
+     * So the call moved up one level, to the one method every tool inherits and
+     * every caller goes through — the two API routes that start sessions, and
+     * anything added later. A tool author cannot forget it, because there is
+     * nothing left to remember: implement {@link launchSession} and the reporting
+     * is already wired.
+     *
+     * ## Fire-and-forget, and a deferred import
+     *
+     * The notification is NOT awaited. Web push fans out to every registered
+     * device, and holding a 503 open for that would make a failed start slower to
+     * report than a successful one. `notifySessionStartFailurePush` contains its
+     * own failures, and the `.catch` here is the belt for the import itself.
+     *
+     * `await import()` rather than a static import, for the reason Issue #1984
+     * gives on `CLIToolManager.stopPollers`: `push/failure-push-notifier` pulls
+     * the database and `web-push` behind it, and every one of the seven tool
+     * modules loads THIS file. Deferring it to the failure path keeps the
+     * cli-tools graph the size #1984 cut it down to.
+     *
+     * @param worktreeId - Worktree ID
+     * @param worktreePath - Worktree path
+     * @param instanceId - Agent instance ID (defaults to the primary instance)
+     * @param model - Model to launch with; only antigravity honours it (#989)
+     * @throws Whatever {@link launchSession} threw — unchanged, after reporting
+     */
+    async startSession(worktreeId, worktreePath, instanceId, model) {
+        try {
+            await this.launchSession(worktreeId, worktreePath, instanceId, model);
+        }
+        catch (error) {
+            void Promise.resolve().then(() => __importStar(require('../push/failure-push-notifier'))).then(({ notifySessionStartFailurePush }) => notifySessionStartFailurePush({
+                worktreeId,
+                cliToolId: this.id,
+                instanceId,
+                toolName: this.name,
+                error,
+            }))
+                .catch(() => { });
+            throw error;
         }
-        const suffix = (0, types_1.deriveSessionSuffix)(instanceId, this.id);
-        const sessionName = suffix ? `${base}-${suffix}` : base;
-        (0, validation_1.validateSessionName)(sessionName);
-        return sessionName;
     }
     /** Repair geometry when reusing a tmux session that predates the current defaults. */
     async reconcileExistingSession(sessionName, options) {
@@ -70,5 +155,41 @@ class BaseCLITool {
         const sessionName = this.getSessionName(worktreeId, instanceId);
         await (0, tmux_1.sendSpecialKey)(sessionName, 'Escape');
     }
+    /**
+     * Describe this tool's input box (Issue #1933, §6.3).
+     *
+     * The default is claude's — a marked input line at the bottom of the pane, a
+     * twelve-row read-back, one Enter, and the composer emptied before the body
+     * is typed. Every tool's answer is resolved from `./composer-spec`, which is
+     * where the values that used to be three module-level tables inside
+     * `submit-verified-sender.ts` now live; a tool overrides this method when its
+     * box is not describable that way.
+     *
+     * @returns This tool's {@link ComposerSpec}
+     */
+    describeComposer() {
+        return (0, composer_spec_1.resolveComposerSpec)(this.id);
+    }
+    /**
+     * Describe how this tool is asked to quit (Issue #1933, §13.2).
+     *
+     * The default is claude's: one Ctrl-D, then the generic TUI shutdown window.
+     * The sequence is a DESCRIPTION — `killSession()` still sends its own
+     * measured keystrokes, and the conformance suite pins that the two agree.
+     *
+     * @returns This tool's {@link GracefulExitSpec}
+     */
+    gracefulExitSequence() {
+        return (0, graceful_exit_1.resolveGracefulExitSpec)(this.id);
+    }
+    /**
+     * Describe what a status capture of this tool must ask tmux for
+     * (Issue #1933, §10.12).
+     *
+     * @returns This tool's {@link CaptureSpec}
+     */
+    captureSpec() {
+        return (0, capture_spec_1.resolveCaptureSpec)(this.id);
+    }
 }
 exports.BaseCLITool = BaseCLITool;

package/dist/server/src/lib/cli-tools/capture-spec.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * How many rows a status probe asks tmux for, per tool (Issue #1933, §10.12).
+ *
+ * The ladder this replaces lived in `src/lib/session/worktree-status-helper.ts`
+ * as a private `getStatusCaptureLines()`, which meant a module outside
+ * `src/lib/cli-tools/**` had to import `@/lib/cli-tools/opencode` and
+ * `@/lib/cli-tools/gemini` for two numbers — dragging opencode's
+ * `child_process` use and gemini's whole graph into the sidebar's status poll,
+ * and forcing four unrelated test files to mock both tool modules just to reach
+ * a capture count.
+ *
+ * @module lib/cli-tools/capture-spec
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GEMINI_PANE_HEIGHT = void 0;
+exports.resolveCaptureSpec = resolveCaptureSpec;
+const tmux_pane_config_1 = require("../../config/tmux-pane-config");
+const status_capture_config_1 = require("../../config/status-capture-config");
+const types_1 = require("./types");
+/**
+ * Gemini tmux pane height (rows).
+ *
+ * Declared here since Issue #1933 and re-exported from `./gemini`, so existing
+ * importers are unchanged. It moved for the same reason `OPENCODE_PANE_HEIGHT`
+ * moved to `@/config/tmux-pane-config` in #1906: the module that needs the
+ * number must not have to import the tool.
+ */
+exports.GEMINI_PANE_HEIGHT = 200;
+/**
+ * The capture description for a CLI tool.
+ *
+ * A tool with a fixed pane height asks for exactly that height, because it
+ * renders in the alternate screen and `capture-pane` can return nothing else.
+ * Everything else asks for {@link STATUS_DETECTION_CAPTURE_LINES}: detection
+ * trims trailing blank padding before windowing, so it only needs the captured
+ * slice to reach past that padding to the real content, and asking for the
+ * display path's 10000 rows on every sidebar poll was measurably wasteful
+ * (#965).
+ *
+ * @param cliToolId - CLI tool identifier
+ * @returns That tool's {@link CaptureSpec}
+ */
+function resolveCaptureSpec(cliToolId) {
+    return {
+        statusLines: resolveStatusCaptureLines(cliToolId),
+        usesAlternateScreen: (0, types_1.usesAlternateScreen)(cliToolId),
+    };
+}
+function resolveStatusCaptureLines(cliToolId) {
+    if (cliToolId === 'opencode')
+        return tmux_pane_config_1.OPENCODE_PANE_HEIGHT;
+    if (cliToolId === 'gemini')
+        return exports.GEMINI_PANE_HEIGHT;
+    return status_capture_config_1.STATUS_DETECTION_CAPTURE_LINES;
+}

package/dist/server/src/lib/cli-tools/claude.js

@@ -38,7 +38,7 @@ class ClaudeTool extends base_1.BaseCLITool {
      * @param worktreePath - Worktree path
      * @param instanceId - Optional agent instance ID (defaults to primary)
      */
-    async startSession(worktreeId, worktreePath, instanceId) {
+    async launchSession(worktreeId, worktreePath, instanceId) {
         const options = {
             worktreeId,
             worktreePath,

package/dist/server/src/lib/cli-tools/codex.js

@@ -15,6 +15,7 @@ const logger_1 = require("../../lib/logger");
 const sources_1 = require("../../lib/hooks/sources");
 const agent_session_lifecycle_1 = require("../../lib/session/agent-session-lifecycle");
 const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
+const session_start_error_1 = require("../session/session-start-error");
 const logger = (0, logger_1.createLogger)('cli-tools/codex');
 /**
  * Extract error message from unknown error type (DRY)
@@ -121,11 +122,11 @@ class CodexTool extends base_1.BaseCLITool {
      * @param worktreeId - Worktree ID
      * @param worktreePath - Worktree path
      */
-    async startSession(worktreeId, worktreePath, instanceId) {
+    async launchSession(worktreeId, worktreePath, instanceId) {
         // Check if Codex is installed
         const codexAvailable = await this.isInstalled();
         if (!codexAvailable) {
-            throw new Error('Codex CLI is not installed or not in PATH');
+            throw new session_start_error_1.SessionStartUnavailableError(this.name, 'Codex CLI is not installed or not in PATH');
         }
         const sessionName = this.getSessionName(worktreeId, instanceId);
         // Check if session already exists
@@ -343,6 +344,9 @@ class CodexTool extends base_1.BaseCLITool {
                 sessionName,
                 message,
                 cliToolId: 'codex',
+                // Issue #1933: the tool describes its own composer; the sender no
+                // longer keys three module-level tables on the id.
+                composer: this.describeComposer(),
             });
             // Issue #405: Invalidate cache after sending message
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);