commandmate 0.49.2 → 0.50.0

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

@@ -14,6 +14,9 @@ const base_1 = require("./base");
 const types_1 = require("./types");
 const tmux_1 = require("../tmux/tmux");
 const submit_verified_sender_1 = require("./submit-verified-sender");
+const readiness_1 = require("../detection/tools/vibe-local/readiness");
+const status_detector_1 = require("../detection/status-detector");
+const prompt_wait_dialog_1 = require("./prompt-wait-dialog");
 const tmux_capture_cache_1 = require("../tmux/tmux-capture-cache");
 const db_instance_1 = require("../db/db-instance");
 const db_1 = require("../db");
@@ -28,6 +31,52 @@ const logger = (0, logger_1.createLogger)('cli-tools/vibe-local');
  * vibe-local shows a permission check prompt, banner, and model loading.
  */
 const VIBE_LOCAL_INIT_WAIT_MS = 5000;
+/**
+ * How long a send waits for vibe-local's input prompt (Issue #4040).
+ *
+ * Measured on vibe-local 1.3.3 (`vibe-local -y`, isolated `HOME`, private tmux
+ * socket, model `qwen3-coder:30b` not loaded in Ollama before each run): the
+ * empty `ctx:N% ❯` row was up 1.15 s, 0.62 s and 0.60 s after the launch
+ * keystroke — vibe-local loads the model on the first message, not at launch.
+ * gemini's and codex's 15 s therefore covers it with room to spare.
+ */
+const VIBE_LOCAL_PROMPT_WAIT_TIMEOUT_MS = 15000;
+/** Interval between the send's readiness polls (Issue #4040). */
+const VIBE_LOCAL_PROMPT_POLL_INTERVAL_MS = 500;
+/** Scrollback rows plus the visible pane in a readiness capture (`-S -200 -E -`). */
+const VIBE_LOCAL_PROMPT_CAPTURE_LINES = 200;
+/**
+ * Whether {@link VibeLocalTool}'s prompt wait counts this frame towards giving
+ * up on a dialog (Issue #4084): the detector reports an active prompt — what
+ * the re-check under the input lock refuses — and no turn is being generated.
+ * Unlike copilot's wait, there is no folder-trust dialog here to leave out:
+ * this wait answers none.
+ */
+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
@@ -118,6 +167,10 @@ class VibeLocalTool extends base_1.BaseCLITool {
         // same pane when the tool is gone; costs one `capture-pane` when it is not.
         await this.requireSession('Vibe Local', worktreeId, instanceId, { relaunch: true });
         try {
+            // Issue #4040: nothing is typed (the two Enters included) until the
+            // newest prompt row is up and empty — a relaunch or a fresh launch is
+            // still drawing its banner when the first send arrives.
+            await this.waitForPrompt(sessionName);
             // Issue #1471: Body/Enter separation + read-back submit verification via the
             // shared helper. vibe-local's IME mode needs TWO Enter presses (first Enter
             // inserts a newline, the second submits), preserved via submitEnterCount: 2
@@ -131,6 +184,8 @@ class VibeLocalTool extends base_1.BaseCLITool {
                 // the one call site that knew about it.
                 composer: this.describeComposer(),
                 interEnterWaitMs: cli_tool_timing_config_1.VIBE_LOCAL_DOUBLE_ENTER_WAIT_MS,
+                // Issue #4040: the same test, of the newest frame read under the input lock.
+                readiness: { label: 'Vibe Local', isReady: readiness_1.isVibeLocalComposerReady },
             });
             // Issue #405: Invalidate cache after sending message
             (0, tmux_capture_cache_1.invalidateCache)(sessionName);
@@ -142,6 +197,62 @@ class VibeLocalTool extends base_1.BaseCLITool {
             throw new Error(`Failed to send message to Vibe Local: ${errorMessage}`, { cause: error });
         }
     }
+    /**
+     * Wait for vibe-local's input prompt before a send (Issue #4040).
+     *
+     * {@link isVibeLocalComposerReady} is the test — the newest `ctx:N% ❯` row
+     * empty with only the footer below it (or a turn being generated under it),
+     * never "the row is somewhere on the pane": the scrollback keeps every old
+     * one.
+     *
+     * Issue #4084: a dialog (`hasActivePrompt`, not while a turn is being
+     * generated) ends the wait only once it is confirmed — seen on 2 reads in a
+     * row spanning `PROMPT_WAIT_DIALOG_CONFIRM_MS` (2 s), the count copilot's
+     * wait uses (#4067) — and is then refused as `prompt-waiting` at once, on the
+     * wait's own reads. A dialog read once (a frame mid-paint) and then gone does
+     * not refuse the send; it used to end the wait on that one read. A dialog
+     * that opens after the wait is still refused by the shared sender's re-read
+     * under the input lock, on one read. No capture is waited for past the
+     * window: one still running at the deadline is not used.
+     *
+     * @throws Error (`Vibe Local prompt not ready`) when the prompt did not come
+     *   up within {@link VIBE_LOCAL_PROMPT_WAIT_TIMEOUT_MS}; nothing was typed
+     * @throws Error coded `prompt-waiting` ({@link confirmedDialogRefusal}) for a
+     *   confirmed dialog; nothing was typed
+     */
+    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) });
+            }
+            if (confirmed) {
+                logger.warn('vibe-local-prompt-wait-dialog', { sessionName, reads: dialog.reads });
+                throw (0, prompt_wait_dialog_1.confirmedDialogRefusal)(sessionName, 'Vibe Local');
+            }
+            const remaining = deadline - Date.now();
+            if (remaining <= 0)
+                break;
+            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 (${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;
+}

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

@@ -0,0 +1,409 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INSTANCE_CREATION_KEY_TTL_MS = exports.AgentRoleInUseError = exports.AgentRoleNameChangedError = exports.AgentRoleVersionConflictError = exports.AgentRoleNameConflictError = exports.AgentRoleNotFoundError = exports.AgentRoleValidationError = void 0;
+exports.listAgentRoles = listAgentRoles;
+exports.getAgentRole = getAgentRole;
+exports.createAgentRole = createAgentRole;
+exports.getAgentRoleReferences = getAgentRoleReferences;
+exports.updateAgentRole = updateAgentRole;
+exports.deleteAgentRole = deleteAgentRole;
+exports.getSystemRoleDefaults = getSystemRoleDefaults;
+exports.setSystemRoleDefault = setSystemRoleDefault;
+exports.getRepositoryRoleStates = getRepositoryRoleStates;
+exports.setRepositoryRoleState = setRepositoryRoleState;
+exports.getInstanceRoleState = getInstanceRoleState;
+exports.setInstanceRoleState = setInstanceRoleState;
+exports.hasAnyRoleSetting = hasAnyRoleSetting;
+exports.getInstanceCreationKey = getInstanceCreationKey;
+exports.recordInstanceCreationKey = recordInstanceCreationKey;
+exports.settleInstanceCreationKey = settleInstanceCreationKey;
+exports.recordRoleLaunch = recordRoleLaunch;
+exports.getLatestRoleLaunchRecords = getLatestRoleLaunchRecords;
+/**
+ * Role tables (Issue #4114, migration v64).
+ *
+ * Every write that could leave a reference half done runs in a transaction. The
+ * body is never logged and never placed in an error message.
+ *
+ * @module lib/db/agent-roles-db
+ */
+const crypto_1 = require("crypto");
+const fingerprint_1 = require("../../lib/agent-roles/fingerprint");
+const validation_1 = require("../../lib/agent-roles/validation");
+class AgentRoleValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AgentRoleValidationError';
+    }
+}
+exports.AgentRoleValidationError = AgentRoleValidationError;
+class AgentRoleNotFoundError extends Error {
+    roleId;
+    constructor(roleId) {
+        super(`Role not found: ${roleId}`);
+        this.roleId = roleId;
+        this.name = 'AgentRoleNotFoundError';
+    }
+}
+exports.AgentRoleNotFoundError = AgentRoleNotFoundError;
+class AgentRoleNameConflictError extends Error {
+    constructor(name) {
+        super(`A role named "${name}" already exists`);
+        this.name = 'AgentRoleNameConflictError';
+    }
+}
+exports.AgentRoleNameConflictError = AgentRoleNameConflictError;
+class AgentRoleVersionConflictError extends Error {
+    currentBodyVersion;
+    constructor(currentBodyVersion) {
+        super(`The role is at body version ${currentBodyVersion}`);
+        this.currentBodyVersion = currentBodyVersion;
+        this.name = 'AgentRoleVersionConflictError';
+    }
+}
+exports.AgentRoleVersionConflictError = AgentRoleVersionConflictError;
+class AgentRoleNameChangedError extends Error {
+    currentName;
+    constructor(currentName) {
+        super('The role was renamed since it was read');
+        this.currentName = currentName;
+        this.name = 'AgentRoleNameChangedError';
+    }
+}
+exports.AgentRoleNameChangedError = AgentRoleNameChangedError;
+class AgentRoleInUseError extends Error {
+    references;
+    constructor(references) {
+        super('The role is in use');
+        this.references = references;
+        this.name = 'AgentRoleInUseError';
+    }
+}
+exports.AgentRoleInUseError = AgentRoleInUseError;
+function mapRole(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        body: row.body,
+        bodyVersion: row.body_version,
+        bodyFingerprint: (0, fingerprint_1.computeBodyFingerprint)(row.body),
+        bodyBytes: Buffer.byteLength(row.body, 'utf8'),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function isUniqueNameViolation(error) {
+    return error instanceof Error && error.message.includes('UNIQUE constraint failed: agent_roles.name');
+}
+function validatedName(name) {
+    const normalized = (0, validation_1.normalizeRoleName)(name);
+    if (!normalized.ok)
+        throw new AgentRoleValidationError(normalized.problem);
+    return normalized.name;
+}
+function assertBody(body) {
+    const problem = (0, validation_1.roleBodyProblem)(body);
+    if (problem)
+        throw new AgentRoleValidationError(problem);
+}
+// ---------------------------------------------------------------------------
+// Roles
+// ---------------------------------------------------------------------------
+/** Every role, by name. */
+function listAgentRoles(db) {
+    const rows = db.prepare('SELECT * FROM agent_roles ORDER BY name ASC').all();
+    return rows.map(mapRole);
+}
+function getAgentRole(db, id) {
+    const row = db.prepare('SELECT * FROM agent_roles WHERE id = ?').get(id);
+    return row ? mapRole(row) : null;
+}
+/**
+ * @throws {AgentRoleValidationError} The name or body is not acceptable
+ * @throws {AgentRoleNameConflictError} The name is taken
+ */
+function createAgentRole(db, input) {
+    const name = validatedName(input.name);
+    assertBody(input.body);
+    // Short and hex: it becomes part of a generated file name.
+    const id = (0, crypto_1.randomBytes)(8).toString('hex');
+    const now = Date.now();
+    try {
+        db.prepare(`INSERT INTO agent_roles (id, name, body, body_version, created_at, updated_at) VALUES (?, ?, ?, 1, ?, ?)`).run(id, name, input.body, now, now);
+    }
+    catch (error) {
+        if (isUniqueNameViolation(error))
+            throw new AgentRoleNameConflictError(name);
+        throw error;
+    }
+    return getAgentRole(db, id);
+}
+/** What points directly at this role. */
+function getAgentRoleReferences(db, roleId) {
+    const instances = db
+        .prepare(`SELECT worktree_id AS worktreeId, instance_id AS instanceId FROM agent_instance_roles
+       WHERE role_id = ? ORDER BY worktree_id, instance_id`)
+        .all(roleId);
+    const repositories = db
+        .prepare(`SELECT d.repository_id AS repositoryId, r.path AS repositoryPath, d.cli_tool_id AS cliToolId
+       FROM agent_role_repository_defaults d JOIN repositories r ON r.id = d.repository_id
+       WHERE d.role_id = ? ORDER BY r.path, d.cli_tool_id`)
+        .all(roleId);
+    const system = db
+        .prepare(`SELECT cli_tool_id AS cliToolId FROM agent_role_system_defaults WHERE role_id = ? ORDER BY cli_tool_id`)
+        .all(roleId);
+    return { instances, repositories, system };
+}
+/**
+ * Edit a role. The body version moves only when the bytes change, so a rename is
+ * not a new version of the text.
+ *
+ * @param input.expectedBodyVersion - When given, the edit applies only at this version
+ * @param input.expectedName - When given, the edit applies only under this name, or
+ *   when the role already has the name asked for
+ * @throws {AgentRoleNotFoundError}
+ * @throws {AgentRoleVersionConflictError} Someone else got there first; nothing changed
+ * @throws {AgentRoleNameChangedError} Someone else renamed it first; nothing changed
+ * @throws {AgentRoleValidationError}
+ * @throws {AgentRoleNameConflictError}
+ */
+function updateAgentRole(db, id, input) {
+    const name = input.name === undefined ? undefined : validatedName(input.name);
+    if (input.body !== undefined)
+        assertBody(input.body);
+    const newBody = input.body;
+    return db.transaction(() => {
+        const before = getAgentRole(db, id);
+        if (!before)
+            throw new AgentRoleNotFoundError(id);
+        if (input.expectedBodyVersion !== undefined && input.expectedBodyVersion !== before.bodyVersion) {
+            throw new AgentRoleVersionConflictError(before.bodyVersion);
+        }
+        if (input.expectedName !== undefined && input.expectedName !== before.name && name !== before.name) {
+            throw new AgentRoleNameChangedError(before.name);
+        }
+        const bodyChanged = newBody !== undefined && newBody !== before.body;
+        try {
+            db.prepare(`UPDATE agent_roles SET name = ?, body = ?, body_version = ?, updated_at = ? WHERE id = ?`).run(name ?? before.name, newBody ?? before.body, bodyChanged ? before.bodyVersion + 1 : before.bodyVersion, Date.now(), id);
+        }
+        catch (error) {
+            if (isUniqueNameViolation(error))
+                throw new AgentRoleNameConflictError(name ?? before.name);
+            throw error;
+        }
+        return {
+            before,
+            after: getAgentRole(db, id),
+            affected: getAgentRoleReferences(db, id),
+        };
+    })();
+}
+/**
+ * Delete a role. With `force`, the settings pointing at it go in the same
+ * transaction, so they read as "inherit" afterwards and not as an explicit none.
+ * Launch records and generated files stay.
+ *
+ * @throws {AgentRoleNotFoundError}
+ * @throws {AgentRoleInUseError} It has references and `force` was not given
+ */
+function deleteAgentRole(db, id, options = {}) {
+    return db.transaction(() => {
+        const role = getAgentRole(db, id);
+        if (!role)
+            throw new AgentRoleNotFoundError(id);
+        const affected = getAgentRoleReferences(db, id);
+        const inUse = affected.instances.length + affected.repositories.length + affected.system.length > 0;
+        if (inUse && !options.force)
+            throw new AgentRoleInUseError(affected);
+        db.prepare('DELETE FROM agent_instance_roles WHERE role_id = ?').run(id);
+        db.prepare('DELETE FROM agent_role_repository_defaults WHERE role_id = ?').run(id);
+        db.prepare('DELETE FROM agent_role_system_defaults WHERE role_id = ?').run(id);
+        db.prepare('DELETE FROM agent_roles WHERE id = ?').run(id);
+        return { role, affected };
+    })();
+}
+function assertRoleExists(db, roleId) {
+    if (!db.prepare('SELECT 1 FROM agent_roles WHERE id = ?').get(roleId)) {
+        throw new AgentRoleNotFoundError(roleId);
+    }
+}
+// ---------------------------------------------------------------------------
+// Settings
+// ---------------------------------------------------------------------------
+function toStoredState(row) {
+    if (!row)
+        return { state: 'inherit' };
+    if (row.role_id === null)
+        return { state: 'none' };
+    return { state: 'role', roleId: row.role_id, roleName: row.role_name };
+}
+/** @returns The tools with a system default. A missing key means unset. */
+function getSystemRoleDefaults(db) {
+    const rows = db
+        .prepare(`SELECT d.cli_tool_id, d.role_id, r.name AS role_name
+       FROM agent_role_system_defaults d JOIN agent_roles r ON r.id = d.role_id`)
+        .all();
+    return Object.fromEntries(rows.map((row) => [row.cli_tool_id, { roleId: row.role_id, roleName: row.role_name }]));
+}
+/**
+ * @param roleId - The role, or null for unset (no row)
+ * @throws {AgentRoleNotFoundError}
+ */
+function setSystemRoleDefault(db, cliToolId, roleId) {
+    if (roleId === null) {
+        db.prepare('DELETE FROM agent_role_system_defaults WHERE cli_tool_id = ?').run(cliToolId);
+        return;
+    }
+    assertRoleExists(db, roleId);
+    db.prepare(`INSERT INTO agent_role_system_defaults (cli_tool_id, role_id, updated_at) VALUES (?, ?, ?)
+     ON CONFLICT(cli_tool_id) DO UPDATE SET role_id = excluded.role_id, updated_at = excluded.updated_at`).run(cliToolId, roleId, Date.now());
+}
+/** @returns The tools with a row for this root. A missing key means inherit. */
+function getRepositoryRoleStates(db, repositoryId) {
+    const rows = db
+        .prepare(`SELECT d.cli_tool_id, d.role_id, r.name AS role_name
+       FROM agent_role_repository_defaults d LEFT JOIN agent_roles r ON r.id = d.role_id
+       WHERE d.repository_id = ?`)
+        .all(repositoryId);
+    return Object.fromEntries(rows.map((row) => [row.cli_tool_id, toStoredState(row)]));
+}
+/** @throws {AgentRoleNotFoundError} */
+function setRepositoryRoleState(db, repositoryId, cliToolId, input) {
+    if (input.state === 'inherit') {
+        db.prepare('DELETE FROM agent_role_repository_defaults WHERE repository_id = ? AND cli_tool_id = ?').run(repositoryId, cliToolId);
+        return;
+    }
+    const roleId = input.state === 'role' ? input.roleId : null;
+    if (roleId !== null)
+        assertRoleExists(db, roleId);
+    db.prepare(`INSERT INTO agent_role_repository_defaults (repository_id, cli_tool_id, role_id, updated_at) VALUES (?, ?, ?, ?)
+     ON CONFLICT(repository_id, cli_tool_id) DO UPDATE SET role_id = excluded.role_id, updated_at = excluded.updated_at`).run(repositoryId, cliToolId, roleId, Date.now());
+}
+function getInstanceRoleState(db, worktreeId, instanceId) {
+    const row = db
+        .prepare(`SELECT i.role_id, r.name AS role_name
+       FROM agent_instance_roles i LEFT JOIN agent_roles r ON r.id = i.role_id
+       WHERE i.worktree_id = ? AND i.instance_id = ?`)
+        .get(worktreeId, instanceId);
+    return toStoredState(row);
+}
+/**
+ * Whether the target may hold a setting is for the caller to decide
+ * (`agent-roles/management.ts`): this writes what it is told.
+ *
+ * @throws {AgentRoleNotFoundError}
+ */
+function setInstanceRoleState(db, worktreeId, instanceId, input) {
+    if (input.state === 'inherit') {
+        db.prepare('DELETE FROM agent_instance_roles WHERE worktree_id = ? AND instance_id = ?').run(worktreeId, instanceId);
+        return;
+    }
+    const roleId = input.state === 'role' ? input.roleId : null;
+    if (roleId !== null)
+        assertRoleExists(db, roleId);
+    db.prepare(`INSERT INTO agent_instance_roles (worktree_id, instance_id, role_id, updated_at) VALUES (?, ?, ?, ?)
+     ON CONFLICT(worktree_id, instance_id) DO UPDATE SET role_id = excluded.role_id, updated_at = excluded.updated_at`).run(worktreeId, instanceId, roleId, Date.now());
+}
+/**
+ * Whether any level holds a setting. With none, every instance of every tool
+ * resolves to no role, so a launch need not run git to find that out (#4115).
+ */
+function hasAnyRoleSetting(db) {
+    const row = db
+        .prepare(`SELECT (EXISTS (SELECT 1 FROM agent_instance_roles)
+            OR EXISTS (SELECT 1 FROM agent_role_repository_defaults)
+            OR EXISTS (SELECT 1 FROM agent_role_system_defaults)) AS present`)
+        .get();
+    return row?.present === 1;
+}
+// ---------------------------------------------------------------------------
+// Creation keys (#4132, migration v65)
+// ---------------------------------------------------------------------------
+/** How long a key is remembered. A request's deadline is seconds, so a late one is well inside it. */
+exports.INSTANCE_CREATION_KEY_TTL_MS = 24 * 60 * 60 * 1000;
+function getInstanceCreationKey(db, worktreeId, key) {
+    const row = db
+        .prepare(`SELECT instance_id, request_fingerprint FROM agent_instance_creation_keys
+       WHERE worktree_id = ? AND idempotency_key = ?`)
+        .get(worktreeId, key);
+    return row ? { instanceId: row.instance_id, requestFingerprint: row.request_fingerprint } : null;
+}
+function writeInstanceCreationKey(db, worktreeId, key, record) {
+    const now = Date.now();
+    db.prepare('DELETE FROM agent_instance_creation_keys WHERE created_at < ?').run(now - exports.INSTANCE_CREATION_KEY_TTL_MS);
+    db.prepare(`INSERT INTO agent_instance_creation_keys (worktree_id, idempotency_key, instance_id, request_fingerprint, created_at)
+     VALUES (?, ?, ?, ?, ?)`).run(worktreeId, key, record.instanceId, record.requestFingerprint, now);
+}
+/** Written in the transaction that creates the row, so one never exists without the other. */
+function recordInstanceCreationKey(db, worktreeId, key, instanceId, requestFingerprint) {
+    writeInstanceCreationKey(db, worktreeId, key, { instanceId, requestFingerprint });
+}
+/**
+ * What a key came to. One that has made nothing is marked given up on here, so a request
+ * still on its way with it makes nothing either: the answer holds from now on.
+ *
+ * @returns The instance it made, or null when it made none and never will
+ */
+function settleInstanceCreationKey(db, worktreeId, key) {
+    return db.transaction(() => {
+        const existing = getInstanceCreationKey(db, worktreeId, key);
+        if (existing)
+            return existing.instanceId;
+        writeInstanceCreationKey(db, worktreeId, key, { instanceId: null, requestFingerprint: null });
+        return null;
+    })();
+}
+function mapLaunchRecord(row) {
+    return {
+        id: row.id,
+        worktreeId: row.worktree_id,
+        instanceId: row.instance_id,
+        cliToolId: row.cli_tool_id,
+        phase: row.phase,
+        sessionGeneration: row.session_generation,
+        source: row.source,
+        repositoryId: row.repository_id,
+        roleId: row.role_id,
+        roleName: row.role_name,
+        bodyVersion: row.body_version,
+        bodyFingerprint: row.body_fingerprint,
+        injectionFingerprint: row.injection_fingerprint,
+        artifactFingerprint: row.artifact_fingerprint,
+        adapterId: row.adapter_id,
+        adapterVersion: row.adapter_version,
+        wrapperVersion: row.wrapper_version,
+        artifactPath: row.artifact_path,
+        effectiveAgent: row.effective_agent,
+        compositionSourceFingerprint: row.composition_source_fingerprint,
+        noRoleReason: row.no_role_reason,
+        recordedAt: row.recorded_at,
+    };
+}
+/**
+ * Add one line of evidence. There is no function that changes one.
+ *
+ * @throws When this generation already has a record of this phase
+ */
+function recordRoleLaunch(db, record) {
+    const id = (0, crypto_1.randomUUID)();
+    db.prepare(`INSERT INTO agent_role_launch_records (
+       id, worktree_id, instance_id, cli_tool_id, phase, session_generation, source,
+       repository_id, role_id, role_name, body_version, body_fingerprint,
+       injection_fingerprint, artifact_fingerprint, adapter_id, adapter_version,
+       wrapper_version, artifact_path, effective_agent, composition_source_fingerprint,
+       no_role_reason, recorded_at
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, record.worktreeId, record.instanceId, record.cliToolId, record.phase, record.sessionGeneration, record.source, record.repositoryId, record.roleId, record.roleName, record.bodyVersion, record.bodyFingerprint, record.injectionFingerprint, record.artifactFingerprint, record.adapterId, record.adapterVersion, record.wrapperVersion, record.artifactPath, record.effectiveAgent, record.compositionSourceFingerprint, record.noRoleReason, Date.now());
+    return id;
+}
+/** The latest record of each phase for one instance. Ties on the clock go to the later insert. */
+function getLatestRoleLaunchRecords(db, worktreeId, instanceId) {
+    const latest = (phase) => {
+        const row = db
+            .prepare(`SELECT * FROM agent_role_launch_records
+         WHERE worktree_id = ? AND instance_id = ? AND phase = ?
+         ORDER BY recorded_at DESC, rowid DESC LIMIT 1`)
+            .get(worktreeId, instanceId, phase);
+        return row ? mapLaunchRecord(row) : null;
+    };
+    return { requested: latest('requested'), launched: latest('launched') };
+}

package/dist/server/src/lib/db/agent-session-cost-sampler.js

@@ -41,6 +41,7 @@ exports.stopAgentSessionCostSampler = stopAgentSessionCostSampler;
 const agent_session_telemetry_1 = require("../../lib/hooks/agent-session-telemetry");
 const types_1 = require("../../lib/cli-tools/types");
 const logger_1 = require("../../lib/logger");
+const test_run_detection_1 = require("../../lib/test-run-detection");
 const agent_session_cost_db_1 = require("./agent-session-cost-db");
 const logger = (0, logger_1.createLogger)('agent-session-cost-sampler');
 /**
@@ -160,7 +161,7 @@ function sampleAgentSessionCosts(db, now = Date.now()) {
  * needing to know which kind of process it is in.
  *
  * The timer is `unref()`d so it never keeps Node alive, and skipped outright
- * under Vitest: a suite that opens a database should not acquire a background
+ * in a test run ({@link isUnderTest}): a suite that opens a database should not acquire a background
  * writer to a file it is about to delete.
  *
  * @param db - Database instance to write into
@@ -169,7 +170,7 @@ function sampleAgentSessionCosts(db, now = Date.now()) {
 function startAgentSessionCostSampler(db) {
     if (globalThis.__agentSessionCostSampler)
         return false;
-    if (process.env.VITEST || process.env.NODE_ENV === 'test')
+    if ((0, test_run_detection_1.isUnderTest)())
         return false;
     const timer = setInterval(() => {
         try {