commandmate 0.18.0 → 0.19.0

package/dist/server/src/lib/db/migrations/v52-orphaned-worktree-children.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Migration v52: delete child rows pointing at a worktree that no longer exists
+ * (Issue #1621, Phase 0).
+ *
+ * `getWorktreeChildTables` used to enumerate child tables from foreign-key
+ * metadata alone, so `tasks` (#1548), `verification_runs` (#1544) and
+ * `skill_operations` (#1428) — each holding a `worktree_id` with no constraint
+ * declared — were invisible to both the rename path and the delete path. No
+ * CASCADE fires without a foreign key, so every worktree deleted since those
+ * tables landed left their rows behind, and every worktree ID rename left them
+ * addressing an ID nothing resolves. The code fix stops new orphans; this
+ * migration removes the ones already written.
+ *
+ * The sweep reuses the shared enumeration rather than naming tables, so the
+ * FK-less tables above and the FK-declared ones are treated identically — an
+ * orphan in a CASCADE table is equally unreachable, it just needed a
+ * `foreign_keys = OFF` window to be created.
+ *
+ * Three deliberate narrowings:
+ *
+ * - Append-only ledgers are excluded (`getDeletableWorktreeChildTables`).
+ *   `skill_operations` holds a `worktree_id` and does have rows referencing
+ *   worktrees that are gone, but it declares `BEFORE DELETE ... RAISE(ABORT)`
+ *   (#1234) and is read across every worktree by the audit feed. Deleting from
+ *   it aborts the statement, which here would roll back the migration and take
+ *   startup with it (measured). Its rows are history, not orphans.
+ * - `worktree_id IS NULL` rows are left alone. Every current child table
+ *   declares the column NOT NULL, so this cannot fire today; if a future table
+ *   makes it nullable, a NULL means "not attached", not "attached to something
+ *   gone", and deleting it would be data loss rather than cleanup.
+ * - `verification_gate_results` has no `worktree_id` and is not swept directly.
+ *   It reaches its worktree through `verification_runs(id) ON DELETE CASCADE`,
+ *   so deleting the orphaned runs takes its rows with them (better-sqlite3
+ *   enables `foreign_keys` by default, and db-instance.ts sets it explicitly).
+ *   `task_events` is *not* in the same position: v51 declares no foreign key to
+ *   `tasks` on purpose, because history that vanishes with its subject cannot
+ *   be audited afterwards. That is a design choice, not an orphan, so it stays.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v52_migrations = void 0;
+const worktree_child_tables_1 = require("./worktree-child-tables");
+exports.v52_migrations = [
+    {
+        version: 52,
+        name: 'delete-orphaned-worktree-children',
+        up: (db) => {
+            let deleted = 0;
+            for (const { table, column } of (0, worktree_child_tables_1.getDeletableWorktreeChildTables)(db)) {
+                // Identifiers come from sqlite_master / PRAGMA, never from user input.
+                // The alias is `cm_parent` rather than something short like `w` so it
+                // cannot collide with a child table that happens to be named the same.
+                const result = db
+                    .prepare(`DELETE FROM "${table}"
+              WHERE "${column}" IS NOT NULL
+                AND NOT EXISTS (
+                  SELECT 1 FROM worktrees AS cm_parent
+                  WHERE cm_parent.id = "${table}"."${column}"
+                )`)
+                    .run();
+                if (result.changes > 0) {
+                    console.log(`Deleted ${result.changes} orphaned row(s) from ${table}.${column}`);
+                    deleted += result.changes;
+                }
+            }
+            if (deleted === 0) {
+                console.log('No orphaned worktree child rows found');
+            }
+        },
+        down: () => {
+            // Deleted rows cannot be resurrected. Defined anyway so rollback tooling
+            // (and the tests that rebuild a v51 database) keep working.
+            console.log('No rollback for orphaned child row cleanup (rows are gone)');
+        },
+    },
+];

package/dist/server/src/lib/db/migrations/worktree-child-tables.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * Live-schema introspection for "which tables reference a worktree".
+ *
+ * Lives under `migrations/` rather than next to `worktree-db.ts` because the
+ * dependency has to point this way: migration v52 sweeps orphans with the same
+ * enumeration the runtime uses, and a migration that imports `worktree-db.ts`
+ * inherits every mock of it — `vi.mock('@/lib/db/worktree-db')` in an unrelated
+ * suite made `runMigrations` throw `No "getDeletableWorktreeChildTables" export
+ * is defined` (measured across 5 tests). Schema introspection is the more
+ * foundational of the two, so it is what the other side imports.
+ *
+ * Issue #1621.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorktreeChildTables = getWorktreeChildTables;
+exports.getWriteGuardedTables = getWriteGuardedTables;
+exports.getDeletableWorktreeChildTables = getDeletableWorktreeChildTables;
+/** Conventional name of the column holding a worktree reference. */
+const WORKTREE_REFERENCE_COLUMN = 'worktree_id';
+/**
+ * Discover every table that references a worktree, along with the referencing
+ * column. Derived dynamically from the live schema so it never drifts out of
+ * sync with future migrations that add child tables.
+ *
+ * Two sources are unioned:
+ *
+ * 1. a `worktree_id` column, **whether or not** the table declares a foreign key
+ * 2. a declared foreign key to `worktrees(id)`, whatever the column is named
+ *
+ * Source 1 is what Issue #1621 adds. FK metadata alone (all this did before)
+ * silently skipped `tasks` (#1548), `verification_runs` (#1544) and
+ * `skill_operations` (#1428): all three carry a `worktree_id` but declare no
+ * constraint, so a rename left them pointing at an ID that no longer exists and
+ * a delete left them behind as orphans — no CASCADE fires without a FK.
+ *
+ * Source 2 is kept so a future table whose FK column is *not* named
+ * `worktree_id` keeps being followed; dropping it would be a regression for
+ * every table #1151 already handled.
+ *
+ * Issue #1151, #1621.
+ */
+function getWorktreeChildTables(db) {
+    const tables = db
+        .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'")
+        .all();
+    const children = [];
+    const seen = new Set();
+    const add = (table, column) => {
+        // JSON encoding keeps the pair unambiguous whatever the identifiers contain.
+        const key = JSON.stringify([table, column]);
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        children.push({ table, column });
+    };
+    for (const { name: tableName } of tables) {
+        if (tableName === 'worktrees')
+            continue;
+        // PRAGMA identifiers cannot be bound; `tableName` comes from sqlite_master,
+        // not user input, so string interpolation here is safe.
+        const columns = db.prepare(`PRAGMA table_info("${tableName}")`).all();
+        if (columns.some((column) => column.name === WORKTREE_REFERENCE_COLUMN)) {
+            add(tableName, WORKTREE_REFERENCE_COLUMN);
+        }
+        const fks = db.prepare(`PRAGMA foreign_key_list("${tableName}")`).all();
+        for (const fk of fks) {
+            if (fk.table === 'worktrees' && (fk.to === 'id' || fk.to === null)) {
+                add(tableName, fk.from);
+            }
+        }
+    }
+    return children;
+}
+/**
+ * Tables the schema itself refuses to let us rewrite, per statement kind.
+ *
+ * An append-only ledger enforces itself with a `BEFORE UPDATE` / `BEFORE DELETE`
+ * trigger that calls `RAISE(ABORT, ...)`; `skill_operations` declares both
+ * (#1234, migrations v44/v48). Such a table carries a `worktree_id` yet is
+ * deliberately *not* owned by its worktree's lifetime: `querySkillOperationAudit`
+ * reads it across every worktree for the dashboard feed, exactly like v51 keeps
+ * `task_events` alive after its task is gone. Sweeping it is not cleanup, it is
+ * destroying audit history — and it does not even fail safely: the trigger
+ * aborts the statement, which rolls back the whole enclosing transaction, so a
+ * blind sweep breaks worktree deletion outright (measured: `deleteWorktreesByIds`
+ * threw `skill_operations is append-only` and the worktree row survived; the
+ * same sweep inside migration v52 fails startup).
+ *
+ * Detected from trigger SQL rather than by table name so a future ledger is
+ * protected the moment it declares its guard (Issue #1621).
+ */
+function getWriteGuardedTables(db) {
+    const triggers = db
+        .prepare("SELECT tbl_name, sql FROM sqlite_master WHERE type = 'trigger'")
+        .all();
+    const noUpdate = new Set();
+    const noDelete = new Set();
+    for (const trigger of triggers) {
+        if (!trigger.sql)
+            continue;
+        if (!/\bRAISE\s*\(\s*ABORT/i.test(trigger.sql))
+            continue;
+        if (/\bBEFORE\s+UPDATE\b/i.test(trigger.sql))
+            noUpdate.add(trigger.tbl_name);
+        if (/\bBEFORE\s+DELETE\b/i.test(trigger.sql))
+            noDelete.add(trigger.tbl_name);
+    }
+    return { noUpdate, noDelete };
+}
+/**
+ * Child tables whose rows a worktree actually owns — everything
+ * getWorktreeChildTables reports, minus the append-only ledgers that outlive it.
+ * This is the set a delete or an orphan sweep may touch (Issue #1621).
+ */
+function getDeletableWorktreeChildTables(db) {
+    const { noDelete } = getWriteGuardedTables(db);
+    return getWorktreeChildTables(db).filter(({ table }) => !noDelete.has(table));
+}

package/dist/server/src/lib/db/worktree-db.js

@@ -28,6 +28,7 @@ exports.deleteRepositoryWorktrees = deleteRepositoryWorktrees;
 exports.deleteWorktreesByIds = deleteWorktreesByIds;
 const selected_agents_validator_1 = require("../../lib/selected-agents-validator");
 const chat_db_1 = require("./chat-db");
+const worktree_child_tables_1 = require("./migrations/worktree-child-tables");
 /**
  * Get latest user message per CLI tool for multiple worktrees (batch query)
  * Optimized to avoid N+1 query problem
@@ -269,30 +270,24 @@ function upsertWorktree(db, worktree) {
     run();
 }
 /**
- * Discover every table that has a foreign key referencing `worktrees(id)`,
- * along with the referencing column. Derived dynamically from the live schema
- * so it never drifts out of sync with future migrations that add child tables.
+ * Delete every child row pointing at any of `worktreeIds`.
  *
- * Issue #1151.
+ * Deliberately covers *all* deletable child tables, not just the FK-less ones:
+ * doing so makes deletion correct even when `PRAGMA foreign_keys` is off, and
+ * the extra statements against CASCADE tables remove rows that would have been
+ * removed anyway. Append-only ledgers are skipped (see getWriteGuardedTables).
+ * Must run before the parent row is deleted (Issue #1621).
  */
-function getWorktreeChildTables(db) {
-    const tables = db
-        .prepare("SELECT name FROM sqlite_master WHERE type = 'table'")
-        .all();
-    const children = [];
-    for (const { name } of tables) {
-        if (name === 'worktrees')
+function deleteWorktreeChildRows(db, worktreeIds, children = (0, worktree_child_tables_1.getWorktreeChildTables)(db)) {
+    if (worktreeIds.length === 0)
+        return;
+    const { noDelete } = (0, worktree_child_tables_1.getWriteGuardedTables)(db);
+    const placeholders = worktreeIds.map(() => '?').join(',');
+    for (const { table, column } of children) {
+        if (noDelete.has(table))
             continue;
-        // PRAGMA identifiers cannot be bound; `name` comes from sqlite_master, not
-        // user input, so string interpolation here is safe.
-        const fks = db.prepare(`PRAGMA foreign_key_list("${name}")`).all();
-        for (const fk of fks) {
-            if (fk.table === 'worktrees' && (fk.to === 'id' || fk.to === null)) {
-                children.push({ table: name, column: fk.from });
-            }
-        }
+        db.prepare(`DELETE FROM "${table}" WHERE "${column}" IN (${placeholders})`).run(...worktreeIds);
     }
-    return children;
 }
 /**
  * Rename a worktree row's primary key from `oldId` to `newId`, re-pointing every
@@ -300,6 +295,18 @@ function getWorktreeChildTables(db) {
  * same-directory branch switch preserve chat history and all related data
  * instead of destroying it (Issue #1151).
  *
+ * "Every child table" means every table carrying a worktree reference, not just
+ * the ones that declare a foreign key: `tasks`, `verification_runs` and
+ * `skill_operations` do not, and used to be left addressing an ID that no
+ * longer resolves (Issue #1621).
+ *
+ * Append-only ledgers are the one exception, and the schema states it itself —
+ * `skill_operations` aborts any UPDATE (#1234). An immutable audit row records
+ * what happened under the identity in force at the time, and rewriting it is
+ * precisely what its trigger exists to prevent; attempting it does not fail
+ * quietly either, it aborts the enclosing transaction and takes the rename with
+ * it (measured). See getWriteGuardedTables.
+ *
  * Must be called inside a transaction. `PRAGMA defer_foreign_keys` defers FK
  * enforcement to COMMIT, letting us repoint the parent PK and its children in
  * any order without needing `ON UPDATE CASCADE` on every constraint.
@@ -314,15 +321,20 @@ function migrateWorktreeIdPreservingChildren(db, oldId, newId) {
     // independently. Resets automatically at the end of the transaction.
     db.pragma('defer_foreign_keys = ON');
     const newExists = db.prepare('SELECT 1 FROM worktrees WHERE id = ?').get(newId);
-    const children = getWorktreeChildTables(db);
+    const { noUpdate } = (0, worktree_child_tables_1.getWriteGuardedTables)(db);
+    const allChildren = (0, worktree_child_tables_1.getWorktreeChildTables)(db);
+    const children = allChildren.filter(({ table }) => !noUpdate.has(table));
     if (newExists) {
         // Collision guard. `path` is UNIQUE so two rows for the same directory
         // should never coexist, but if the DB is already inconsistent keep the
-        // destination row's data and fold in the source's non-conflicting children;
-        // conflicting leftovers are removed by CASCADE when the old row is deleted.
+        // destination row's data and fold in the source's non-conflicting children.
         for (const { table, column } of children) {
             db.prepare(`UPDATE OR IGNORE "${table}" SET "${column}" = ? WHERE "${column}" = ?`).run(newId, oldId);
         }
+        // Conflicting leftovers are dropped explicitly rather than left to CASCADE:
+        // tables without a foreign key never cascade, so relying on the parent
+        // delete alone would strand their rows on a dead ID (#1621).
+        deleteWorktreeChildRows(db, [oldId], allChildren);
         db.prepare('DELETE FROM worktrees WHERE id = ?').run(oldId);
         return;
     }
@@ -523,29 +535,38 @@ function getWorktreesByRepository(db, repositoryPath) {
 }
 /**
  * Delete all worktrees for a given repository path
- * Related data is automatically deleted via ON DELETE CASCADE in every table
- * holding a foreign key to worktrees(id) — chat_messages, session_states,
- * worktree_memos, worktree_todos, agent_instances, scheduled_executions,
- * execution_logs, timer_messages and skill_installations (#1430). The live list
- * is whatever `PRAGMA foreign_key_list` reports; see getWorktreeChildTables.
+ * Child rows are deleted explicitly before the parent, for every table
+ * getWorktreeChildTables reports. ON DELETE CASCADE covers only the tables that
+ * declare a foreign key; `tasks`, `verification_runs` and `skill_operations`
+ * hold a `worktree_id` with no constraint and would otherwise survive their
+ * worktree as orphans (#1621). Deleting `verification_runs` still cascades to
+ * `verification_gate_results`, which does declare its foreign key.
  *
  * @param db - Database instance
  * @param repositoryPath - Path of the repository to delete
  * @returns Object containing the count of deleted worktrees
  */
 function deleteRepositoryWorktrees(db, repositoryPath) {
-    const stmt = db.prepare(`
-    DELETE FROM worktrees WHERE repository_path = ?
-  `);
-    const result = stmt.run(repositoryPath);
-    return { deletedCount: result.changes };
+    const run = db.transaction(() => {
+        const ids = db
+            .prepare('SELECT id FROM worktrees WHERE repository_path = ?')
+            .all(repositoryPath)
+            .map((row) => row.id)
+            .filter((id) => id !== null);
+        deleteWorktreeChildRows(db, ids);
+        return db
+            .prepare('DELETE FROM worktrees WHERE repository_path = ?')
+            .run(repositoryPath).changes;
+    });
+    return { deletedCount: run() };
 }
 /**
  * Delete worktrees by their IDs
- * Related data is automatically deleted via ON DELETE CASCADE in every table
- * holding a foreign key to worktrees(id) — including skill_installations, whose
- * rows used to survive the worktree and make a re-created worktree at the same
- * path un-installable (#1430). See getWorktreeChildTables for the live list.
+ * Child rows are deleted explicitly before the parent, for every table
+ * getWorktreeChildTables reports — including skill_installations, whose rows
+ * used to survive the worktree and make a re-created worktree at the same path
+ * un-installable (#1430), and the constraint-less `tasks` / `verification_runs`
+ * / `skill_operations`, which no CASCADE can reach (#1621).
  *
  * @param db - Database instance
  * @param worktreeIds - Array of worktree IDs to delete
@@ -556,9 +577,11 @@ function deleteWorktreesByIds(db, worktreeIds) {
         return { deletedCount: 0 };
     }
     const placeholders = worktreeIds.map(() => '?').join(',');
-    const stmt = db.prepare(`
-    DELETE FROM worktrees WHERE id IN (${placeholders})
-  `);
-    const result = stmt.run(...worktreeIds);
-    return { deletedCount: result.changes };
+    const run = db.transaction(() => {
+        deleteWorktreeChildRows(db, worktreeIds);
+        return db
+            .prepare(`DELETE FROM worktrees WHERE id IN (${placeholders})`)
+            .run(...worktreeIds).changes;
+    });
+    return { deletedCount: run() };
 }

package/dist/server/src/lib/detection/cli-patterns.js

@@ -4,7 +4,7 @@
  * Shared between response-poller.ts and API routes
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CLAUDE_SESSION_ERROR_REGEX_PATTERNS = exports.CLAUDE_SESSION_ERROR_PATTERNS = exports.extractAnsiSequences = exports.stripAnsi = exports.ANTIGRAVITY_SKIP_PATTERNS = exports.ANTIGRAVITY_SELECTION_LIST_PATTERN = exports.ANTIGRAVITY_SEPARATOR_PATTERN = exports.ANTIGRAVITY_THINKING_PATTERN = exports.ANTIGRAVITY_PROMPT_PATTERN = exports.VIBE_LOCAL_THINKING_PATTERN = exports.VIBE_LOCAL_PROMPT_PATTERN = exports.COPILOT_SKIP_PATTERNS = exports.COPILOT_SELECTION_LIST_PATTERN = exports.COPILOT_SEPARATOR_PATTERN = exports.COPILOT_THINKING_PATTERN = exports.COPILOT_PROMPT_PATTERN = exports.OPENCODE_SKIP_PATTERNS = exports.OPENCODE_SEPARATOR_PATTERN = exports.CLAUDE_SELECTION_LIST_FOOTER = exports.CLAUDE_MODEL_OVERLAY_FOOTER_PATTERN = exports.OPENCODE_SELECTION_LIST_PATTERN = exports.OPENCODE_PROCESSING_INDICATOR = exports.OPENCODE_RESPONSE_COMPLETE = exports.OPENCODE_LOADING_PATTERN = exports.OPENCODE_THINKING_PATTERN = exports.OPENCODE_PROMPT_AFTER_RESPONSE = exports.OPENCODE_PROMPT_PATTERN = exports.GEMINI_THINKING_PATTERN = exports.GEMINI_PROMPT_PATTERN = exports.MAX_PASTED_TEXT_RETRIES = exports.PASTED_TEXT_DETECT_DELAY = exports.PASTED_TEXT_PATTERN = exports.CODEX_STATUS_BAR_PATTERN = exports.CODEX_PAGER_FOOTER_PATTERN = exports.CODEX_SELECTION_LIST_PATTERN = exports.CODEX_SEPARATOR_PATTERN = exports.CODEX_DIALOG_PATTERN = exports.CODEX_PROMPT_PATTERN = exports.CLAUDE_TRUST_DIALOG_PATTERN = exports.CLAUDE_SEPARATOR_PATTERN = exports.CLAUDE_PROMPT_PATTERN = exports.CODEX_THINKING_PATTERN = exports.CLAUDE_INTERRUPT_HINT_PATTERN = exports.CLAUDE_THINKING_PATTERN = exports.CLAUDE_SPINNER_CHARS = void 0;
+exports.CLAUDE_SESSION_ERROR_REGEX_PATTERNS = exports.CLAUDE_SESSION_ERROR_PATTERNS = exports.extractAnsiSequences = exports.stripAnsi = exports.ANTIGRAVITY_SKIP_PATTERNS = exports.ANTIGRAVITY_SELECTION_LIST_PATTERN = exports.ANTIGRAVITY_SEPARATOR_PATTERN = exports.ANTIGRAVITY_THINKING_PATTERN = exports.ANTIGRAVITY_PROMPT_PATTERN = exports.VIBE_LOCAL_THINKING_PATTERN = exports.VIBE_LOCAL_PROMPT_PATTERN = exports.COPILOT_SKIP_PATTERNS = exports.COPILOT_SELECTION_LIST_PATTERN = exports.COPILOT_SEPARATOR_PATTERN = exports.COPILOT_THINKING_PATTERN = exports.COPILOT_PROMPT_PATTERN = exports.OPENCODE_SKIP_PATTERNS = exports.OPENCODE_SEPARATOR_PATTERN = exports.CLAUDE_SELECTION_LIST_FOOTER = exports.CLAUDE_MODEL_OVERLAY_FOOTER_PATTERN = exports.OPENCODE_SELECTION_LIST_PATTERN = exports.OPENCODE_PROCESSING_INDICATOR = exports.OPENCODE_RESPONSE_COMPLETE = exports.OPENCODE_LOADING_PATTERN = exports.OPENCODE_THINKING_PATTERN = exports.OPENCODE_PROMPT_AFTER_RESPONSE = exports.OPENCODE_PROMPT_PATTERN = exports.GEMINI_THINKING_PATTERN = exports.GEMINI_PROMPT_PATTERN = exports.MAX_PASTED_TEXT_RETRIES = exports.PASTED_TEXT_DETECT_DELAY = exports.PASTED_TEXT_PATTERN = exports.CODEX_STATUS_BAR_PATTERN = exports.CODEX_PAGER_FOOTER_PATTERN = exports.CODEX_APPROVAL_FOOTER_PATTERN = exports.CODEX_SELECTION_LIST_PATTERN = exports.CODEX_SEPARATOR_PATTERN = exports.CODEX_DIALOG_PATTERN = exports.CODEX_PROMPT_PATTERN = exports.CLAUDE_TRUST_DIALOG_PATTERN = exports.CLAUDE_SEPARATOR_PATTERN = exports.CLAUDE_PROMPT_PATTERN = exports.CODEX_THINKING_PATTERN = exports.CLAUDE_INTERRUPT_HINT_PATTERN = exports.CLAUDE_THINKING_PATTERN = exports.CLAUDE_SPINNER_CHARS = void 0;
 exports.findClaudeChromeStart = findClaudeChromeStart;
 exports.isCodexPromptReady = isCodexPromptReady;
 exports.getCodexActiveDialog = getCodexActiveDialog;
@@ -295,6 +295,29 @@ exports.CODEX_SEPARATOR_PATTERN = /^─.*Worked for.*─+$/m;
  * a numbered prompt (PromptPanel with buttons).
  */
 exports.CODEX_SELECTION_LIST_PATTERN = /press\s+enter\s+to\s+(?:confirm|select)/i;
+/**
+ * Codex CLI approval-request footer pattern (Issue #1628).
+ *
+ * Codex renders an approval request ("Would you like to run the following
+ * command?" / "Would you like to make the following edits?") with the SAME
+ * "Press enter to confirm" footer as a `/model`-style menu, which is why
+ * CODEX_SELECTION_LIST_PATTERN swallows it. The two differ in the escape verb:
+ * an approval request can be *cancelled* (it is the agent asking the human for
+ * permission), a menu can only be *gone back* from.
+ *
+ * Measured on codex-cli 0.146.0 (five consecutive live approval frames captured
+ * from a real session, plus two live `/model` picker frames):
+ *   - approval : "Press enter to confirm or esc to cancel"
+ *   - /model   : "Press enter to confirm or esc to go back"
+ *   - /model   : "Press enter to select reasoning effort, or esc to dismiss."
+ *
+ * Used only as one of two OR'd approval signals (see isCodexApprovalRequest in
+ * status-detector.ts); the other is an interrogative question line, so a future
+ * rewording of either signal alone does not reopen Issue #1628.
+ *
+ * No /g flag (keeps .test() stateless), no nested quantifiers (ReDoS-safe).
+ */
+exports.CODEX_APPROVAL_FOOTER_PATTERN = /esc\s+to\s+cancel/i;
 /**
  * Codex CLI pager / edit-previous (transcript) mode footer pattern (Issue #1017)
  *

package/dist/server/src/lib/detection/status-detector.js

@@ -100,7 +100,8 @@ const CODEX_NUMBERED_OPTION_PATTERN = /^\s*[❯›●]?\s*\d{1,2}[.)]\s/;
  * already-answered prompt left in the 50-line scan window rather than an active one.
  *
  * Codex keeps the answered "1. Yes / 2. No" block + "press number to confirm" footer in
- * its transcript (session historyLimit 50000) instead of repainting it away like Claude,
+ * its transcript (it draws on the normal screen, so tmux retains a scrollback for it —
+ * TMUX_HISTORY_LIMIT lines deep) instead of repainting it away like Claude,
  * so detectPrompt() keeps matching it and detectSessionStatus() reports `waiting` even
  * after the user answered and Codex resumed — the sidebar status dot then stays orange
  * forever (the reported bug).
@@ -147,6 +148,39 @@ function isCodexStalePrompt(contentLines) {
     }
     return lastPromptIdx >= 0 && lastThinkingIdx > lastPromptIdx;
 }
+/**
+ * Issue #1628: decide whether a Codex frame that matched CODEX_SELECTION_LIST_PATTERN
+ * is the agent ASKING FOR APPROVAL rather than the user browsing a menu.
+ *
+ * Why this exists: Codex renders both with a "Press enter to confirm" footer, so the
+ * priority-0.8 selection-list branch (added for `/model` in Issue #622) also swallowed
+ * every approval request and returned `hasActivePrompt: false`. `isPromptWaiting` is the
+ * only blocked-on-a-human signal the current-output payload carries, so `commandmate wait
+ * --on-prompt agent` could never raise exit 10 for a Codex worker sitting on
+ * "Would you like to run the following command?" — it polled until the timeout while the
+ * agent was stopped. Auto-Yes was unaffected because it calls detectPrompt() directly,
+ * which parses these frames correctly; only the status-detector layer lost them.
+ *
+ * Two OR'd signals, both measured against live codex-cli 0.146.0 captures
+ * (5 approval frames from one real session + 2 `/model` picker frames):
+ *   1. an interrogative question line directly above the options
+ *      ("Would you like to run the following command?" → the extracted question ends
+ *      with "?"; a picker's ends with its description, e.g. "…browse all models.")
+ *   2. the approval escape verb ("esc to cancel" vs a menu's "esc to go back" /
+ *      "esc to dismiss")
+ * Either alone covers every measured approval frame, so a rewording of one does not
+ * reopen the bug.
+ *
+ * Gated on `promptDetection.isPrompt` so a frame detectPrompt() could not parse into
+ * options (e.g. the unnumbered "Select a model" list of Issue #619) can never be
+ * promoted to an active prompt.
+ */
+function isCodexApprovalRequest(promptDetection, selectionWindow) {
+    if (!promptDetection.isPrompt)
+        return false;
+    const question = promptDetection.promptData?.question?.trim() ?? '';
+    return question.endsWith('?') || cli_patterns_1.CODEX_APPROVAL_FOOTER_PATTERN.test(selectionWindow);
+}
 /**
  * Detect session status with confidence level
  *
@@ -286,6 +320,21 @@ function detectSessionStatus(output, cliToolId, lastOutputTimestamp) {
             if (cli_patterns_1.CODEX_SELECTION_LIST_PATTERN.test(codexSelectionWindow)) {
                 const codexPromptOptions = (0, cli_patterns_1.buildDetectPromptOptions)(cliToolId);
                 const codexPromptDetection = (0, prompt_detector_1.detectPrompt)((0, cli_patterns_1.stripBoxDrawing)(cleanOutput), codexPromptOptions);
+                // Issue #1628: an approval request wears the same footer as a menu but is the
+                // agent blocked on the human, so it must surface as an active prompt (exit 10
+                // for `wait`, PromptPanel in the UI) instead of a navigable list. The #1160
+                // staleness guard still applies: an ALREADY-ANSWERED approval whose footer is
+                // still inside the window, with Codex running below it, is dead scrollback.
+                if (isCodexApprovalRequest(codexPromptDetection, codexSelectionWindow) &&
+                    !isCodexStalePrompt(contentLines)) {
+                    return {
+                        status: 'waiting',
+                        confidence: 'high',
+                        reason: exports.STATUS_REASON.PROMPT_DETECTED,
+                        hasActivePrompt: true,
+                        promptDetection: codexPromptDetection,
+                    };
+                }
                 return {
                     status: 'waiting',
                     confidence: 'high',
@@ -333,7 +382,8 @@ function detectSessionStatus(output, cliToolId, lastOutputTimestamp) {
     if (promptDetection.isPrompt) {
         // Issue #1160: Codex keeps an ANSWERED approval / numbered-choice block
         // ("1. Yes / 2. No" + "press number to confirm" footer) in its transcript
-        // (historyLimit 50000) instead of repainting it away like Claude. detectPrompt's
+        // (non-alternate-screen, so tmux keeps TMUX_HISTORY_LIMIT lines of scrollback for
+        // it) instead of repainting it away like Claude. detectPrompt's
         // 50-line window then keeps matching that dead prompt, so this priority-1 branch
         // returns `waiting` even after the user answered and Codex resumed — the sidebar
         // status dot stays orange forever (the reported bug). Guard with a position check:

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

@@ -502,11 +502,13 @@ async function startClaudeSession(options) {
         // (SF-S2-004: Explicit fall-through instead of hidden re-entry)
     }
     try {
-        // Create tmux session with large history buffer for Claude output
+        // Create tmux session. Scrollback depth comes from the shared
+        // TMUX_HISTORY_LIMIT default (Issue #1624) — do not re-hardcode it here.
+        // (Claude itself renders in the alternate screen and keeps history_size at 0,
+        // so the limit is inert for this tool; it still applies to the bare shell.)
         await (0, tmux_1.createSession)({
             sessionName,
             workingDirectory: worktreePath,
-            historyLimit: 50000,
         });
         // SF-S2-003: Sanitize environment after createSession, before launching Claude CLI
         await (0, session_key_sender_1.sanitizeSessionEnvironment)(sessionName);