commandmate 0.29.1 → 0.30.0

package/dist/server/src/lib/db/app-settings-db.js

@@ -0,0 +1,202 @@
+"use strict";
+/**
+ * app-settings-db: Key-value store for application settings.
+ *
+ * Provides typed helpers for reading/writing the app_settings table
+ * created in migration v27.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RECENT_BROWSE_PATHS_LIMIT = void 0;
+exports.getSidebarGroupOrder = getSidebarGroupOrder;
+exports.setSidebarGroupOrder = setSidebarGroupOrder;
+exports.getRecentBrowsePaths = getRecentBrowsePaths;
+exports.addRecentBrowsePath = addRecentBrowsePath;
+exports.getDefaultSelectedAgents = getDefaultSelectedAgents;
+exports.setDefaultSelectedAgents = setDefaultSelectedAgents;
+exports.clearDefaultSelectedAgents = clearDefaultSelectedAgents;
+exports.getDefaultSurfaceMode = getDefaultSurfaceMode;
+exports.setDefaultSurfaceMode = setDefaultSurfaceMode;
+const selected_agents_validator_1 = require("../../lib/selected-agents-validator");
+const ui_state_1 = require("../../types/ui-state");
+// ============================================================================
+// Key constants
+// ============================================================================
+/** Storage key for sidebar repository group display order */
+const KEY_SIDEBAR_GROUP_ORDER = 'sidebar_group_order';
+/** Storage key for directories recently chosen in the repository picker */
+const KEY_RECENT_BROWSE_PATHS = 'recent_browse_paths';
+/**
+ * Storage key for the agent list new worktrees start with (Issue #2065).
+ *
+ * Server-wide, ordered, and `[0]` is the primary. Absent means "no preference";
+ * it is NOT written with the compiled-in default at install time, because a
+ * stored copy of the constant would silently pin every install to whatever the
+ * constant was on the day it was written.
+ */
+const KEY_DEFAULT_SELECTED_AGENTS = 'default_selected_agents';
+/**
+ * Storage key for the output surface new sessions open in (Issue #2201).
+ *
+ * Server-wide, and stored as the bare mode string rather than JSON: it is a
+ * single enum value, and `readStringArray` exists for the two list-shaped
+ * settings above. Absent means "no preference" — exactly as for
+ * {@link KEY_DEFAULT_SELECTED_AGENTS}, the constant is never written into the
+ * row at install time, so a later change to `DEFAULT_SURFACE_MODE` still
+ * reaches an install that never chose.
+ */
+const KEY_DEFAULT_SURFACE_MODE = 'default_surface_mode';
+/** How many recently used directories to remember (Issue #1517) */
+exports.RECENT_BROWSE_PATHS_LIMIT = 5;
+// ============================================================================
+// Helpers
+// ============================================================================
+function readStringArray(db, key) {
+    try {
+        const row = db
+            .prepare('SELECT value FROM app_settings WHERE key = ?')
+            .get(key);
+        if (!row)
+            return null;
+        const parsed = JSON.parse(row.value);
+        if (!Array.isArray(parsed))
+            return null;
+        if (!parsed.every((v) => typeof v === 'string'))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function writeStringArray(db, key, values) {
+    const now = Date.now();
+    db.prepare(`
+    INSERT INTO app_settings (key, value, created_at, updated_at)
+    VALUES (?, ?, ?, ?)
+    ON CONFLICT(key) DO UPDATE SET
+      value = excluded.value,
+      updated_at = excluded.updated_at
+  `).run(key, JSON.stringify(values), now, now);
+}
+function readScalar(db, key) {
+    try {
+        const row = db
+            .prepare('SELECT value FROM app_settings WHERE key = ?')
+            .get(key);
+        return row ? row.value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeScalar(db, key, value) {
+    const now = Date.now();
+    db.prepare(`
+    INSERT INTO app_settings (key, value, created_at, updated_at)
+    VALUES (?, ?, ?, ?)
+    ON CONFLICT(key) DO UPDATE SET
+      value = excluded.value,
+      updated_at = excluded.updated_at
+  `).run(key, value, now, now);
+}
+/**
+ * Get the sidebar repository group order.
+ *
+ * @returns Array of repository names in display order, or null if not set.
+ */
+function getSidebarGroupOrder(db) {
+    return readStringArray(db, KEY_SIDEBAR_GROUP_ORDER);
+}
+/**
+ * Save the sidebar repository group order.
+ *
+ * @param order - Array of repository names in desired display order.
+ */
+function setSidebarGroupOrder(db, order) {
+    writeStringArray(db, KEY_SIDEBAR_GROUP_ORDER, order);
+}
+/**
+ * Get directories recently chosen in the repository picker, newest first.
+ *
+ * Issue #1517: these are display hints only. Callers must still validate each
+ * path against the allowed roots, because the roots can shrink after a path
+ * was stored.
+ */
+function getRecentBrowsePaths(db) {
+    return readStringArray(db, KEY_RECENT_BROWSE_PATHS) ?? [];
+}
+/**
+ * Record a directory as most recently used, keeping the list de-duplicated and
+ * capped at RECENT_BROWSE_PATHS_LIMIT.
+ */
+function addRecentBrowsePath(db, browsePath) {
+    const existing = getRecentBrowsePaths(db).filter((p) => p !== browsePath);
+    const next = [browsePath, ...existing].slice(0, exports.RECENT_BROWSE_PATHS_LIMIT);
+    writeStringArray(db, KEY_RECENT_BROWSE_PATHS, next);
+}
+// ============================================================================
+// Default selected agents (Issue #2065)
+// ============================================================================
+/**
+ * Get the server-wide default agent list for new worktrees.
+ *
+ * Validated on read with the same `validateAgentsPair()` the API writes through,
+ * so a row hand-edited to `["claude"]` or `["bogus","claude"]` reads as "unset"
+ * rather than propagating an invalid roster into every worktree. The caller then
+ * falls through to the next layer (see `resolveSelectedAgents()`).
+ *
+ * Cheap enough to call per request: one prepared point-query on a table with a
+ * handful of rows. It is deliberately NOT called per worktree row — `getWorktrees()`
+ * resolves it once and passes it down — and it never probes the filesystem, so
+ * this stays clear of the `isInstalled()` hot-path rule (Issue #1913).
+ *
+ * @returns Ordered agents (`[0]` is the primary), or null when unset/invalid.
+ */
+function getDefaultSelectedAgents(db) {
+    const raw = readStringArray(db, KEY_DEFAULT_SELECTED_AGENTS);
+    if (!raw)
+        return null;
+    const result = (0, selected_agents_validator_1.validateAgentsPair)(raw);
+    return result.valid ? result.value : null;
+}
+/**
+ * Save the server-wide default agent list for new worktrees.
+ *
+ * @param agents - Ordered, already-validated agents; `agents[0]` becomes the primary.
+ */
+function setDefaultSelectedAgents(db, agents) {
+    writeStringArray(db, KEY_DEFAULT_SELECTED_AGENTS, agents);
+}
+/**
+ * Forget the server-wide default, returning the install to the compiled-in
+ * constant. Deletes the row rather than writing the constant into it, so a later
+ * change to `DEFAULT_SELECTED_AGENTS` still reaches an install that reset.
+ */
+function clearDefaultSelectedAgents(db) {
+    db.prepare('DELETE FROM app_settings WHERE key = ?').run(KEY_DEFAULT_SELECTED_AGENTS);
+}
+// ============================================================================
+// Default surface mode (Issue #2201)
+// ============================================================================
+/**
+ * Get the server-wide output surface new sessions open in.
+ *
+ * Validated on read with `isSurfaceMode()` — the same guard the route writes
+ * through and the same guard the browser applies to localStorage — so a row
+ * hand-edited to `xterm` (Epic #2192 keeps that value reserved but unshipped)
+ * reads as "unset" rather than reaching a component that would switch on it.
+ *
+ * @returns The stored mode, or null when unset or unparseable.
+ */
+function getDefaultSurfaceMode(db) {
+    const raw = readScalar(db, KEY_DEFAULT_SURFACE_MODE);
+    return (0, ui_state_1.isSurfaceMode)(raw) ? raw : null;
+}
+/**
+ * Save the server-wide output surface new sessions open in.
+ *
+ * @param mode - Already-validated mode; callers must narrow with `isSurfaceMode()`.
+ */
+function setDefaultSurfaceMode(db, mode) {
+    writeScalar(db, KEY_DEFAULT_SURFACE_MODE, mode);
+}

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

@@ -6,13 +6,15 @@
  * Issue #479: Extracted from db.ts for single-responsibility separation
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ACTIVE_FILTER = void 0;
+exports.UNKEYED_USER_MESSAGE_LIMIT = exports.ACTIVE_FILTER = void 0;
 exports.getLastAssistantMessageAt = getLastAssistantMessageAt;
 exports.createMessage = createMessage;
 exports.updateMessageContent = updateMessageContent;
 exports.getMessages = getMessages;
 exports.getLastUserMessage = getLastUserMessage;
 exports.findMessageByRequestId = findMessageByRequestId;
+exports.findUnkeyedUserMessages = findUnkeyedUserMessages;
+exports.setMessageRequestId = setMessageRequestId;
 exports.getLastMessage = getLastMessage;
 exports.deleteAllMessages = deleteAllMessages;
 exports.deleteMessageById = deleteMessageById;
@@ -125,7 +127,7 @@ function updateMessageContent(db, messageId, content, options) {
  * Get messages for a worktree, optionally filtered by CLI tool
  */
 function getMessages(db, worktreeId, options = {}) {
-    const { before, limit = 50, cliToolId, instanceId, includeArchived = false, messageType, limitUnit = 'messages' } = options;
+    const { before, limit = 50, cliToolId, instanceId, includeArchived = false, messageType, limitUnit = 'messages', matchResolvedInstance = false } = options;
     // Build the shared scope clause (worktree + before cursor + archived + instance/cli
     // filter) and its bound params. Used for both the message-unit and pair-unit paths
     // so their filtering stays identical.
@@ -138,7 +140,19 @@ function getMessages(db, worktreeId, options = {}) {
             clause += ` ${exports.ACTIVE_FILTER}`;
         }
         // Issue #868: instance filter takes precedence; otherwise fall back to CLI tool filter.
-        if (instanceId) {
+        // Issue #2219: `matchResolvedInstance` reads both columns through the same
+        // COALESCE defaults `mapChatMessage` applies, so pre-#868 rows
+        // (`instance_id IS NULL`) count as the primary instance instead of
+        // vanishing. See the option's doc comment for why the tool filter joins in.
+        if (instanceId && matchResolvedInstance) {
+            if (cliToolId) {
+                clause += ` AND COALESCE(cli_tool_id, 'claude') = ?`;
+                params.push(cliToolId);
+            }
+            clause += ` AND COALESCE(instance_id, cli_tool_id, 'claude') = ?`;
+            params.push(instanceId);
+        }
+        else if (instanceId) {
             clause += ` AND instance_id = ?`;
             params.push(instanceId);
         }
@@ -229,6 +243,80 @@ function findMessageByRequestId(db, worktreeId, requestId) {
     const row = stmt.get(worktreeId, requestId);
     return row ? mapChatMessage(row) : null;
 }
+/**
+ * How many candidate rows {@link findUnkeyedUserMessages} returns.
+ *
+ * The caller compares content in JavaScript, so this bounds the work rather than
+ * the correctness. Twenty is far above the number of user rows one instance can
+ * accumulate inside the caller's few-minute window and still small enough that
+ * the query is never the expensive part of a poll.
+ */
+exports.UNKEYED_USER_MESSAGE_LIMIT = 20;
+/**
+ * User rows for one instance that no producer has claimed yet (Issue #2196).
+ *
+ * The lookup behind "the operator's input is already in History — `/send` put it
+ * there". A row qualifies when it is this instance's, is a `user` row, sits in
+ * the caller's time window, and has **no `request_id`**: that last condition is
+ * what makes the query safe to answer a *claim* with, because a row that already
+ * carries a key belongs to whoever wrote it and must not be re-pointed at
+ * another turn.
+ *
+ * Content is deliberately not compared here. "The same text" is a normalisation
+ * question (trailing whitespace, `\r\n`, a composer that reflowed the body), and
+ * SQL is the wrong place to decide it — see `normalizeUserTurnContent` in
+ * `lib/history/user-turn-recorder`, which owns that rule and is the only thing
+ * that has to change when the rule does.
+ *
+ * `COALESCE` on both tool columns is not defensive noise: rows written before
+ * Issue #868 carry `instance_id IS NULL`, and `mapChatMessage` reads those as
+ * the primary instance. A bare `instance_id = ?` would make those rows
+ * invisible here while the UI still shows them, so the operator would see their
+ * `/send` row *and* a second row this Issue inserted.
+ *
+ * `ACTIVE_FILTER` applies: an archived row has been cleared out of History, and
+ * adopting one would key a turn to a row nobody can see.
+ *
+ * @returns Candidate rows, newest first
+ */
+function findUnkeyedUserMessages(db, query) {
+    const stmt = db.prepare(`
+    SELECT id, worktree_id, role, content, summary, timestamp, log_file_name, request_id, message_type, prompt_data, cli_tool_id, instance_id, archived
+    FROM chat_messages
+    WHERE worktree_id = ?
+      AND role = 'user'
+      AND request_id IS NULL
+      AND COALESCE(cli_tool_id, 'claude') = ?
+      AND COALESCE(instance_id, cli_tool_id, 'claude') = ?
+      AND timestamp >= ? AND timestamp <= ?
+      ${exports.ACTIVE_FILTER}
+    ORDER BY timestamp DESC
+    LIMIT ?
+  `);
+    const rows = stmt.all(query.worktreeId, query.cliToolId, query.instanceId, query.fromMs, query.toMs, query.limit ?? exports.UNKEYED_USER_MESSAGE_LIMIT);
+    return rows.map(mapChatMessage);
+}
+/**
+ * Claim an unkeyed row for a producer, without touching anything else on it
+ * (Issue #2196).
+ *
+ * A compare-and-set and not an `UPDATE … WHERE id = ?`: the `request_id IS NULL`
+ * in the predicate is what makes two pollers racing on the same row safe, since
+ * the loser changes nothing and is told so. {@link updateMessageContent} could
+ * set the column too, but it also rewrites `content`, and rewriting the
+ * operator's own words as a side effect of keying their row is exactly the
+ * failure this Issue is trying not to introduce.
+ *
+ * @returns Whether this call is the one that claimed the row
+ */
+function setMessageRequestId(db, messageId, requestId) {
+    const stmt = db.prepare(`
+    UPDATE chat_messages
+    SET request_id = ?
+    WHERE id = ? AND request_id IS NULL
+  `);
+    return stmt.run(requestId, messageId).changes > 0;
+}
 /**
  * Fetch the most recent message for a worktree (any role).
  * Used to determine if waiting for Claude's response.
@@ -431,14 +519,27 @@ function updatePromptData(db, messageId, promptData) {
  * Mark all pending prompts as answered for a worktree/CLI tool
  * This is called when we detect Claude has started processing (new response detected)
  * which means any pending prompts must have been answered via terminal
+ *
+ * @param onUpdated - Issue #2195. Invoked once per row that was actually
+ *   stamped, with the row as it now reads. This sweep is the one prompt-status
+ *   writer that produced no realtime frame, so a prompt card stayed "pending"
+ *   in every open pane until the next history poll — up to 15s once #2195
+ *   demoted that poll to a fallback. The caller supplies the broadcast rather
+ *   than this module reaching for `ws-server`: the DB layer has no business
+ *   importing the socket, and the two sweep callers that are *not* a poller
+ *   (the worktree list/detail routes) have no room to broadcast into anyway.
+ *   Throwing from the callback is the caller's problem; it is not caught here.
  */
-function markPendingPromptsAsAnswered(db, worktreeId, cliToolId, instanceId) {
+function markPendingPromptsAsAnswered(db, worktreeId, cliToolId, instanceId, onUpdated) {
     // Find all pending prompt messages for this worktree/CLI tool.
     // Issue #868: When instanceId is provided, scope to that instance only;
     // otherwise fall back to the legacy cli_tool_id scoping.
     const resolvedInstanceId = instanceId ?? cliToolId;
+    // Issue #2195: the full column set, not just (id, prompt_data) — `onUpdated`
+    // publishes a `ChatMessage`, and re-reading each row afterwards would be a
+    // second query per prompt for data this statement already has to visit.
     const selectStmt = db.prepare(`
-    SELECT id, prompt_data
+    SELECT id, worktree_id, role, content, summary, timestamp, log_file_name, request_id, message_type, prompt_data, cli_tool_id, instance_id, archived
     FROM chat_messages
     WHERE worktree_id = ?
       AND instance_id = ?
@@ -458,9 +559,12 @@ function markPendingPromptsAsAnswered(db, worktreeId, cliToolId, instanceId) {
     WHERE id = ?
   `);
     let updatedCount = 0;
+    const updated = [];
     for (const row of rows) {
         try {
-            const promptData = JSON.parse(row.prompt_data);
+            const promptData = JSON.parse(row.prompt_data ?? 'null');
+            if (!promptData || typeof promptData !== 'object')
+                continue;
             promptData.status = 'answered';
             promptData.answer = '(answered via terminal)';
             promptData.answeredAt = new Date().toISOString();
@@ -468,13 +572,22 @@ function markPendingPromptsAsAnswered(db, worktreeId, cliToolId, instanceId) {
             // prompts nothing else claimed, so all that is known is that the agent
             // moved on — i.e. someone acted in the terminal.
             promptData.answeredBy = 'terminal';
-            updateStmt.run(JSON.stringify(promptData), row.id);
+            const serialized = JSON.stringify(promptData);
+            updateStmt.run(serialized, row.id);
             updatedCount++;
+            if (onUpdated) {
+                updated.push(mapChatMessage({ ...row, prompt_data: serialized }));
+            }
         }
         catch {
             // Skip if prompt_data is invalid JSON
         }
     }
+    // Published after every write lands, so a listener that reacts by reading the
+    // table back cannot observe a half-swept instance.
+    for (const message of updated) {
+        onUpdated?.(message);
+    }
     return updatedCount;
 }
 /**

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

@@ -18,6 +18,8 @@ exports.updateFavorite = updateFavorite;
 exports.updateStatus = updateStatus;
 exports.updateCliToolId = updateCliToolId;
 exports.updateSelectedAgents = updateSelectedAgents;
+exports.findUnchangedAgentWorktrees = findUnchangedAgentWorktrees;
+exports.applySelectedAgentsToUnchanged = applySelectedAgentsToUnchanged;
 exports.updateVibeLocalModel = updateVibeLocalModel;
 exports.updateVibeLocalContextWindow = updateVibeLocalContextWindow;
 exports.saveInitialBranch = saveInitialBranch;
@@ -29,6 +31,8 @@ exports.getWorktreesByRepository = getWorktreesByRepository;
 exports.deleteRepositoryWorktrees = deleteRepositoryWorktrees;
 exports.deleteWorktreesByIds = deleteWorktreesByIds;
 const selected_agents_validator_1 = require("../../lib/selected-agents-validator");
+const agents_config_1 = require("../../lib/repo-config/agents-config");
+const app_settings_db_1 = require("./app-settings-db");
 const chat_db_1 = require("./chat-db");
 const worktree_id_rename_1 = require("./migrations/worktree-id-rename");
 /**
@@ -82,6 +86,38 @@ function getLastMessagesByCliBatch(db, worktreeIds) {
     }
     return result;
 }
+/** Shared empty set, so the common "no repository declares anything" path allocates nothing. */
+const EMPTY_ID_SET = new Set();
+/**
+ * IDs of every worktree that already owns an `agent_instances` roster.
+ *
+ * One query for the whole list rather than one per row (Issue #2066): the
+ * sidebar poll must not grow N point queries. `agent_instances` holds a handful
+ * of rows per registered worktree, and only the distinct worktree ids are read.
+ */
+function worktreeIdsWithAgentInstances(db) {
+    const rows = db
+        .prepare('SELECT DISTINCT worktree_id FROM agent_instances')
+        .all();
+    return new Set(rows.map((row) => row.worktree_id));
+}
+/** Whether one worktree already owns an `agent_instances` roster (Issue #2066). */
+function hasAgentInstances(db, worktreeId) {
+    return (db.prepare('SELECT 1 FROM agent_instances WHERE worktree_id = ? LIMIT 1').get(worktreeId) !==
+        undefined);
+}
+/**
+ * The repository layer for ONE worktree, withheld when that worktree already
+ * owns a roster (Issue #2066). The single-row twin of the batch logic in
+ * `getWorktrees()`; see the long comment there for why the withholding exists
+ * and why it is narrowed to this layer.
+ */
+function repoDefaultWithheldFromRoster(db, worktreeId, repositoryPath) {
+    const declared = (0, agents_config_1.getRepoDefaultSelectedAgents)(repositoryPath);
+    if (declared === null)
+        return null;
+    return hasAgentInstances(db, worktreeId) ? null : declared;
+}
 /**
  * Get all worktrees sorted by updated_at (desc)
  * Optionally filter by repository path
@@ -111,6 +147,52 @@ function getWorktrees(db, repositoryPath) {
     // Batch fetch last messages for all worktrees (N+1 optimization)
     const worktreeIds = rows.map(row => row.id);
     const lastMessagesByCliMap = getLastMessagesByCliBatch(db, worktreeIds);
+    // Issue #2065: read the server-wide default ONCE. `upsertWorktree` never
+    // writes `selected_agents`, so on a scan/sync-populated install every row
+    // below takes the fallback path — resolving it per row would turn one point
+    // query into one per worktree on the sidebar's poll.
+    const appSettingsDefault = (0, app_settings_db_1.getDefaultSelectedAgents)(db);
+    // Issue #2066: the repository layer, resolved ONCE per distinct
+    // `repository_path` rather than per row. `getRepoDefaultSelectedAgents()` is
+    // itself served from a process-wide cache filled at sync — see its module
+    // header for why the read does not belong on this (polled) path.
+    const repoDefaults = new Map();
+    for (const repositoryPath of new Set(rows.map((row) => row.repository_path))) {
+        if (!repositoryPath)
+            continue;
+        repoDefaults.set(repositoryPath, (0, agents_config_1.getRepoDefaultSelectedAgents)(repositoryPath));
+    }
+    // Issue #2066: a worktree that ALREADY has an `agent_instances` roster is not
+    // offered the repository declaration.
+    //
+    // `resolveAgentInstances()` protects the roster itself with an early return,
+    // but `selectedAgents` is a SECOND channel: `/sessions` and the Review tab
+    // render `wt.selectedAgents ?? clientDefault` and never look at
+    // `agentInstances`. Without this, committing an `agents.yaml` would repaint
+    // the chips of a branch whose tabs it cannot and must not change — and the
+    // running agent would drop out of "active agents" because it is not in the
+    // declared list. `PATCH /api/worktrees/[id]` writes `agentInstances` and
+    // `selectedAgents` from independent branches, so "has a roster, column still
+    // NULL" is a state the product produces routinely, not an edge case.
+    //
+    // Deliberately narrowed to the repository layer. The `app_settings` layer has
+    // the same shape (#2065) and the same gap, but changing it is a change to
+    // #2065's behaviour; what #2066 has to answer for is that it widened the gap
+    // from "an admin who can reach server settings" to "anyone who can commit to
+    // the repository". See docs/design/repo-agents-config.md §2.
+    //
+    // The roster query runs only when some repository actually declares
+    // something, so an install with no `agents.yaml` anywhere issues exactly the
+    // queries it issued before this Issue.
+    const anyRepoDeclares = [...repoDefaults.values()].some((value) => value !== null);
+    const withRoster = anyRepoDeclares ? worktreeIdsWithAgentInstances(db) : EMPTY_ID_SET;
+    const repoDefaultFor = (row) => {
+        if (!row.repository_path)
+            return null;
+        if (withRoster.has(row.id))
+            return null;
+        return repoDefaults.get(row.repository_path) ?? null;
+    };
     return rows.map((row) => {
         const lastMessagesByCli = lastMessagesByCliMap.get(row.id) || {};
         return {
@@ -133,7 +215,7 @@ function getWorktrees(db, repositoryPath) {
             status: row.status || null,
             link: row.link || undefined,
             cliToolId: row.cli_tool_id ?? 'claude',
-            selectedAgents: (0, selected_agents_validator_1.parseSelectedAgents)(row.selected_agents),
+            selectedAgents: (0, selected_agents_validator_1.parseSelectedAgents)(row.selected_agents, appSettingsDefault, repoDefaultFor(row)),
             vibeLocalModel: row.vibe_local_model ?? null,
             vibeLocalContextWindow: row.vibe_local_context_window ?? null,
         };
@@ -216,7 +298,10 @@ function getWorktreeById(db, id) {
         status: row.status || null,
         link: row.link || undefined,
         cliToolId: row.cli_tool_id ?? 'claude',
-        selectedAgents: (0, selected_agents_validator_1.parseSelectedAgents)(row.selected_agents),
+        // Issue #2066: same layers, and the same withholding, as getWorktrees().
+        // The roster probe runs only when this repository actually declares
+        // something, so a tree with no `agents.yaml` issues no extra query.
+        selectedAgents: (0, selected_agents_validator_1.parseSelectedAgents)(row.selected_agents, (0, app_settings_db_1.getDefaultSelectedAgents)(db), repoDefaultWithheldFromRoster(db, row.id, row.repository_path)),
         vibeLocalModel: row.vibe_local_model ?? null,
         vibeLocalContextWindow: row.vibe_local_context_window ?? null,
     };
@@ -359,7 +444,7 @@ function updateCliToolId(db, id, cliToolId) {
  *
  * @param db - Database instance
  * @param id - Worktree ID
- * @param selectedAgents - Array of 2-4 CLIToolType values
+ * @param selectedAgents - Array of 2-6 CLIToolType values (MIN/MAX_SELECTED_AGENTS)
  */
 function updateSelectedAgents(db, id, selectedAgents) {
     const stmt = db.prepare(`
@@ -369,6 +454,96 @@ function updateSelectedAgents(db, id, selectedAgents) {
   `);
     stmt.run(JSON.stringify(selectedAgents), id);
 }
+/**
+ * The worktrees of ONE repository whose agent list is still UNCHANGED by its
+ * user (Issue #2067).
+ *
+ * ## The repository argument is not optional, and that is the point
+ *
+ * The action this serves lives in the agent pane of ONE worktree, so its blast
+ * radius has to be the repository that worktree belongs to. An earlier revision
+ * of this function took no repository and scanned `worktrees` whole: pressing
+ * "apply to unchanged branches" from a worktree of repository B rewrote the
+ * unchanged worktrees of repository A as well. Requiring the argument is what
+ * makes that impossible to reintroduce by omission.
+ *
+ * ## "Unchanged"
+ *
+ * `selected_agents IS NULL` **and** no `agent_instances` row — deliberately the
+ * same two facts #2066 checks before it lets a repository declaration reach a
+ * worktree, checked with the same helper (`worktreeIdsWithAgentInstances`)
+ * rather than a second query that says the same thing. The two channels are
+ * independent: `PATCH /api/worktrees/[id]` writes `agentInstances` and
+ * `selectedAgents` from separate branches, so "has a roster, column still NULL"
+ * and "column set, no roster" are both states the product produces routinely,
+ * and a worktree in EITHER of them has been touched by a human.
+ *
+ * ## Why a declaring repository yields nothing
+ *
+ * `SELECTED_AGENTS_LAYERS` puts the `worktree` column ABOVE the repository file,
+ * so writing `selected_agents` onto a worktree of a repository that ships
+ * `.commandmate/agents.yaml` does not merely win once — it retires the
+ * declaration for that branch permanently, and editing the file afterwards has
+ * no effect and no explanation. A committed declaration is a more deliberate
+ * answer to "which agents does this branch open with" than a button press in one
+ * branch's settings pane, so the declaration wins and the caller is told why
+ * (`repoDeclares`) instead of being handed a count of zero it cannot explain.
+ *
+ * @param db - Database instance
+ * @param repositoryPath - The repository to scope to (`worktrees.repository_path`)
+ * @returns The scope, whether the repository declares, and the eligible IDs
+ */
+function findUnchangedAgentWorktrees(db, repositoryPath) {
+    // Served from #2066's process-wide cache; see `agents-config.ts` for why this
+    // is not a filesystem probe on a hot path.
+    const repoDeclares = (0, agents_config_1.getRepoDefaultSelectedAgents)(repositoryPath) !== null;
+    if (repoDeclares) {
+        return { repositoryPath, repoDeclares, ids: [] };
+    }
+    const withRoster = worktreeIdsWithAgentInstances(db);
+    const rows = db
+        .prepare('SELECT id FROM worktrees WHERE repository_path = ? AND selected_agents IS NULL ORDER BY id ASC')
+        .all(repositoryPath);
+    return {
+        repositoryPath,
+        repoDeclares,
+        ids: rows.map((row) => row.id).filter((id) => !withRoster.has(id)),
+    };
+}
+/**
+ * Write `selectedAgents` onto every worktree {@link findUnchangedAgentWorktrees}
+ * reports for `repositoryPath`, in ONE transaction (Issue #2067).
+ *
+ * The eligible set is recomputed INSIDE the transaction rather than taken as an
+ * argument: the UI shows a count before it asks for confirmation, and the number
+ * it shows has to be the number of rows this actually writes. Passing the ids in
+ * would make the caller's snapshot authoritative and turn a worktree created
+ * between the count and the confirmation into a silent miss.
+ *
+ * The transaction is not decoration. Without it, a write that fails partway —
+ * a locked database, a constraint, a trigger — leaves a repository split between
+ * branches that took the new order and branches that did not, with nothing on
+ * screen saying which. `tests/unit/db/apply-default-agents-2067.test.ts` pins
+ * this by aborting a middle row and asserting the earlier ones rolled back.
+ *
+ * Rows are written through `updateSelectedAgents()` so the column's one writer
+ * stays its one writer.
+ *
+ * @param db - Database instance
+ * @param repositoryPath - The repository to scope to; never server-wide
+ * @param selectedAgents - Ordered, already-validated agents; `[0]` is the primary
+ * @returns The IDs that were written, in the order they were written
+ */
+function applySelectedAgentsToUnchanged(db, repositoryPath, selectedAgents) {
+    const apply = db.transaction(() => {
+        const { ids } = findUnchangedAgentWorktrees(db, repositoryPath);
+        for (const id of ids) {
+            updateSelectedAgents(db, id, selectedAgents);
+        }
+        return ids;
+    });
+    return apply();
+}
 /**
  * Update vibe_local_model for a worktree
  * Issue #368: Persists the user's Ollama model selection for vibe-local

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

@@ -72,8 +72,9 @@ exports.SELECTION_LIST_REASONS = new Set([
  * one: branch A of the opencode block answers `opencode_processing_indicator`
  * for the footer that reads `esc interrupt`, which is opencode's ONLY signal
  * while it is between the submitted prompt and the first transcript row. A
- * scraper-only session (no hooks) therefore showed no thinking indicator in
- * `MessageList` for exactly the stretch where one is wanted.
+ * scraper-only session (no hooks) therefore showed no thinking indicator on the
+ * chat surface for exactly the stretch where one is wanted. The consumer is
+ * `ChatSurface`, which reads this through `current-output`'s `thinking` flag.
  *
  * `DEFAULT` is deliberately absent: it is the "output changed recently" fallback
  * and says nothing about the agent having announced itself, so promoting it

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

@@ -56,6 +56,23 @@ exports.STATUS_REASON = {
     OPENCODE_RESPONSE_COMPLETE: 'opencode_response_complete',
     INPUT_PROMPT: 'input_prompt',
     NO_RECENT_OUTPUT: 'no_recent_output',
+    /**
+     * Issue #2070: the tmux session is there, and the TOOL is not.
+     *
+     * Published by `worktree-status-helper` when the liveness probe reads a bare
+     * shell prompt at the bottom of a pane whose agent quit, updated itself or
+     * crashed (`judgeToolLiveness`). It is the ONE reason on this list that
+     * accompanies `isRunning: false` — every other one describes a frame a live
+     * agent drew — which is exactly why it is worth a token of its own: without
+     * it the sidebar and `commandmate ls` render such a session as plain `idle`,
+     * indistinguishable from one that was never started, and the operator has no
+     * way to tell "start it" from "it died under you".
+     *
+     * ADDITIVE, in the strict sense: no existing reason's value or meaning
+     * changes, and no surface that does not know the token behaves differently —
+     * a reader that does not recognise it sees the same `idle` it saw before.
+     */
+    EXITED: 'exited',
     /**
      * A tool's own detector looked at this frame and recognised nothing
      * (Issue #1927, §6.1).