commandmate 0.44.1 → 0.44.3

package/dist/server/src/lib/session/agent-session-lifecycle.js

@@ -44,6 +44,7 @@ const sources_1 = require("../../lib/hooks/sources");
 const agent_event_state_1 = require("../../lib/session/agent-event-state");
 const session_generation_archive_1 = require("../../lib/session/session-generation-archive");
 const session_starting_state_1 = require("../../lib/session/session-starting-state");
+const auto_yes_enter_fallback_state_1 = require("../../lib/polling/auto-yes-enter-fallback-state");
 const logger_1 = require("../../lib/logger");
 const logger = (0, logger_1.createLogger)('lib/session/agent-session-lifecycle');
 /**
@@ -79,6 +80,10 @@ function beginAgentSession(target, at = Date.now()) {
     (0, session_starting_state_1.markSessionStarting)(target.worktreeId, target.cliToolId, target.instanceId, at);
     const before = (0, agent_event_state_1.getAgentEventDropCounts)(target.worktreeId, target.cliToolId, target.instanceId).decisionEvicted;
     (0, agent_event_state_1.beginAgentEventGeneration)(target.worktreeId, target.cliToolId, target.instanceId, at);
+    // Issue #3397: Auto-Yes's Enter belongs to the process whose screen it went
+    // to. A relaunch does not stop the Auto-Yes poller, so the record (and the
+    // poller's keys, through the epoch) are expired here, with the generation.
+    (0, auto_yes_enter_fallback_state_1.beginEnterFallbackSession)(target.worktreeId, target.cliToolId, target.instanceId);
     const after = (0, agent_event_state_1.getAgentEventDropCounts)(target.worktreeId, target.cliToolId, target.instanceId).decisionEvicted;
     const source = (0, sources_1.getAgentEventSource)(target.cliToolId);
     logger.info('agent-session-generation-begun', {
@@ -120,8 +125,12 @@ function beginAgentSession(target, at = Date.now()) {
  * does not import a settings generator: which file gets written, and whether
  * one gets written at all, is the source's business.
  *
- * Never throws — see `AgentEventSource.prepareLaunch`. A tool whose config
- * could not be written starts bare, which is the pre-#1722 status quo.
+ * Never throws outside UAT isolation — see `AgentEventSource.prepareLaunch`. A
+ * tool whose config could not be written starts bare, which is the pre-#1722
+ * status quo. Under `CM_UAT_ISOLATION=1` codex and antigravity throw instead
+ * (Issue #3360), and under `own-home` claude too when its settings directory
+ * is outside the dedicated user's HOME (Issue #3312), so call this before
+ * creating the tmux session.
  *
  * @param context - The instance, its executable, and the worktree it runs in
  * @returns The command, its environment, and the config file when one landed

package/dist/server/src/lib/session/chat-turn-progress.js

@@ -0,0 +1,322 @@
+"use strict";
+/**
+ * Chat turn progress: the frames that carry the body of an open turn
+ * (Issue #3215).
+ *
+ * Moved verbatim out of `current-output-builder`, which re-exports every name
+ * it used to export, so an import from either module reads the same
+ * declaration. The comments came along unedited: where one says "this file" or
+ * "this module", it was written about `current-output-builder`.
+ *
+ * `publishChatTurnProgress` is exported for `buildCurrentOutput` and for
+ * nothing else; it is not part of what `current-output-builder` re-exports.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetChatTurnProgressState = resetChatTurnProgressState;
+exports.buildChatTurnProgress = buildChatTurnProgress;
+exports.emitChatTurnProgress = emitChatTurnProgress;
+exports.publishChatTurnProgress = publishChatTurnProgress;
+const types_1 = require("../../lib/realtime/types");
+const logger_1 = require("../../lib/logger");
+const global_state_1 = require("../global-state");
+// Issue #3215: the name is the one these lines have always been logged under.
+// It is what an operator greps for, so it did not move with the code.
+const logger = (0, logger_1.createLogger)('current-output-builder');
+function newChatTurnProgressState() {
+    return {
+        version: 0,
+        askedAt: Number.NEGATIVE_INFINITY,
+        turnKey: null,
+        body: null,
+        loggedOutcome: null,
+        loggedTurnKey: null,
+    };
+}
+/**
+ * On `globalThis` for the reason every shared map in this subsystem is (#1736):
+ * under `next dev` the poller's bundle and the opencode subscription's bundle
+ * would each get a private copy, and two producers throttling against two
+ * different maps is no throttle at all.
+ */
+const chatTurnProgressState = (0, global_state_1.getOrInitGlobal)('__chatTurnProgressState', () => new Map());
+function chatTurnProgressKey(target) {
+    return `${target.worktreeId}:${target.cliToolId}:${target.instanceId ?? target.cliToolId}`;
+}
+/** Forget every instance's progress bookkeeping. Test seam. */
+function resetChatTurnProgressState() {
+    chatTurnProgressState.clear();
+}
+/**
+ * Say once, at info, what happened to this instance's progress frames (Issue #2248).
+ *
+ * ## Why info, and why this file had none
+ *
+ * Every outcome here was `logger.debug`, including the two that mean the reader
+ * is watching a blank space: a push that threw, and a room with no subscribers.
+ * Issue #2248 was opened after a live session where the body reached the browser
+ * — or did not — and the server logs could not answer which, because debug is
+ * off in the builds people run. An unobservable push is a feature that can only
+ * be debugged by reproducing it.
+ *
+ * ## Why once
+ *
+ * The publisher runs on EVERY poll tick of a generating session. Logging each
+ * tick at info would put a line per second per agent into the operator's log and
+ * make the level useless, so this collapses a run of identical ticks into its
+ * first: the outcome and the turn it happened on are the identity, and a repeat
+ * of the pair says nothing the first line did not.
+ *
+ * The consequences of that identity, both deliberate:
+ *
+ *  - **a new turn always logs**, because `turnKey` is part of the pair. That is
+ *    the acceptance criterion — one info line per turn — and the reason
+ *    `loggedTurnKey` exists at all rather than a bare boolean;
+ *  - **a CHANGE of outcome always logs**, so "the subscriber left" and "it
+ *    started failing" are both visible the tick they happen, without the
+ *    steady state that follows repeating them.
+ *
+ * `no-subscribers` and `failed` carry no turn key — neither knows one; the first
+ * returns before the source is asked and the second is why there is no frame —
+ * so for them the pair is `(outcome, null)` and the run collapses to one line
+ * until something else happens.
+ */
+function logChatTurnProgressOutcome(target, outcome, turnKey, extra = {}) {
+    const key = chatTurnProgressKey(target);
+    const state = chatTurnProgressState.get(key) ?? newChatTurnProgressState();
+    chatTurnProgressState.set(key, state);
+    if (state.loggedOutcome === outcome && state.loggedTurnKey === turnKey)
+        return;
+    state.loggedOutcome = outcome;
+    state.loggedTurnKey = turnKey;
+    // Written out rather than interpolated: these strings are what an operator
+    // greps the log for, and an interpolated name cannot be found in the source.
+    const message = outcome === 'published'
+        ? 'chat-turn-progress-published'
+        : outcome === 'no-subscribers'
+            ? 'chat-turn-progress-no-subscribers'
+            : 'chat-turn-progress-failed';
+    logger.info(message, {
+        worktreeId: target.worktreeId,
+        cliToolId: target.cliToolId,
+        instanceId: target.instanceId ?? target.cliToolId,
+        turnKey,
+        ...extra,
+    });
+}
+/**
+ * Decide whether this instance has a new progress frame, and build it.
+ *
+ * The single generator both tools go through, on the same argument
+ * {@link buildCurrentOutput} makes for the terminal payload: two producers of one
+ * wire shape drift, and the drift is invisible because each of them is
+ * individually correct. Three rules, in this order, and each of them is a way
+ * this feature goes wrong if it is missing:
+ *
+ *  1. **Throttle.** At most one *ask* per {@link CHAT_TURN_PROGRESS_MIN_INTERVAL_MS}
+ *     per instance. It gates the ask rather than the send because the source is
+ *     the expensive half (see {@link ChatTurnProgressSource}); a gate on the send
+ *     alone would re-read a 4 MiB transcript to discover it had not changed.
+ *  2. **No-change suppression.** Same turn, same body → no frame. A reply that
+ *     has stopped growing must not keep waking every subscribed browser.
+ *  3. **Monotonic version**, per instance and NOT per turn. A client drops
+ *     anything at or below what it has already rendered, and restarting the
+ *     counter on a new turn would make the first frame of turn N+1 look stale
+ *     against the last frame of turn N.
+ *
+ * The body is bounded by {@link truncateChatTurnProgressBody}, whose cut is
+ * folded into `partial` together with the reader's own — see
+ * {@link ChatTurnProgressEvent.partial} for why one flag answers both.
+ *
+ * Never throws: a source that throws is a turn with nothing to show, not a
+ * broken poll tick.
+ *
+ * @param target - The instance
+ * @param source - Asked only when the throttle allows it
+ * @param now - Epoch ms; injected by the tests
+ * @returns The frame to broadcast, or null when there is nothing new to say
+ */
+async function buildChatTurnProgress(target, source, now = Date.now()) {
+    const key = chatTurnProgressKey(target);
+    const state = chatTurnProgressState.get(key) ?? newChatTurnProgressState();
+    if (now - state.askedAt < types_1.CHAT_TURN_PROGRESS_MIN_INTERVAL_MS)
+        return null;
+    state.askedAt = now;
+    chatTurnProgressState.set(key, state);
+    let draft;
+    try {
+        draft = await source();
+    }
+    catch {
+        // The readers already promise never to throw; this is the belt for the
+        // dynamic import that reaches them.
+        return null;
+    }
+    if (!draft || draft.body.length === 0)
+        return null;
+    const bounded = (0, types_1.truncateChatTurnProgressBody)(draft.body);
+    if (draft.turnKey === state.turnKey && bounded.body === state.body)
+        return null;
+    state.turnKey = draft.turnKey;
+    state.body = bounded.body;
+    state.version += 1;
+    return {
+        type: types_1.CHAT_TURN_PROGRESS_EVENT_TYPE,
+        worktreeId: target.worktreeId,
+        cliToolId: target.cliToolId,
+        instanceId: target.instanceId ?? target.cliToolId,
+        turnKey: draft.turnKey,
+        body: bounded.body,
+        partial: bounded.truncated || draft.partial === true,
+        version: state.version,
+        done: false,
+    };
+}
+/**
+ * Build a progress frame and push it to the worktree room.
+ *
+ * Subscribers are checked FIRST, before the throttle state is touched and long
+ * before the source is asked, so a session nobody is watching costs one map
+ * lookup per tick — the same bargain `broadcastTerminalSnapshot` strikes, and
+ * the reason a 4 MiB transcript read does not happen for every claude session on
+ * the machine.
+ *
+ * The `ws-server` import is dynamic so this module's *other* callers — the
+ * `/current-output` route and `commandmate capture` — do not pull the WebSocket
+ * server into their graph just by building a payload.
+ *
+ * Never throws; a failed push is a moment of staleness on a surface that has the
+ * settled row coming anyway.
+ *
+ * @returns Whether a frame was broadcast
+ */
+async function emitChatTurnProgress(target, source, now = Date.now()) {
+    try {
+        const { broadcast, hasRoomSubscribers } = await Promise.resolve().then(() => __importStar(require('../../lib/ws-server')));
+        if (!hasRoomSubscribers(target.worktreeId)) {
+            // Issue #2248. Reported, not silent: "the body never reached the browser"
+            // and "nobody was listening" look identical from a screenshot, and this is
+            // the only place that can tell them apart.
+            logChatTurnProgressOutcome(target, 'no-subscribers', null);
+            return false;
+        }
+        const event = await buildChatTurnProgress(target, source, now);
+        // Not logged: null is the throttle, an unchanged body, or a turn with no
+        // text yet — the quiet, correct majority of ticks.
+        if (!event)
+            return false;
+        broadcast(target.worktreeId, event);
+        logChatTurnProgressOutcome(target, 'published', event.turnKey, {
+            version: event.version,
+            bodyLength: event.body.length,
+            partial: event.partial,
+        });
+        return true;
+    }
+    catch (error) {
+        logChatTurnProgressOutcome(target, 'failed', null, {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return false;
+    }
+}
+/**
+ * Ask the tool that has a transcript for the body of its open turn (Issue #2199).
+ *
+ * claude only, and that is a statement about which tools have a *pull* reader
+ * rather than a list to extend by hand. opencode's body arrives on its own SSE
+ * stream and is published from `sources/opencode/history` at the moment a part
+ * lands — polling for it here would be a second producer of the same frames.
+ * codex and antigravity have neither, and stay on the indicator (#2197 / #2198).
+ *
+ * The reader is imported dynamically so `sources/claude/history` — and through
+ * it `fs/promises`, the session-pointer latch and `user-turn-recorder` — stays
+ * out of the module graph of the `/current-output` route and of `commandmate
+ * capture`, both of which reach this file for a payload and nothing else.
+ *
+ * ## Which half the caller waits for (Issue #2248)
+ *
+ * The caller awaits the CHEAP half — the worktree row and "is anybody watching"
+ * — and not the expensive one. That split is what `void` was protecting in the
+ * first place: the 4 MiB transcript read, the JSONL parse, the render and the
+ * broadcast still run detached, so no poll tick and no WebSocket snapshot waits
+ * on them.
+ *
+ * What awaiting the prelude buys is the reason this Issue exists: the line that
+ * says whether anybody received the frame is written while the tick it belongs
+ * to is still the tick in progress. Left inside the detached half it landed
+ * wherever the event loop happened to get to it, next to some unrelated
+ * request's output, which is not a log an operator can read backwards.
+ *
+ * Never throws: `emitChatTurnProgress` swallows, and so does this.
+ */
+async function publishChatTurnProgress(db, worktreeId, cliToolId, instanceId) {
+    if (cliToolId !== 'claude')
+        return;
+    const target = { worktreeId, cliToolId, instanceId };
+    try {
+        // The slug the transcript directory is named after is a function of the
+        // worktree's path, so the row is what makes the file findable at all. Read
+        // before the throttle only because it is a single indexed lookup against a
+        // connection this function was handed; everything expensive is behind the
+        // gate.
+        const { getWorktreeById } = await Promise.resolve().then(() => __importStar(require('../../lib/db/worktree-db')));
+        const worktreePath = getWorktreeById(db, worktreeId)?.path;
+        if (!worktreePath)
+            return;
+        // Issue #2248. Hoisted out of `emitChatTurnProgress` — which still makes the
+        // same check for its other caller — so the answer, and the line that reports
+        // it, are settled before this function returns. Costs one Map lookup on the
+        // sessions nobody is watching, which is the bargain that was already being
+        // struck one frame later.
+        const { hasRoomSubscribers } = await Promise.resolve().then(() => __importStar(require('../../lib/ws-server')));
+        if (!hasRoomSubscribers(worktreeId)) {
+            logChatTurnProgressOutcome(target, 'no-subscribers', null);
+            return;
+        }
+        // Detached on purpose: everything past this point is the transcript read.
+        void emitChatTurnProgress(target, async () => {
+            const { readClaudeTurnProgress } = await Promise.resolve().then(() => __importStar(require('../../lib/hooks/sources/claude/history')));
+            return readClaudeTurnProgress({ worktreeId, cliToolId, instanceId: instanceId ?? cliToolId }, { worktreePath });
+        });
+    }
+    catch (error) {
+        // Issue #2248: the reader's half of the same failure — the worktree row or
+        // one of the dynamic imports — on the same once-per-run gate as the push's.
+        logChatTurnProgressOutcome(target, 'failed', null, {
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}

package/dist/server/src/lib/session/claude-executor.js

@@ -28,14 +28,17 @@ exports.readCommandCodeStream = readCommandCodeStream;
 exports.describeCommandCodeBlockedToolCalls = describeCommandCodeBlockedToolCalls;
 exports.readExecutionLogWarning = readExecutionLogWarning;
 exports.describeCommandCodeFailure = describeCommandCodeFailure;
+exports.uatIsolationHeadlessRefusal = uatIsolationHeadlessRefusal;
 exports.executeClaudeCommand = executeClaudeCommand;
 exports.getActiveProcesses = getActiveProcesses;
 const child_process_1 = require("child_process");
+const uat_isolation_1 = require("../../config/uat-isolation");
 const env_sanitizer_1 = require("../../lib/security/env-sanitizer");
 const cli_patterns_1 = require("../../lib/detection/cli-patterns");
 const types_1 = require("../../lib/cli-tools/types");
 const schedule_config_1 = require("../../config/schedule-config");
 const opencode_executable_1 = require("../../lib/cli-tools/opencode-executable");
+const global_state_1 = require("../global-state");
 // =============================================================================
 // Constants
 // =============================================================================
@@ -335,7 +338,15 @@ function buildCliArgs(message, cliToolId, permission, options) {
         }
         case 'claude':
         default:
-            return ['-p', message, '--output-format', 'text', '--permission-mode', permission ?? 'acceptEdits'];
+            {
+                const args = ['-p', message, '--output-format', 'text', '--permission-mode', permission ?? 'acceptEdits'];
+                // Issue #3360: the interactive launch's restriction, for `claude -p` too
+                // (Schedules, daily summary): under UAT isolation the user's own
+                // settings.json — whose hooks post to production — is not loaded.
+                if ((0, uat_isolation_1.isUatIsolationEnabled)())
+                    args.push('--setting-sources', uat_isolation_1.CLAUDE_UAT_SETTING_SOURCES);
+                return args;
+            }
     }
 }
 // =============================================================================
@@ -792,6 +803,33 @@ function describeCommandCodeFailure(exitCode, result) {
  * @param options - Additional options (e.g., model for vibe-local)
  * @returns Execution result with output and status
  */
+/**
+ * Why a headless run of `cliToolId` may not happen under `CM_UAT_ISOLATION=1`,
+ * or null when it may (Issue #3360).
+ *
+ * `codex exec` and `agy -p` read the user's shared hook config —
+ * `$CODEX_HOME/hooks.json` and `~/.gemini/config/hooks.json`, the trusted files
+ * the production server wrote — whatever this process passes. A headless run is
+ * started with none of the correlation keys or receiver URLs an interactive
+ * launch puts in its environment, so those hooks fall back to the relay's
+ * default port, which is the production server's. There is no per-run way to turn
+ * them off or point them elsewhere, so in isolation the run is refused rather
+ * than allowed to reach production. claude's `-p` is not here: it gets
+ * `--setting-sources project,local` in {@link buildCliArgs}.
+ */
+function uatIsolationHeadlessRefusal(cliToolId) {
+    if (!(0, uat_isolation_1.isUatIsolationEnabled)())
+        return null;
+    const shared = UAT_ISOLATION_SHARED_HOOK_FILES[cliToolId];
+    if (!shared)
+        return null;
+    return new uat_isolation_1.UatIsolationLaunchRefusedError(`a headless ${cliToolId} run`, `it reads the shared ${shared} and its hooks post to the relay's default port (the production server); see docs/user-guide/uat-isolation.md`, 'Headless codex / antigravity runs (Schedules, daily summary) cannot be isolated; skip those scenarios in a UAT.').message;
+}
+/** Tools whose headless run reads a hook config shared with production (Issue #3360). */
+const UAT_ISOLATION_SHARED_HOOK_FILES = {
+    codex: '$CODEX_HOME/hooks.json',
+    antigravity: '~/.gemini/config/hooks.json',
+};
 async function executeClaudeCommand(message, cwd, cliToolId = 'claude', permission, options) {
     // Validate cliToolId against whitelist [SEC-001]
     if (!exports.ALLOWED_CLI_TOOLS.has(cliToolId)) {
@@ -802,6 +840,11 @@ async function executeClaudeCommand(message, cwd, cliToolId = 'claude', permissi
             error: `Invalid CLI tool: ${cliToolId}`,
         };
     }
+    // Issue #3360: refused under UAT isolation before anything is spawned.
+    const refusal = uatIsolationHeadlessRefusal(cliToolId);
+    if (refusal) {
+        return { output: refusal, exitCode: null, status: 'failed', error: refusal };
+    }
     // Validate message length
     const truncatedMessage = message.length > exports.MAX_MESSAGE_LENGTH
         ? message.substring(0, exports.MAX_MESSAGE_LENGTH)
@@ -984,8 +1027,5 @@ async function executeClaudeCommand(message, cwd, cliToolId = 'claude', permissi
  * Uses globalThis for hot reload persistence.
  */
 function getActiveProcesses() {
-    if (!globalThis.__scheduleActiveProcesses) {
-        globalThis.__scheduleActiveProcesses = new Map();
-    }
-    return globalThis.__scheduleActiveProcesses;
+    return (0, global_state_1.getOrInitGlobal)('__scheduleActiveProcesses', () => new Map());
 }

package/dist/server/src/lib/session/claude-session.js

@@ -10,13 +10,11 @@ exports.isSessionHealthy = isSessionHealthy;
 exports.getSessionName = getSessionName;
 exports.isClaudeInstalled = isClaudeInstalled;
 exports.isClaudeRunning = isClaudeRunning;
-exports.getClaudeSessionState = getClaudeSessionState;
 exports.waitForPrompt = waitForPrompt;
 exports.startClaudeSession = startClaudeSession;
 exports.sendMessageToClaude = sendMessageToClaude;
 exports.captureClaudeOutput = captureClaudeOutput;
 exports.stopClaudeSession = stopClaudeSession;
-exports.restartClaudeSession = restartClaudeSession;
 const tmux_1 = require("../../lib/tmux/tmux");
 const cli_patterns_1 = require("../../lib/detection/cli-patterns");
 const tool_liveness_1 = require("../../lib/detection/tool-liveness");
@@ -28,7 +26,6 @@ const util_1 = require("util");
 const promises_1 = require("fs/promises");
 const logger_1 = require("../../lib/logger");
 const session_ownership_1 = require("../../lib/cli-tools/session-ownership");
-const cli_tool_timing_config_1 = require("../../config/cli-tool-timing-config");
 const session_name_1 = require("../../lib/cli-tools/session-name");
 const sources_1 = require("../../lib/hooks/sources");
 const hook_settings_generator_1 = require("../../lib/hooks/hook-settings-generator");
@@ -347,7 +344,7 @@ async function getClaudePath() {
                 return cachedClaudePath;
             }
             catch {
-                logger.info('claudepath-is-not-executable:envclaudepa');
+                logger.info('claude-path-env-not-executable');
                 // Fall through to fallback paths
             }
         }
@@ -453,7 +450,7 @@ async function isSessionHealthy(sessionName) {
 async function ensureHealthySession(sessionName) {
     const result = await isSessionHealthy(sessionName);
     if (!result.healthy) {
-        logger.warn('session-sessionname-unhealthy:resultreas');
+        logger.warn('claude-session-unhealthy');
         await (0, tmux_1.killSession)(sessionName);
         return false;
     }
@@ -528,35 +525,11 @@ async function isClaudeRunning(worktreeId, instanceId) {
     // S2-F001: await + extract .healthy to maintain boolean return type
     const result = await isSessionHealthy(sessionName);
     if (!result.healthy) {
-        logger.warn('session-sessionname-unhealthy:resultreas');
+        logger.warn('claude-session-unhealthy');
         return false;
     }
     return true;
 }
-/**
- * Get Claude session state
- *
- * C-S3-002: This function checks tmux session existence via hasSession() but
- * does NOT perform health checks (unlike isClaudeRunning()). This is intentional:
- * getClaudeSessionState() is a lightweight status query for UI display purposes,
- * while isClaudeRunning() performs the more expensive health check for operational
- * decisions (e.g., whether to recreate a session).
- *
- * If health-aware state is needed, callers should use isClaudeRunning() instead
- * or call ensureHealthySession() separately.
- *
- * @param worktreeId - Worktree ID
- * @returns Session state information (existence-based, not health-based)
- */
-async function getClaudeSessionState(worktreeId, instanceId) {
-    const sessionName = getSessionName(worktreeId, instanceId);
-    const isRunning = await (0, tmux_1.hasSession)(sessionName);
-    return {
-        sessionName,
-        isRunning,
-        lastActivity: new Date(),
-    };
-}
 /**
  * Wait for session to be at prompt state
  * Delegates to session-key-sender.ts (Issue #479: SRP split)
@@ -615,7 +588,7 @@ async function startClaudeSession(options) {
         const healthy = await ensureHealthySession(sessionName);
         if (healthy) {
             await (0, tmux_1.reconcileSessionGeometry)(sessionName);
-            logger.info('claude-session-sessionname');
+            logger.info('claude-session-exists');
             return;
         }
         // If not healthy, ensureHealthySession() already killed the session.
@@ -639,16 +612,6 @@ async function startClaudeSession(options) {
     // making it the helper's job is what lets Phase 4-2…4-5 have one too.
     (0, agent_session_lifecycle_1.beginAgentSession)({ worktreeId, cliToolId: sources_1.CLAUDE_CLI_TOOL_ID, instanceId });
     try {
-        // Create tmux session. Scrollback depth comes from the shared
-        // TMUX_HISTORY_LIMIT default (Issue #1624) — do not re-hardcode it here.
-        // (Claude itself renders in the alternate screen and keeps history_size at 0,
-        // so the limit is inert for this tool; it still applies to the bare shell.)
-        await (0, tmux_1.createSession)({
-            sessionName,
-            workingDirectory: worktreePath,
-        });
-        // SF-S2-003: Sanitize environment after createSession, before launching Claude CLI
-        await (0, session_key_sender_1.sanitizeSessionEnvironment)(sessionName);
         // Get Claude CLI path dynamically
         const claudePath = await getClaudePath();
         // Issue #1722: hand this session its own hooks config, so structured
@@ -668,6 +631,11 @@ async function startClaudeSession(options) {
         // Issue #1759: which config file gets written, and whether one is written
         // at all, belongs to the tool's `AgentEventSource` (S3/S4). Claude's
         // delegates to `buildClaudeLaunchCommand`, unchanged.
+        //
+        // Issue #3312: built BEFORE the tmux session, as codex's is. Under
+        // `CM_UAT_ISOLATION=own-home` the plan throws `UatIsolationLaunchRefusedError`
+        // (wrong user / HOME / write target, or a settings file it could not
+        // write), and a refused launch must not leave an empty pane behind.
         const baseLaunchCommand = (0, agent_session_lifecycle_1.buildAgentLaunchCommandLine)({
             target: { worktreeId, cliToolId: sources_1.CLAUDE_CLI_TOOL_ID, instanceId },
             executablePath: claudePath,
@@ -679,6 +647,16 @@ async function startClaudeSession(options) {
         // The flag outranks a `model` in the worktree's `.claude/settings.local.json`
         // and the operator's `~/.claude/settings.json` (measured on 2.1.278).
         const launchCommand = model === undefined ? baseLaunchCommand : `${baseLaunchCommand} --model ${(0, hook_settings_generator_1.shellQuote)(model)}`;
+        // Create tmux session. Scrollback depth comes from the shared
+        // TMUX_HISTORY_LIMIT default (Issue #1624) — do not re-hardcode it here.
+        // (Claude itself renders in the alternate screen and keeps history_size at 0,
+        // so the limit is inert for this tool; it still applies to the bare shell.)
+        await (0, tmux_1.createSession)({
+            sessionName,
+            workingDirectory: worktreePath,
+        });
+        // SF-S2-003: Sanitize environment after createSession, before launching Claude CLI
+        await (0, session_key_sender_1.sanitizeSessionEnvironment)(sessionName);
         // Start Claude CLI in interactive mode using dynamically resolved path
         await (0, tmux_1.sendKeys)(sessionName, (0, launch_screen_1.withLaunchScreenCleared)(launchCommand), true);
         // Wait for Claude to initialize with dynamic detection (OCP-001)
@@ -713,7 +691,7 @@ async function startClaudeSession(options) {
             if (!trustDialogOpen && cli_patterns_1.CLAUDE_PROMPT_PATTERN.test(cleanOutput)) {
                 // Wait for stability after prompt detection (CONS-007, DOC-001)
                 await new Promise((resolve) => setTimeout(resolve, exports.CLAUDE_POST_PROMPT_DELAY));
-                logger.info('claude-initialized-in');
+                logger.info('claude-initialized');
                 initialized = true;
                 break;
             }
@@ -752,7 +730,7 @@ async function startClaudeSession(options) {
         if (!initialized) {
             throw new session_start_error_1.SessionStartTimeoutError('Claude Code', sessionName, exports.CLAUDE_INIT_TIMEOUT);
         }
-        logger.info('started-claude-session:sessionname');
+        logger.info('started-claude-session');
     }
     catch (error) {
         // MF-S2-002: Clear cached path on all failures (harmless for non-path failures)
@@ -840,25 +818,3 @@ async function stopClaudeSession(worktreeId, instanceId) {
     (0, agent_event_state_1.discardAgentEventState)(worktreeId, 'claude', instanceId);
     return stopped;
 }
-/**
- * Restart a Claude session
- *
- * @param options - Session options
- *
- * @example
- * ```typescript
- * await restartClaudeSession({
- *   worktreeId: 'feature-foo',
- *   worktreePath: '/path/to/worktree',
- * });
- * ```
- */
-async function restartClaudeSession(options) {
-    const { worktreeId, instanceId } = options;
-    // Stop existing session
-    await stopClaudeSession(worktreeId, instanceId);
-    // Wait a moment before restarting
-    await new Promise((resolve) => setTimeout(resolve, cli_tool_timing_config_1.CLAUDE_RESTART_DELAY_MS));
-    // Start new session
-    await startClaudeSession(options);
-}

package/dist/server/src/lib/session/cli-session.js

@@ -13,6 +13,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSessionRunning = isSessionRunning;
+exports.getSessionPresence = getSessionPresence;
 exports.captureSessionOutput = captureSessionOutput;
 exports.captureSessionOutputFresh = captureSessionOutputFresh;
 exports.getSessionName = getSessionName;
@@ -29,6 +30,7 @@ const tmux_capture_cache_1 = require("../../lib/tmux/tmux-capture-cache");
 // zero"), and this module already imports from `lib/tmux/**` above.
 const session_hooks_1 = require("../../lib/tmux/session-hooks");
 const session_status_options_1 = require("../../lib/tmux/session-status-options");
+const tmux_1 = require("../../lib/tmux/tmux");
 const tmux_session_surface_1 = require("./tmux-session-surface");
 const logger = (0, logger_1.createLogger)('cli-session');
 function getDefaultTransport() {
@@ -52,6 +54,21 @@ async function isSessionRunning(worktreeId, cliToolId, instanceId) {
     const { sessionName } = resolveSessionContext(worktreeId, cliToolId, instanceId);
     return getDefaultTransport().sessionExists(sessionName);
 }
+/**
+ * Whether the CLI tool session exists, keeping "could not tell" apart from
+ * "absent" (Issue #3329). Asks tmux directly rather than through the transport:
+ * both transports answer `sessionExists` with the same `tmux has-session`, and
+ * that boolean is exactly what loses the difference.
+ *
+ * @param worktreeId - Worktree ID
+ * @param cliToolId - CLI tool ID
+ * @param instanceId - Optional agent instance ID (defaults to primary)
+ * @returns `present`, `absent`, or `unknown`
+ */
+async function getSessionPresence(worktreeId, cliToolId, instanceId) {
+    const { sessionName } = resolveSessionContext(worktreeId, cliToolId, instanceId);
+    return (0, tmux_1.probeSession)(sessionName);
+}
 /**
  * Capture CLI session output (cache-backed)
  *