commandmate 0.49.1 → 0.49.3

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

@@ -0,0 +1,243 @@
+"use strict";
+/**
+ * One launch per session at a time (Issue #3981).
+ *
+ * Two requests could start the same session at once. A (a send to an instance
+ * that is not running) creates the pane and is about to type the launch line;
+ * B arrives in that window. For seven tools `isRunning` is `has-session`, so B
+ * read "running" and went on to type its body into the pane's shell; for claude
+ * `isRunning` also checks health, so on an unhealthy-looking pane (empty, `%`)
+ * B started the session too and the reuse branch killed A's half-launched pane.
+ * Nothing said "this session is already being started".
+ *
+ * This module is that fact, keyed by tmux session name, and the order it has to
+ * be taken in relative to the instance input lock (`./instance-input-lock`):
+ *
+ * - **The flight is outside, the lock inside.** A launch types its lines in one
+ *   `exclusive` turn of the lock (`typeLaunchLines`), and its init polls and
+ *   readiness waits run outside it (#3975). A naive "wait for the launch" would
+ *   let a send that holds the lock wait for a launch that is waiting for the
+ *   lock — a cycle that ends only at `INSTANCE_INPUT_LOCK_WAIT_MS`.
+ * - **R1: a lock holder never waits for another request's launch.** It gets
+ *   {@link SessionLaunchInFlightError} (`SESSION_STARTING`, nothing typed)
+ *   instead, and the launch types once the holder lets go.
+ * - **R2: the launch's own keys join a lock the launcher already holds** (codex
+ *   relaunching inside a send): the lock's `AsyncLocalStorage`, which a launch
+ *   started here inherits.
+ * - **R4: the launch is registered before anything is read.** {@link
+ *   runSessionLaunch} records it synchronously, before the tool's `hasSession`,
+ *   its health check or claude's reuse-branch kill run; `POST /send` and
+ *   `requireSession` look here before they read `isRunning`.
+ *
+ * - **A wait has a bound** (review P3-1): a caller that joins or waits out
+ *   another request's launch gives up at the launch's own start budget
+ *   (`getSessionStartingMaxMs`, counted from when the launch began) with
+ *   {@link SessionLaunchWaitTimeoutError} (`SESSION_STARTING`, nothing typed),
+ *   so a launch that stops returning does not hang every send to its session.
+ * - **A model is not dropped on a join** (review P3-2): a start that asks for
+ *   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.
+ *
+ * In memory and on `globalThis` for the reason the lock is: the routes that
+ * start sessions are separate bundles under `next dev`.
+ *
+ * @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.isSessionLaunchModelMismatchError = isSessionLaunchModelMismatchError;
+exports.isSessionLaunchInFlight = isSessionLaunchInFlight;
+exports.runSessionLaunch = runSessionLaunch;
+exports.forgetSessionLaunch = forgetSessionLaunch;
+exports.settleSessionLaunch = settleSessionLaunch;
+exports.resetSessionLaunchFlightsForTest = resetSessionLaunchFlightsForTest;
+const global_state_1 = require("../../lib/global-state");
+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 logger = (0, logger_1.createLogger)('session/session-launch-flight');
+const flights = (0, global_state_1.getOrInitGlobal)('__sessionLaunchFlights', () => new Map());
+/**
+ * Another request is starting this session, and the caller holds its input lock
+ * (R1). Nothing was typed; retrying after the launch is the whole remedy.
+ *
+ * A {@link SessionStartTimeoutError}, so every reader of `SESSION_STARTING`
+ * (the send service, the route's 503, `classifySendFailure`) answers it as the
+ * slow start it is.
+ */
+class SessionLaunchInFlightError extends session_start_error_1.SessionStartTimeoutError {
+    constructor(toolName, sessionName) {
+        super(toolName, sessionName, 0);
+        this.message =
+            `${toolName} is being started by another request (tmux session '${sessionName}'), ` +
+                'and this send holds its input, so it did not wait for that launch — the message was ' +
+                'not delivered and nothing was typed. Retry the send in a few seconds.';
+        this.name = 'SessionLaunchInFlightError';
+    }
+}
+exports.SessionLaunchInFlightError = SessionLaunchInFlightError;
+/**
+ * Another request's launch of this session did not finish within its start
+ * budget, and this caller stopped waiting for it (review P3-1). Nothing was
+ * typed; the launch is left running.
+ */
+class SessionLaunchWaitTimeoutError extends session_start_error_1.SessionStartTimeoutError {
+    constructor(toolName, sessionName, timeoutMs) {
+        super(toolName, sessionName, timeoutMs);
+        this.message =
+            `${toolName} is being started by another request (tmux session '${sessionName}'), and that ` +
+                `launch did not finish within ${Math.round(timeoutMs / 1000)}s — the message was not ` +
+                'delivered and nothing was typed. Retry the send in a few seconds, or run ' +
+                '`commandmate capture <worktree-id>` to see what the launch is waiting on.';
+        this.name = 'SessionLaunchWaitTimeoutError';
+    }
+}
+exports.SessionLaunchWaitTimeoutError = SessionLaunchWaitTimeoutError;
+/** Code of {@link SessionLaunchModelMismatchError}. */
+exports.SESSION_LAUNCH_MODEL_MISMATCH_CODE = 'SESSION_LAUNCH_MODEL_MISMATCH';
+/**
+ * A start asked for a model, and the launch of the session already in
+ * progress is starting with another (review P3-2). Nothing was typed. The
+ * model is fixed when the process starts (#989 / #2771), so joining would
+ * silently run the request on the other model.
+ */
+class SessionLaunchModelMismatchError extends Error {
+    code = exports.SESSION_LAUNCH_MODEL_MISMATCH_CODE;
+    constructor(toolName, sessionName, requested, launching) {
+        super(`${toolName} is being started by another request (tmux session '${sessionName}') with ` +
+            `${launching === undefined ? 'its default model' : `model '${launching}'`}, not '${requested}'. ` +
+            'The model can only be set when starting a new session — the message was not delivered and ' +
+            'nothing was typed. Stop the session and resend with --model to switch models.');
+        this.name = 'SessionLaunchModelMismatchError';
+    }
+}
+exports.SessionLaunchModelMismatchError = SessionLaunchModelMismatchError;
+/** Duck-typed on `code`, like the session-start errors (bundles do not share classes). */
+function isSessionLaunchModelMismatchError(error) {
+    return (error instanceof Error && error.code === exports.SESSION_LAUNCH_MODEL_MISMATCH_CODE);
+}
+/** How long a caller may wait for `flight`, counted from when it began. */
+function launchWaitLimitMs(flight) {
+    return flight.cliToolId === undefined
+        ? (0, session_starting_config_1.getSessionStartingMaxMsAcrossTools)()
+        : (0, session_starting_config_1.getSessionStartingMaxMs)(flight.cliToolId);
+}
+/** `flight`'s outcome, or {@link SessionLaunchWaitTimeoutError} once its budget has run out. */
+function waitForFlight(sessionName, toolName, flight) {
+    const limitMs = launchWaitLimitMs(flight);
+    const remaining = flight.startedAt + limitMs - Date.now();
+    const timedOut = () => {
+        logger.warn('session-launch-wait-timed-out', { sessionName, limitMs });
+        return new SessionLaunchWaitTimeoutError(toolName, sessionName, limitMs);
+    };
+    if (remaining <= 0)
+        return Promise.reject(timedOut());
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(timedOut()), remaining);
+        timer.unref?.();
+        flight.promise.then(() => {
+            clearTimeout(timer);
+            resolve();
+        }, (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+/** Whether a launch of `sessionName` is in progress in this process. */
+function isSessionLaunchInFlight(sessionName) {
+    return flights.has(sessionName);
+}
+/**
+ * Run `launch` as `sessionName`'s only launch.
+ *
+ * When one is already in progress, the caller joins it (same outcome, waited
+ * for within the launch's start budget) instead of starting a second — unless
+ * it asks for a model that launch is not starting with, or holds the session's
+ * input lock (R1); both are refused at once. Registration happens in the same
+ * synchronous step as the check, before `launch` reads anything (R4).
+ *
+ * @throws SessionLaunchModelMismatchError when another launch is in progress with another model
+ * @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
+ */
+function runSessionLaunch(sessionName, toolName, launch, options = {}) {
+    const inFlight = flights.get(sessionName);
+    if (inFlight !== undefined) {
+        if (options.model !== undefined && options.model !== inFlight.model) {
+            logger.info('session-launch-model-mismatch-refused', { sessionName });
+            return Promise.reject(new SessionLaunchModelMismatchError(toolName, sessionName, options.model, inFlight.model));
+        }
+        if ((0, instance_input_lock_1.currentInstanceInputTicket)(sessionName) !== null) {
+            logger.info('session-launch-in-flight-refused', { sessionName });
+            return Promise.reject(new SessionLaunchInFlightError(toolName, sessionName));
+        }
+        logger.info('session-launch-joined', { sessionName });
+        return waitForFlight(sessionName, toolName, inFlight);
+    }
+    // The entry is in the map before `launch` runs a single line. Called in the
+    // caller's async context, so a launcher that holds the lock still owns it
+    // inside the launch (R2).
+    let settle;
+    const promise = new Promise((resolve, reject) => (settle = { resolve, reject }));
+    const flight = {
+        promise,
+        startedAt: Date.now(),
+        cliToolId: options.cliToolId,
+        model: options.model,
+    };
+    flights.set(sessionName, flight);
+    const clear = () => {
+        if (flights.get(sessionName) === flight)
+            flights.delete(sessionName);
+    };
+    promise.then(clear, clear);
+    let running;
+    try {
+        running = launch();
+    }
+    catch (error) {
+        running = Promise.reject(error);
+    }
+    running.then(settle.resolve, settle.reject);
+    return promise;
+}
+/**
+ * The session was killed: a launch still running against it is not one a new
+ * start may join (Issue #3195's case — a launch killed mid-way keeps running
+ * until its readiness wait runs out). The killed launch's own end then leaves
+ * a successor's entry alone.
+ */
+function forgetSessionLaunch(sessionName) {
+    flights.delete(sessionName);
+}
+/**
+ * Wait out a launch of `sessionName` another request has in progress, before
+ * reading whether the session is running (R4). Its outcome is not the caller's:
+ * a launch that failed is left for the caller's own check to find. The wait
+ * ends at the launch's start budget (review P3-1).
+ *
+ * @returns Whether there was a launch to wait for
+ * @throws SessionLaunchInFlightError when there is one and the caller holds the input lock (R1)
+ * @throws SessionLaunchWaitTimeoutError when it outlives its start budget
+ */
+async function settleSessionLaunch(sessionName, toolName) {
+    const inFlight = flights.get(sessionName);
+    if (inFlight === undefined)
+        return false;
+    if ((0, instance_input_lock_1.currentInstanceInputTicket)(sessionName) !== null) {
+        logger.info('session-launch-in-flight-refused', { sessionName });
+        throw new SessionLaunchInFlightError(toolName, sessionName);
+    }
+    await waitForFlight(sessionName, toolName, inFlight).catch((error) => {
+        if (error instanceof SessionLaunchWaitTimeoutError)
+            throw error;
+    });
+    return true;
+}
+/** Forget every launch in progress. Test-only. */
+function resetSessionLaunchFlightsForTest() {
+    flights.clear();
+}

package/dist/server/src/lib/session/session-starting-state.js

@@ -36,6 +36,28 @@
  * key back from its successor. `clearSessionStarting` without a token — the
  * kill-session route — drops the record whoever wrote it.
  *
+ * ## The stops that do not forget (Issue #4032)
+ *
+ * Only the kill-session route clears without a token. The other stops of a
+ * session kill the tmux session directly and call neither this nor
+ * `forgetSessionLaunch`:
+ *
+ *  - `session-cleanup`'s `killWorktreeSession`, for the worktrees a repository
+ *    delete or a `syncWorktreesAndCleanup` removes;
+ *  - `cleanupGlobalSessions`, the `__global__` sessions, on every
+ *    `syncWorktreesAndCleanup` — `commandmate sync`, repository scan and
+ *    restore, and the end of a clone.
+ *
+ * A launch they cut short stays the session's launch until it settles: a
+ * start that comes in meanwhile joins it and gets its outcome (often the
+ * failure of the killed launch), and the "starting" record keeps answering.
+ * The flight is dropped as soon as the killed launch returns or throws, so a
+ * launch that fails fast frees the session early; the launch's own bound
+ * (`getSessionStartingMaxMs`, which #3981 put on a join's wait too) is only the
+ * longest it can last. A server shutdown drops both maps. Recorded rather than
+ * changed (Issue #4032). A stop that should forget calls
+ * `clearSessionStarting` without a token after its kill.
+ *
  * ## The escape hatches
  *
  * A starting display that never ends would hide a stuck launch, which is worse
@@ -74,6 +96,8 @@ const auto_yes_state_1 = require("../../lib/auto-yes-state");
 const status_reason_1 = require("../../lib/detection/status-reason");
 const session_starting_config_1 = require("../../config/session-starting-config");
 const global_state_1 = require("../global-state");
+const session_name_1 = require("../../lib/cli-tools/session-name");
+const session_launch_flight_1 = require("../../lib/session/session-launch-flight");
 const records = (0, global_state_1.getOrInitGlobal)('__sessionStartingRecords', () => new Map());
 /** On `globalThis` like the map, so tokens keep growing across route bundles. */
 const tokenSeq = (0, global_state_1.getOrInitGlobal)('__sessionStartingTokenSeq', () => ({ last: 0 }));
@@ -131,7 +155,8 @@ function markSessionStarting(worktreeId, cliToolId, instanceId, at = Date.now())
  *
  * With a token, only that launch's record is dropped — a launch that was
  * killed and replaced must not end its successor's display (Issue #3195).
- * Without one (kill-session), the record is dropped whoever wrote it.
+ * Without one (kill-session), the record is dropped whoever wrote it, and the
+ * session's launch in progress stops being one a new start joins (Issue #3981).
  *
  * @param worktreeId - Worktree ID
  * @param cliToolId - Tool that was launched
@@ -141,13 +166,24 @@ function markSessionStarting(worktreeId, cliToolId, instanceId, at = Date.now())
 function clearSessionStarting(worktreeId, cliToolId, instanceId, token) {
     try {
         const key = (0, auto_yes_state_1.buildCompositeKey)(worktreeId, cliToolId, instanceId);
-        if (token !== undefined && records.get(key)?.token !== token)
-            return;
-        records.delete(key);
+        if (token === undefined || records.get(key)?.token === token)
+            records.delete(key);
     }
     catch {
         // Nothing was recorded under an id that does not compose into a key.
     }
+    if (token !== undefined)
+        return;
+    // Issue #3981: a killed launch is no longer the session's one launch
+    // (`session-launch-flight`); the next start is a launch of its own. Apart
+    // from the record above, so a name that does not resolve cannot leave the
+    // "starting" display behind (review P3-4).
+    try {
+        (0, session_launch_flight_1.forgetSessionLaunch)((0, session_name_1.resolveSessionName)(cliToolId, worktreeId, instanceId));
+    }
+    catch {
+        // No launch was registered under a name that does not resolve.
+    }
 }
 /** The record's start time while it still answers, else null (dropping an expired one). */
 function activeSince(key, record, now) {

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,7 +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) {
+function buildStructuredPromptQuestion(worktreeId, facts, instanceId, agent) {
+    // Issue #4031: the `respond` this names goes to the instance whose prompt it
+    // 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 ` +
@@ -167,16 +175,16 @@ function buildStructuredPromptQuestion(worktreeId, facts) {
         // Issue #1898. The numbers are real here — they address a decision the
         // agent is holding, not a line on a screen — so the guidance says which one
         // to send instead of warning that none of them can be trusted.
-        parts.push(`Answer it with \`commandmate respond ${worktreeId} <number>\`: ` +
+        parts.push(`Answer it with \`commandmate respond ${worktreeId} <number>${target}\`: ` +
             facts.decisionOptions
                 .map((option) => `${option.number} = ${option.label} (${option.reply})`)
                 .join(', ') +
             `. The reply goes to the agent's own API, so no keys are sent to the terminal ` +
-            `and the label works too (\`respond ${worktreeId} "Allow once"\`).`);
+            `and the label works too (\`respond ${worktreeId} "Allow once"${target}\`).`);
     }
     else {
         parts.push(`Answer it in the terminal, or send the option NUMBER with ` +
-            `\`commandmate respond ${worktreeId} <number>\` — yes/no is not resolved on a numbered ` +
+            `\`commandmate respond ${worktreeId} <number>${target}\` — yes/no is not resolved on a numbered ` +
             `dialog (Issue #1681).`);
     }
     if (facts.message) {
@@ -202,7 +210,7 @@ function buildStructuredPromptQuestion(worktreeId, facts) {
         parts.push(`The agent asked${questionCount > 1 ? ` ${questionCount} questions, the first being` : ''}: ` +
             `"${question}" — offering: ${labels.join(' / ')}. ` +
             (answerable
-                ? `Answer it with \`commandmate respond ${worktreeId} <number>\`: ` +
+                ? `Answer it with \`commandmate respond ${worktreeId} <number>${target}\`: ` +
                     labels.map((label, index) => `${index + 1} = ${label}`).join(', ') +
                     `. The number is this list's own position and the reply goes to the agent's own ` +
                     `API, so no keys are sent to the terminal (the label works too).`
@@ -212,11 +220,11 @@ function buildStructuredPromptQuestion(worktreeId, facts) {
     return parts.join(' ');
 }
 /** The live `promptData` for a structured prompt. */
-function buildStructuredPromptData(worktreeId, facts) {
+function buildStructuredPromptData(worktreeId, facts, instanceId, agent) {
     return {
         type: models_1.UNCLASSIFIED_PROMPT_TYPE,
         status: 'pending',
-        question: buildStructuredPromptQuestion(worktreeId, facts),
+        question: buildStructuredPromptQuestion(worktreeId, facts, instanceId, agent),
         options: [],
         source: facts.source,
         ...(facts.message ? { message: facts.message } : {}),
@@ -238,11 +246,11 @@ function buildStructuredPromptData(worktreeId, facts) {
     };
 }
 /** The prompt-history row for a structured prompt the scraper never saw. */
-function buildStructuredPromptHistoryRecord(worktreeId, facts) {
+function buildStructuredPromptHistoryRecord(worktreeId, facts, instanceId, agent) {
     return {
         type: models_1.UNCLASSIFIED_PROMPT_TYPE,
         status: 'unclassified',
-        question: buildStructuredPromptQuestion(worktreeId, facts),
+        question: buildStructuredPromptQuestion(worktreeId, facts, instanceId, agent),
         options: [],
         source: facts.source,
         ...(facts.message ? { message: facts.message } : {}),

package/dist/server/src/lib/session/waiting-episode-binding.js

@@ -7,7 +7,8 @@
  * it is bound to; the turn model (`agent-event-turn`) knows how each delivery
  * moved the instance's turn. This module joins the two:
  *
- *  - {@link resolveEpisodeBinding} decides what a new episode is bound to, from
+ *  - {@link resolveEpisodeBinding} (defined in `waiting-episode-binding-resolve.ts`,
+ *    imported here) decides what a new episode is bound to, from
  *    the turn model as it stands (design §2.4 規則 1). It is registered with the
  *    store, so an episode `observeWaitingEdge` opens is bound like any other.
  *  - {@link applyTurnOutcomesToEpisode} is the T table (design §2.4): what a
@@ -19,7 +20,8 @@
  *  - {@link captureLegacyStopTarget} / {@link settleLegacyStop} are the one
  *    closer that cannot be synchronous: `/api/hooks/claude-done` names no
  *    session and awaits a capture and a log before it is done (design 規則 6).
- *  - {@link planWaitingObservation} / {@link commitWaitingObservation} are the
+ *  - {@link planWaitingObservation} (defined in `waiting-episode-binding-observation.ts`,
+ *    imported here) / {@link commitWaitingObservation} are the
  *    tables O-1 and O-2 (design §2.4 規則 3・4・5): what one observer's reading
  *    of a frame does to the open episode. The three observers — the status
  *    probe, the response poller and the Auto-Yes poller — fix an

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

@@ -89,6 +89,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');
 /**
@@ -591,6 +592,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-cleanup.js

@@ -29,7 +29,37 @@ const tmux_1 = require("./tmux/tmux");
 const worktrees_1 = require("./git/worktrees");
 const worktree_db_1 = require("./db/worktree-db");
 const session_ownership_1 = require("./cli-tools/session-ownership");
+const session_kill_ledger_1 = require("./verification/session-kill-ledger");
 const logger = (0, logger_1.createLogger)('session-cleanup');
+/**
+ * Record a session the server's cleanup stopped (Issue #3993). env-clean never
+ * excuses a removal on this line — the cleanup runs after a `commandmate sync` a
+ * worker can issue — but names it next to the violation. The session name is
+ * the primary instance's, which is what {@link killWorktreeSession} stops; when
+ * it cannot be resolved the line names none. Best effort: never throws.
+ */
+function recordCleanupKill(worktreeId, cliToolId, sessionName) {
+    let name = sessionName;
+    if (name === undefined) {
+        try {
+            name = manager_1.CLIToolManager.getInstance().getTool(cliToolId).getSessionName(worktreeId);
+        }
+        catch {
+            name = undefined;
+        }
+    }
+    (0, session_kill_ledger_1.appendSessionKillRecord)({
+        version: session_kill_ledger_1.SESSION_KILL_LEDGER_VERSION,
+        at: Date.now(),
+        api: 'session-cleanup',
+        origin: 'server',
+        worktreeId,
+        instanceId: cliToolId,
+        sessionNames: name ? [name] : [],
+        callerCwd: null,
+        callerSession: null,
+    });
+}
 /**
  * Clean up all CLI tool sessions and pollers for a single worktree
  *
@@ -65,6 +95,7 @@ async function cleanupWorktreeSessions(worktreeId, killSessionFn) {
             if (killed) {
                 result.sessionsKilled.push(cliToolId);
                 logger.info('session:killed', { worktreeId, cliToolId });
+                recordCleanupKill(worktreeId, cliToolId);
             }
         }
         catch (error) {
@@ -234,6 +265,7 @@ async function cleanupGlobalSessions() {
                 if (killed) {
                     sessionsKilled++;
                     logger.info('global-session:killed', { cliToolId, sessionName });
+                    recordCleanupKill(global_session_constants_1.GLOBAL_SESSION_WORKTREE_ID, cliToolId, sessionName);
                 }
             }
         }

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

@@ -9,7 +9,6 @@
  * claude-session.ts -> session-key-sender.ts -> tmux.ts
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sanitizeSessionEnvironment = sanitizeSessionEnvironment;
 exports.waitForPrompt = waitForPrompt;
 exports.sendMessageToSession = sendMessageToSession;
 exports.stopSession = stopSession;
@@ -19,11 +18,8 @@ const submit_verified_sender_1 = require("./cli-tools/submit-verified-sender");
 const tmux_capture_cache_1 = require("./tmux/tmux-capture-cache");
 const errors_1 = require("./errors");
 const cli_tool_timing_config_1 = require("../config/cli-tool-timing-config");
-const child_process_1 = require("child_process");
-const util_1 = require("util");
 const logger_1 = require("../lib/logger");
 const logger = (0, logger_1.createLogger)('session-key-sender');
-const execAsync = (0, util_1.promisify)(child_process_1.exec);
 /**
  * Capture tmux pane output and strip ANSI escape sequences
  *
@@ -43,29 +39,6 @@ async function getCleanPaneOutput(sessionName, lines = 50) {
  */
 const PROMPT_POLL_INTERVAL = 200;
 // =============================================================================
-// Environment Sanitization
-// =============================================================================
-/**
- * Remove CLAUDECODE environment variable from tmux session environment
- * Prevents Claude Code from detecting nested session and refusing to start
- * (SF-002: SRP - environment sanitization separated from session creation)
- *
- * MF-S3-002: tmux set-environment -g -u operates on the global tmux environment.
- *
- * SEC-SF-001: sessionName is validated by the caller chain:
- * ClaudeTool.startSession() -> BaseCLITool.getSessionName() -> validateSessionName()
- *
- * @param sessionName - tmux session name
- */
-async function sanitizeSessionEnvironment(sessionName) {
-    // 3-1: Remove from tmux global environment
-    await execAsync('tmux set-environment -g -u CLAUDECODE 2>/dev/null || true');
-    // 3-2: Unset inside the session shell (safety net)
-    // 100ms wait: empirically determined time for sendKeys command to reach the shell
-    await (0, tmux_1.sendKeys)(sessionName, 'unset CLAUDECODE', true);
-    await new Promise(resolve => setTimeout(resolve, cli_tool_timing_config_1.CLAUDE_ENV_SANITIZE_WAIT_MS));
-}
-// =============================================================================
 // Prompt Wait
 // =============================================================================
 /**
@@ -97,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) {
@@ -121,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);