@rynx-ai/runtime 0.1.11-beta.2 → 0.1.11-beta.4

package/dist/host.d.ts

@@ -191,6 +191,7 @@ export declare class LocalAgentHost implements CodexCapabilities {
         args: string[];
         cwd: string;
         env?: Record<string, string>;
+        skipTraexStartupPrompts?: boolean;
     } | null>;
     /**
      * Bring up (idempotently) a session's persistent codex forwarder and emit its

package/dist/host.js

@@ -279,7 +279,7 @@ export class LocalAgentHost {
         this.runtimeHomeSessionId = runtimeHomeSessionId ?? this.sessionId;
         this.sessionStore = sessionStore;
         this.allowedRoots = allowedRoots;
-        this.defaultRuntime = config.AGENT_RUNTIME ?? "codex";
+        this.defaultRuntime = config.DEFAULT_RUNTIME ?? "codex";
         this.injectedCommandRunner = commandRunner;
         this.injectedAppServerClient = appServerClient;
         this.clock = now;
@@ -472,6 +472,9 @@ export class LocalAgentHost {
         // to the same effective sandbox.
         const sandbox = live?.sandbox ?? this.sessionSandbox ?? this.config.AGENT_SANDBOX;
         const approvalPolicy = live?.approvalPolicy ?? this.sessionApprovalPolicy ?? this.config.AGENT_APPROVAL_POLICY;
+        const traexYolo = runtime === "traex" &&
+            sandbox === "danger-full-access" &&
+            approvalPolicy === "never";
         const configOverrides = sandbox === "workspace-write"
             ? ["sandbox_workspace_write.network_access=true"]
             : [];
@@ -500,9 +503,11 @@ export class LocalAgentHost {
                 remoteUrl,
                 ...(activeThreadId ? { threadId: activeThreadId } : {}),
                 configOverrides,
+                codexArgs: traexYolo ? ["--dangerously-bypass-hook-trust"] : [],
                 additionalDirs: providerAdditionalDirs(live.workspace),
             }),
             cwd: live.workspace.cwd,
+            ...(runtime === "traex" ? { skipTraexStartupPrompts: true } : {}),
             // Share the app-server's private CODEX_HOME so the TUI inherits the same
             // login/settings and skips the real home's update/NUX prompt. RYNX_SESSION_ID
             // scopes agent-run CLIs (rynx-emulator) to this session at the daemon.
@@ -1633,8 +1638,16 @@ export class LocalAgentHost {
                 throw failedPluginSkill.reason;
             }
             const pluginSkills = materializedPluginSkills.flatMap((result) => result.status === "fulfilled" ? result.value : []);
+            const selectedSkills = [...skillEnv.resolved, ...pluginSkills];
+            const selectedNames = new Set();
+            for (const skill of selectedSkills) {
+                if (selectedNames.has(skill.name)) {
+                    throw new Error(`duplicate final Session skill name: ${skill.name}`);
+                }
+                selectedNames.add(skill.name);
+            }
             return {
-                selectedSkills: [...skillEnv.resolved, ...pluginSkills],
+                selectedSkills,
                 skillsCleanup: () => rm(sessionSkillsDir, { recursive: true, force: true }),
             };
         }

package/dist/index.d.ts

@@ -13,6 +13,6 @@ export type { InjectOutcome, TerminalOpenErrorCode, TerminalRole } from "./runne
 export type { ResolveInteractionResult, RuntimeInteractionEvent, RuntimeInteractionListener, } from "./interactions.js";
 export { probeRuntimeStatus } from "./runtime-status.js";
 export { listRuntimeModels } from "./models-catalog.js";
-export { TmuxTerminal, isTmuxAvailable } from "./terminal/tmux.js";
+export { TmuxTerminal, isTmuxAvailable, terminateTmuxServer, tmuxSocketPath, } from "./terminal/tmux.js";
 export type { TerminalAttachment, TmuxTerminalOptions } from "./terminal/tmux.js";
 export { TerminalRegistry } from "./terminal/registry.js";

package/dist/index.js

@@ -12,5 +12,5 @@ export { RunnerManager, TerminalOpenError } from "./runner/manager.js";
 export { probeRuntimeStatus } from "./runtime-status.js";
 export { listRuntimeModels } from "./models-catalog.js";
 // Live-terminal subsystem (Phase C): tmux-backed terminals + per-runner registry.
-export { TmuxTerminal, isTmuxAvailable } from "./terminal/tmux.js";
+export { TmuxTerminal, isTmuxAvailable, terminateTmuxServer, tmuxSocketPath, } from "./terminal/tmux.js";
 export { TerminalRegistry } from "./terminal/registry.js";

package/dist/runner/child.d.ts

@@ -31,6 +31,7 @@ interface LiveCodexProvider {
         args: string[];
         cwd: string;
         env?: Record<string, string>;
+        skipTraexStartupPrompts?: boolean;
     } | null>;
     ensureLiveCodexSession?(localThreadId: string, emit: (event: SessionEvent) => void, opts: {
         workspace: SessionWorkspaceSnapshot;
@@ -71,6 +72,8 @@ export declare class RunnerSession {
     /** Live terminals hosted by this session, and per-attach client handles. */
     private readonly terminals;
     private readonly attachments;
+    private readonly attachmentThreadIds;
+    private readonly traexStartupWatchers;
     /** Opens are async; a close received before attach resolves tombstones the id. */
     private readonly pendingTerminalOpens;
     private readonly cancelledTerminalOpens;
@@ -101,6 +104,8 @@ export declare class RunnerSession {
      *  `codexTerminalSpec`. Shares the `${id}-main` terminal id with `term.open`,
      *  so the web attach reuses the same detached pane. */
     private launchCodexPane;
+    private cancelTraexStartupWatcher;
+    private skipTraexStartupPrompts;
     private stopLive;
     /** Stop event forwarding, kill native terminals/hooks, then synchronously
      * scrub provider handoff files before the child process is allowed to exit. */

package/dist/runner/child.js

@@ -7,6 +7,8 @@ export class RunnerSession {
     /** Live terminals hosted by this session, and per-attach client handles. */
     terminals = new TerminalRegistry();
     attachments = new Map();
+    attachmentThreadIds = new Map();
+    traexStartupWatchers = new Map();
     /** Opens are async; a close received before attach resolves tombstones the id. */
     pendingTerminalOpens = new Set();
     cancelledTerminalOpens = new Set();
@@ -46,6 +48,7 @@ export class RunnerSession {
                 });
                 return;
             case "term.input":
+                this.cancelTraexStartupWatcher(this.attachmentThreadIds.get(msg.attachId));
                 this.attachments.get(msg.attachId)?.write(Buffer.from(msg.dataB64, "base64").toString("utf8"));
                 return;
             case "term.resize":
@@ -57,6 +60,7 @@ export class RunnerSession {
                 }
                 const attachment = this.attachments.get(msg.attachId);
                 this.attachments.delete(msg.attachId);
+                this.attachmentThreadIds.delete(msg.attachId);
                 attachment?.kill();
                 return;
             }
@@ -211,6 +215,8 @@ export class RunnerSession {
         try {
             const input = msg.input ?? msg.text;
             const outcome = (await provider.injectMessage?.(msg.localThreadId, input)) ?? "notLive";
+            if (outcome === "injected")
+                this.cancelTraexStartupWatcher(msg.localThreadId);
             this.transport.send({ t: "injected", reqId: msg.reqId, localThreadId: msg.localThreadId, outcome });
         }
         catch (error) {
@@ -248,7 +254,9 @@ export class RunnerSession {
         const spec = await this.liveProvider.codexTerminalSpec?.(localThreadId);
         if (!spec)
             return;
-        const term = this.terminals.getOrCreate(`${localThreadId}-main`, {
+        const terminalId = `${localThreadId}-main`;
+        const coldStart = !this.terminals.has(terminalId);
+        const term = this.terminals.getOrCreate(terminalId, {
             cwd: spec.cwd,
             command: spec.command,
             args: spec.args,
@@ -256,8 +264,68 @@ export class RunnerSession {
             rows: rows ?? 40,
             ...(spec.env ? { env: spec.env } : {}),
         });
+        if (coldStart && spec.skipTraexStartupPrompts) {
+            const watcher = Symbol(localThreadId);
+            this.traexStartupWatchers.set(localThreadId, watcher);
+            void this.skipTraexStartupPrompts(localThreadId, term, watcher);
+        }
         this.liveProvider.attachTerminalInjector?.(localThreadId, term);
     }
+    cancelTraexStartupWatcher(localThreadId) {
+        if (localThreadId)
+            this.traexStartupWatchers.delete(localThreadId);
+    }
+    async skipTraexStartupPrompts(localThreadId, terminal, watcher) {
+        const prompts = [
+            {
+                id: "welcome",
+                matches: (pane) => pane.includes("Welcome to TRAE CLI") && pane.includes("Press enter to continue"),
+                dismiss: () => terminal.sendEnter(),
+            },
+            {
+                id: "migration",
+                matches: (pane) => pane.includes("Legacy TRAE CLI data detected") &&
+                    pane.includes("Would you like to migrate detected data to the new TRAE CLI storage?") &&
+                    pane.includes("Select what to import:"),
+                dismiss: () => terminal.interrupt(),
+            },
+            {
+                id: "hooks",
+                matches: (pane) => pane.includes("Hooks need review") &&
+                    pane.includes("hooks are new or changed.") &&
+                    pane.includes("Trust all and continue") &&
+                    pane.includes("Continue without trusting"),
+                dismiss: () => terminal.interrupt(),
+            },
+        ];
+        const dismissed = new Set();
+        const deadline = Date.now() + 20_000;
+        const terminalId = `${localThreadId}-main`;
+        while (!this.shuttingDown &&
+            Date.now() < deadline &&
+            this.traexStartupWatchers.get(localThreadId) === watcher &&
+            this.terminals.get(terminalId) === terminal) {
+            const pane = terminal.capturePane();
+            // Once the normal composer is visible, startup is complete and there is
+            // no reason to keep polling the tmux pane for the remainder of the window.
+            if (pane.includes("TRAE CLI Next"))
+                break;
+            const prompt = prompts.find((candidate) => candidate.matches(pane));
+            if (prompt && !dismissed.has(prompt.id)) {
+                prompt.dismiss();
+                dismissed.add(prompt.id);
+                if (dismissed.size === prompts.length)
+                    break;
+            }
+            await new Promise((resolve) => {
+                const timer = setTimeout(resolve, 100);
+                timer.unref();
+            });
+        }
+        if (this.traexStartupWatchers.get(localThreadId) === watcher) {
+            this.traexStartupWatchers.delete(localThreadId);
+        }
+    }
     stopLive() {
         for (const id of this.liveIds) {
             this.liveProvider.stopLiveCodexSession?.(id, {
@@ -336,6 +404,8 @@ export class RunnerSession {
             return;
         }
         this.attachments.set(msg.attachId, attachment);
+        if (msg.localThreadId)
+            this.attachmentThreadIds.set(msg.attachId, msg.localThreadId);
         attachment.onData((chunk) => this.transport.send({
             t: "term.data",
             attachId: msg.attachId,
@@ -343,6 +413,7 @@ export class RunnerSession {
         }));
         attachment.onExit((info) => {
             this.attachments.delete(msg.attachId);
+            this.attachmentThreadIds.delete(msg.attachId);
             this.transport.send({ t: "term.exit", attachId: msg.attachId, exitCode: info.exitCode });
         });
         this.transport.send({ t: "term.opened", attachId: msg.attachId, role });

package/dist/runner/manager.d.ts

@@ -15,8 +15,8 @@
  * transport drops in here later without touching `ConversationRuntime` or any
  * channel.
  */
-import { spawn as nodeSpawn } from "node:child_process";
-import { type AgentCapabilities, type AgentRuntimeId, type AppConfig, type CapabilityResult, type ModelListResponse, type ResolvedExecutionSnapshot, type RuntimeUserInput, type SessionInteractionResolution, type SessionEvent, type SessionWorkspaceSnapshot, type ThreadGoal } from "@rynx-ai/core";
+import { spawn as nodeSpawn, type ChildProcess } from "node:child_process";
+import { type AdmissionReservation, type AgentCapabilities, type AgentRuntimeId, type AppConfig, type CapabilityResult, type ModelListResponse, type ResolvedExecutionSnapshot, type RuntimeUserInput, type SessionInteractionResolution, type SessionEvent, type SessionWorkspaceSnapshot, type ThreadGoal } from "@rynx-ai/core";
 import { type CodexSessionStore } from "../host.js";
 import type { ResolveInteractionResult } from "../interactions.js";
 import { type InjectOutcome, type TerminalOpenErrorCode, type TerminalRole } from "./protocol.js";
@@ -53,8 +53,22 @@ export interface RunnerManagerOptions {
     liveStartTimeoutMs?: number;
     /** Max wait for a Provider-native thread to become ready. */
     liveReadyTimeoutMs?: number;
+    /** Max wait for a native interrupt acknowledgement before reporting it
+     * unproven. Callers may then use the explicit force-stop path. */
+    liveInterruptTimeoutMs?: number;
+    /** Max wait for an accepted owner TUI submission to become observable as a
+     * mirrored response or a published native rotation. */
+    terminalInputHandoffTimeoutMs?: number;
+    /** Initial exponential backoff for retrying unproven terminal cleanup. */
+    terminalInputCleanupRetryMs?: number;
     /** Injected for tests. */
     spawn?: typeof nodeSpawn;
+    /** Injected for tests. Defaults to signaling the whole POSIX process group
+     * created for the runner child, with direct-child fallback. */
+    signalChild?: (child: ChildProcess, signal: NodeJS.Signals, processGroup: boolean) => void;
+    /** Injected for tests. Kills and verifies the deterministic private tmux
+     * server owned by a Session runner. */
+    terminateTerminalServer?: (terminalName: string) => boolean | Promise<boolean>;
     now?: () => number;
     /** Extra env merged into every spawned runner child — e.g. the control-plane
      *  URL + token so a claude-native PermissionRequest hook can POST back. */
@@ -62,6 +76,13 @@ export interface RunnerManagerOptions {
     /** Optional lifecycle context for Session runners. The shared `__cap__`
      * runner never opens one. */
     sessionContextProvider?: RunnerSessionContextProvider;
+    /** Dynamic process-wide admission fence. Existing cancellation and read-only
+     * inspection remain available; every path that may spawn or attach execution
+     * checks this immediately before admission. */
+    admissionOpen?: () => boolean;
+    /** Atomically reserves one work-producing admission while it crosses the
+     * asynchronous boundary into an observable live runner/turn. */
+    admissionReserve?: () => AdmissionReservation | undefined;
 }
 /** A session rotation reported by a runner child (claude `/clear`·`/fork`): the
  *  new session `to` is now aliased to `from`'s runner; carries meta to carry over. */
@@ -118,6 +139,8 @@ export declare class RunnerManager implements AgentCapabilities {
     private readonly spawn;
     private readonly childEnv;
     private readonly sessionContextProvider;
+    private readonly admissionOpen;
+    private readonly admissionReserve;
     private readonly now;
     private readonly defaultRuntime;
     private readonly handles;
@@ -127,8 +150,13 @@ export declare class RunnerManager implements AgentCapabilities {
     private readonly reapTimer;
     private readonly shutdownGraceMs;
     private readonly shutdownKillGraceMs;
+    private readonly signalChild;
+    private readonly terminateTerminalServer;
     private readonly liveStartTimeoutMs;
     private readonly liveReadyTimeoutMs;
+    private readonly liveInterruptTimeoutMs;
+    private readonly terminalInputHandoffTimeoutMs;
+    private readonly terminalInputCleanupRetryMs;
     private stopping;
     private stopPromise;
     /** Sink for mirrored {@link SessionEvent}s from every session's forwarder. */
@@ -154,6 +182,9 @@ export declare class RunnerManager implements AgentCapabilities {
     private readonly forkOperations;
     private readonly forkBufferedMessages;
     private readonly forkBufferedTerminalInputs;
+    /** Owner TUI submissions accepted by the parent but not yet represented by a
+     * mirrored response or a durably published native rotation. */
+    private readonly terminalInputHandoffs;
     constructor(opts: RunnerManagerOptions);
     /**
      * Open a live terminal on the session's runner child (spawning it if needed).
@@ -181,6 +212,18 @@ export declare class RunnerManager implements AgentCapabilities {
     /** Register the sink for session rotations (claude `/clear`·`/fork`): the server
      *  records the new session's meta (carry-over agent/model/title). */
     onRotate(listener: (rotation: RotateInfo) => void | Promise<void>): void;
+    /** Accepted TUI submissions that have not crossed into an observable runtime
+     * state. The daemon folds this into runningTurns after closing admission. */
+    pendingTerminalInputCount(): number;
+    private beginTerminalInputHandoffs;
+    private settleTerminalInputHandoff;
+    private settleTerminalRotationHandoff;
+    private currentTerminalSessionId;
+    private finishTerminalInputHandoff;
+    private finishAllTerminalInputHandoffs;
+    private preserveTerminalInputHandoffsAsActivity;
+    private scheduleTerminalInputCleanupRetry;
+    private expireTerminalInputHandoffs;
     /**
      * Eagerly bring up a session's codex-native live view (persistent forwarder +
      * detached `codex --remote` TUI) in its runner child, spawning the runner if
@@ -211,6 +254,7 @@ export declare class RunnerManager implements AgentCapabilities {
      * the session has no live forwarder (caller falls back to the run path).
      */
     injectMessage(localThreadId: string, input: RuntimeUserInput | string): Promise<InjectOutcome>;
+    private injectMessageAdmitted;
     /**
      * Interrupt a session's active live turn — the web Stop button (codex
      * `turn/interrupt`, claude Escape). Best-effort: resolves false with NO spawn
@@ -243,13 +287,19 @@ export declare class RunnerManager implements AgentCapabilities {
     }): Promise<import("../host.js").CodexRuntimeStatus>;
     /** Stop the runner bound to one session (if any), rejecting its in-flight work. */
     stopRunner(localThreadId: string): void;
+    /** Force-stop and join the runner bound to one Session. Unlike stopRunner,
+     * completion proves that the child process has exited. */
+    terminateLiveSession(localThreadId: string): Promise<boolean>;
     /** Stop every runner and join all child exits. Idempotent across concurrent calls. */
     stop(): Promise<void>;
+    private handleForCleanup;
     /** Forward a capability to a runner child. Session-less caps (listModels/status)
      *  use the shared `CAP_KEY` child; per-thread caps pass the session's key so they
      *  run on that session's child (which owns its private CODEX_HOME). */
     private forwardCap;
     private getOrSpawn;
+    private assertAdmissionOpen;
+    private reserveAdmission;
     private performManagedFork;
     private performClaudeManagedFork;
     private bufferForkTargetMessage;

package/dist/runner/manager.js

@@ -22,6 +22,7 @@ import { fileURLToPath } from "node:url";
 import { AgentRuntimeError, } from "@rynx-ai/core";
 import { listRuntimeModels } from "../models-catalog.js";
 import { probeRuntimeStatus } from "../runtime-status.js";
+import { terminateTmuxServer } from "../terminal/tmux.js";
 import { fromWireError, } from "./protocol.js";
 import { StdioRunnerTransport } from "./transport.js";
 /** Routing key for the shared capability runner (slash-command RPCs). */
@@ -36,6 +37,13 @@ const DEFAULT_SHUTDOWN_KILL_GRACE_MS = 5_000;
 const DEFAULT_LIVE_START_TIMEOUT_MS = 10_000;
 /** Thread readiness may legitimately wait through Provider startup. */
 const DEFAULT_LIVE_READY_TIMEOUT_MS = 25_000;
+/** A submitted TUI command should become a mirrored turn or native rotation
+ * quickly. If it does not, the runner is fenced by a verified process-tree
+ * shutdown before maintenance may treat the submission as settled. */
+const DEFAULT_TERMINAL_INPUT_HANDOFF_TIMEOUT_MS = 30_000;
+/** Retry transient terminal-server cleanup without spinning forever. */
+const DEFAULT_TERMINAL_INPUT_CLEANUP_RETRY_MS = 1_000;
+const MAX_TERMINAL_INPUT_CLEANUP_RETRY_MS = 30_000;
 /** Keep per-Session spawn context small enough to remain an environment handoff,
  * not an unbounded transport. */
 const MAX_SESSION_CONTEXT_ENV_ENTRIES = 32;
@@ -139,6 +147,8 @@ export class RunnerManager {
     spawn;
     childEnv;
     sessionContextProvider;
+    admissionOpen;
+    admissionReserve;
     now;
     defaultRuntime;
     handles = new Map();
@@ -148,8 +158,13 @@ export class RunnerManager {
     reapTimer;
     shutdownGraceMs;
     shutdownKillGraceMs;
+    signalChild;
+    terminateTerminalServer;
     liveStartTimeoutMs;
     liveReadyTimeoutMs;
+    liveInterruptTimeoutMs;
+    terminalInputHandoffTimeoutMs;
+    terminalInputCleanupRetryMs;
     stopping = false;
     stopPromise;
     /** Sink for mirrored {@link SessionEvent}s from every session's forwarder. */
@@ -175,6 +190,9 @@ export class RunnerManager {
     forkOperations = new Map();
     forkBufferedMessages = new Map();
     forkBufferedTerminalInputs = new Map();
+    /** Owner TUI submissions accepted by the parent but not yet represented by a
+     * mirrored response or a durably published native rotation. */
+    terminalInputHandoffs = new Map();
     constructor(opts) {
         this.config = opts.config;
         this.sessionStore = opts.sessionStore;
@@ -183,12 +201,19 @@ export class RunnerManager {
         this.spawn = opts.spawn ?? nodeSpawn;
         this.childEnv = opts.childEnv ?? {};
         this.sessionContextProvider = opts.sessionContextProvider;
+        this.admissionOpen = opts.admissionOpen ?? (() => true);
+        this.admissionReserve = opts.admissionReserve;
         this.now = opts.now ?? (() => Date.now());
-        this.defaultRuntime = opts.config.AGENT_RUNTIME ?? "codex";
+        this.defaultRuntime = opts.config.DEFAULT_RUNTIME ?? "codex";
         this.shutdownGraceMs = Math.max(0, opts.shutdownGraceMs ?? DEFAULT_SHUTDOWN_GRACE_MS);
         this.shutdownKillGraceMs = Math.max(0, opts.shutdownKillGraceMs ?? DEFAULT_SHUTDOWN_KILL_GRACE_MS);
+        this.signalChild = opts.signalChild ?? signalRunnerChild;
+        this.terminateTerminalServer = opts.terminateTerminalServer ?? terminateTmuxServer;
         this.liveStartTimeoutMs = Math.max(1, opts.liveStartTimeoutMs ?? DEFAULT_LIVE_START_TIMEOUT_MS);
         this.liveReadyTimeoutMs = Math.max(1, opts.liveReadyTimeoutMs ?? DEFAULT_LIVE_READY_TIMEOUT_MS);
+        this.liveInterruptTimeoutMs = Math.max(1, opts.liveInterruptTimeoutMs ?? 10_000);
+        this.terminalInputHandoffTimeoutMs = Math.max(1, opts.terminalInputHandoffTimeoutMs ?? DEFAULT_TERMINAL_INPUT_HANDOFF_TIMEOUT_MS);
+        this.terminalInputCleanupRetryMs = Math.max(1, opts.terminalInputCleanupRetryMs ?? DEFAULT_TERMINAL_INPUT_CLEANUP_RETRY_MS);
         const reapIntervalMs = opts.reapIntervalMs ?? 60_000;
         if (reapIntervalMs > 0) {
             this.reapTimer = setInterval(() => this.reapIdle(), reapIntervalMs);
@@ -216,6 +241,7 @@ export class RunnerManager {
      * and attach.
      */
     openLiveTerminal(localThreadId, opts) {
+        this.assertAdmissionOpen();
         if (this.forkReservations.has(localThreadId)) {
             throw new TerminalOpenError("Session fork is still being committed", "terminal_not_live");
         }
@@ -228,12 +254,36 @@ export class RunnerManager {
     openTerminalOnHandle(handle, localThreadId, opts) {
         handle.lastUsedAt = this.now();
         const attachId = randomUUID();
+        const inputTracker = {
+            buffer: "",
+            previousWasCarriageReturn: false,
+            bracketedPaste: false,
+            pendingEscape: "",
+        };
         const terminal = new ManagedTerminal(attachId, (msg) => {
+            const handoffs = msg.t === "term.input" && opts.role === "owner"
+                ? this.beginTerminalInputHandoffs(handle, this.currentTerminalSessionId(handle, localThreadId), trackedTerminalSubmissions(inputTracker, Buffer.from(msg.dataB64, "base64").toString("utf8")))
+                : [];
+            const send = () => {
+                try {
+                    handle.transport.send(msg);
+                }
+                catch (error) {
+                    for (const handoff of handoffs) {
+                        this.finishTerminalInputHandoff(handle, handoff);
+                    }
+                    throw error;
+                }
+            };
             const sourceReservation = this.sourceForkReservations.get(localThreadId);
             if (msg.t === "term.input" && sourceReservation) {
                 void sourceReservation.then(() => {
                     if (!handle.dead)
-                        handle.transport.send(msg);
+                        send();
+                }).catch((error) => {
+                    void this.terminateHandle(handle, `terminal input delivery failed: ${errorMessage(error)}`).catch((terminationError) => {
+                        logTerminationFailure(handle, terminationError);
+                    });
                 });
                 return;
             }
@@ -246,7 +296,7 @@ export class RunnerManager {
                     return;
                 }
             }
-            handle.transport.send(msg);
+            send();
         }, () => handle.terminals.delete(attachId));
         handle.terminals.set(attachId, terminal);
         handle.transport.send({
@@ -284,6 +334,152 @@ export class RunnerManager {
     onRotate(listener) {
         this.rotateListener = listener;
     }
+    /** Accepted TUI submissions that have not crossed into an observable runtime
+     * state. The daemon folds this into runningTurns after closing admission. */
+    pendingTerminalInputCount() {
+        let count = 0;
+        for (const handoffs of this.terminalInputHandoffs.values()) {
+            count += handoffs.length;
+        }
+        return count;
+    }
+    beginTerminalInputHandoffs(handle, sessionId, kinds) {
+        if (kinds.length === 0)
+            return [];
+        const created = [];
+        try {
+            for (const kind of kinds) {
+                const handoff = {
+                    sessionId,
+                    kind,
+                    reservation: this.reserveAdmission(),
+                    timer: undefined,
+                };
+                handoff.timer = setTimeout(() => {
+                    this.expireTerminalInputHandoffs(handle);
+                }, this.terminalInputHandoffTimeoutMs);
+                handoff.timer.unref?.();
+                const handoffs = this.terminalInputHandoffs.get(handle);
+                if (handoffs)
+                    handoffs.push(handoff);
+                else
+                    this.terminalInputHandoffs.set(handle, [handoff]);
+                created.push(handoff);
+            }
+            return created;
+        }
+        catch (error) {
+            for (const handoff of created) {
+                this.finishTerminalInputHandoff(handle, handoff);
+            }
+            throw error;
+        }
+    }
+    settleTerminalInputHandoff(handle, sessionId, kind) {
+        const handoff = this.terminalInputHandoffs
+            .get(handle)
+            ?.find((candidate) => candidate.sessionId === sessionId);
+        // Runtime observations settle accepted input in submission order. In
+        // particular, a response from the source Session while /clear or /fork is
+        // still publishing must not skip that rotation and release a later turn
+        // which has not yet been rebound or delivered.
+        if (handoff?.kind === kind)
+            this.finishTerminalInputHandoff(handle, handoff);
+    }
+    settleTerminalRotationHandoff(handle, sourceSessionId, targetSessionId) {
+        const handoffs = this.terminalInputHandoffs.get(handle);
+        const rotationIndex = handoffs?.findIndex((handoff) => handoff.sessionId === sourceSessionId && handoff.kind === "rotation") ?? -1;
+        if (!handoffs || rotationIndex < 0)
+            return;
+        // Turns submitted before /clear or /fork are superseded once the rotation
+        // is published. Inputs accepted afterwards belong to the transferred pane
+        // and must follow it to the target Session.
+        const rotation = handoffs[rotationIndex];
+        for (const handoff of [...handoffs.slice(0, rotationIndex)]) {
+            if (handoff.sessionId === sourceSessionId && handoff.kind === "turn") {
+                this.finishTerminalInputHandoff(handle, handoff);
+            }
+        }
+        if (rotation)
+            this.finishTerminalInputHandoff(handle, rotation);
+        for (const handoff of this.terminalInputHandoffs.get(handle) ?? []) {
+            if (handoff.sessionId === sourceSessionId)
+                handoff.sessionId = targetSessionId;
+        }
+    }
+    currentTerminalSessionId(handle, fallback) {
+        for (const [sessionId, candidate] of this.handles) {
+            if (candidate === handle && this.liveSessionKeys.has(sessionId))
+                return sessionId;
+        }
+        return fallback;
+    }
+    finishTerminalInputHandoff(handle, handoff) {
+        if (handoff.timer) {
+            clearTimeout(handoff.timer);
+            handoff.timer = undefined;
+        }
+        handoff.reservation?.release();
+        handoff.reservation = undefined;
+        const handoffs = this.terminalInputHandoffs.get(handle);
+        if (!handoffs)
+            return;
+        const index = handoffs.indexOf(handoff);
+        if (index >= 0)
+            handoffs.splice(index, 1);
+        if (handoffs.length === 0)
+            this.terminalInputHandoffs.delete(handle);
+    }
+    finishAllTerminalInputHandoffs(handle) {
+        if (handle.terminalCleanupRetryTimer) {
+            clearTimeout(handle.terminalCleanupRetryTimer);
+            delete handle.terminalCleanupRetryTimer;
+        }
+        handle.terminalCleanupRetryFailures = 0;
+        for (const handoff of [...(this.terminalInputHandoffs.get(handle) ?? [])]) {
+            this.finishTerminalInputHandoff(handle, handoff);
+        }
+    }
+    preserveTerminalInputHandoffsAsActivity(handle) {
+        for (const handoff of this.terminalInputHandoffs.get(handle) ?? []) {
+            if (handoff.timer) {
+                clearTimeout(handoff.timer);
+                handoff.timer = undefined;
+            }
+            handoff.reservation?.release();
+            handoff.reservation = undefined;
+        }
+    }
+    scheduleTerminalInputCleanupRetry(handle) {
+        if (handle.terminalCleanupRetryTimer ||
+            !this.terminalInputHandoffs.has(handle))
+            return;
+        const exponent = Math.min(handle.terminalCleanupRetryFailures - 1, 10);
+        const delay = Math.min(this.terminalInputCleanupRetryMs * (2 ** Math.max(0, exponent)), MAX_TERMINAL_INPUT_CLEANUP_RETRY_MS);
+        handle.terminalCleanupRetryTimer = setTimeout(() => {
+            delete handle.terminalCleanupRetryTimer;
+            if (!this.terminalInputHandoffs.has(handle))
+                return;
+            void this.terminateHandle(handle, "retrying unproven terminal input cleanup").catch((error) => {
+                logTerminationFailure(handle, error);
+            });
+        }, delay);
+        handle.terminalCleanupRetryTimer.unref?.();
+    }
+    expireTerminalInputHandoffs(handle) {
+        const handoffs = this.terminalInputHandoffs.get(handle);
+        if (!handoffs?.length)
+            return;
+        for (const handoff of handoffs) {
+            if (handoff.timer) {
+                clearTimeout(handoff.timer);
+                handoff.timer = undefined;
+            }
+        }
+        void this.terminateHandle(handle, "accepted terminal input did not become observable before maintenance timeout").catch((error) => {
+            logTerminationFailure(handle, error);
+        });
+    }
     /**
      * Eagerly bring up a session's codex-native live view (persistent forwarder +
      * detached `codex --remote` TUI) in its runner child, spawning the runner if
@@ -291,13 +487,17 @@ export class RunnerManager {
      * non-codex / non-live session (the caller then uses the normal run path).
      */
     ensureLiveSession(localThreadId, opts) {
-        return this.requestLiveSession(localThreadId, opts, true);
+        const admission = this.reserveAdmission();
+        return this.requestLiveSession(localThreadId, opts, true)
+            .finally(() => admission.release());
     }
     /** Start the Provider pane without waiting for login/onboarding to create a
      * native thread. This is the setup-terminal gate; callers may attach as soon
      * as it resolves, while normal message delivery still uses ensureLiveSession. */
     startLiveSession(localThreadId, opts) {
-        return this.requestLiveSession(localThreadId, opts, false);
+        const admission = this.reserveAdmission();
+        return this.requestLiveSession(localThreadId, opts, false)
+            .finally(() => admission.release());
     }
     requestLiveSession(localThreadId, opts, waitForReady, allowReservedForkTarget = false) {
         const sourceReservation = allowReservedForkTarget
@@ -395,13 +595,18 @@ export class RunnerManager {
      * the session has no live forwarder (caller falls back to the run path).
      */
     injectMessage(localThreadId, input) {
+        const admission = this.reserveAdmission();
+        return this.injectMessageAdmitted(localThreadId, input)
+            .finally(() => admission.release());
+    }
+    injectMessageAdmitted(localThreadId, input) {
         const sourceReservation = this.sourceForkReservations.get(localThreadId);
         if (sourceReservation) {
-            return sourceReservation.then(() => this.injectMessage(localThreadId, input));
+            return sourceReservation.then(() => this.injectMessageAdmitted(localThreadId, input));
         }
         const reservation = this.forkReservations.get(localThreadId);
         if (reservation) {
-            return reservation.then(() => this.injectMessage(localThreadId, input));
+            return reservation.then(() => this.injectMessageAdmitted(localThreadId, input));
         }
         const handle = this.getOrSpawn(localThreadId);
         handle.lastUsedAt = this.now();
@@ -444,7 +649,16 @@ export class RunnerManager {
         handle.lastUsedAt = this.now();
         const reqId = randomUUID();
         return new Promise((resolve) => {
-            handle.live.set(reqId, (res) => resolve(res.ok ?? false));
+            const timeout = setTimeout(() => {
+                if (!handle.live.delete(reqId))
+                    return;
+                resolve(false);
+            }, this.liveInterruptTimeoutMs);
+            timeout.unref?.();
+            handle.live.set(reqId, (res) => {
+                clearTimeout(timeout);
+                resolve(res.ok ?? false);
+            });
             handle.transport.send({ t: "live.interrupt", reqId, localThreadId });
         });
     }
@@ -488,6 +702,7 @@ export class RunnerManager {
         return this.forwardCap("clearGoal", [localThreadId], localThreadId);
     }
     forkSession(currentLocalThreadId, newLocalThreadId, options) {
+        this.assertAdmissionOpen();
         if (currentLocalThreadId === newLocalThreadId) {
             return Promise.resolve({
                 ok: false,
@@ -573,7 +788,7 @@ export class RunnerManager {
     }
     /** Stop the runner bound to one session (if any), rejecting its in-flight work. */
     stopRunner(localThreadId) {
-        const handle = this.handles.get(localThreadId);
+        const handle = this.handleForCleanup(localThreadId);
         if (!handle) {
             return;
         }
@@ -581,6 +796,15 @@ export class RunnerManager {
             logTerminationFailure(handle, error);
         });
     }
+    /** Force-stop and join the runner bound to one Session. Unlike stopRunner,
+     * completion proves that the child process has exited. */
+    async terminateLiveSession(localThreadId) {
+        const handle = this.handleForCleanup(localThreadId);
+        if (!handle)
+            return false;
+        await this.terminateHandle(handle, "runner force-stopped");
+        return true;
+    }
     /** Stop every runner and join all child exits. Idempotent across concurrent calls. */
     stop() {
         if (this.stopPromise)
@@ -589,9 +813,12 @@ export class RunnerManager {
         if (this.reapTimer) {
             clearInterval(this.reapTimer);
         }
-        const children = [...this.childHandles];
-        this.stopPromise = (async () => {
-            const results = await Promise.allSettled(children.map((handle) => this.terminateHandle(handle, "runner manager stopped")));
+        const children = new Set([
+            ...this.childHandles,
+            ...this.terminalInputHandoffs.keys(),
+        ]);
+        const attempt = (async () => {
+            const results = await Promise.allSettled([...children].map((handle) => this.terminateHandle(handle, "runner manager stopped")));
             this.handles.clear();
             this.liveSessionKeys.clear();
             this.liveErrors.clear();
@@ -606,9 +833,19 @@ export class RunnerManager {
             }
             this.childHandles.clear();
         })();
-        return this.stopPromise;
+        this.stopPromise = attempt;
+        void attempt.catch(() => {
+            if (this.stopPromise === attempt)
+                this.stopPromise = undefined;
+        });
+        return attempt;
     }
     // ── internals ──────────────────────────────────────────────────────────────
+    handleForCleanup(localThreadId) {
+        return this.handles.get(localThreadId) ??
+            [...this.terminalInputHandoffs].find(([handle, handoffs]) => handle.key === localThreadId ||
+                handoffs.some((handoff) => handoff.sessionId === localThreadId))?.[0];
+    }
     /** Forward a capability to a runner child. Session-less caps (listModels/status)
      *  use the shared `CAP_KEY` child; per-thread caps pass the session's key so they
      *  run on that session's child (which owns its private CODEX_HOME). */
@@ -622,23 +859,48 @@ export class RunnerManager {
         });
     }
     getOrSpawn(key, allowReservedForkTarget = false) {
-        if (this.stopping) {
-            throw new AgentRuntimeError("runner manager is stopped", 503, "runner_stopped");
-        }
-        if (key !== CAP_KEY &&
-            this.forkReservations.has(key) &&
-            !allowReservedForkTarget) {
-            throw new AgentRuntimeError("Session fork is still being committed", 409, "session_fork_pending");
-        }
-        this.reapIdle();
-        const existing = this.handles.get(key);
-        if (existing && !existing.dead) {
-            existing.lastUsedAt = this.now();
-            return existing;
-        }
-        const handle = this.spawnHandle(key);
-        this.handles.set(key, handle);
-        return handle;
+        const admission = this.reserveAdmission();
+        try {
+            if (this.stopping) {
+                throw new AgentRuntimeError("runner manager is stopped", 503, "runner_stopped");
+            }
+            if (key !== CAP_KEY &&
+                this.forkReservations.has(key) &&
+                !allowReservedForkTarget) {
+                throw new AgentRuntimeError("Session fork is still being committed", 409, "session_fork_pending");
+            }
+            this.reapIdle();
+            const existing = this.handles.get(key);
+            if (existing && !existing.dead) {
+                existing.lastUsedAt = this.now();
+                return existing;
+            }
+            const handle = this.spawnHandle(key);
+            this.handles.set(key, handle);
+            return handle;
+        }
+        finally {
+            admission.release();
+        }
+    }
+    assertAdmissionOpen() {
+        const reservation = this.admissionReserve?.();
+        if (reservation) {
+            reservation.release();
+            return;
+        }
+        if (!this.admissionReserve && this.admissionOpen())
+            return;
+        throw new AgentRuntimeError("daemon maintenance is in progress", 503, "daemon_maintenance");
+    }
+    reserveAdmission() {
+        const reservation = this.admissionReserve?.();
+        if (reservation)
+            return reservation;
+        if (!this.admissionReserve && this.admissionOpen()) {
+            return { release() { } };
+        }
+        throw new AgentRuntimeError("daemon maintenance is in progress", 503, "daemon_maintenance");
     }
     async performManagedFork(currentLocalThreadId, newLocalThreadId, options) {
         const existingTarget = await this.sessionStore.get(newLocalThreadId);
@@ -750,6 +1012,9 @@ export class RunnerManager {
             return;
         if (message.t === "mirror") {
             this.mirrorListener?.(message.sessionId, message.event);
+            if (message.event.type === "response.created") {
+                this.settleTerminalInputHandoff(handle, message.sessionId, "turn");
+            }
             return;
         }
         this.deliverRotateMessage(handle, message);
@@ -806,6 +1071,11 @@ export class RunnerManager {
         };
         void Promise.resolve(this.rotateListener?.(rotation))
             .then(() => {
+            // The server's rotation listener resolves only after the target Session
+            // is published. Release the terminal admission handoff afterwards so a
+            // maintenance snapshot cannot observe a gap with neither source work
+            // nor the target Session.
+            this.settleTerminalRotationHandoff(handle, message.from, message.to);
             if (handle.dead)
                 return;
             this.handles.set(message.to, handle);
@@ -845,10 +1115,12 @@ export class RunnerManager {
         const sessionContext = key === CAP_KEY
             ? undefined
             : this.openSessionContext(key);
+        const processGroup = process.platform !== "win32";
         let child;
         try {
             child = this.spawn(process.execPath, args, {
                 stdio: ["pipe", "pipe", "pipe"],
+                detached: processGroup,
                 // `RYNX_RUNNER_SESSION` = the child's session key (localThreadId, or `__cap__`
                 // for the shared capability child) so its LocalAgentHost scopes the private
                 // CODEX_HOME to this session. It is deliberately applied last.
@@ -874,6 +1146,8 @@ export class RunnerManager {
             lastUsedAt: this.now(),
             dead: false,
             completion,
+            terminalCleanupRetryFailures: 0,
+            processGroup,
             ...(sessionContext ? { sessionContext } : {}),
             caps: new Map(),
             terminals: new Map(),
@@ -937,6 +1211,12 @@ export class RunnerManager {
                 if (this.bufferForkTargetMessage(handle, msg))
                     return;
                 this.mirrorListener?.(msg.sessionId, msg.event);
+                if (msg.event.type === "response.created") {
+                    // The listener projects response.created into SessionRuntimeIndex
+                    // synchronously. Only then may the accepted terminal reservation
+                    // drain into a maintenance activity snapshot.
+                    this.settleTerminalInputHandoff(handle, msg.sessionId, "turn");
+                }
                 return;
             case "rotate": {
                 if (handle.dead)
@@ -1002,7 +1282,11 @@ export class RunnerManager {
     terminateHandle(handle, reason) {
         if (handle.termination)
             return handle.termination;
-        handle.termination = (async () => {
+        if (handle.terminalCleanupRetryTimer) {
+            clearTimeout(handle.terminalCleanupRetryTimer);
+            delete handle.terminalCleanupRetryTimer;
+        }
+        const attempt = (async () => {
             if (!handle.dead) {
                 try {
                     handle.transport.send({ t: "shutdown" });
@@ -1012,16 +1296,37 @@ export class RunnerManager {
                 }
                 this.failHandle(handle, reason);
             }
-            signalChild(handle.child, "SIGTERM");
-            if (!(await waitForChildExit(handle.completion, this.shutdownGraceMs))) {
-                signalChild(handle.child, "SIGKILL");
-                if (!(await waitForChildExit(handle.completion, this.shutdownKillGraceMs))) {
-                    throw new Error(`runner child ${handle.child.pid ?? handle.key} did not exit after SIGKILL`);
-                }
+            this.signalChild(handle.child, "SIGTERM", handle.processGroup);
+            let childExited = await waitForChildExit(handle.completion, this.shutdownGraceMs);
+            if (!childExited) {
+                this.signalChild(handle.child, "SIGKILL", handle.processGroup);
+                childExited = await waitForChildExit(handle.completion, this.shutdownKillGraceMs);
+            }
+            const terminalStopped = handle.key === CAP_KEY
+                ? true
+                : await Promise.resolve(this.terminateTerminalServer(`${handle.key}-main`)).catch(() => false);
+            if (!childExited) {
+                throw new Error(`runner child ${handle.child.pid ?? handle.key} did not exit after SIGKILL`);
+            }
+            if (!terminalStopped) {
+                throw new Error(`runner terminal ${handle.key}-main remained live after child exit`);
             }
             this.childHandles.delete(handle);
         })();
-        return handle.termination;
+        handle.termination = attempt;
+        void attempt.then(() => {
+            this.finishAllTerminalInputHandoffs(handle);
+        }, () => {
+            if (handle.termination === attempt)
+                delete handle.termination;
+            handle.terminalCleanupRetryFailures += 1;
+            // A failed cleanup must not pin closeAndDrain forever. Keep the
+            // submission in the daemon activity snapshot, but release its gate
+            // reservation so maintenance returns a structured busy result.
+            this.preserveTerminalInputHandoffsAsActivity(handle);
+            this.scheduleTerminalInputCleanupRetry(handle);
+        });
+        return attempt;
     }
     reapIdle() {
         const now = this.now();
@@ -1060,6 +1365,70 @@ export class RunnerManager {
         }
     }
 }
+function trackedTerminalSubmissions(tracker, data) {
+    const pasteStart = "\u001b[200~";
+    const pasteEnd = "\u001b[201~";
+    const input = tracker.pendingEscape + data;
+    tracker.pendingEscape = "";
+    const submissions = [];
+    for (let index = 0; index < input.length; index += 1) {
+        const character = input[index] ?? "";
+        if (character === "\u001b") {
+            const remaining = input.slice(index);
+            if (remaining.startsWith(pasteStart)) {
+                tracker.bracketedPaste = true;
+                tracker.previousWasCarriageReturn = false;
+                index += pasteStart.length - 1;
+                continue;
+            }
+            if (remaining.startsWith(pasteEnd)) {
+                tracker.bracketedPaste = false;
+                tracker.previousWasCarriageReturn = false;
+                index += pasteEnd.length - 1;
+                continue;
+            }
+            if (pasteStart.startsWith(remaining) || pasteEnd.startsWith(remaining)) {
+                tracker.pendingEscape = remaining;
+                break;
+            }
+        }
+        if (tracker.bracketedPaste) {
+            tracker.buffer += character;
+            tracker.previousWasCarriageReturn = false;
+            continue;
+        }
+        if (character === "\n" && tracker.previousWasCarriageReturn) {
+            tracker.previousWasCarriageReturn = false;
+            continue;
+        }
+        tracker.previousWasCarriageReturn = character === "\r";
+        if (character === "\r" || character === "\n") {
+            const command = tracker.buffer.trim();
+            tracker.buffer = "";
+            if (command.length > 0 &&
+                (command.includes("\u001b") ||
+                    !command.startsWith("/") ||
+                    /^\/(?:clear|fork)(?:\s|$)/u.test(command))) {
+                submissions.push(/^\/(?:clear|fork)(?:\s|$)/u.test(command) ? "rotation" : "turn");
+            }
+            continue;
+        }
+        if (character === "\b" || character === "\u007f") {
+            tracker.buffer = tracker.buffer.slice(0, -1);
+            continue;
+        }
+        if (character === "\u0015" || character === "\u0003") {
+            tracker.buffer = "";
+            continue;
+        }
+        // Printable text and tabs are enough to distinguish work-producing prompts
+        // from local TUI slash commands. Other control sequences are ignored.
+        if (character === "\u001b" || character === "\t" || character >= " ") {
+            tracker.buffer += character;
+        }
+    }
+    return submissions;
+}
 function validateSessionContext(context) {
     if (!context || typeof context !== "object") {
         throw new Error("Session context environment provider must return an object");
@@ -1164,9 +1533,18 @@ function observeChildCompletion(child) {
         child.once("exit", onExit);
     });
 }
-function signalChild(child, signal) {
+function signalRunnerChild(child, signal, processGroup) {
     if (childHasExited(child))
         return;
+    if (processGroup && child.pid) {
+        try {
+            process.kill(-child.pid, signal);
+            return;
+        }
+        catch {
+            // The group may have exited between the completion check and the signal.
+        }
+    }
     try {
         child.kill(signal);
     }

package/dist/terminal/tmux.d.ts

@@ -43,6 +43,14 @@ export interface TmuxTerminalOptions {
     /** Injectable for tests; defaults to the real `tmux` binary path. */
     tmuxBin?: string;
 }
+/** Deterministic private socket owned by one terminal name. Parent-side
+ * shutdown uses the same mapping when the runner child is too wedged to clean
+ * up its own tmux server. */
+export declare function tmuxSocketPath(name: string): string;
+/** Kill one private tmux server and verify it no longer answers. Missing
+ * sockets are already stopped; an existing socket with an unusable tmux
+ * command is unproven and returns false. */
+export declare function terminateTmuxServer(name: string, tmuxBin?: string): boolean;
 /** Is a usable `tmux` on PATH? Cheap probe for the capability gate. */
 export declare function isTmuxAvailable(tmuxBin?: string): boolean;
 export declare class TmuxTerminal {

package/dist/terminal/tmux.js

@@ -16,7 +16,7 @@
  */
 import { execFile, execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { mkdirSync } from "node:fs";
+import { existsSync, mkdirSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 const TMUX_TARGET = "main";
@@ -26,6 +26,40 @@ const DEFAULT_ROWS = 24;
  *  wheel-scroll (tmux copy-mode, enabled by `mouse on`) reaches as far back as
  *  the terminal shows. Mirrors reference implementation's `TerminalEnvSpec.scrollback`. */
 const DEFAULT_SCROLLBACK = 20000;
+/** Deterministic private socket owned by one terminal name. Parent-side
+ * shutdown uses the same mapping when the runner child is too wedged to clean
+ * up its own tmux server. */
+export function tmuxSocketPath(name) {
+    const key = createHash("sha256").update(name).digest("hex").slice(0, 16);
+    return join(tmpdir(), "rynx-term", `${key}.sock`);
+}
+/** Kill one private tmux server and verify it no longer answers. Missing
+ * sockets are already stopped; an existing socket with an unusable tmux
+ * command is unproven and returns false. */
+export function terminateTmuxServer(name, tmuxBin = "tmux") {
+    const socketPath = tmuxSocketPath(name);
+    if (!existsSync(socketPath))
+        return true;
+    const base = ["-u", "-S", socketPath];
+    try {
+        execFileSync(tmuxBin, [...base, "kill-server"], { stdio: "ignore" });
+    }
+    catch {
+        // A server may have exited between existsSync and kill-server. Verify below.
+    }
+    try {
+        execFileSync(tmuxBin, [...base, "has-session", "-t", TMUX_TARGET], {
+            stdio: "ignore",
+        });
+        return false;
+    }
+    catch (error) {
+        return !(error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "ENOENT");
+    }
+}
 /** Is a usable `tmux` on PATH? Cheap probe for the capability gate. */
 export function isTmuxAvailable(tmuxBin = "tmux") {
     try {
@@ -76,8 +110,7 @@ export class TmuxTerminal {
         // under the unix-domain path limit (~104 chars on macOS) — a full session id
         // like `sess_<uuid>-main` under $TMPDIR would overflow it and fail with
         // "File name too long". The hash stays unique per terminal.
-        const key = createHash("sha256").update(opts.name).digest("hex").slice(0, 16);
-        this.socketPath = join(dir, `${key}.sock`);
+        this.socketPath = tmuxSocketPath(opts.name);
     }
     /** tmux argv prefix targeting this terminal's private server. */
     base() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/runtime",
-  "version": "0.1.11-beta.2",
+  "version": "0.1.11-beta.4",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
@@ -26,7 +26,7 @@
   "dependencies": {
     "node-pty": "^1.0.0",
     "ws": "^8.21.0",
-    "@rynx-ai/core": "0.1.11-beta.2"
+    "@rynx-ai/core": "0.1.11-beta.4"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"