@rynx-ai/runtime 0.1.0 → 0.1.10-beta.2

package/dist/codex-app-server/ws-channel.js

@@ -2,13 +2,13 @@
  * WebSocket {@link RpcChannel} for a codex `app-server --listen ws://IP:PORT`.
  *
  * Why a WebSocket and not the default stdio: stdio admits exactly one client
- * (the process that spawned it), so it cannot be co-driven. omnigent's working
+ * (the process that spawned it), so it cannot be co-driven. reference implementation's working
  * codex-native uses a multi-client transport (ws / uds) so a separate `codex
  * --remote` TUI can attach to the SAME app-server and resume the SAME thread.
  * This channel owns that app-server child on a loopback ws port and connects a
  * client to it; the TUI attaches to {@link WsRpcChannel.url}.
  *
- * Framing matches codex (verified from omnigent): one JSON-RPC object per
+ * Framing matches codex (verified from reference implementation): one JSON-RPC object per
  * WebSocket text frame — no newline delimiting. So `send` writes one frame per
  * message and every inbound frame is one complete JSON object.
  */
@@ -69,12 +69,20 @@ export class WsRpcChannel {
         this.ws.on("close", (code) => this.emitClose(code ?? null, null, null));
         this.ws.on("error", (error) => this.emitClose(null, null, error));
     }
-    send(line) {
+    async send(line) {
         if (this.ws?.readyState !== WebSocket.OPEN) {
             throw new Error("codex ws channel is not open");
         }
         // Codex expects one JSON object per frame; drop the NDJSON newline.
-        this.ws.send(line.endsWith("\n") ? line.slice(0, -1) : line);
+        const payload = line.endsWith("\n") ? line.slice(0, -1) : line;
+        await new Promise((resolve, reject) => {
+            this.ws.send(payload, (error) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            });
+        });
     }
     async stop(signal = "SIGTERM") {
         try {
@@ -140,7 +148,7 @@ export class WsRpcChannel {
 /**
  * Connect-only {@link RpcChannel}: attaches an ADDITIONAL client to an app-server
  * someone else already started (a {@link WsRpcChannel}'s `url`) — no spawn. This
- * is how rynx runs omnigent's multi-connection codex-native model: the backend
+ * is how rynx runs reference implementation's multi-connection codex-native model: the backend
  * client owns the app-server + drives injection, while a SEPARATE forwarder
  * connection `thread/resume`s the same thread to subscribe to its item/turn
  * notifications (verified: codex delivers a thread's items to every connection
@@ -189,11 +197,19 @@ export class ExternalWsChannel {
         this.ws.on("close", (code) => this.emitClose(code ?? null, null, null));
         this.ws.on("error", (error) => this.emitClose(null, null, error));
     }
-    send(line) {
+    async send(line) {
         if (this.ws?.readyState !== WebSocket.OPEN) {
             throw new Error("external codex ws channel is not open");
         }
-        this.ws.send(line.endsWith("\n") ? line.slice(0, -1) : line);
+        const payload = line.endsWith("\n") ? line.slice(0, -1) : line;
+        await new Promise((resolve, reject) => {
+            this.ws.send(payload, (error) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            });
+        });
     }
     async stop() {
         try {

package/dist/codex-child-env.js

@@ -6,6 +6,14 @@ const CODEX_CHILD_ENV_ALLOWLIST = [
     "TMPDIR",
     "CODEX_HOME",
     "TRAE_HOME",
+    // Keep Runtime-local CLIs on the same resident daemon when its state root is
+    // configured outside the default ~/.rynx location.
+    "RYNX_HOME",
+    // RunnerManager supplies this rotation-safe handle for the exact managed
+    // Session. Codex command executions need it to call their own Runtime
+    // Browser; the raw Browser capability and internal runner key stay outside
+    // the allowlist.
+    "RYNX_BROWSER_CONTEXT_FILE",
     "HTTP_PROXY",
     "HTTPS_PROXY",
     "ALL_PROXY",
@@ -15,6 +23,24 @@ const CODEX_CHILD_ENV_ALLOWLIST = [
     "all_proxy",
     "no_proxy",
 ];
+const PROXY_ENV_KEYS = [
+    "HTTP_PROXY",
+    "HTTPS_PROXY",
+    "ALL_PROXY",
+    "http_proxy",
+    "https_proxy",
+    "all_proxy",
+];
+const LOOPBACK_NO_PROXY_HOSTS = ["localhost", "127.0.0.1", "::1"];
+function withLoopbackNoProxy(value) {
+    const entries = value?.split(",").map((entry) => entry.trim()).filter(Boolean) ?? [];
+    const seen = new Set(entries.map((entry) => entry.toLowerCase()));
+    for (const host of LOOPBACK_NO_PROXY_HOSTS) {
+        if (!seen.has(host))
+            entries.push(host);
+    }
+    return entries.join(",");
+}
 export function createCodexChildEnv(env) {
     const childEnv = {};
     for (const key of CODEX_CHILD_ENV_ALLOWLIST) {
@@ -23,5 +49,12 @@ export function createCodexChildEnv(env) {
             childEnv[key] = value;
         }
     }
+    if (childEnv.NO_PROXY || childEnv.no_proxy || PROXY_ENV_KEYS.some((key) => childEnv[key])) {
+        const upper = childEnv.NO_PROXY ?? childEnv.no_proxy;
+        const lower = childEnv.no_proxy ?? childEnv.NO_PROXY;
+        // CIDR matching in NO_PROXY varies; Codex's WebSocket client needs exact loopback hosts.
+        childEnv.NO_PROXY = withLoopbackNoProxy(upper);
+        childEnv.no_proxy = withLoopbackNoProxy(lower);
+    }
     return childEnv;
 }

package/dist/codex-home.d.ts

@@ -1,11 +1,15 @@
+import { type AgentRuntimeId } from "@rynx-ai/core";
+export type CodexLineageRuntime = Exclude<AgentRuntimeId, "claude">;
 /**
  * The deterministic private CODEX_HOME path for a rynx session. PER-SESSION
- * (uid-scoped + `sha256(sessionId)[:32]`), mirroring omnigent's per-session
+ * (uid-scoped + `sha256(sessionId)[:32]`), mirroring reference implementation's per-session
  * `bridge_dir/codex-home` and rynx's own `claudeBridgeDir`. Pure — computes the
  * path without touching disk, so the daemon (rollout-synth) and the runner child
  * (app-server) both locate the SAME session's home from `sessionId` alone.
  */
 export declare function codexHomePath(sessionId: string): string;
+/** Deterministic private home for a Codex-lineage runtime. */
+export declare function runtimeHomePath(sessionId: string, runtime: CodexLineageRuntime): string;
 /** The OLD uid-scoped shared home (pre per-session). Kept ONLY for back-compat
  *  resume fallback — a session's rollout may still live under here. */
 export declare function legacyCodexHomePath(): string;
@@ -14,17 +18,23 @@ export declare function legacyCodexHomePath(): string;
  * `auth.json`) and settings (copied `config.toml`) but NOT the real home's pending
  * update / first-run (NUX) state — so a co-driven `codex` app-server + `--remote`
  * TUI never block on an "Update now / Press enter to continue" prompt (which would
- * wedge terminal injection). Ports omnigent's `_CODEX_HOME_SYMLINK_FILES` /
+ * wedge terminal injection). Ports reference implementation's `_CODEX_HOME_SYMLINK_FILES` /
  * `_CODEX_HOME_COPY_FILES`.
  *
- * PER-SESSION: one private home per rynx session (matching omnigent), so concurrent
+ * PER-SESSION: one private home per rynx session (matching reference implementation), so concurrent
  * agents never share a `skills/` dir. Idempotent: the symlink/copy are refreshed each
  * call so a re-login/config change propagates. Returns the private home dir.
  */
 export declare function prepareCodexHome(sessionId: string, realHome?: string): string;
+/**
+ * Prepare a private runtime home while inheriting only the login and settings
+ * files required by the selected CLI. Mutable update/NUX state remains in the
+ * real home and cannot wedge a managed app-server/TUI pair.
+ */
+export declare function prepareRuntimeHome(sessionId: string, runtime: CodexLineageRuntime, realHome?: string): string;
 /**
  * Link a resolved skill set into `<codexHome>/skills/<name>/` so the native Codex
- * discovers them at `$CODEX_HOME/skills/` — the SAME filesystem mechanism omnigent
+ * discovers them at `$CODEX_HOME/skills/` — the SAME filesystem mechanism reference implementation
  * uses (`populate_codex_skills_from_bundle` → `_populate_codex_skills`), NOT a
  * `<skills_instructions>` block injected into the prompt. Codex's app-server
  * watches this dir and re-scans on change, so a live `codex --remote` TUI — whose
@@ -32,9 +42,9 @@ export declare function prepareCodexHome(sessionId: string, realHome?: string):
  * — still sees the agent's skills.
  *
  * Each skill is a symlink to its source dir; a filesystem without symlink support
- * falls back to a recursive copy (matches omnigent's fallback).
+ * falls back to a recursive copy (matches reference implementation's fallback).
  *
- * omnigent boots a fresh per-session CODEX_HOME, so it only ever links into an
+ * reference implementation boots a fresh per-session CODEX_HOME, so it only ever links into an
  * empty dir. rynx shares ONE private home per runtime (see {@link prepareCodexHome}),
  * so this CONVERGES the dir to `skills`: it links the missing ones and removes
  * entries no longer selected, honouring the agent spec's gating. (Concurrent

package/dist/codex-home.js

@@ -1,11 +1,22 @@
 import { copyFileSync, cpSync, existsSync, mkdirSync, readdirSync, rmSync, symlinkSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { homedir, tmpdir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
+import { getRuntimeProfile, resolveRuntimeHome, } from "@rynx-ai/core";
 /** Inherit the user's LIVE login by symlink (stays in sync). */
 const SYMLINK_FILES = ["auth.json"];
 /** Inherit the user's settings by snapshot copy (not the mutable NUX/update state). */
 const COPY_FILES = ["config.toml"];
+const RUNTIME_HOME_FILES = {
+    codex: { symlink: SYMLINK_FILES, copy: COPY_FILES },
+    traex: {
+        // Traex keeps credentials below `cli/`, while its user configuration lives
+        // at the TRAE_HOME root. Keep both the current TOML name and the legacy YAML
+        // name so existing installations remain usable without an implicit migrate.
+        symlink: ["cli/auth.json"],
+        copy: ["traecli.toml", "traecli.yaml"],
+    },
+};
 /** The user's real CODEX_HOME (env override, else `~/.codex`). */
 function realCodexHome() {
     return process.env.CODEX_HOME?.trim() || join(homedir(), ".codex");
@@ -17,7 +28,7 @@ function rynxUidRoot() {
 }
 /**
  * The deterministic private CODEX_HOME path for a rynx session. PER-SESSION
- * (uid-scoped + `sha256(sessionId)[:32]`), mirroring omnigent's per-session
+ * (uid-scoped + `sha256(sessionId)[:32]`), mirroring reference implementation's per-session
  * `bridge_dir/codex-home` and rynx's own `claudeBridgeDir`. Pure — computes the
  * path without touching disk, so the daemon (rollout-synth) and the runner child
  * (app-server) both locate the SAME session's home from `sessionId` alone.
@@ -26,6 +37,13 @@ export function codexHomePath(sessionId) {
     const digest = createHash("sha256").update(sessionId).digest("hex").slice(0, 32);
     return join(rynxUidRoot(), "codex-native", digest, "codex-home");
 }
+/** Deterministic private home for a Codex-lineage runtime. */
+export function runtimeHomePath(sessionId, runtime) {
+    if (runtime === "codex")
+        return codexHomePath(sessionId);
+    const digest = createHash("sha256").update(sessionId).digest("hex").slice(0, 32);
+    return join(rynxUidRoot(), "traex-native", digest, "trae-home");
+}
 /** The OLD uid-scoped shared home (pre per-session). Kept ONLY for back-compat
  *  resume fallback — a session's rollout may still live under here. */
 export function legacyCodexHomePath() {
@@ -36,21 +54,33 @@ export function legacyCodexHomePath() {
  * `auth.json`) and settings (copied `config.toml`) but NOT the real home's pending
  * update / first-run (NUX) state — so a co-driven `codex` app-server + `--remote`
  * TUI never block on an "Update now / Press enter to continue" prompt (which would
- * wedge terminal injection). Ports omnigent's `_CODEX_HOME_SYMLINK_FILES` /
+ * wedge terminal injection). Ports reference implementation's `_CODEX_HOME_SYMLINK_FILES` /
  * `_CODEX_HOME_COPY_FILES`.
  *
- * PER-SESSION: one private home per rynx session (matching omnigent), so concurrent
+ * PER-SESSION: one private home per rynx session (matching reference implementation), so concurrent
  * agents never share a `skills/` dir. Idempotent: the symlink/copy are refreshed each
  * call so a re-login/config change propagates. Returns the private home dir.
  */
 export function prepareCodexHome(sessionId, realHome = realCodexHome()) {
-    const dir = codexHomePath(sessionId);
+    return prepareRuntimeHome(sessionId, "codex", realHome);
+}
+/**
+ * Prepare a private runtime home while inheriting only the login and settings
+ * files required by the selected CLI. Mutable update/NUX state remains in the
+ * real home and cannot wedge a managed app-server/TUI pair.
+ */
+export function prepareRuntimeHome(sessionId, runtime, realHome = runtime === "codex"
+    ? realCodexHome()
+    : resolveRuntimeHome(getRuntimeProfile(runtime))) {
+    const dir = runtimeHomePath(sessionId, runtime);
     mkdirSync(dir, { recursive: true, mode: 0o700 });
-    for (const name of SYMLINK_FILES) {
+    const files = RUNTIME_HOME_FILES[runtime];
+    for (const name of files.symlink) {
         const src = join(realHome, name);
         const dst = join(dir, name);
+        mkdirSync(dirname(dst), { recursive: true, mode: 0o700 });
         try {
-            rmSync(dst, { force: true });
+            rmSync(dst, { recursive: true, force: true });
         }
         catch {
             // absent — fine
@@ -64,11 +94,13 @@ export function prepareCodexHome(sessionId, realHome = realCodexHome()) {
             }
         }
     }
-    for (const name of COPY_FILES) {
+    for (const name of files.copy) {
         const src = join(realHome, name);
         if (existsSync(src)) {
             try {
-                copyFileSync(src, join(dir, name));
+                const dst = join(dir, name);
+                mkdirSync(dirname(dst), { recursive: true, mode: 0o700 });
+                copyFileSync(src, dst);
             }
             catch {
                 // best-effort
@@ -79,7 +111,7 @@ export function prepareCodexHome(sessionId, realHome = realCodexHome()) {
 }
 /**
  * Link a resolved skill set into `<codexHome>/skills/<name>/` so the native Codex
- * discovers them at `$CODEX_HOME/skills/` — the SAME filesystem mechanism omnigent
+ * discovers them at `$CODEX_HOME/skills/` — the SAME filesystem mechanism reference implementation
  * uses (`populate_codex_skills_from_bundle` → `_populate_codex_skills`), NOT a
  * `<skills_instructions>` block injected into the prompt. Codex's app-server
  * watches this dir and re-scans on change, so a live `codex --remote` TUI — whose
@@ -87,9 +119,9 @@ export function prepareCodexHome(sessionId, realHome = realCodexHome()) {
  * — still sees the agent's skills.
  *
  * Each skill is a symlink to its source dir; a filesystem without symlink support
- * falls back to a recursive copy (matches omnigent's fallback).
+ * falls back to a recursive copy (matches reference implementation's fallback).
  *
- * omnigent boots a fresh per-session CODEX_HOME, so it only ever links into an
+ * reference implementation boots a fresh per-session CODEX_HOME, so it only ever links into an
  * empty dir. rynx shares ONE private home per runtime (see {@link prepareCodexHome}),
  * so this CONVERGES the dir to `skills`: it links the missing ones and removes
  * entries no longer selected, honouring the agent spec's gating. (Concurrent
@@ -99,7 +131,7 @@ export function prepareCodexHome(sessionId, realHome = realCodexHome()) {
 export function populateCodexSkills(codexHome, skills) {
     const skillsDir = join(codexHome, "skills");
     const want = new Map(skills.map((s) => [s.name, s.dir]));
-    // Converge: drop entries no longer selected (shared-home adaptation; omnigent's
+    // Converge: drop entries no longer selected (shared-home adaptation; reference implementation's
     // per-session home never needs this). `.system` holds codex's own embedded system
     // skills (the app-server installs them into `$CODEX_HOME/skills/.system`) — never
     // rynx-managed, so leave it untouched; only converge the entries we linked.
@@ -116,8 +148,7 @@ export function populateCodexSkills(codexHome, skills) {
     mkdirSync(skillsDir, { recursive: true });
     for (const [name, src] of want) {
         const link = join(skillsDir, name);
-        if (existsSync(link))
-            continue; // already linked (a skill's dir for a name is stable)
+        rmSync(link, { recursive: true, force: true });
         try {
             symlinkSync(src, link);
         }

package/dist/codex-session-store.d.ts

@@ -1,10 +1,11 @@
-import { type AgentRuntimeId } from "@rynx-ai/core";
+import { type AgentRuntimeId, type ReasoningEffort } from "@rynx-ai/core";
 import type { AppConfig } from "@rynx-ai/core";
 export interface CodexSessionRecord {
     localThreadId: string;
     codexSessionId: string;
     cwd: string;
     model: string;
+    reasoningEffort?: ReasoningEffort;
     /** Runtime this thread is bound to. Legacy records backfill to `codex`. */
     runtime: AgentRuntimeId;
     /** Declarative agent spec name bound to this thread, if any. */

package/dist/host.d.ts

@@ -1,8 +1,9 @@
-import { type AgentSpec, type ResolvedExecutionBudget, type SessionEvent } from "@rynx-ai/core";
+import { type AgentSpec, type ReasoningEffort, type ResolvedExecutionBudget, type RuntimeUserInput, type SessionInteractionResolution, type SessionEvent } from "@rynx-ai/core";
 import { type AgentRuntimeId } from "@rynx-ai/core";
 import { type AppConfig } from "@rynx-ai/core";
 import { createCodexChildEnv } from "./codex-child-env.js";
 import type { InjectOutcome } from "./runner/protocol.js";
+import type { ResolveInteractionResult } from "./interactions.js";
 import { CodexAppServerClient } from "./codex-app-server/client.js";
 import type { ModelListResponse, ThreadGoal } from "./codex-app-server/protocol.js";
 import { type TerminalInjector } from "./claude/native-integration.js";
@@ -107,7 +108,9 @@ export type RetargetMirror = (newSessionId: string, meta: {
     parentSessionId?: string;
 }) => void;
 export interface LiveSessionOpts {
+    cwd?: string;
     runtime?: AgentRuntimeId;
+    reasoningEffort?: ReasoningEffort;
     /** Preset agent id (or inline {@link LiveSessionOpts.agentSpec}), so the live
      *  launch applies the agent's model / skills / instructions — not just the
      *  runtime. Absent ⇒ falls back to the config defaults (prior behavior). */
@@ -137,9 +140,12 @@ export declare class LocalAgentHost implements CodexCapabilities {
     private readonly sessionId;
     private sessionSandbox?;
     private sessionApprovalPolicy?;
-    private cachedCodexHome?;
+    private readonly runtimeHomes;
     private readonly liveSessions;
     private readonly liveClaudeSessions;
+    /** Claude forwarders stopped before their terminal is killed. Runner shutdown
+     * finalizes these synchronously afterwards to scrub raw interaction answers. */
+    private readonly pendingClaudeFinalizers;
     private readonly liveEnsuring;
     constructor({ config, commandRunner, sessionStore, allowedRoots, appServerClient, now, backendIdleTtlMs, forwarderClientFactory, sessionId, }: {
         config: AppConfig;
@@ -169,16 +175,11 @@ export declare class LocalAgentHost implements CodexCapabilities {
      */
     private reapIdleBackends;
     private createBackend;
-    /** This session's private CODEX_HOME (prepared once), shared by its app-server + TUI. */
-    private codexHome;
+    /** This session's private native home, shared by its app-server + TUI. */
+    private runtimeHome;
     private createAppServerClient;
-    /**
-     * Deliver a user's decision for a pending interactive approval (Phase D).
-     * Routes to the codex app-server client for the thread's runtime. Returns
-     * false when no matching pending approval exists (unknown id / already
-     * resolved / claude runtime).
-     */
-    resolveApproval(localThreadId: string, approvalId: string, decision: "acceptForSession" | "accept" | "decline" | "cancel"): Promise<boolean>;
+    /** Resolve a pending native question/approval without opening a new Turn. */
+    resolveInteraction(localThreadId: string, interactionId: string, resolution: SessionInteractionResolution): Promise<ResolveInteractionResult>;
     /**
      * The command to run in a session's live terminal so it co-drives the codex
      * app-server thread (Phase D). Returns `null` when live-terminal is off, the
@@ -195,7 +196,7 @@ export declare class LocalAgentHost implements CodexCapabilities {
     } | null>;
     /**
      * Bring up (idempotently) a session's persistent codex forwarder and emit its
-     * mirrored {@link SessionEvent}s. omnigent's codex-native single-writer model:
+     * mirrored {@link SessionEvent}s. reference implementation's codex-native single-writer model:
      * this forwarder is the SOLE producer of the session's canonical events — every
      * turn on the thread, web-composer-injected AND co-driving-`codex --remote`-TUI
      * initiated. Each turn gets a {@link SessionNormalizer} whose `responseId` is
@@ -211,11 +212,12 @@ export declare class LocalAgentHost implements CodexCapabilities {
      */
     ensureLiveCodexSession(localThreadId: string, emit: (event: SessionEvent) => void, opts?: LiveSessionOpts): Promise<boolean>;
     private startLiveCodexSession;
+    private refreshLiveCodexSession;
     /** Bind a session's codex thread id once known (TUI broadcast or store): persist
      *  it, unblock injection, and kick off the resume-subscribe loop (once). */
     private onLiveThreadStarted;
     /**
-     * Subscribe the forwarder connection to a thread (omnigent's
+     * Subscribe the forwarder connection to a thread (reference implementation's
      * `_subscribe_until_ready`). A fresh TUI thread has no rollout until its first
      * turn, so `thread/resume` is retried: park until the forwarder observes the
      * thread active, then retry WITHOUT `excludeTurns` so the response backfills the
@@ -227,7 +229,7 @@ export declare class LocalAgentHost implements CodexCapabilities {
      *  no live session. Injection and the runner's `live.ready` gate on this. */
     waitLiveReady(localThreadId: string, timeoutMs?: number): Promise<boolean>;
     /**
-     * Inject a user turn into a session's live codex thread — omnigent's
+     * Inject a user turn into a session's live codex thread — reference implementation's
      * single-writer web send. `turn/steer` when a turn is open (mid-turn
      * supplement), else `turn/start`. NEVER creates a thread (the TUI owns creation;
      * this targets the id the forwarder captured). Serialized per session so two
@@ -236,67 +238,66 @@ export declare class LocalAgentHost implements CodexCapabilities {
      * Returns an {@link InjectOutcome}: `notLive` when this session has no live
      * forwarder (caller may use the run path); `notReady`/`failed` are hard errors
      * the caller reports WITHOUT re-running (re-running double-writes alongside the
-     * forwarder). Park-until-ready (~60s), aligning omnigent's executor waiting for
+     * forwarder). Park-until-ready (~60s), aligning reference implementation's executor waiting for
      * the bridge instead of a short race that falls back to a second output path.
      */
-    injectMessage(localThreadId: string, text: string): Promise<InjectOutcome>;
+    injectMessage(localThreadId: string, input: RuntimeUserInput | string): Promise<InjectOutcome>;
     /**
      * Interrupt the session's active turn — the web Stop button. codex: the
      * app-server `turn/interrupt` on the active `{threadId, turnId}` (exactly what
-     * codex's own TUI interrupt key sends — omnigent `_handle_codex_native_interrupt`).
-     * claude: an Escape keystroke into the pane (no app-server — omnigent
+     * codex's own TUI interrupt key sends — reference implementation `_handle_codex_native_interrupt`).
+     * claude: an Escape keystroke into the pane (no app-server — reference implementation
      * `inject_interrupt`). Returns false as a no-op when there is no active turn.
      */
     interruptLive(localThreadId: string): Promise<boolean>;
     /** Stop + drop a session's live forwarder and its dedicated connection (session
      *  close / runner shutdown). The backend inject client is shared — left running. */
-    stopLiveCodexSession(localThreadId: string): void;
+    stopLiveCodexSession(localThreadId: string, opts?: {
+        deferClaudeInteractionCleanup?: boolean;
+    }): void;
+    /** Complete the second shutdown phase after the runner has killed all native
+     * terminals and hook subprocesses. Must run before the runner process exits. */
+    finalizeStoppedLiveSessions(): void;
     /** The interactive `claude` TUI spec for a claude-native live session: the real
      *  `claude` binary with rynx's hooks (`--settings`), resuming the bound session.
      *  Trust is pre-seeded so the daemon-spawned TUI never blocks on a first-run
-     *  prompt. (PermissionRequest approvals land in Phase 6; until then the TUI
-     *  surfaces its own permission prompt in the co-driven pane.) */
+     *  prompt. Questions and PermissionRequest approvals use the runtime-local
+     *  generic interaction bridge and remain inside the active Turn. */
     private claudeTerminalSpec;
     /** Bring up a claude-native live forwarder: prepare the bridge dir (the TUI's
      *  hooks write into it), then tail bridge + transcript and drive a per-turn
      *  {@link SessionNormalizer} → `emit` (the SAME sink shape the codex path uses). */
-    /** Resolve an agent spec's launch config — model + the session skill env —
+    /** Resolve an agent spec's launch config — model, instructions, and the session skill env —
      *  for a LIVE native session, reusing the same core resolvers the non-live
      *  run path uses ({@link resolveAgentExecution} for the model,
-     *  {@link resolveAgent} for skills). Instructions are intentionally NOT
-     *  returned: the co-driven TUI runs on vendor defaults (see
-     *  startLiveClaudeSession).
+     *  {@link resolveAgent} for instructions and skills).
      *
      *  Skills are spec-rooted: each declared ref is replayed into a
      *  SESSION-scoped temp dir (cache-accelerated); the owner's catalog plays no
-     *  role, and no spec / no `skills` means ZERO skills. The env-build report
-     *  (installs, failures, content drift) is logged — a declared skill that
-     *  can't be provisioned is loudly absent, never silent; the session still
-     *  starts. `skillsCleanup` removes the session dir (call on session stop). */
+     *  role, and no spec / no `skills` means ZERO skills. Every declared skill
+     *  must resolve at its declared content hash; missing, failed, or drifted
+     *  materialization aborts launch before a native session starts.
+     *  `skillsCleanup` removes the session dir (call on session stop). */
     private resolveLiveAgentConfig;
     private startLiveClaudeSession;
     /** Persist claude's discovered session id (reusing the `codexSessionId` store
      *  field, as the claude executor already does) and release the readiness gate. */
     private onClaudeDiscovered;
-    /** Inject a web message into a claude-native pane via tmux (omnigent recipe),
+    /** Inject a web message into a claude-native pane via tmux (reference implementation recipe),
      *  serialized per session. Parks until the thread is ready AND the tmux injector
      *  is (re)attached, then pastes; `injectViaTerminal` RAISES if the prompt never
-     *  appears (omnigent RAISE), so a not-ready pane is a hard error — NOT a
+     *  appears (reference implementation RAISE), so a not-ready pane is a hard error — NOT a
      *  fall-through-to-run signal. Returns {@link InjectOutcome}. */
     private injectClaude;
     /** Park until the claude session's tmux injector is (re)attached by the
      *  runner-child, or the deadline passes. Pane relaunch re-attaches it via
      *  {@link attachTerminalInjector}; without this a message during that window
-     *  would fail and (pre-omnigent) fall through to a second output path. */
+     *  would fail and (pre-reference implementation) fall through to a second output path. */
     private waitInjector;
     /** Attach a session's tmux pane injector (from the runner-child, which owns the
      *  terminal registry — the host does not hold tmux). Ignored for codex sessions
      *  (they inject via the app-server). Idempotent. */
     attachTerminalInjector(localThreadId: string, injector: TerminalInjector): void;
-    /** The PermissionRequest hook's server target from the runner-child env (the
-     *  daemon control URL + token), or undefined when unset — then no permission
-     *  hook is registered and claude surfaces its own TUI prompt in the pane. */
-    private claudePermissionConfig;
     /** List the models a runtime exposes (App Server for codex/traex; static for claude). */
     listModels(runtime?: AgentRuntimeId): Promise<ModelListResponse | null>;
     /**
@@ -315,10 +316,9 @@ export declare function parseCodexLoginStatus(exitCode: number, output: string):
     authMode: string | null;
     issues: string[];
 };
-export declare function getCodexModel(config: AppConfig, override?: string): string;
 export { createCodexChildEnv };
 export declare function isUnsupportedMethodError(error: unknown): boolean;
 /** A `thread/resume` failure meaning the thread has no (or an empty) rollout yet
  *  — a fresh TUI thread before its first turn. Retryable (park until active).
- *  Mirrors omnigent's `_is_thread_not_ready_error`. */
+ *  Mirrors reference implementation's `_is_thread_not_ready_error`. */
 export declare function isThreadNotReadyError(error: unknown): boolean;