@rynx-ai/runtime 0.1.0 → 0.1.9

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 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). */
@@ -140,6 +143,9 @@ export declare class LocalAgentHost implements CodexCapabilities {
     private cachedCodexHome?;
     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;
@@ -172,13 +178,8 @@ export declare class LocalAgentHost implements CodexCapabilities {
     /** This session's private CODEX_HOME (prepared once), shared by its app-server + TUI. */
     private codexHome;
     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>;
     /**
      * 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>;
     /**
@@ -320,5 +321,5 @@ 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;