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

package/dist/runner/manager.js

@@ -24,7 +24,7 @@ import { listRuntimeModels } from "../models-catalog.js";
 import { probeRuntimeStatus } from "../runtime-status.js";
 import { terminateTmuxServer, tmuxHasAttachedClient, tmuxWindowActivityAt, } from "../terminal/tmux.js";
 import { fromWireError, } from "./protocol.js";
-import { isManagedNativeProvider } from "./startup-policy.js";
+import { isCodexLineageProvider, isManagedNativeProvider } from "./startup-policy.js";
 import { StdioRunnerTransport } from "./transport.js";
 /** Routing key for the shared capability runner (slash-command RPCs). */
 const CAP_KEY = "__cap__";
@@ -34,9 +34,8 @@ const STDERR_TAIL_LINES = 40;
 const DEFAULT_SHUTDOWN_GRACE_MS = 5_000;
 /** Time allowed for exit after SIGKILL before shutdown reports failure. */
 const DEFAULT_SHUTDOWN_KILL_GRACE_MS = 5_000;
-/** Setup-pane launch includes the app-server readiness phase but does not wait
- * for native thread discovery. Keep enough headroom around the app-server's
- * own 10s gate so scheduling/IPC overhead cannot win the same deadline. */
+/** Legacy setup-pane acknowledgement deadline for providers that do not own
+ * phase-specific startup errors. Codex/Traex are deliberately excluded. */
 const DEFAULT_LIVE_START_TIMEOUT_MS = 30_000;
 /** Legacy fallback for a provider without a native startup policy. */
 const DEFAULT_LIVE_READY_TIMEOUT_MS = 25_000;
@@ -48,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. */
@@ -181,7 +177,6 @@ export class RunnerManager {
     nativeLiveStartTimeoutMs;
     liveInterruptTimeoutMs;
     terminalInputHandoffTimeoutMs;
-    terminalInputCleanupRetryMs;
     reapPromise = null;
     stopping = false;
     stopPromise;
@@ -237,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);
@@ -457,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);
         }
@@ -476,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)
@@ -509,9 +482,10 @@ export class RunnerManager {
     /**
      * Eagerly bring up a session's codex-native live view (persistent forwarder +
      * detached `codex --remote` TUI) in its runner child, spawning the runner if
-     * needed. Idempotent. For Codex-lineage fresh sessions, resolves after the
-     * app-server/observer and pane are launched; thread discovery continues in
-     * parallel with injection. Other providers retain their readiness gate.
+     * needed. Idempotent. For Codex-lineage sessions, resolves after backend
+     * preload and pane launch; known-thread observer attach and fresh-thread
+     * discovery continue in the background. Other providers retain their
+     * readiness gate.
      */
     ensureLiveSession(localThreadId, opts) {
         const admission = this.reserveAdmission();
@@ -550,55 +524,66 @@ export class RunnerManager {
         this.liveSessionKeys.add(localThreadId);
         const reqId = randomUUID();
         return new Promise((resolve) => {
-            const timeoutMs = !waitForReady
-                ? this.liveStartTimeoutMs
-                : opts.execution.provider === "claude"
-                    ? this.nativeLiveStartTimeoutMs
-                    : isManagedNativeProvider(opts.execution.provider)
-                        ? this.liveStartTimeoutMs
+            const provider = opts.execution.provider;
+            const timeoutMs = isCodexLineageProvider(provider)
+                ? null
+                : !waitForReady
+                    ? this.liveStartTimeoutMs
+                    : provider === "claude"
+                        ? this.nativeLiveStartTimeoutMs
                         : this.liveReadyTimeoutMs;
-            const timeout = setTimeout(() => {
-                if (!handle.live.delete(reqId))
-                    return;
-                const finishTimeout = () => {
-                    const provider = opts.execution.provider;
-                    const reason = !waitForReady
-                        ? `runner did not acknowledge terminal start within ${timeoutMs}ms`
-                        : provider === "claude"
-                            ? `Claude SessionStart was not observed within ${Math.round(timeoutMs / 1_000)}s; the runner process was reset before retry`
-                            : provider === "codex" || provider === "traex"
-                                ? `${provider === "traex" ? "Traex" : "Codex"} app-server/observer/Terminal launch was not acknowledged within ${Math.round(timeoutMs / 1_000)}s; the runner process was reset before retry`
+            const timeout = timeoutMs === null
+                ? undefined
+                : setTimeout(() => {
+                    if (!handle.live.delete(reqId))
+                        return;
+                    const finishTimeout = () => {
+                        const reason = !waitForReady
+                            ? `runner did not acknowledge terminal start within ${timeoutMs}ms`
+                            : provider === "claude"
+                                ? `Claude SessionStart was not observed within ${Math.round(timeoutMs / 1_000)}s; the runner process was reset before retry`
                                 : `runner did not acknowledge live readiness within ${timeoutMs}ms`;
-                    this.liveErrors.set(localThreadId, reason);
-                    this.liveSessionKeys.delete(localThreadId);
-                    // A child that cannot answer a bounded control round-trip is unsafe
-                    // to reuse. Reap it so the next click gets a fresh runner.
-                    void this.terminateHandle(handle, reason).catch((error) => {
-                        logTerminationFailure(handle, error);
-                    });
-                    return false;
-                };
-                const reservation = allowReservedForkTarget
-                    ? undefined
-                    : this.forkReservations.get(localThreadId);
-                if (reservation) {
-                    void reservation
-                        .then(() => finishTimeout())
-                        .then(resolve, () => resolve(false));
-                    return;
-                }
-                resolve(finishTimeout());
-            }, timeoutMs);
-            timeout.unref?.();
+                        this.liveErrors.set(localThreadId, {
+                            message: reason,
+                            code: provider === "claude"
+                                ? "claude_session_start_timeout"
+                                : "native_runner_ack_timeout",
+                            statusCode: 503,
+                        });
+                        this.liveSessionKeys.delete(localThreadId);
+                        // Legacy providers without phase-owned startup errors retain the
+                        // bounded control guard. Codex/Traex never enter this branch.
+                        void this.terminateHandle(handle, reason).catch((error) => {
+                            logTerminationFailure(handle, error);
+                        });
+                        return false;
+                    };
+                    const reservation = allowReservedForkTarget
+                        ? undefined
+                        : this.forkReservations.get(localThreadId);
+                    if (reservation) {
+                        void reservation
+                            .then(() => finishTimeout())
+                            .then(resolve, () => resolve(false));
+                        return;
+                    }
+                    resolve(finishTimeout());
+                }, timeoutMs);
+            timeout?.unref?.();
             handle.live.set(reqId, (res) => {
-                clearTimeout(timeout);
+                if (timeout)
+                    clearTimeout(timeout);
                 const ok = res.ok ?? false;
                 const finish = () => {
                     if (ok) {
                         this.liveErrors.delete(localThreadId);
                     }
                     else {
-                        this.liveErrors.set(localThreadId, res.error ?? "live session did not become ready");
+                        this.liveErrors.set(localThreadId, res.error ?? {
+                            message: "live session did not become ready",
+                            code: "native_readiness_failed",
+                            statusCode: 503,
+                        });
                     }
                     return ok;
                 };
@@ -626,7 +611,11 @@ export class RunnerManager {
         });
     }
     lastLiveSessionError(localThreadId) {
-        return this.liveErrors.get(localThreadId);
+        return this.liveErrors.get(localThreadId)?.message;
+    }
+    lastLiveSessionFailure(localThreadId) {
+        const failure = this.liveErrors.get(localThreadId);
+        return failure ? { ...failure } : undefined;
     }
     /**
      * Inject a user turn into a session's live codex thread — reference implementation's
@@ -653,21 +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 ?? `live injection ${outcome}`);
+                        this.liveErrors.set(localThreadId, res.error ?? {
+                            message: `live injection ${result.outcome}`,
+                            code: result.outcome === "notReady"
+                                ? "native_thread_not_ready"
+                                : 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());
@@ -714,7 +711,7 @@ export class RunnerManager {
             handle.live.set(reqId, (reply) => {
                 resolve(reply.interactionResult ?? {
                     disposition: "invalid",
-                    message: reply.error ?? "runner did not return an interaction result",
+                    message: reply.error?.message ?? "runner did not return an interaction result",
                 });
             });
             handle.transport.send({
@@ -1188,7 +1185,6 @@ export class RunnerManager {
             activeResponseIds: new Set(),
             dead: false,
             completion,
-            terminalCleanupRetryFailures: 0,
             processGroup,
             ...(sessionContext ? { sessionContext } : {}),
             caps: new Map(),
@@ -1275,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;
             }
@@ -1318,7 +1314,10 @@ export class RunnerManager {
             terminal._fail(message);
         }
         for (const resolve of handle.live.values()) {
-            resolve({ ok: false, error: message });
+            resolve({
+                ok: false,
+                error: { message, code: "runner_crashed", statusCode: 500 },
+            });
         }
         handle.caps.clear();
         handle.terminals.clear();
@@ -1328,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 {
@@ -1348,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;
@@ -1365,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;
     }
@@ -1503,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 {
@@ -64,9 +64,9 @@ export type ToChild = {
 }
 /** Eagerly bring up a session's live codex TUI + forwarder (codex-native), so
  *  its turns mirror to the bus regardless of whether the web has attached the
- *  terminal. For Codex-lineage fresh sessions, `live.ready` acknowledges that
- *  the pane and observer exist; background thread discovery races the
- *  executor's bridge wait. */
+ *  terminal. Fresh sessions connect the discovery listener before TUI launch;
+ *  known-thread resumes launch the TUI after backend preload and attach their
+ *  observer in the background. */
  | {
     t: "live.ensure";
     reqId: string;
@@ -155,25 +155,26 @@ export type FromChild = {
     execution: ResolvedExecutionSnapshot;
     parentSessionId?: string;
 }
-/** Result of a `live.ensure`: for Codex-lineage sessions `ok` means the pane
- *  and observer started; thread discovery continues in parallel with
- *  injection. Other Providers retain their own readiness gate. */
+/** Result of a `live.ensure`: for Codex-lineage sessions `ok` means backend
+ *  preload and pane launch completed. A resume observer and fresh-thread
+ *  discovery may continue in the background. Other Providers retain their
+ *  own readiness gate. */
  | {
     t: "live.ready";
     reqId: string;
     localThreadId: string;
     ok: boolean;
-    error?: string;
+    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;
-    error?: string;
+    result: InjectResult;
+    error?: WireError;
 }
 /** Result of a `live.interrupt`: `ok` when an active turn was interrupted (false
  *  when there was none). Echoes the request `reqId`. */
@@ -182,7 +183,7 @@ export type FromChild = {
     reqId: string;
     localThreadId: string;
     ok: boolean;
-    error?: string;
+    error?: WireError;
 } | {
     t: "interaction.resolved";
     reqId: string;

package/dist/runner/startup-policy.d.ts

@@ -2,3 +2,6 @@ import type { AgentRuntimeId } from "@rynx-ai/core";
 /** Current live providers are native CLI sessions. Keep this explicit so a
  * future non-native provider does not silently inherit their startup budget. */
 export declare function isManagedNativeProvider(provider: AgentRuntimeId | undefined): provider is AgentRuntimeId;
+/** Codex-lineage providers own app-server, thread-discovery, and injection
+ * phase errors. Claude instead retains its parent-owned SessionStart gate. */
+export declare function isCodexLineageProvider(provider: AgentRuntimeId | undefined): provider is Exclude<AgentRuntimeId, "claude">;

package/dist/runner/startup-policy.js

@@ -3,3 +3,8 @@
 export function isManagedNativeProvider(provider) {
     return provider === "codex" || provider === "traex" || provider === "claude";
 }
+/** Codex-lineage providers own app-server, thread-discovery, and injection
+ * phase errors. Claude instead retains its parent-owned SessionStart gate. */
+export function isCodexLineageProvider(provider) {
+    return provider === "codex" || provider === "traex";
+}

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;