@rynx-ai/runtime 0.1.11-beta.32 → 0.1.11-beta.34

package/dist/host.js

@@ -15,8 +15,10 @@ import { validateInteractionResolution } from "./interactions.js";
 import { CodexAppServerClient, buildRuntimeUserInput, } from "./codex-app-server/client.js";
 import { buildAppServerBaseArgs, CodexTransportError, } from "./codex-app-server/transport.js";
 import { WsRpcChannel, ExternalWsChannel } from "./codex-app-server/ws-channel.js";
+import { reapRuntimeProcessesForStateDir } from "./codex-app-server/process-registry.js";
 import { CodexSessionForwarder } from "./codex-app-server/forwarder.js";
 import { readMcpStartupPlan } from "./codex-app-server/mcp-startup.js";
+import { runtimeSessionStateDir } from "./runtime-state-paths.js";
 import { buildCodexRemoteArgs } from "./terminal/codex-tui.js";
 import { buildClaudeTuiArgs } from "./terminal/claude-tui.js";
 import { providerAdditionalDirs, threadWorkspaceParams, turnWorkspaceParams, } from "./provider-workspace.js";
@@ -361,6 +363,7 @@ export class LocalAgentHost {
     /** Claude forwarders stopped before their terminal is killed. Runner shutdown
      * finalizes these synchronously afterwards to scrub raw interaction answers. */
     pendingClaudeFinalizers = new Set();
+    pendingCleanupTasks = new Set();
     // In-flight `ensureLiveCodexSession` calls, so concurrent triggers (a web
     // `live.ensure` racing a `term.open`) share ONE forwarder — never two.
     liveEnsuring = new Map();
@@ -477,6 +480,7 @@ export class LocalAgentHost {
         const channel = new WsRpcChannel({
             cliPath,
             baseArgs: buildAppServerBaseArgs(sandbox),
+            stateDir: runtimeSessionStateDir(this.runtimeHomeSessionId),
             extraEnv: {
                 ...(extraEnv ?? {}),
                 [profile.homeEnvVar]: this.runtimeHome(runtime),
@@ -639,6 +643,7 @@ export class LocalAgentHost {
         const profile = getRuntimeProfile(runtime);
         const activeThreadId = live?.threadId ?? record?.codexSessionId;
         return {
+            lifecycle: "auxiliary",
             command: resolveRuntimeBinary(runtime),
             args: buildCodexRemoteArgs({
                 remoteUrl,
@@ -648,6 +653,10 @@ export class LocalAgentHost {
                 additionalDirs: providerAdditionalDirs(live.workspace),
             }),
             cwd: live.workspace.cwd,
+            scrollback: 100_000,
+            tmuxAllowPassthrough: true,
+            tmuxStartOnAttach: false,
+            keepAliveAfterExit: false,
             ...(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
@@ -765,6 +774,7 @@ export class LocalAgentHost {
             void snapshotSkills.skillsCleanup();
             return false;
         };
+        reapRuntimeProcessesForStateDir(runtimeSessionStateDir(this.runtimeHomeSessionId));
         const appServerOwner = this.getBackend(runtime, execution.budget ?? undefined).appServerClient;
         if (!appServerOwner) {
             this.liveStartupErrors.set(localThreadId, nativeLiveFailure(runtime, "native_app_server_unavailable", "app-server is unavailable for this Session"));
@@ -1418,6 +1428,7 @@ export class LocalAgentHost {
                     kind,
                 });
                 this.liveSessions.set(newSessionId, live);
+                this.liveSessions.delete(previousSessionId);
                 retargetMirror?.(newSessionId, {
                     kind,
                     workspace: structuredClone(live.workspace),
@@ -1843,7 +1854,8 @@ export class LocalAgentHost {
                     claude.pendingImageInputs.delete(token);
             }
             else {
-                pendingInput.responseId = result.responseId;
+                if (result.responseId)
+                    pendingInput.responseId = result.responseId;
                 if (pendingInput.observed)
                     forgetPendingInput();
                 else
@@ -2088,6 +2100,7 @@ export class LocalAgentHost {
             this.liveClaudeSessions.delete(localThreadId);
             claude.stopped = true;
             claude.forwarder.stop();
+            this.trackCleanup(claude.forwarder.waitForStop());
             if (opts.deferClaudeInteractionCleanup) {
                 this.pendingClaudeFinalizers.add(claude.forwarder);
             }
@@ -2118,9 +2131,10 @@ export class LocalAgentHost {
         live.canonicalInteractions.clear();
         live.settledInteractions.clear();
         live.syntheticInteractions.clear();
-        void live.forwarderClient.stop().catch(() => undefined);
+        this.trackCleanup(live.forwarderClient.stop().catch(() => undefined));
         // Remove the session-scoped skills dir — the machine keeps zero task residue.
-        void live.skillsCleanup?.();
+        if (live.skillsCleanup)
+            this.trackCleanup(live.skillsCleanup());
     }
     /** Tear down one codex-lineage native runtime without deleting its durable
      * session-store binding. reference implementation couples its auxiliary Terminal, observer,
@@ -2138,14 +2152,19 @@ export class LocalAgentHost {
         if (backend?.appServerClient === appServerOwner) {
             this.backends.delete(backendKey);
         }
-        void appServerOwner.stop().catch((stopError) => {
+        this.trackCleanup(appServerOwner.stop().catch((stopError) => {
             console.warn(`[codex-live] session=${localThreadId} runtime=${live.runtime} app-server teardown failed: ${stopError instanceof Error ? stopError.message : String(stopError)}`);
-        });
+        }));
         return turnFailed;
     }
+    async teardownAuxiliaryTerminalRuntime(localThreadId) {
+        const owner = this.liveSessions.get(localThreadId)?.appServerOwner;
+        this.teardownLiveCodexSession(localThreadId);
+        await owner?.stop().catch(() => undefined);
+    }
     /** Complete the second shutdown phase after the runner has killed all native
      * terminals and hook subprocesses. Must run before the runner process exits. */
-    finalizeStoppedLiveSessions() {
+    async finalizeStoppedLiveSessions() {
         for (const forwarder of this.pendingClaudeFinalizers)
             forwarder.finalizeStop();
         this.pendingClaudeFinalizers.clear();
@@ -2154,10 +2173,20 @@ export class LocalAgentHost {
         // that can only reconnect to a dead session. `stop()` sends SIGTERM before
         // its returned promise yields, so this remains safe in the synchronous
         // runner shutdown path.
-        for (const backend of this.backends.values()) {
-            void backend.appServerClient?.stop().catch(() => undefined);
-        }
+        const backendStops = [...this.backends.values()].map((backend) => backend.appServerClient?.stop().catch(() => undefined));
         this.backends.clear();
+        await Promise.all([
+            ...backendStops,
+            ...this.pendingCleanupTasks,
+        ]);
+        this.pendingCleanupTasks.clear();
+    }
+    trackCleanup(task) {
+        const guarded = task.catch((error) => {
+            console.warn(`[native-runtime] cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
+        this.pendingCleanupTasks.add(guarded);
+        void guarded.then(() => this.pendingCleanupTasks.delete(guarded));
     }
     // --- claude-native live session (parallel to the codex methods above) -----
     /** The interactive `claude` TUI spec for a claude-native live session: the real
@@ -2216,9 +2245,14 @@ export class LocalAgentHost {
             ...(live.launchExtraArgs.length ? { extraArgs: live.launchExtraArgs } : {}),
         });
         return {
+            lifecycle: "required",
             command: resolveRuntimeBinary("claude"),
             args,
             cwd,
+            scrollback: 50_000,
+            tmuxAllowPassthrough: false,
+            tmuxStartOnAttach: false,
+            keepAliveAfterExit: true,
             // Same env the pane would inherit by default, plus the session scope for
             // agent-run CLIs (rynx-emulator resolves device-less commands via it).
             env: { ...process.env, RYNX_SESSION_ID: localThreadId },
@@ -2598,6 +2632,7 @@ export class LocalAgentHost {
                 live.contextWarned = false;
                 pendingRotationEvents = [];
                 this.liveClaudeSessions.set(newSessionId, live);
+                this.liveClaudeSessions.delete(previousSessionId);
                 void this.sessionStore
                     .set({
                     localThreadId: newSessionId,
@@ -2703,11 +2738,10 @@ export class LocalAgentHost {
                 if (!ok)
                     return { outcome: "failed" };
                 const responseId = pendingInput.responseId ?? live.currentResponseId();
-                if (!responseId) {
-                    live.error = "Claude accepted the message but did not publish its native Turn identity";
-                    return { outcome: "failed" };
-                }
-                return { outcome: steered ? "steered" : "injected", responseId };
+                return {
+                    outcome: steered ? "steered" : "injected",
+                    ...(responseId ? { responseId } : {}),
+                };
             }
             catch (error) {
                 live.error = error instanceof Error ? error.message : String(error);

package/dist/index.d.ts

@@ -13,6 +13,6 @@ export type { InjectOutcome, InjectResult, TerminalOpenErrorCode, TerminalRole }
 export type { ResolveInteractionResult, RuntimeInteractionEvent, RuntimeInteractionListener, } from "./interactions.js";
 export { probeRuntimeStatus } from "./runtime-status.js";
 export { listRuntimeModels } from "./models-catalog.js";
-export { TmuxTerminal, isTmuxAvailable, terminateTmuxServer, tmuxSocketPath, } from "./terminal/tmux.js";
-export type { TerminalAttachment, TmuxTerminalOptions } from "./terminal/tmux.js";
+export { TmuxTerminal, isTmuxAvailable, resolveTmuxBin, terminateTmuxServer, tmuxSocketPath, } from "./terminal/tmux.js";
+export type { PreparedTerminalAttachment, PullTerminalAttachment, 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, terminateTmuxServer, tmuxSocketPath, } from "./terminal/tmux.js";
+export { TmuxTerminal, isTmuxAvailable, resolveTmuxBin, terminateTmuxServer, tmuxSocketPath, } from "./terminal/tmux.js";
 export { TerminalRegistry } from "./terminal/registry.js";

package/dist/runner/child.d.ts

@@ -1,5 +1,6 @@
 import { type AgentCapabilities, type LiveSessionFailure, type ResolvedExecutionSnapshot, type RuntimeTurnOptions, type RuntimeUserInput, type SessionCollaborationMode, type SessionInteractionResolution, type SessionWorkspaceSnapshot } from "@rynx-ai/core";
 import type { SessionEvent } from "@rynx-ai/core";
+import { type TerminalLifecycle } from "../terminal/registry.js";
 import type { TerminalInjector } from "../claude/native-integration.js";
 import type { ResolveInteractionResult } from "../interactions.js";
 import { type InjectResult } from "./protocol.js";
@@ -23,6 +24,11 @@ interface LiveCodexProvider {
         cwd: string;
         env?: Record<string, string>;
         skipTraexStartupPrompts?: boolean;
+        scrollback?: number;
+        tmuxAllowPassthrough?: boolean;
+        tmuxStartOnAttach?: boolean;
+        keepAliveAfterExit?: boolean;
+        lifecycle: TerminalLifecycle;
     } | null>;
     ensureLiveCodexSession?(localThreadId: string, emit: (event: SessionEvent) => void, opts: {
         workspace: SessionWorkspaceSnapshot;
@@ -45,13 +51,16 @@ interface LiveCodexProvider {
      * 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;
+    /** Cleanup coupled runtime resources after an auxiliary terminal is
+     * intentionally idle-reaped. Unexpected auxiliary exit does not call this. */
+    teardownAuxiliaryTerminalRuntime?(localThreadId: string): Promise<void>;
     injectMessage?(localThreadId: string, input: RuntimeUserInput | string, options?: RuntimeTurnOptions): Promise<InjectResult>;
     updateCollaborationMode?(localThreadId: string, mode: SessionCollaborationMode): Promise<void>;
     interruptLive?(localThreadId: string): Promise<boolean>;
     stopLiveCodexSession?(localThreadId: string, opts?: {
         deferClaudeInteractionCleanup?: boolean;
     }): void;
-    finalizeStoppedLiveSessions?(): void;
+    finalizeStoppedLiveSessions?(): void | Promise<void>;
     resolveInteraction?(localThreadId: string, interactionId: string, resolution: SessionInteractionResolution): Promise<ResolveInteractionResult>;
     /** Hand the session's tmux pane injector to the host (which doesn't own
      * tmux). Claude uses it for messages; Codex uses it only for TUI-local
@@ -77,8 +86,10 @@ export declare class RunnerSession {
     private readonly onShutdown;
     /** Live terminals hosted by this session, and per-attach client handles. */
     private readonly terminals;
+    private readonly preparations;
     private readonly attachments;
     private readonly attachmentThreadIds;
+    private readonly attachmentRoles;
     private readonly traexStartupWatchers;
     private readonly traexStartupGates;
     private readonly terminalWatchers;
@@ -91,7 +102,9 @@ export declare class RunnerSession {
     private readonly mirrorImageAcks;
     /** Provider name retained for asynchronous Terminal-exit diagnostics. */
     private readonly liveRuntimes;
+    private readonly terminalStatuses;
     private shuttingDown;
+    private shutdownPromise;
     constructor({ transport, executor, onShutdown }: RunnerSessionDeps);
     private handle;
     private get liveProvider();
@@ -102,6 +115,7 @@ export declare class RunnerSession {
      *  new session AND tells the daemon to alias the runner (terminal transfer) so
      *  the new session stays injectable. */
     private mirrorChannel;
+    private transferNativeSessionResources;
     private enqueueMirror;
     private sendMirroredEvent;
     private sendMirrorImageFrame;
@@ -122,6 +136,7 @@ export declare class RunnerSession {
     private inject;
     private updateCollaborationMode;
     private interruptLive;
+    private reapTerminal;
     /** Launch (idempotently) the session's codex TUI pane from the executor's
      *  `codexTerminalSpec`. Shares the `${id}-main` terminal id with `term.open`,
      *  so the web attach reuses the same detached pane. */
@@ -132,10 +147,16 @@ export declare class RunnerSession {
     private stopLive;
     /** Stop event forwarding, kill native terminals/hooks, then synchronously
      * scrub provider handoff files before the child process is allowed to exit. */
-    shutdown(): void;
+    shutdown(): Promise<void>;
     private openTerminal;
-    /** Attach an already-created terminal and forward its data/exit to the parent. */
+    /** Prepare captured history without starting the live control client. */
     private attachExisting;
+    private readTerminalSeed;
+    private startTerminal;
+    private readTerminalOutput;
+    private writeTerminalInput;
+    private resizeTerminal;
+    private sendTerminalOperationError;
     private runCap;
     private dispatchCap;
 }