commandmate 0.49.2 → 0.50.0

package/dist/server/src/lib/session/send-attempt-state.js

@@ -22,11 +22,46 @@
  * Recording must never change a send's outcome: {@link recordSendAttempt}
  * swallows its own failures.
  *
+ * Issue #4065: which attempt is "the last" is decided by the input lock's
+ * grant order, not by which attempt finished last. Three kinds of record:
+ *
+ * - **granted** — the attempt held the body's input lock (`inputGeneration`,
+ *   the ticket's generation g). Includes one refused after the grant before
+ *   any key (g does not mean "typed"). Kept when g ≥ the instance's highest
+ *   granted generation so far (maxG), dropped when g < maxG: a send granted
+ *   later has already said how it went.
+ * - **refused** — `not-sent` before any lock was granted to it
+ *   (`observedGeneration`, the generation counter o read once at the request's
+ *   outermost entry). Kept when maxG ≤ o, dropped when maxG > o: a send granted
+ *   after this request began has already said how it went. o is only ever
+ *   compared with maxG — never with another o, nor with another instance's
+ *   grants; o = 0 is a value like any other.
+ * - **excluded / unknown** — neither (copilot's selection-list commands and
+ *   `/model`, opencode's HTTP delivery including its keyboard fallback after an
+ *   `unknown` dispatch, a tool path that reports nothing). Kept in the order
+ *   they finish, as before #4065, and they never move maxG.
+ *
+ * maxG is held beside the published record and only ever grows: a refused or
+ * excluded record, or a demotion ({@link markLastSendDiscarded}), never lowers
+ * it, so an older grant's late outcome cannot come back after them. Within one
+ * process the generation never goes back (a recreated session keeps counting);
+ * a restart forgets the records and maxG together. A worktree ID migration
+ * does not move them (the old ID's records are dropped). When more than
+ * {@link MAX_TRACKED_INSTANCES} instances are tracked the least recently sent
+ * to loses its record and its maxG together — a late outcome for it is then
+ * recorded as if it were the first.
+ *
+ * The published `lastSend` is still the three fields `at` / `state` /
+ * `reason`; neither g nor o is published, and `at` is not an order. It is the
+ * instance's last attempt by the rules above — not necessarily the reading
+ * request's own (that is `onAttempt` / `sendOutcome`).
+ *
  * @module lib/session/send-attempt-state
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sendMessageDigest = sendMessageDigest;
 exports.recordSendAttempt = recordSendAttempt;
+exports.forgetSendAttemptsForWorktree = forgetSendAttemptsForWorktree;
 exports.getLastSendAttempt = getLastSendAttempt;
 exports.markLastSendDiscarded = markLastSendDiscarded;
 exports.clearSendAttempts = clearSendAttempts;
@@ -37,11 +72,19 @@ const crypto_1 = require("crypto");
 const global_state_1 = require("../../lib/global-state");
 const logger_1 = require("../../lib/logger");
 const session_start_error_1 = require("../../lib/session/session-start-error");
+const launch_errors_1 = require("../../lib/agent-roles/launch-errors");
 const send_attempt_types_1 = require("./send-attempt-types");
 const logger = (0, logger_1.createLogger)('session/send-attempt-state');
 /** How many instances are tracked at once; the least recently sent to is forgotten first. */
 const MAX_TRACKED_INSTANCES = 1024;
 const records = (0, global_state_1.getOrInitGlobal)('__sendAttemptRecords', () => new Map());
+/**
+ * Issue #4065: per instance, the highest input generation a granted record
+ * carried (maxG). Kept apart from the published record so that a refused or
+ * excluded record — or a demotion — that replaces it does not forget it.
+ * Evicted with the instance's record.
+ */
+const maxGenerations = (0, global_state_1.getOrInitGlobal)('__sendAttemptMaxGeneration', () => new Map());
 function keyOf(instance) {
     return JSON.stringify([instance.worktreeId, instance.cliToolId, instance.instanceId]);
 }
@@ -52,27 +95,90 @@ function sendMessageDigest(content) {
 /**
  * Record how a send attempt ended. Never throws: a record that cannot be made
  * leaves the send exactly as it was.
+ *
+ * Issue #4048: `typedContent` is the body the sender actually typed when it
+ * differs from `content`; `inputGeneration` is the input lock generation the
+ * attempt ran under.
+ *
+ * Issue #4065: `observedGeneration` is the generation counter the request read
+ * at its outermost entry (`instanceInputGenerationMark` in `instance-input-lock`), given for a
+ * `not-sent` refusal made before any lock was granted to it. Which record is
+ * kept is decided against the instance's maxG (see the module comment):
+ * granted g ≥ maxG is kept (and raises maxG), g < maxG dropped; a refusal is
+ * kept when maxG ≤ o; a record with neither is kept, in the order recorded.
+ * `inputGeneration` wins when both are given.
+ *
+ * @returns Whether the attempt became the instance's record. The request's own
+ *   outcome is the caller's to report whatever this says (`onAttempt`).
  */
 function recordSendAttempt(instance, attempt, now = Date.now()) {
     try {
         const key = keyOf(instance);
+        const maxGeneration = maxGenerations.get(key);
+        if (attempt.inputGeneration !== undefined) {
+            if (maxGeneration !== undefined && maxGeneration > attempt.inputGeneration) {
+                logger.info('send-attempt-record-skipped-stale-generation', {
+                    generation: attempt.inputGeneration,
+                    heldGeneration: maxGeneration,
+                });
+                return false;
+            }
+        }
+        else if (attempt.observedGeneration !== undefined) {
+            if (maxGeneration !== undefined && maxGeneration > attempt.observedGeneration) {
+                logger.info('send-attempt-record-skipped-refusal-before-newer-grant', {
+                    observedGeneration: attempt.observedGeneration,
+                    heldGeneration: maxGeneration,
+                });
+                return false;
+            }
+        }
+        const messageDigest = sendMessageDigest(attempt.content);
+        const typedDigest = attempt.typedContent === undefined ? undefined : sendMessageDigest(attempt.typedContent);
         // Re-inserted, so the map's order is least recently sent to first.
         records.delete(key);
         records.set(key, {
             at: Math.floor(now),
             state: attempt.state,
             reason: attempt.reason,
-            messageDigest: sendMessageDigest(attempt.content),
+            messageDigest,
+            ...(typedDigest !== undefined && typedDigest !== messageDigest ? { typedDigest } : {}),
+            ...(attempt.inputGeneration !== undefined ? { inputGeneration: attempt.inputGeneration } : {}),
         });
+        if (attempt.inputGeneration !== undefined) {
+            maxGenerations.set(key, Math.max(maxGeneration ?? attempt.inputGeneration, attempt.inputGeneration));
+        }
         while (records.size > MAX_TRACKED_INSTANCES) {
             const oldest = records.keys().next().value;
             if (oldest === undefined)
                 break;
             records.delete(oldest);
+            maxGenerations.delete(oldest);
         }
+        return true;
     }
     catch (error) {
         logger.warn('send-attempt-record-failed', { error: error instanceof Error ? error.message : String(error) });
+        return false;
+    }
+}
+/**
+ * Forget the records — and their maxG — of every instance of `worktreeId`
+ * (Issue #4065): a worktree ID migration drops them rather than moving them,
+ * so the new ID starts with no record. Never throws.
+ */
+function forgetSendAttemptsForWorktree(worktreeId) {
+    try {
+        for (const key of [...records.keys(), ...maxGenerations.keys()]) {
+            const parsed = JSON.parse(key);
+            if (Array.isArray(parsed) && parsed[0] === worktreeId) {
+                records.delete(key);
+                maxGenerations.delete(key);
+            }
+        }
+    }
+    catch (error) {
+        logger.warn('send-attempt-forget-failed', { error: error instanceof Error ? error.message : String(error) });
     }
 }
 /** The instance's last recorded attempt, or null when none is held. */
@@ -83,22 +189,35 @@ function getLastSendAttempt(instance) {
  * Turn the instance's last `sent` record `indeterminate` (Issue #4035): the
  * next send found that body still in the composer, so it never reached the
  * agent. Any other record is left as it is. Never throws.
+ *
+ * `messageDigest` (Issue #4048) is the digest of the body that was found (the
+ * body typed, so it is matched against the record's `typedDigest` too): a
+ * record of another attempt — a later send, or one whose body differs — is
+ * left as it is. Omitted, the last `sent` record is demoted as before.
  */
-function markLastSendDiscarded(instance, now = Date.now()) {
+function markLastSendDiscarded(instance, now = Date.now(), messageDigest) {
     try {
         const key = keyOf(instance);
         const record = records.get(key);
         if (record === undefined || record.state !== 'sent')
             return;
+        if (messageDigest !== undefined &&
+            record.messageDigest !== messageDigest &&
+            record.typedDigest !== messageDigest) {
+            return;
+        }
+        // Issue #4065: the spread keeps the record's generation, and maxG is not
+        // touched — a demotion is not a newer attempt.
         records.set(key, { ...record, at: Math.floor(now), state: 'indeterminate', reason: 'found-in-composer' });
     }
     catch (error) {
         logger.warn('send-attempt-record-failed', { error: error instanceof Error ? error.message : String(error) });
     }
 }
-/** Forget every record (tests). */
+/** Forget every record and every maxG (tests). */
 function clearSendAttempts() {
     records.clear();
+    maxGenerations.clear();
 }
 /**
  * The wordings of a failed tmux call that can carry the message body: `tmux.ts`
@@ -134,6 +253,21 @@ function carriesCode(error, code) {
  * (`Failed to send message to <tool>: …`), so they are matched anywhere in it.
  */
 function classifySendFailure(error) {
+    // #4040: opencode's keyboard fallback refused before any key (its cause says
+    // why — a code like `paste-not-started` included), but the server dispatch
+    // before it ended `unknown`: the message may already be there, so the attempt
+    // as a whole stays unknown, never "safe to resend". Read FIRST, before any
+    // code the cause carries.
+    if (error instanceof Error &&
+        /an earlier server dispatch may have delivered the message \(Issue #4040\)/.test(error.message)) {
+        return { state: 'indeterminate', reason: 'send-error' };
+    }
+    // #4115: refused before any key, whichever layer wrapped the message on the way out.
+    if ((0, launch_errors_1.isRoleConditionUnmet)(error))
+        return { state: 'not-sent', reason: 'role-condition-failed' };
+    if ((0, launch_errors_1.readRoleLaunchRefusal)(error) !== null || carriesCode(error, launch_errors_1.SESSION_LAUNCH_ROLE_MISMATCH_CODE)) {
+        return { state: 'not-sent', reason: 'role-launch-refused' };
+    }
     if (typeof error === 'object' &&
         error !== null &&
         error.code === session_start_error_1.SESSION_STARTING_CODE) {

package/dist/server/src/lib/session/send-user-message.js

@@ -63,6 +63,7 @@ const session_start_error_1 = require("../../lib/session/session-start-error");
 const cli_session_1 = require("../../lib/session/cli-session");
 const send_attempt_state_1 = require("../../lib/session/send-attempt-state");
 const send_attempt_types_1 = require("../../lib/session/send-attempt-types");
+const launch_errors_1 = require("../../lib/agent-roles/launch-errors");
 const composer_text_1 = require("../../lib/detection/composer-text");
 const status_capture_config_1 = require("../../config/status-capture-config");
 const instance_input_lock_1 = require("../../lib/session/instance-input-lock");
@@ -132,6 +133,18 @@ async function composerStillHolds(worktreeId, cliToolId, instanceId, content) {
         return false;
     }
 }
+/**
+ * The body the tool will actually type for `content` (Issue #4048): with an
+ * image, the image-capable tool's own body (`imageMessageBody`) or the path
+ * fallback; otherwise `content` itself. Must match what `sendToTool` sends.
+ */
+function typedBodyFor(cliTool, content, absoluteImagePath) {
+    if (!absoluteImagePath)
+        return content;
+    if ((0, types_1.isImageCapableCLITool)(cliTool))
+        return cliTool.imageMessageBody?.(content, absoluteImagePath) ?? content;
+    return (0, opencode_1.formatImagePathFallbackMessage)(content, absoluteImagePath);
+}
 /**
  * Send a validated user message to the CLI tool and record it in history.
  *
@@ -140,7 +153,11 @@ async function composerStillHolds(worktreeId, cliToolId, instanceId, content) {
  * DB record failures throw (same as before the extraction).
  */
 async function sendUserMessage(db, params) {
-    const { worktreeId, content, cliToolId, instanceId, absoluteImagePath, copilotModel } = params;
+    const { worktreeId, content, cliToolId, instanceId, absoluteImagePath, copilotModel, respondAgent } = params;
+    // Issue #4065: read once, before the first await — a send granted while this
+    // request waits (ownership, the prompt guard, `/model`, the lock) is newer
+    // than this request's refusal.
+    const observedGeneration = params.observedInputGeneration ?? (0, instance_input_lock_1.instanceInputGenerationMark)();
     const messageType = params.messageType ?? 'normal';
     /**
      * The instance this send belongs to, resolved the way `createMessage` and
@@ -154,8 +171,47 @@ async function sendUserMessage(db, params) {
     // Issue #3759: how this attempt left the message, kept for `lastSend` (and
     // read back by the send route for its error). The result's shape is
     // unchanged; recording never throws.
+    //
+    // Issue #4048: the record also carries the body actually typed (an image
+    // reference appended), which is what the composer and the first-prompt
+    // receipt know the attempt by, and the input lock generation the delivery
+    // ran under, so the late outcome of a send whose session was replaced does
+    // not overwrite the newer generation's record.
+    //
+    // Issue #4065: which record is the instance's last is decided by the lock's
+    // grant order (`send-attempt-state`). This send's record is one of:
+    // - granted: the body's lock was granted to it (`inputGeneration`) — the
+    //   outer lock below for claude / codex, the shared sender's own lock for the
+    //   others, told through `observeInputStart` as it is granted, so a send that
+    //   throws after it keeps it. Refused after the grant, before any key, too.
+    // - refused: `not-sent` with no lock granted (ownership, the prompt guard,
+    //   `/model`, the lock not admitted, a readiness wait before the sender's
+    //   lock) — carries `observedGeneration`.
+    // - excluded: typed or dispatched outside the shared sender's lock —
+    //   copilot's selection-list keys (input noted, no ticket), opencode's HTTP
+    //   delivery and its keyboard fallback (a dispatch noted) — or anything else
+    //   that reports neither; kept in the order attempts finish.
+    const typedContent = typedBodyFor(cliTool, content, absoluteImagePath);
+    let inputGeneration;
+    let inputNotedWithoutTicket = false;
+    let dispatched = false;
     const settle = (state, reason) => {
-        (0, send_attempt_state_1.recordSendAttempt)({ worktreeId, cliToolId, instanceId: resolvedInstanceId }, { state, reason, content });
+        const excluded = dispatched || (inputGeneration === undefined && inputNotedWithoutTicket);
+        const order = excluded
+            ? {}
+            : inputGeneration !== undefined
+                ? { inputGeneration }
+                : state === 'not-sent'
+                    ? { observedGeneration }
+                    : {};
+        (0, send_attempt_state_1.recordSendAttempt)({ worktreeId, cliToolId, instanceId: resolvedInstanceId }, {
+            state,
+            reason,
+            content,
+            ...(typedContent !== content ? { typedContent } : {}),
+            ...order,
+        });
+        // Told whether or not the shared record took it: this is the request's own.
         params.onAttempt?.({ state, reason });
     };
     // Issue #2865: the send route checks ownership itself, but the timer manager
@@ -215,7 +271,7 @@ async function sendUserMessage(db, params) {
         return {
             ok: false,
             stage: 'prompt_waiting',
-            error: (0, prompt_waiting_guard_1.promptWaitingMessage)(worktreeId, promptGuard.blockedBy, instanceId),
+            error: (0, prompt_waiting_guard_1.promptWaitingMessage)(worktreeId, promptGuard.blockedBy, instanceId, respondAgent),
         };
     }
     // 1. Issue #576: Send /model command before message if model is specified (copilot only).
@@ -248,7 +304,7 @@ async function sendUserMessage(db, params) {
             const code = error?.code;
             if (code === send_attempt_types_1.INPUT_RECHECK_PROMPT_WAITING_CODE) {
                 settle('not-sent', 'prompt-waiting');
-                return { ok: false, stage: 'prompt_waiting', error: (0, prompt_waiting_guard_1.promptWaitingMessage)(worktreeId, undefined, instanceId) };
+                return { ok: false, stage: 'prompt_waiting', error: (0, prompt_waiting_guard_1.promptWaitingMessage)(worktreeId, undefined, instanceId, respondAgent) };
             }
             settle('not-sent', code === send_attempt_types_1.INPUT_RECHECK_FAILED_CODE ? 'recheck-failed' : 'model-switch-failed');
             return { ok: false, stage: 'model', error: getErrorMessage(error) };
@@ -347,11 +403,29 @@ async function sendUserMessage(db, params) {
     // path that does not report it).
     async function deliver() {
         try {
-            const { inputStartedAt } = await (0, instance_input_lock_1.observeInputStart)(sendToTool, params.onInputStart, params.inputBoundary);
+            const { inputStartedAt } = await (0, instance_input_lock_1.observeInputStart)(sendToTool, (at) => {
+                // Issue #4065: input noted before any body lock was told — copilot's
+                // selection-list keys, under its own lock.
+                if (inputGeneration === undefined)
+                    inputNotedWithoutTicket = true;
+                params.onInputStart?.(at);
+            }, params.inputBoundary, {
+                onTicket: (generation) => {
+                    inputGeneration = inputGeneration === undefined ? generation : Math.max(inputGeneration, generation);
+                },
+                onDispatch: () => {
+                    dispatched = true;
+                },
+            });
             return { sent: true, inputStartedAt };
         }
         catch (error) {
             logger.error('failed-to-send-message-to:', { error: getErrorMessage(error) });
+            // Issue #4115: the role this send was conditional on, or the role a driver's
+            // relaunch resolved, refused it before the first key.
+            if ((0, launch_errors_1.isRoleConditionUnmet)(error) || (0, launch_errors_1.readRoleLaunchRefusal)(error) !== null) {
+                return { error, failure: (0, send_attempt_state_1.classifySendFailure)(error) };
+            }
             // Issue #3957: the relay's boundary hook refused before the first key —
             // nothing was typed because the reservation the body was going in under
             // was gone. Issue #3992: its own reason, not `input-lock-lost`.
@@ -405,7 +479,10 @@ async function sendUserMessage(db, params) {
     // the lock across it would stall a concurrent tmux send for nothing; their
     // tmux path takes the lock inside the shared sender.
     const delivery = composer_text_1.SUPPORTED_COMPOSER_TOOLS.has(cliToolId)
-        ? await (0, instance_input_lock_1.withInstanceInputLock)(sessionName, () => deliver()).catch((error) => ({
+        ? await (0, instance_input_lock_1.withInstanceInputLock)(sessionName, (ticket) => {
+            inputGeneration = ticket.generation;
+            return deliver();
+        }).catch((error) => ({
             error,
             failure: (0, send_attempt_state_1.classifySendFailure)(error),
         }))
@@ -416,7 +493,7 @@ async function sendUserMessage(db, params) {
         // Issue #3945: a dialog found by the re-check under the lock is the prompt
         // guard's refusal, found late — answered as that refusal (relay holds it).
         if (failure.reason === 'prompt-waiting') {
-            return { ok: false, stage: 'prompt_waiting', error: (0, prompt_waiting_guard_1.promptWaitingMessage)(worktreeId, undefined, instanceId) };
+            return { ok: false, stage: 'prompt_waiting', error: (0, prompt_waiting_guard_1.promptWaitingMessage)(worktreeId, undefined, instanceId, respondAgent) };
         }
         if ((0, session_start_error_1.isSessionStartTimeoutError)(error)) {
             return { ok: false, stage: 'send', error: error.message, code: session_start_error_1.SESSION_STARTING_CODE };

package/dist/server/src/lib/session/session-generation-archive.js

@@ -88,6 +88,7 @@ const db_instance_1 = require("../../lib/db/db-instance");
 const chat_db_1 = require("../../lib/db/chat-db");
 const types_1 = require("../../lib/realtime/types");
 const logger_1 = require("../../lib/logger");
+const test_run_detection_1 = require("../../lib/test-run-detection");
 const logger = (0, logger_1.createLogger)('lib/session/session-generation-archive');
 /**
  * The database this module archives through, or `null` when there is none to
@@ -102,16 +103,14 @@ const logger = (0, logger_1.createLogger)('lib/session/session-generation-archiv
  * fabricate `<cwd>/data/cm.db` or — when the suite runs in a checkout that has
  * one — hand those fixtures the developer's real chat history to write into.
  *
- * So under Vitest the answer is "no database" unless a test hands one in
- * explicitly (see {@link archiveSupersededSessionMessages}'s `db` parameter) or
- * mocks `@/lib/db/db-instance` **and** clears `VITEST`, which is how the
- * integration test drives the production branch. Only `VITEST` is consulted,
- * never `NODE_ENV`: `vitest.config.ts` `define`s `process.env.NODE_ENV` to the
- * literal `'test'` at transform time, so a `NODE_ENV` check here would fold to
- * a constant and no test could ever reach the other branch.
+ * So in a test run ({@link isUnderTest}) the answer is "no database" unless a
+ * test hands one in explicitly (see {@link archiveSupersededSessionMessages}'s
+ * `db` parameter) or mocks both `@/lib/db/db-instance` and `isUnderTest`, which
+ * is how the integration test drives the production branch. `VITEST` is not
+ * consulted: a production server can inherit it (Issue #4097).
  */
 function resolveSessionArchiveDatabase() {
-    if (process.env.VITEST)
+    if ((0, test_run_detection_1.isUnderTest)())
         return null;
     return (0, db_instance_1.getDbInstance)();
 }

package/dist/server/src/lib/session/session-launch-flight.js

@@ -38,6 +38,8 @@
  *   a model the launch in progress is not starting with gets {@link
  *   SessionLaunchModelMismatchError}, as a `--model` to a running session
  *   gets a 400 (#989 / #2771), instead of joining and running on another model.
+ * - **Nor is a role** (Issue #4115): {@link SessionLaunchRoleMismatchError}, on
+ *   the injection fingerprint.
  *
  * In memory and on `globalThis` for the reason the lock is: the routes that
  * start sessions are separate bundles under `next dev`.
@@ -45,8 +47,9 @@
  * @module lib/session/session-launch-flight
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SessionLaunchModelMismatchError = exports.SESSION_LAUNCH_MODEL_MISMATCH_CODE = exports.SessionLaunchWaitTimeoutError = exports.SessionLaunchInFlightError = void 0;
+exports.SessionLaunchRoleMismatchError = exports.SessionLaunchModelMismatchError = exports.SESSION_LAUNCH_MODEL_MISMATCH_CODE = exports.SessionLaunchWaitTimeoutError = exports.SessionLaunchInFlightError = void 0;
 exports.isSessionLaunchModelMismatchError = isSessionLaunchModelMismatchError;
+exports.isSessionLaunchRoleMismatchError = isSessionLaunchRoleMismatchError;
 exports.isSessionLaunchInFlight = isSessionLaunchInFlight;
 exports.runSessionLaunch = runSessionLaunch;
 exports.forgetSessionLaunch = forgetSessionLaunch;
@@ -57,6 +60,7 @@ const logger_1 = require("../../lib/logger");
 const session_starting_config_1 = require("../../config/session-starting-config");
 const instance_input_lock_1 = require("../../lib/session/instance-input-lock");
 const session_start_error_1 = require("../../lib/session/session-start-error");
+const launch_errors_1 = require("../../lib/agent-roles/launch-errors");
 const logger = (0, logger_1.createLogger)('session/session-launch-flight');
 const flights = (0, global_state_1.getOrInitGlobal)('__sessionLaunchFlights', () => new Map());
 /**
@@ -118,6 +122,26 @@ exports.SessionLaunchModelMismatchError = SessionLaunchModelMismatchError;
 function isSessionLaunchModelMismatchError(error) {
     return (error instanceof Error && error.code === exports.SESSION_LAUNCH_MODEL_MISMATCH_CODE);
 }
+/**
+ * A start resolved a different role from the launch of the session already in
+ * progress (Issue #4115). A role is fixed when the process starts, so joining
+ * would silently run the request under the other one. Nothing was typed. Compared
+ * by the injection fingerprint: another name for the same text is the same role.
+ */
+class SessionLaunchRoleMismatchError extends Error {
+    code = launch_errors_1.SESSION_LAUNCH_ROLE_MISMATCH_CODE;
+    constructor(toolName, sessionName) {
+        super(`${toolName} is being started by another request (tmux session '${sessionName}') with a different role. ` +
+            'A role is fixed when the process starts — the message was not delivered and nothing was typed. ' +
+            'Retry once that start has finished; the session will show which role it has.');
+        this.name = 'SessionLaunchRoleMismatchError';
+    }
+}
+exports.SessionLaunchRoleMismatchError = SessionLaunchRoleMismatchError;
+/** Duck-typed on `code`, like the session-start errors (bundles do not share classes). */
+function isSessionLaunchRoleMismatchError(error) {
+    return error instanceof Error && error.code === launch_errors_1.SESSION_LAUNCH_ROLE_MISMATCH_CODE;
+}
 /** How long a caller may wait for `flight`, counted from when it began. */
 function launchWaitLimitMs(flight) {
     return flight.cliToolId === undefined
@@ -160,6 +184,7 @@ function isSessionLaunchInFlight(sessionName) {
  * synchronous step as the check, before `launch` reads anything (R4).
  *
  * @throws SessionLaunchModelMismatchError when another launch is in progress with another model
+ * @throws SessionLaunchRoleMismatchError when another launch is in progress with another role
  * @throws SessionLaunchInFlightError when another launch is in progress and the caller holds the input lock
  * @throws SessionLaunchWaitTimeoutError when the joined launch outlives its start budget
  */
@@ -170,6 +195,12 @@ function runSessionLaunch(sessionName, toolName, launch, options = {}) {
             logger.info('session-launch-model-mismatch-refused', { sessionName });
             return Promise.reject(new SessionLaunchModelMismatchError(toolName, sessionName, options.model, inFlight.model));
         }
+        if (options.injectionFingerprint !== undefined &&
+            inFlight.injectionFingerprint !== undefined &&
+            options.injectionFingerprint !== inFlight.injectionFingerprint) {
+            logger.info('session-launch-role-mismatch-refused', { sessionName });
+            return Promise.reject(new SessionLaunchRoleMismatchError(toolName, sessionName));
+        }
         if ((0, instance_input_lock_1.currentInstanceInputTicket)(sessionName) !== null) {
             logger.info('session-launch-in-flight-refused', { sessionName });
             return Promise.reject(new SessionLaunchInFlightError(toolName, sessionName));
@@ -187,6 +218,7 @@ function runSessionLaunch(sessionName, toolName, launch, options = {}) {
         startedAt: Date.now(),
         cliToolId: options.cliToolId,
         model: options.model,
+        injectionFingerprint: options.injectionFingerprint,
     };
     flights.set(sessionName, flight);
     const clear = () => {

package/dist/server/src/lib/session/structured-prompt.js

@@ -43,6 +43,7 @@ exports.buildStructuredPromptData = buildStructuredPromptData;
 exports.buildStructuredPromptHistoryRecord = buildStructuredPromptHistoryRecord;
 exports.isStructuredPromptWaitingData = isStructuredPromptWaitingData;
 const models_1 = require("../../types/models");
+const respond_target_1 = require("../../lib/session/respond-target");
 const decision_labels_1 = require("../../lib/hooks/sources/opencode-v2/decision-labels");
 /**
  * The three verdicts an approval dialog accepts, in the order `respond` numbers
@@ -157,10 +158,14 @@ const SOURCE_LABEL = {
  * is the only guidance a caller of `wait` gets, so it has to say which form
  * actually works.
  */
-function buildStructuredPromptQuestion(worktreeId, facts, instanceId) {
+function buildStructuredPromptQuestion(worktreeId, facts, instanceId, agent) {
     // Issue #4031: the `respond` this names goes to the instance whose prompt it
-    // is. Without an instance (the primary) the sentence is as before.
-    const target = instanceId ? ` --instance ${instanceId}` : '';
+    // is. Issue #4063: `buildCurrentOutput` always passes one — the primary's is
+    // the tool's own id (`--instance <tool>`, `resolveSessionTarget`'s rule), on
+    // every path (HTTP, WS push, poller, history). Without one (a caller outside
+    // that builder) the sentence names no target.
+    // Issue #4049: or to the tool, when the caller names one (`respondAgentFor`).
+    const target = (0, respond_target_1.respondTargetFlags)(instanceId, agent);
     const parts = [
         `A dialog is open in ${worktreeId}: the agent reported it via ${SOURCE_LABEL[facts.source]}` +
             `${facts.toolName ? ` for ${facts.toolName}` : ''}, but the detection layer published no ` +
@@ -215,11 +220,11 @@ function buildStructuredPromptQuestion(worktreeId, facts, instanceId) {
     return parts.join(' ');
 }
 /** The live `promptData` for a structured prompt. */
-function buildStructuredPromptData(worktreeId, facts, instanceId) {
+function buildStructuredPromptData(worktreeId, facts, instanceId, agent) {
     return {
         type: models_1.UNCLASSIFIED_PROMPT_TYPE,
         status: 'pending',
-        question: buildStructuredPromptQuestion(worktreeId, facts, instanceId),
+        question: buildStructuredPromptQuestion(worktreeId, facts, instanceId, agent),
         options: [],
         source: facts.source,
         ...(facts.message ? { message: facts.message } : {}),
@@ -241,11 +246,11 @@ function buildStructuredPromptData(worktreeId, facts, instanceId) {
     };
 }
 /** The prompt-history row for a structured prompt the scraper never saw. */
-function buildStructuredPromptHistoryRecord(worktreeId, facts, instanceId) {
+function buildStructuredPromptHistoryRecord(worktreeId, facts, instanceId, agent) {
     return {
         type: models_1.UNCLASSIFIED_PROMPT_TYPE,
         status: 'unclassified',
-        question: buildStructuredPromptQuestion(worktreeId, facts, instanceId),
+        question: buildStructuredPromptQuestion(worktreeId, facts, instanceId, agent),
         options: [],
         source: facts.source,
         ...(facts.message ? { message: facts.message } : {}),

package/dist/server/src/lib/session/worktree-session-reconcile.js

@@ -72,6 +72,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.__internal = void 0;
 exports.reconcileWorktreeSessions = reconcileWorktreeSessions;
 exports.reconcileWorktreeSessionsFromAliases = reconcileWorktreeSessionsFromAliases;
+const role_launch_1 = require("../../lib/session/role-launch");
 const manager_1 = require("../../lib/cli-tools/manager");
 const types_1 = require("../../lib/cli-tools/types");
 const agent_instances_db_1 = require("../../lib/db/agent-instances-db");
@@ -89,6 +90,7 @@ const response_poller_1 = require("../../lib/polling/response-poller");
 const auto_yes_poller_state_1 = require("../../lib/polling/auto-yes-poller-state");
 const auto_yes_enter_fallback_1 = require("../../lib/polling/auto-yes-enter-fallback");
 const ws_server_1 = require("../../lib/ws-server");
+const send_attempt_state_1 = require("./send-attempt-state");
 const logger_1 = require("../../lib/logger");
 const logger = (0, logger_1.createLogger)('worktree-session-reconcile');
 /**
@@ -514,6 +516,10 @@ function moveAutoYesPartialAnswers(completed, sourceEpochs) {
  * and leaving either behind is exactly the silent breakage this guards against.
  */
 function migrateRuntimeState(db, renames, result) {
+    // --- Roles ----------------------------------------------------------------
+    // Issue #4115: the sessions were renamed and the processes are the same, so what
+    // this server knows about them follows. The records moved with the worktree row.
+    (0, role_launch_1.moveLaunchRoleEvidence)(renames);
     // --- Auto-Yes -------------------------------------------------------------
     // Snapshot which pollers are running BEFORE the state moves: startAutoYesPolling
     // refuses to start when the state at its key is not enabled, so the state has
@@ -591,6 +597,15 @@ function migrateRuntimeState(db, renames, result) {
     catch (error) {
         result.errors.push(`websocket rooms: ${error instanceof Error ? error.message : String(error)}`);
     }
+    // --- lastSend (Issue #4065) -------------------------------------------------
+    // Dropped, not moved: a record and its order (maxG) describe the sends made
+    // under the ID they were made under, and an old request that finishes late
+    // records under its own (old) ID. Both sides of every pair start with none.
+    // Never throws.
+    for (const rename of renames) {
+        (0, send_attempt_state_1.forgetSendAttemptsForWorktree)(rename.oldId);
+        (0, send_attempt_state_1.forgetSendAttemptsForWorktree)(rename.newId);
+    }
 }
 async function reconcileWorktreeSessions(db, renamesOrOldId, newIdOrOptions, maybeOptions) {
     const requested = typeof renamesOrOldId === 'string'

package/dist/server/src/lib/session-key-sender.js

@@ -70,9 +70,13 @@ async function waitForPrompt(sessionName, timeout) {
  * @param message - Message content to send
  * @param postPromptDelay - Stability delay after prompt detection (ms)
  * @param promptWaitTimeout - Timeout for waiting for prompt state (ms)
+ * @param target - The instance the session runs (Issue #4048). The first
+ *   prompt's hook check and the remembered body are then taken only from the
+ *   entry both this and `sessionName` name; omitted, the name alone decides.
+ *   Never registers or resets anything.
  * @throws {Error} If session doesn't exist
  */
-async function sendMessageToSession(sessionName, message, postPromptDelay, promptWaitTimeout) {
+async function sendMessageToSession(sessionName, message, postPromptDelay, promptWaitTimeout, target) {
     // Check if session exists
     const exists = await (0, tmux_1.hasSession)(sessionName);
     if (!exists) {
@@ -94,6 +98,7 @@ async function sendMessageToSession(sessionName, message, postPromptDelay, promp
         sessionName,
         message,
         cliToolId: 'claude',
+        ...(target !== undefined ? { target } : {}),
     });
     // Issue #405: Invalidate cache after sending message
     (0, tmux_capture_cache_1.invalidateCache)(sessionName);