commandmate 0.49.3 → 0.50.0

package/dist/server/src/lib/cli-tools/launch-answer-skips.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Launch answers that did not go out (Issue #4161).
+ *
+ * The automatic answer to a launch screen goes through the instance input lock,
+ * which can decline it, and the screen is due again on every poll. The record of
+ * that is a warn, as the Claude trust dialog's is (#4149): at info a WARN- or
+ * ERROR-only setting left no trace of a start that sent nothing. It is written
+ * once while the same reason goes on, per event, per wait.
+ *
+ * @module lib/cli-tools/launch-answer-skips
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newLaunchAnswerSkips = newLaunchAnswerSkips;
+exports.noteLaunchAnswerSkipped = noteLaunchAnswerSkipped;
+exports.forgetLaunchAnswerSkip = forgetLaunchAnswerSkip;
+const instance_input_lock_1 = require("../../lib/session/instance-input-lock");
+function newLaunchAnswerSkips() {
+    return { byEvent: new Map(), last: null, lastEvent: null, lifeByEvent: new Map() };
+}
+/**
+ * Record a declined answer at warn, unless the same reason was the last under `event`
+ * in the same life of the session (Issue #4189: `fields.sessionName`; without it
+ * the life is not compared, as before).
+ *
+ * The life is the one the answer started in (`startedIn`, taken before its await),
+ * as the input lock judges its own warn: a decline of an older life — the session
+ * was made again while it waited or read the screen again — is written, but neither
+ * reads nor writes the record of the new life. Without `startedIn` the life at this
+ * call is used.
+ *
+ * @param logger - The caller's logger, so the record keeps its module
+ * @param skips - This wait's record
+ * @param event - The log event, one per kind of answer
+ * @param fields - The log fields; `reason` is an enum, nothing captured goes in
+ * @param startedIn - {@link instanceInputAnswerSkipLife} of `fields.sessionName`, taken before the answer
+ */
+function noteLaunchAnswerSkipped(logger, skips, event, fields, startedIn) {
+    const sessionName = typeof fields.sessionName === 'string' ? fields.sessionName : null;
+    if (sessionName !== null && startedIn !== undefined && !(0, instance_input_lock_1.isInstanceInputAnswerSkipLife)(sessionName, startedIn)) {
+        // An answer of an older life: its warn, and no record for the new one.
+        logger.warn(event, fields);
+        skips.last = fields.reason;
+        skips.lastEvent = event;
+        return;
+    }
+    const recorded = skips.lifeByEvent.get(event);
+    const sameLife = recorded === undefined ||
+        (recorded.sessionName === sessionName && (0, instance_input_lock_1.isInstanceInputAnswerSkipLife)(recorded.sessionName, recorded.life));
+    if (skips.byEvent.get(event) !== fields.reason || !sameLife)
+        logger.warn(event, fields);
+    skips.byEvent.set(event, fields.reason);
+    if (sessionName === null)
+        skips.lifeByEvent.delete(event);
+    else
+        skips.lifeByEvent.set(event, { sessionName, life: startedIn ?? (0, instance_input_lock_1.instanceInputAnswerSkipLife)(sessionName) });
+    skips.last = fields.reason;
+    skips.lastEvent = event;
+}
+/**
+ * Forget what was declined under `event`: the answer went through, or the screen it
+ * was for has gone. The record describes a key that has not gone out, so a refusal
+ * must not repeat it after that, and a later decline is a new one to report, even
+ * for the same reason. Other events' records are theirs.
+ *
+ * @param skips - This wait's record
+ * @param event - The log event the answer belongs to
+ */
+function forgetLaunchAnswerSkip(skips, event) {
+    skips.byEvent.delete(event);
+    skips.lifeByEvent.delete(event);
+    if (skips.lastEvent === event) {
+        skips.last = null;
+        skips.lastEvent = null;
+    }
+}

package/dist/server/src/lib/cli-tools/opencode-v2.js

@@ -51,6 +51,7 @@ const errors_1 = require("../../lib/errors");
 const agent_session_lifecycle_1 = require("../../lib/session/agent-session-lifecycle");
 const runtime_1 = require("../../lib/hooks/sources/opencode-v2/runtime");
 const client_1 = require("../../lib/hooks/sources/opencode-v2/client");
+const secrets_1 = require("../../lib/hooks/sources/opencode-v2/secrets");
 const ports_1 = require("../../lib/hooks/sources/opencode-v2/ports");
 const subscription_1 = require("../../lib/hooks/sources/opencode-v2/subscription");
 const tool_id_1 = require("../../lib/hooks/sources/opencode-v2/tool-id");
@@ -247,6 +248,15 @@ class OpenCodeV2Tool extends base_1.BaseCLITool {
             throw new Error(`Failed to start OpenCode V2 session: ${(0, errors_1.getErrorMessage)(error)}`);
         }
     }
+    /** Issue #4115: `GET /api/config`, the evidence that the server read the role (§14). */
+    async readServerConfig(worktreeId, worktreePath, instanceId) {
+        const target = (0, runtime_1.opencodeV2Target)(worktreeId, instanceId);
+        const port = (0, ports_1.getAssignedOpencodeV2Port)(target);
+        const password = (0, secrets_1.readOpencodeV2Password)(target);
+        if (port === null || password === null)
+            return null;
+        return (0, client_1.fetchOpencodeV2Config)(port, password, worktreePath);
+    }
     /** Poll until the composer is on screen (or give up quietly). */
     async waitForReady(sessionName) {
         for (let attempt = 0; attempt < exports.OPENCODE_V2_READY_MAX_ATTEMPTS; attempt++) {

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

@@ -52,6 +52,7 @@ const terminal_keys_1 = require("../../types/terminal-keys");
 const tmux_1 = require("../tmux/tmux");
 const cli_patterns_1 = require("../detection/cli-patterns");
 const submit_verified_sender_1 = require("./submit-verified-sender");
+const opencode_modal_overlay_1 = require("../detection/opencode-modal-overlay");
 const readiness_1 = require("../detection/tools/opencode/readiness");
 const status_detector_1 = require("../detection/status-detector");
 const prompt_wait_dialog_1 = require("./prompt-wait-dialog");
@@ -70,6 +71,7 @@ const image_extensions_1 = require("../../config/image-extensions");
 const agent_session_lifecycle_1 = require("../../lib/session/agent-session-lifecycle");
 const runtime_1 = require("../../lib/hooks/sources/opencode/runtime");
 const ports_1 = require("../../lib/hooks/sources/opencode/ports");
+const role_launch_1 = require("../../lib/session/role-launch");
 const launch_settings_1 = require("../../lib/hooks/sources/opencode/launch-settings");
 const client_1 = require("../../lib/hooks/sources/opencode/client");
 const subscription_1 = require("../../lib/hooks/sources/opencode/subscription");
@@ -136,6 +138,25 @@ function isOpenCodeWaitDialog(status) {
         return false;
     return status.hasActivePrompt || status.status === 'waiting';
 }
+/**
+ * What held the pane when the wait for the input box ran out (Issue #4161), for the
+ * refusal `send` reports. Names the screen only: nothing captured goes into it. A
+ * dialog here is one read too briefly to be confirmed.
+ *
+ * @param output - The last capture; null when the last read failed
+ */
+function describeOpenCodePaneHold(output) {
+    if (output === null)
+        return 'the pane could not be read';
+    switch ((0, readiness_1.readOpenCodeNotReadyScreen)(output)) {
+        case 'dialog':
+            return 'a dialog or overlay is open: answer it in the terminal';
+        case 'input-box-holds-text':
+            return 'the input box still holds text';
+        default:
+            return 'no input box on the pane: opencode may still be starting';
+    }
+}
 /**
  * Waits before each read-back of a message just posted to the server (#2035).
  *
@@ -354,6 +375,8 @@ class OpenCodeTool extends base_1.BaseCLITool {
                 ? plannedCommand
                 : (0, opencode_session_store_1.withOpencodeResumedSession)(plannedCommand, resumeSessionId);
             if (resumeSessionId !== null) {
+                // Issue #4115 (§6.4): a role that changed goes on in this conversation; it is told.
+                (0, role_launch_1.noteLaunchResumedConversation)(target);
                 logger.info('opencode-session-resumed', {
                     worktreeId,
                     instanceId: instanceId ?? this.id,
@@ -395,6 +418,11 @@ class OpenCodeTool extends base_1.BaseCLITool {
             throw new Error(`Failed to start OpenCode session: ${errorMessage}`);
         }
     }
+    /** Issue #4115: `GET /config`, the evidence that the server read the role (§14). */
+    async readServerConfig(worktreeId, _worktreePath, instanceId) {
+        const port = (0, ports_1.getAssignedOpencodePort)((0, runtime_1.opencodeTarget)(worktreeId, instanceId));
+        return port === null ? null : (0, client_1.fetchOpencodeConfig)(port);
+    }
     /**
      * Wait until opencode has painted something only opencode paints.
      *
@@ -408,9 +436,10 @@ class OpenCodeTool extends base_1.BaseCLITool {
      *
      * ## What counts as evidence
      *
-     * `OPENCODE_IDLE_COMPOSER_PATTERN` (Issue #1883) — the `Ask anything...`
-     * placeholder **behind the input box's gutter**. Not reimplemented here on
-     * purpose; it is the same positive-evidence row `status-detector` reads.
+     * `findOpenCodeIdleComposer` (Issue #1883, by position since Issue #4209) — the
+     * `Ask anything...` placeholder **behind the input box's gutter, in the box over
+     * its bottom border**. Not reimplemented here on purpose; it is the same
+     * positive-evidence row `status-detector` reads.
      *
      * The copilot hazard that #1907 hit does not reach opencode, and this was
      * checked rather than assumed. Removing copilot's blind sleep exposed the
@@ -429,6 +458,16 @@ class OpenCodeTool extends base_1.BaseCLITool {
      * operator's config, which is the same line codex's launch draws at its
      * hooks-review dialog (#1760).
      *
+     * A modal overlay is the third (Issue #4104): the palette hides `Ask anything`
+     * too when it opens before the wait has seen the box, and its heading is not
+     * on that allowlist. Measured on 1.18.35: 30 s here for a send that was then
+     * refused in 2 s. The overlay is opencode's own painting, and the TUI is a
+     * client of its server, so the stream attach below still finds the server up
+     * (#1908). It ends the wait only once confirmed, as the send's own wait does
+     * ({@link waitForPrompt}), so a palette closed sooner still ends on the box. A
+     * wrong reading costs nothing typed: the send's wait reads the pane itself.
+     * The rectangle needs the SGR, so the raw capture is what is read.
+     *
      * ## On failure
      *
      * Returns false and lets the launch continue, exactly as the sleep did: a
@@ -439,11 +478,14 @@ class OpenCodeTool extends base_1.BaseCLITool {
      * @returns Whether readiness evidence was seen inside the window
      */
     async waitForReady(sessionName) {
+        const overlay = (0, prompt_wait_dialog_1.createDialogConfirmation)();
         for (let attempt = 0; attempt < exports.OPENCODE_READY_MAX_ATTEMPTS; attempt++) {
             try {
-                const output = (0, cli_patterns_1.stripAnsi)(await (0, tmux_1.capturePane)(sessionName, OPENCODE_READY_CAPTURE_LINES));
+                const frame = await (0, tmux_1.capturePane)(sessionName, OPENCODE_READY_CAPTURE_LINES);
+                const output = (0, cli_patterns_1.stripAnsi)(frame);
                 // Do NOT stripBoxDrawing() this frame: the gutter is the anchor.
-                if (cli_patterns_1.OPENCODE_IDLE_COMPOSER_PATTERN.test(output)) {
+                // Issue #4209: by position — the placeholder in the box over its border.
+                if ((0, cli_patterns_1.findOpenCodeIdleComposer)(output) !== null) {
                     logger.info('opencode-composer-detected', { attempt });
                     return true;
                 }
@@ -451,9 +493,15 @@ class OpenCodeTool extends base_1.BaseCLITool {
                     logger.info('opencode-overlay-detected', { attempt });
                     return true;
                 }
+                if (overlay.observe((0, opencode_modal_overlay_1.detectOpenCodeModalOverlay)(frame) !== null)) {
+                    logger.info('opencode-launch-dialog-confirmed', { attempt, reads: overlay.reads });
+                    return true;
+                }
             }
             catch {
-                // Capture may fail while the pane is still coming up - keep polling
+                // Capture may fail while the pane is still coming up - keep polling.
+                // Not an overlay read: the run restarts.
+                overlay.reset();
             }
             await new Promise((resolve) => setTimeout(resolve, exports.OPENCODE_READY_POLL_INTERVAL_MS));
         }
@@ -811,10 +859,12 @@ class OpenCodeTool extends base_1.BaseCLITool {
     async waitForPrompt(sessionName) {
         const deadline = Date.now() + OPENCODE_PROMPT_WAIT_TIMEOUT_MS;
         const dialog = (0, prompt_wait_dialog_1.createDialogConfirmation)();
+        let lastOutput = null;
         while (Date.now() < deadline) {
             let refusal = null;
             try {
                 const output = await (0, prompt_wait_dialog_1.readBeforeDeadline)(() => (0, tmux_1.capturePane)(sessionName, OPENCODE_READY_CAPTURE_LINES), deadline);
+                lastOutput = output;
                 if (output === null)
                     break;
                 if ((0, readiness_1.isOpenCodeComposerReady)(output))
@@ -830,6 +880,7 @@ class OpenCodeTool extends base_1.BaseCLITool {
             }
             catch (error) {
                 // Capture may fail - continue polling. Not a dialog read: the run restarts.
+                lastOutput = null;
                 dialog.reset();
                 logger.debug('opencode-prompt-capture-failed', { sessionName, error: (0, errors_1.getErrorMessage)(error) });
             }
@@ -841,7 +892,7 @@ class OpenCodeTool extends base_1.BaseCLITool {
             await new Promise((resolve) => setTimeout(resolve, Math.min(OPENCODE_PROMPT_POLL_INTERVAL_MS, remaining)));
         }
         logger.info('opencode-prompt-not-detected');
-        throw new Error('OpenCode prompt not ready: timed out waiting for the input prompt before sending');
+        throw new Error(`OpenCode prompt not ready: timed out waiting for the input prompt before sending (${describeOpenCodePaneHold(lastOutput)})`);
     }
     /**
      * opencode can attach an image — sometimes (Issue #2035).

package/dist/server/src/lib/cli-tools/submit-composer-read.js

@@ -17,6 +17,8 @@ exports.compactText = compactText;
 const composer_spec_1 = require("./composer-spec");
 const cli_patterns_1 = require("../detection/cli-patterns");
 const composer_own_text_1 = require("../detection/tools/opencode/composer-own-text");
+const patterns_1 = require("../detection/tools/opencode/patterns");
+const thinking_constants_1 = require("../../config/thinking-constants");
 const composer_text_1 = require("../../lib/detection/composer-text");
 /**
  * Version-resilient pasted-text placeholder.
@@ -489,10 +491,10 @@ function classifySubmitWithRule(output, cliToolId, message, composerSpec = (0, c
     const windowLines = lines.slice(-exports.VERIFY_WINDOW_LINES);
     const windowStr = windowLines.join('\n');
     // A. Actively generating a response => the message was accepted. Read from the
-    //    tail window for every tool: each one's busy marker lives in a status bar
-    //    pinned to the bottom of the pane, and widening it to opencode's whole
-    //    frame would match `esc interrupt` printed inside a reply.
-    if ((0, cli_patterns_1.detectThinking)(cliToolId, windowStr)) {
+    //    tail window for every tool but opencode: each one's busy marker lives in a
+    //    status bar pinned to the bottom of the pane. opencode's is read by position
+    //    instead ({@link isOpenCodeGenerating}).
+    if (cliToolId === 'opencode' ? isOpenCodeGenerating(lines) : (0, cli_patterns_1.detectThinking)(cliToolId, windowStr)) {
         return { state: 'submitted', rule: 'A' };
     }
     const composer = readSubmitComposer(output, cliToolId, composerSpec.reader, lines, windowLines, message);
@@ -533,6 +535,24 @@ function classifySubmitWithRule(output, cliToolId, message, composerSpec = (0, c
     //    neither that the message left nor that Enter would send it.
     return composer.outsideWindow ? { state: 'indeterminate', rule: 'F-outside' } : { state: 'submitted', rule: 'F' };
 }
+/**
+ * Rule A of {@link classifySubmitWithRule} for opencode (Issue #4209): a
+ * `Thinking:` row read by the position rules the status detector's thinking
+ * step and branch B read (`../detection/tools/opencode/detect.ts`), which the
+ * poller's save also reads — the spinner's progress row under the composer's
+ * bottom border, or a `Thinking:` row at the end of the still-open turn.
+ *
+ * Before #4209 this was `/Thinking:/` anywhere in the 12-row tail window, which
+ * holds the footer's cwd: with a cwd of `/tmp/Thinking:demo` a body still unsent
+ * in the box read as `submitted`, so Enter was never pressed again and the send
+ * was reported as done. The busy hint (`esc interrupt`) is still not read here,
+ * as before: a reply may print it.
+ *
+ * @param lines - The ANSI-stripped pane, box drawing intact, trailing blank rows dropped
+ */
+function isOpenCodeGenerating(lines) {
+    return (0, patterns_1.isOpenCodeThinkingBelowComposer)(lines) || (0, patterns_1.isOpenCodeThinkingInOpenTurn)(lines, thinking_constants_1.THINKING_TAIL_LINE_COUNT);
+}
 /**
  * Backward-compatible boolean view of {@link classifySubmit}: submitted vs not.
  * A `replaced` verdict is NOT "submitted", so this returns false for it too.

package/dist/server/src/lib/cli-tools/vibe-local.js

@@ -56,6 +56,27 @@ function isVibeLocalWaitDialog(output) {
     const status = (0, status_detector_1.detectSessionStatus)(output, 'vibe-local');
     return status.hasActivePrompt && !(0, status_detector_1.isGeneratingStatus)(status);
 }
+/**
+ * What held the pane when the wait for the prompt ran out (Issue #4146), for the
+ * refusal `send` reports. Names the screen only: nothing captured goes into it.
+ * A dialog here is one read too briefly to be refused as `prompt-waiting`.
+ *
+ * @param output - The last capture; null when the last read failed
+ */
+function describeVibeLocalPaneHold(output) {
+    if (output === null)
+        return 'the pane could not be read';
+    if (isVibeLocalWaitDialog(output))
+        return 'a prompt dialog is open: answer it in the terminal';
+    switch ((0, readiness_1.readVibeLocalNotReadyScreen)(output)) {
+        case 'no-input-row':
+            return 'no input row on the pane: vibe-local may still be starting';
+        case 'input-row-holds-text':
+            return 'the input row still holds text';
+        case 'output-below-input-row':
+            return 'output is drawn below the newest input row: vibe-local may still be starting or working';
+    }
+}
 /**
  * Vibe Local CLI tool implementation
  * Manages vibe-local interactive sessions using tmux
@@ -202,18 +223,21 @@ class VibeLocalTool extends base_1.BaseCLITool {
     async waitForPrompt(sessionName) {
         const deadline = Date.now() + VIBE_LOCAL_PROMPT_WAIT_TIMEOUT_MS;
         const dialog = (0, prompt_wait_dialog_1.createDialogConfirmation)();
+        let lastOutput = null;
         while (Date.now() < deadline) {
             let confirmed = false;
             try {
                 const output = await (0, prompt_wait_dialog_1.readBeforeDeadline)(() => (0, tmux_1.capturePane)(sessionName, VIBE_LOCAL_PROMPT_CAPTURE_LINES), deadline);
                 if (output === null)
                     break;
+                lastOutput = output;
                 if ((0, readiness_1.isVibeLocalComposerReady)(output))
                     return;
                 confirmed = dialog.observe(isVibeLocalWaitDialog(output));
             }
             catch (error) {
                 // Capture may fail - continue polling. Not a dialog read: the run restarts.
+                lastOutput = null;
                 dialog.reset();
                 logger.debug('vibe-local-prompt-capture-failed', { sessionName, error: (0, errors_1.getErrorMessage)(error) });
             }
@@ -227,7 +251,7 @@ class VibeLocalTool extends base_1.BaseCLITool {
             await new Promise((resolve) => setTimeout(resolve, Math.min(VIBE_LOCAL_PROMPT_POLL_INTERVAL_MS, remaining)));
         }
         logger.info('vibe-local-prompt-not-detected');
-        throw new Error('Vibe Local prompt not ready: timed out waiting for the input prompt before sending');
+        throw new Error(`Vibe Local prompt not ready: timed out waiting for the input prompt before sending (${describeVibeLocalPaneHold(lastOutput)})`);
     }
     /**
      * Kill vibe-local session

package/dist/server/src/lib/db/agent-instances-db.js

@@ -31,6 +31,8 @@ exports.getSessionNotesByWorktree = getSessionNotesByWorktree;
 exports.getAllSessionNotes = getAllSessionNotes;
 exports.setSessionNote = setSessionNote;
 exports.pruneSessionNotes = pruneSessionNotes;
+exports.revokeInstanceCreationKeys = revokeInstanceCreationKeys;
+exports.pruneAgentInstanceRoles = pruneAgentInstanceRoles;
 const opencode_instance_settings_1 = require("../../types/opencode-instance-settings");
 const types_1 = require("../../lib/cli-tools/types");
 /**
@@ -212,6 +214,14 @@ function setAgentInstances(db, worktreeId, instances) {
     }
     const now = Date.now();
     const replace = db.transaction(() => {
+        // Issue #4132: an id kept with another tool is another row, so this goes by the pair.
+        const kept = new Set(instances.map((instance) => `${instance.id}\u0000${instance.cliTool}`));
+        const leaving = db.prepare(`
+      SELECT instance_id, cli_tool_id FROM agent_instances WHERE worktree_id = ?
+    `).all(worktreeId)
+            .filter((row) => !kept.has(`${row.instance_id}\u0000${row.cli_tool_id}`))
+            .map((row) => row.instance_id);
+        revokeInstanceCreationKeys(db, worktreeId, leaving);
         db.prepare(`DELETE FROM agent_instances WHERE worktree_id = ?`).run(worktreeId);
         // Issue #2048: the settings table is keyed on an instance id and this write
         // is a full replace, so an instance dropped from the roster would otherwise
@@ -224,6 +234,9 @@ function setAgentInstances(db, worktreeId, instances) {
         // Issue's third acceptance condition; a mutation that drops this call makes
         // the note of a *removed* instance haunt the next instance to claim its id.
         pruneSessionNotes(db, worktreeId, instances.map((instance) => instance.id));
+        // Issue #4114: and the role setting. A rename or a reorder keeps it; leaving
+        // the roster ends it, so an id that comes back starts from the defaults.
+        pruneAgentInstanceRoles(db, worktreeId, instances.map((instance) => instance.id));
         const insertStmt = db.prepare(`
       INSERT INTO agent_instances
         (worktree_id, instance_id, cli_tool_id, alias, sort_order, created_at)
@@ -282,6 +295,13 @@ function removeAgentInstance(db, worktreeId, instanceId) {
     db.prepare(`
     DELETE FROM session_notes WHERE worktree_id = ? AND instance_id = ?
   `).run(worktreeId, instanceId);
+    // Issue #4114: and its role setting, whose re-use would hand the next instance
+    // to claim this id a decision made about another.
+    db.prepare(`
+    DELETE FROM agent_instance_roles WHERE worktree_id = ? AND instance_id = ?
+  `).run(worktreeId, instanceId);
+    // Issue #4132: and the key that made it.
+    revokeInstanceCreationKeys(db, worktreeId, [instanceId]);
     return result.changes > 0;
 }
 /**
@@ -592,3 +612,36 @@ function pruneSessionNotes(db, worktreeId, keepInstanceIds) {
     WHERE worktree_id = ? AND instance_id NOT IN (${placeholders})
   `).run(worktreeId, ...keepInstanceIds).changes;
 }
+/**
+ * Remove the role settings of instances that left the roster (Issue #4114). Same
+ * rule as {@link pruneSessionNotes}. Launch records are evidence and stay.
+ *
+ * @param keepInstanceIds - The ids that survive; every other row is deleted
+ * @returns How many rows were removed
+ */
+/**
+ * Issue #4132: the rows these keys made have left the roster, so an id made again is
+ * another row, which those keys must not claim. Each becomes a key given up on, not
+ * nothing: a request still on its way with one must not make the row again.
+ */
+function revokeInstanceCreationKeys(db, worktreeId, instanceIds) {
+    if (instanceIds.length === 0)
+        return;
+    const placeholders = instanceIds.map(() => '?').join(', ');
+    db.prepare(`
+    UPDATE agent_instance_creation_keys SET instance_id = NULL, request_fingerprint = NULL
+    WHERE worktree_id = ? AND instance_id IN (${placeholders})
+  `).run(worktreeId, ...instanceIds);
+}
+function pruneAgentInstanceRoles(db, worktreeId, keepInstanceIds) {
+    if (keepInstanceIds.length === 0) {
+        return db.prepare(`
+      DELETE FROM agent_instance_roles WHERE worktree_id = ?
+    `).run(worktreeId).changes;
+    }
+    const placeholders = keepInstanceIds.map(() => '?').join(', ');
+    return db.prepare(`
+    DELETE FROM agent_instance_roles
+    WHERE worktree_id = ? AND instance_id NOT IN (${placeholders})
+  `).run(worktreeId, ...keepInstanceIds).changes;
+}