@rynx-ai/runtime 0.1.11-beta.22 → 0.1.11-beta.23

package/dist/runner/child.d.ts

@@ -11,7 +11,7 @@ import { type AgentCapabilities, type LiveSessionFailure, type ResolvedExecution
 import type { SessionEvent } from "@rynx-ai/core";
 import type { TerminalInjector } from "../claude/native-integration.js";
 import type { ResolveInteractionResult } from "../interactions.js";
-import { type InjectOutcome } from "./protocol.js";
+import { type InjectResult } from "./protocol.js";
 import type { ChildTransport } from "./transport.js";
 /** Re-target the mirror to a freshly minted rynx session (claude `/clear`·`/fork`)
  *  + record the terminal transfer with the daemon. The child owns the transport,
@@ -50,7 +50,11 @@ interface LiveCodexProvider {
     liveSessionFailure?(localThreadId: string): LiveSessionFailure | undefined;
     failLiveStartup?(localThreadId: string, error: Error): boolean;
     failLiveSession?(localThreadId: string, error: Error): boolean;
-    injectMessage?(localThreadId: string, input: RuntimeUserInput | string): Promise<InjectOutcome>;
+    /** Codex/Traex auxiliary Terminal lifecycle: settle the current Turn, stop
+     * observer/forwarder, and evict the owned app-server while preserving the
+     * durable native-session binding for a later cold resume. */
+    teardownLiveCodexSession?(localThreadId: string, error?: Error): boolean;
+    injectMessage?(localThreadId: string, input: RuntimeUserInput | string): Promise<InjectResult>;
     interruptLive?(localThreadId: string): Promise<boolean>;
     stopLiveCodexSession?(localThreadId: string, opts?: {
         deferClaudeInteractionCleanup?: boolean;

package/dist/runner/child.js

@@ -30,10 +30,15 @@ function nativePhaseError(runtime, code, phase, cause) {
     return new AgentRuntimeError(`${providerDisplayName(runtime)} ${phase}${detail}`, 503, code);
 }
 function terminalFailureDetail(pane) {
+    // A captured pane is a screen snapshot, not stderr. Do not present ordinary
+    // TUI chrome ("Working", shortcuts, model/status bars) as the process's exit
+    // cause. Retain only lines that plausibly carry an actual startup/runtime
+    // failure; the structured error still reports the proven pane exit itself.
     return pane
         .split("\n")
         .map((line) => line.trim())
         .filter(Boolean)
+        .filter((line) => /\b(?:error|fatal|failed|failure|panic|refused|denied|unauthorized|invalid)\b/i.test(line))
         .slice(-6)
         .join(" ")
         .slice(-1_000);
@@ -347,7 +352,7 @@ export class RunnerSession {
      * already-rejected readiness promise. */
     failCodexThreadStartup(localThreadId, provider, error) {
         if (!provider.failLiveStartup?.(localThreadId, error))
-            return;
+            return false;
         const watcher = this.terminalWatchers.get(localThreadId);
         if (watcher)
             clearInterval(watcher);
@@ -359,27 +364,34 @@ export class RunnerSession {
         catch (closeError) {
             console.warn(`[runner] session=${localThreadId} failed to close native Terminal after startup failure: ${closeError instanceof Error ? closeError.message : String(closeError)}`);
         }
-        provider.stopLiveCodexSession?.(localThreadId);
+        if (provider.teardownLiveCodexSession) {
+            provider.teardownLiveCodexSession(localThreadId);
+        }
+        else {
+            provider.stopLiveCodexSession?.(localThreadId);
+        }
         this.liveIds.delete(localThreadId);
+        return true;
     }
     async inject(msg) {
         const provider = this.liveProvider;
         try {
             const input = msg.input ?? msg.text;
-            const outcome = (await provider.injectMessage?.(msg.localThreadId, input)) ?? "notLive";
+            const result = (await provider.injectMessage?.(msg.localThreadId, input))
+                ?? { outcome: "notLive" };
             // App-server injection is independent of the Terminal TUI startup, so it
             // must not cancel prompt handling for the pane that is still starting.
-            const error = outcome === "injected" || outcome === "steered"
+            const error = result.outcome === "injected" || result.outcome === "steered"
                 ? undefined
                 : providerFailure(provider, msg.localThreadId, {
-                    code: outcome === "notReady"
+                    code: result.outcome === "notReady"
                         ? "native_thread_not_ready"
-                        : outcome === "notLive"
+                        : result.outcome === "notLive"
                             ? "native_session_not_live"
                             : "native_message_injection_failed",
-                    message: outcome === "notReady"
+                    message: result.outcome === "notReady"
                         ? "Native session was not ready for message injection"
-                        : outcome === "notLive"
+                        : result.outcome === "notLive"
                             ? "Native session was not live for message injection"
                             : "Native message injection failed",
                 });
@@ -387,7 +399,7 @@ export class RunnerSession {
                 t: "injected",
                 reqId: msg.reqId,
                 localThreadId: msg.localThreadId,
-                outcome,
+                result,
                 ...(error ? { error } : {}),
             });
         }
@@ -396,7 +408,7 @@ export class RunnerSession {
                 t: "injected",
                 reqId: msg.reqId,
                 localThreadId: msg.localThreadId,
-                outcome: "failed",
+                result: { outcome: "failed" },
                 error: toWireError(error),
             });
         }
@@ -452,17 +464,50 @@ export class RunnerSession {
             if (checking || this.shuttingDown || this.terminals.get(terminalId) !== terminal)
                 return;
             checking = true;
-            const probe = terminal.isAliveAsync?.() ?? Promise.resolve(terminal.isAlive());
-            void probe.then((alive) => {
-                if (alive || this.shuttingDown || this.terminals.get(terminalId) !== terminal)
+            const probe = terminal.lifecycleLivenessAsync
+                ? terminal.lifecycleLivenessAsync()
+                : terminal.livenessAsync
+                    ? terminal.livenessAsync()
+                    : terminal.isAliveAsync
+                        ? terminal.isAliveAsync().then((alive) => alive ? "alive" : "dead")
+                        : Promise.resolve(terminal.isAlive() ? "alive" : "dead");
+            void probe.then((liveness) => {
+                // A failed pane probe is inconclusive. Only Omnigent's lifecycle
+                // evidence — capture target gone or explicit pane_dead — may fail it.
+                if (liveness !== "dead" ||
+                    this.shuttingDown ||
+                    this.terminals.get(terminalId) !== terminal)
                     return;
                 clearInterval(timer);
                 this.terminalWatchers.delete(localThreadId);
                 this.cancelTraexStartupWatcher(localThreadId);
                 const runtime = this.liveRuntimes.get(localThreadId);
                 const paneFailure = terminalFailureDetail(terminal.capturePane?.() ?? "");
+                const startupFailed = this.failCodexThreadStartup(localThreadId, this.liveProvider, nativePhaseError(runtime, "native_terminal_exited_before_session", "Terminal exited before native session discovery completed", paneFailure || undefined));
+                if (isCodexLineageProvider(runtime)) {
+                    if (!startupFailed) {
+                        try {
+                            this.terminals.close(terminalId);
+                        }
+                        catch (closeError) {
+                            console.warn(`[runner] session=${localThreadId} failed to close exited native Terminal: ${closeError instanceof Error ? closeError.message : String(closeError)}`);
+                        }
+                        const exitError = nativePhaseError(runtime, "native_terminal_exited", "Terminal exited unexpectedly", paneFailure || undefined);
+                        if (this.liveProvider.teardownLiveCodexSession) {
+                            this.liveProvider.teardownLiveCodexSession(localThreadId, exitError);
+                        }
+                        else {
+                            this.liveProvider.failLiveSession?.(localThreadId, exitError);
+                            this.liveProvider.stopLiveCodexSession?.(localThreadId);
+                        }
+                        this.liveIds.delete(localThreadId);
+                        console.warn(`[runner] session=${localThreadId} ${providerDisplayName(runtime)} auxiliary Terminal exited; native runtime torn down for cold resume`);
+                    }
+                    return;
+                }
                 this.liveProvider.failLiveSession?.(localThreadId, nativePhaseError(runtime, "native_terminal_exited", "Terminal exited unexpectedly", paneFailure || undefined));
-                this.failCodexThreadStartup(localThreadId, this.liveProvider, nativePhaseError(runtime, "native_terminal_exited_before_session", "Terminal exited before native session discovery completed", paneFailure || undefined));
+            }).catch((error) => {
+                console.warn(`[runner] session=${localThreadId} native Terminal liveness probe failed: ${error instanceof Error ? error.message : String(error)}`);
             }).finally(() => {
                 checking = false;
             });

package/dist/runner/manager.d.ts

@@ -16,10 +16,10 @@
  * channel.
  */
 import { spawn as nodeSpawn, type ChildProcess } from "node:child_process";
-import { type AdmissionReservation, type AgentCapabilities, type AgentRuntimeId, type AppConfig, type CapabilityResult, type ModelListResponse, type LiveSessionFailure, type ResolvedExecutionSnapshot, type RuntimeUserInput, type SessionInteractionResolution, type SessionEvent, type SessionWorkspaceSnapshot, type ThreadGoal } from "@rynx-ai/core";
+import { type AdmissionReservation, type AgentCapabilities, type AgentRuntimeId, type AppConfig, type CapabilityResult, type ModelListResponse, type LiveSessionFailure, type InjectResult, 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";
+import { type TerminalOpenErrorCode, type TerminalRole } from "./protocol.js";
 /** Runtime-local context attached to one Session runner process. The provider is
  * intentionally generic: package-specific resources stay in the composition
  * root that implements this port. */
@@ -67,15 +67,13 @@ export interface RunnerManagerOptions {
     /** 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. */
+    /** Injected for tests. Best-effort close of the deterministic private tmux
+     * server owned by a Session runner; Omnigent does not verify/retry close. */
     terminateTerminalServer?: (terminalName: string) => boolean | Promise<boolean>;
     /** Injected tmux `#{window_activity}` reader. Returns epoch seconds. */
     terminalWindowActivityAt?: (terminalName: string) => number | null | Promise<number | null>;
@@ -176,7 +174,6 @@ export declare class RunnerManager implements AgentCapabilities {
     private readonly nativeLiveStartTimeoutMs;
     private readonly liveInterruptTimeoutMs;
     private readonly terminalInputHandoffTimeoutMs;
-    private readonly terminalInputCleanupRetryMs;
     private reapPromise;
     private stopping;
     private stopPromise;
@@ -243,7 +240,6 @@ export declare class RunnerManager implements AgentCapabilities {
     private finishTerminalInputHandoff;
     private finishAllTerminalInputHandoffs;
     private preserveTerminalInputHandoffsAsActivity;
-    private scheduleTerminalInputCleanupRetry;
     private expireTerminalInputHandoffs;
     /**
      * Eagerly bring up a session's codex-native live view (persistent forwarder +
@@ -277,7 +273,7 @@ export declare class RunnerManager implements AgentCapabilities {
      * all output. Resolves true when the app-server accepted the turn, false when
      * the session has no live forwarder (caller falls back to the run path).
      */
-    injectMessage(localThreadId: string, input: RuntimeUserInput | string): Promise<InjectOutcome>;
+    injectMessage(localThreadId: string, input: RuntimeUserInput | string): Promise<InjectResult>;
     private injectMessageAdmitted;
     /**
      * Interrupt a session's active live turn — the web Stop button (codex

package/dist/runner/manager.js

@@ -47,9 +47,6 @@ const DEFAULT_NATIVE_LIVE_START_TIMEOUT_MS = 60_000;
  * 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;
 /** Full idle window before an inactive native pane becomes reapable. */
 const DEFAULT_NATIVE_PANE_IDLE_TTL_MS = 60 * 60_000;
 /** tmux output this recent independently proves that a native pane is busy. */
@@ -180,7 +177,6 @@ export class RunnerManager {
     nativeLiveStartTimeoutMs;
     liveInterruptTimeoutMs;
     terminalInputHandoffTimeoutMs;
-    terminalInputCleanupRetryMs;
     reapPromise = null;
     stopping = false;
     stopPromise;
@@ -236,7 +232,6 @@ export class RunnerManager {
         this.nativeLiveStartTimeoutMs = Math.max(1, opts.nativeLiveStartTimeoutMs ?? DEFAULT_NATIVE_LIVE_START_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(() => void this.reapIdle(), reapIntervalMs);
@@ -456,11 +451,6 @@ export class RunnerManager {
             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);
         }
@@ -475,22 +465,6 @@ export class RunnerManager {
             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)
@@ -668,29 +642,29 @@ export class RunnerManager {
         const reqId = randomUUID();
         return new Promise((resolve) => {
             handle.live.set(reqId, (res) => {
-                const outcome = res.outcome ?? "failed";
+                const result = res.result ?? { outcome: "failed" };
                 const finish = () => {
-                    if (outcome === "injected" || outcome === "steered") {
+                    if (result.outcome === "injected" || result.outcome === "steered") {
                         this.liveErrors.delete(localThreadId);
                     }
                     else {
                         this.liveErrors.set(localThreadId, res.error ?? {
-                            message: `live injection ${outcome}`,
-                            code: outcome === "notReady"
+                            message: `live injection ${result.outcome}`,
+                            code: result.outcome === "notReady"
                                 ? "native_thread_not_ready"
-                                : outcome === "notLive"
+                                : result.outcome === "notLive"
                                     ? "native_session_not_live"
                                     : "native_message_injection_failed",
                             statusCode: 503,
                         });
                     }
-                    return outcome;
+                    return result;
                 };
                 const reservation = this.forkReservations.get(localThreadId);
                 if (reservation) {
                     void reservation
                         .then(() => finish())
-                        .then(resolve, () => resolve("failed"));
+                        .then(resolve, () => resolve({ outcome: "failed" }));
                     return;
                 }
                 resolve(finish());
@@ -1211,7 +1185,6 @@ export class RunnerManager {
             activeResponseIds: new Set(),
             dead: false,
             completion,
-            terminalCleanupRetryFailures: 0,
             processGroup,
             ...(sessionContext ? { sessionContext } : {}),
             caps: new Map(),
@@ -1298,7 +1271,7 @@ export class RunnerManager {
                 const resolve = handle.live.get(msg.reqId);
                 handle.live.delete(msg.reqId);
                 resolve?.(msg.t === "injected"
-                    ? { outcome: msg.outcome, error: msg.error }
+                    ? { result: msg.result, error: msg.error }
                     : { ok: msg.ok, error: msg.error });
                 return;
             }
@@ -1354,10 +1327,6 @@ export class RunnerManager {
     terminateHandle(handle, reason) {
         if (handle.termination)
             return handle.termination;
-        if (handle.terminalCleanupRetryTimer) {
-            clearTimeout(handle.terminalCleanupRetryTimer);
-            delete handle.terminalCleanupRetryTimer;
-        }
         const attempt = (async () => {
             if (!handle.dead) {
                 try {
@@ -1374,15 +1343,14 @@ export class RunnerManager {
                 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 (handle.key !== CAP_KEY) {
+                await Promise.resolve(this.terminateTerminalServer(`${handle.key}-main`)).catch((error) => {
+                    console.warn(`[runner-manager] best-effort terminal close failed for ${handle.key}-main: ${error instanceof Error ? error.message : String(error)}`);
+                });
+            }
             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);
         })();
         handle.termination = attempt;
@@ -1391,12 +1359,9 @@ export class RunnerManager {
         }, () => {
             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.
+            // A child that survives SIGKILL is still real activity. Release the
+            // gate reservation but retain the handoff until a later explicit stop.
             this.preserveTerminalInputHandoffsAsActivity(handle);
-            this.scheduleTerminalInputCleanupRetry(handle);
         });
         return attempt;
     }
@@ -1529,6 +1494,7 @@ export class RunnerManager {
                 return;
             case "response.completed":
             case "response.failed":
+            case "session.interrupted":
                 handle.activeResponseIds.delete(event.responseId);
                 return;
             case "session.status":

package/dist/runner/protocol.d.ts

@@ -6,8 +6,8 @@
  * (`live.ensure` / `inject` / `live.interrupt`) plus per-thread capabilities and
  * terminal attachment; the reply channels mirror each request's `reqId`.
  */
-import { AgentRuntimeError, type InjectOutcome, type ResolvedExecutionSnapshot, type RuntimeUserInput, type SessionInteractionResolution, type SessionEvent, type SessionWorkspaceSnapshot } from "@rynx-ai/core";
-export type { InjectOutcome } from "@rynx-ai/core";
+import { AgentRuntimeError, type InjectResult, type ResolvedExecutionSnapshot, type RuntimeUserInput, type SessionInteractionResolution, type SessionEvent, type SessionWorkspaceSnapshot } from "@rynx-ai/core";
+export type { InjectOutcome, InjectResult } from "@rynx-ai/core";
 import type { ResolveInteractionResult } from "../interactions.js";
 /** A runtime error flattened for the wire; rebuilt parent-side as `AgentRuntimeError`. */
 export interface WireError {
@@ -166,14 +166,14 @@ export type FromChild = {
     ok: boolean;
     error?: WireError;
 }
-/** Result of an `inject`: `outcome` distinguishes a new turn, an active-turn
- *  steer, and failures so the caller never falls back to a second output path.
- *  Echoes the request `reqId`. */
+/** Result of an `inject`: `result.outcome` distinguishes a new turn, an
+ * active-turn steer, and failures. Successful results also carry the
+ * runtime-owned canonical Response identity. Echoes the request `reqId`. */
  | {
     t: "injected";
     reqId: string;
     localThreadId: string;
-    outcome: InjectOutcome;
+    result: InjectResult;
     error?: WireError;
 }
 /** Result of a `live.interrupt`: `ok` when an active turn was interrupted (false

package/dist/terminal/registry.js

@@ -31,13 +31,13 @@ export class TerminalRegistry {
             return existing;
         if (existing) {
             // Dead pane (its TUI exited) — kill the husk + drop it before relaunching.
+            this.terminals.delete(id);
             try {
                 existing.kill();
             }
             catch {
                 // already gone — fine
             }
-            this.terminals.delete(id);
         }
         const terminal = new TmuxTerminal({ ...opts, name: id });
         terminal.start();
@@ -59,8 +59,9 @@ export class TerminalRegistry {
         const terminal = this.terminals.get(id);
         if (!terminal)
             return;
-        terminal.kill();
+        // Omnigent removes the resource from its registry before best-effort close.
         this.terminals.delete(id);
+        terminal.kill();
     }
     /** Kill every terminal (runner shutdown). */
     closeAll() {

package/dist/terminal/tmux.d.ts

@@ -11,6 +11,11 @@ export interface TerminalAttachment {
     /** Detach this client. The tmux server + pane keep running. */
     kill(): void;
 }
+/** Result of probing the inner tmux pane. `unknown` is deliberately distinct
+ * from `dead`: a timed-out/unexecutable control command is inconclusive;
+ * `dead` requires an explicit dead pane. The lifecycle watcher separately
+ * mirrors Omnigent's capture failure path for a vanished server/session. */
+export type TerminalLiveness = "alive" | "dead" | "unknown";
 /** Minimal node-pty surface (kept local so this module has no type dep on it). */
 interface PtyProcess {
     onData(cb: (data: string) => void): void;
@@ -62,9 +67,11 @@ export declare function tmuxWindowActivityAt(name: string, tmuxBin?: string): Pr
  * This remains authoritative if a parent-side attachment bookkeeping edge was
  * missed during a transport failure. */
 export declare function tmuxHasAttachedClient(name: string, tmuxBin?: string): Promise<boolean>;
-/** 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. */
+/** Best-effort close of one private tmux server. Mirrors Omnigent's bounded
+ * `TerminalInstance.close`: attempt `kill-server`, then retire the private
+ * socket regardless of command outcome. The registry has already forgotten
+ * the resource, so cleanup failure is diagnostic rather than a second
+ * lifecycle state. */
 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;
@@ -80,6 +87,14 @@ export declare class TmuxTerminal {
     private readonly tmuxBin;
     private readonly injectedSpawn?;
     private started;
+    private lastPaneSnapshot;
+    /** Shared by every attachment watcher and by the lifecycle watcher's
+     * pane-dead stage. One Terminal must never fan the same tmux control probe
+     * out once per attached client. */
+    private paneLivenessFlight?;
+    /** Shared by lifecycle callers so capture + pane-dead remains one ordered
+     * Omnigent-style observation per Terminal. */
+    private lifecycleLivenessFlight?;
     constructor(opts: TmuxTerminalOptions);
     /** tmux argv prefix targeting this terminal's private server. */
     private base;
@@ -123,8 +138,17 @@ export declare class TmuxTerminal {
     /** Async pane-liveness probe — MUST NOT block the event loop. The attach
      *  pane-death watcher polls this on an interval; a synchronous `execFileSync`
      *  there stalls the runner child's event loop (freezing the PTY stream → the
-     *  terminal appears "stuck"). reference implementation's `_tmux_session_alive` uses an async
-     *  subprocess + timeout for exactly this reason. */
+     *  terminal appears "stuck"). Exactly like Omnigent's definitive pane probe,
+     *  every command error is `unknown`; only `#{pane_dead}=1` is `dead`. */
+    livenessAsync(): Promise<TerminalLiveness>;
+    /** Omnigent's always-on terminal lifecycle watcher first captures the pane:
+     * a control command that ran and reports the target missing is terminal exit;
+     * a probe that cannot spawn is inconclusive. If capture succeeds, the normal
+     * definitive `pane_dead` probe distinguishes live from exited. */
+    lifecycleLivenessAsync(): Promise<TerminalLiveness>;
+    /** Compatibility boolean for callers that cannot represent an inconclusive
+     * probe. Unknown must remain live so a transient tmux failure cannot tear down
+     * a healthy native Session. */
     isAliveAsync(): Promise<boolean>;
     /** PID of the process currently owning the pane. */
     panePid(): number | undefined;