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

package/dist/codex-app-server/protocol.d.ts

@@ -200,6 +200,20 @@ export interface DynamicToolCallItem extends ThreadItemBase {
 export interface WebSearchItem extends ThreadItemBase {
     type: "webSearch";
     query: string;
+    action?: {
+        type: "search";
+        query: string | null;
+        queries: string[] | null;
+    } | {
+        type: "openPage";
+        url: string | null;
+    } | {
+        type: "findInPage";
+        url: string | null;
+        pattern: string | null;
+    } | {
+        type: "other";
+    } | null;
 }
 export type ThreadItem = UserMessageItem | AgentMessageItem | ReasoningItem | PlanItem | CommandExecutionItem | FileChangeItem | McpToolCallItem | DynamicToolCallItem | WebSearchItem | (ThreadItemBase & Record<string, unknown>);
 export interface ThreadSummary {
@@ -406,6 +420,15 @@ export interface ErrorNotificationParams {
     threadId: string;
     turnId: string;
 }
+/** Traex backend-capacity queue update. */
+export interface QueueStatusNotificationParams {
+    threadId: string;
+    turnId: string;
+    /** `queued` | `waiting` | `ready`. */
+    state: string;
+    position: number | null;
+    message: string | null;
+}
 export type ServerNotification = {
     method: "thread/started";
     params: ThreadStartedNotificationParams;
@@ -445,6 +468,9 @@ export type ServerNotification = {
 } | {
     method: "thread/tokenUsage/updated";
     params: ThreadTokenUsageUpdatedNotificationParams;
+} | {
+    method: "queue/status";
+    params: QueueStatusNotificationParams;
 } | {
     method: "error";
     params: ErrorNotificationParams;
@@ -528,6 +554,8 @@ export interface ToolRequestUserInputQuestion {
     question: string;
     isOther: boolean;
     isSecret: boolean;
+    /** Traex extension; absent in Codex 0.144. */
+    multiSelect?: boolean;
     options: Array<{
         label: string;
         description: string;
@@ -538,7 +566,10 @@ export interface ToolRequestUserInputParams {
     turnId: string;
     itemId: string;
     questions: ToolRequestUserInputQuestion[];
-    autoResolutionMs: number | null;
+    /** Codex supplies an optional auto-resolution deadline. */
+    autoResolutionMs?: number | null;
+    /** Traex 0.200 supplies blocking semantics instead of a deadline. */
+    isBlocking?: boolean;
 }
 export interface ToolRequestUserInputResponse {
     answers: Record<string, {

package/dist/codex-home.d.ts

@@ -1,3 +1,5 @@
+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 reference implementation's per-session
@@ -6,6 +8,8 @@
  * (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;
@@ -22,6 +26,12 @@ export declare function legacyCodexHomePath(): string;
  * 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 reference implementation

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");
@@ -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() {
@@ -44,13 +62,25 @@ export function legacyCodexHomePath() {
  * 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

package/dist/host.d.ts

@@ -1,4 +1,4 @@
-import { type AgentSpec, type ReasoningEffort, type ResolvedExecutionBudget, type SessionInteractionResolution, 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";
@@ -140,7 +140,7 @@ 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
@@ -175,8 +175,8 @@ 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;
     /** Resolve a pending native question/approval without opening a new Turn. */
     resolveInteraction(localThreadId: string, interactionId: string, resolution: SessionInteractionResolution): Promise<ResolveInteractionResult>;
@@ -241,7 +241,7 @@ export declare class LocalAgentHost implements CodexCapabilities {
      * 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
@@ -316,7 +316,6 @@ 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

package/dist/host.js

@@ -7,10 +7,10 @@ import { resolveAgent, resolveAgentExecution, buildAgentSkillEnvironment, Sessio
 import { getRuntimeProfile, } from "@rynx-ai/core";
 import { resolveRuntimeBinary, resolveRuntimeModel, } from "@rynx-ai/core";
 import { createCodexChildEnv } from "./codex-child-env.js";
-import { prepareCodexHome, populateCodexSkills } from "./codex-home.js";
+import { prepareRuntimeHome, populateCodexSkills, } from "./codex-home.js";
 import { materializeSkillPlugin } from "./claude/executor.js";
 import { listClaudeModels } from "./claude/models.js";
-import { CodexAppServerClient, buildTextUserInput, } from "./codex-app-server/client.js";
+import { CodexAppServerClient, buildRuntimeUserInput, } from "./codex-app-server/client.js";
 import { buildAppServerBaseArgs } from "./codex-app-server/transport.js";
 import { WsRpcChannel, ExternalWsChannel } from "./codex-app-server/ws-channel.js";
 import { CodexSessionForwarder } from "./codex-app-server/forwarder.js";
@@ -18,6 +18,7 @@ import { buildCodexRemoteArgs } from "./terminal/codex-tui.js";
 import { buildClaudeTuiArgs } from "./terminal/claude-tui.js";
 import { ensureProjectTrusted } from "./claude/trust.js";
 import { claudeTranscriptPath } from "./claude/transcript.js";
+import { claudeAttachmentToken, claudeInputText, runtimeUserContent, } from "./input-resources.js";
 import { claudeBridgeDir, prepareClaudeBridgeDir, removeManagedClaudeSettings, writeManagedClaudeSettings, } from "./claude/native-bridge.js";
 import { ClaudeLiveSession, injectViaTerminal, } from "./claude/native-integration.js";
 import { buildClaudeHookSettings } from "./claude/native-hooks.js";
@@ -234,9 +235,9 @@ export class LocalAgentHost {
     // this agent). Absent ⇒ fall back to the daemon `config.*` default.
     sessionSandbox;
     sessionApprovalPolicy;
-    // A private CODEX_HOME (login symlinked, settings copied, update/NUX state NOT
-    // inherited) for this session's codex app-server + TUI — lazily prepared.
-    cachedCodexHome;
+    // Private CODEX_HOME / TRAE_HOME directories (login symlinked, settings
+    // copied, update/NUX state NOT inherited) for this session's app-server + TUI.
+    runtimeHomes = new Map();
     // Per-session codex-native live forwarders, keyed by localThreadId. The
     // single-writer of the session's canonical events + the target of turn injection.
     liveSessions = new Map();
@@ -329,9 +330,14 @@ export class LocalAgentHost {
             : this.createAppServerClient(runtime, retryEnv);
         return { runtime, profile, appServerClient, commandRunner };
     }
-    /** This session's private CODEX_HOME (prepared once), shared by its app-server + TUI. */
-    codexHome() {
-        return (this.cachedCodexHome ??= prepareCodexHome(this.sessionId));
+    /** This session's private native home, shared by its app-server + TUI. */
+    runtimeHome(runtime) {
+        const existing = this.runtimeHomes.get(runtime);
+        if (existing)
+            return existing;
+        const prepared = prepareRuntimeHome(this.sessionId, runtime);
+        this.runtimeHomes.set(runtime, prepared);
+        return prepared;
     }
     createAppServerClient(runtime, extraEnv) {
         const cliPath = resolveRuntimeBinary(runtime);
@@ -343,12 +349,16 @@ export class LocalAgentHost {
         // Native co-drive: run the app-server on a loopback ws (multi-client) so a
         // `codex --remote` TUI can attach to the same thread (stdio admits only one
         // client). This is the sole transport — always native, aligning with reference implementation.
-        // Point it at the private CODEX_HOME so it shares the TUI's login/settings and
-        // never trips the real home's update/NUX state.
+        // Point it at the runtime's private home so it shares the TUI's
+        // login/settings and never trips the real home's update/NUX state.
+        const profile = getRuntimeProfile(runtime);
         const channel = new WsRpcChannel({
             cliPath,
             baseArgs: buildAppServerBaseArgs(sandbox),
-            extraEnv: { ...(extraEnv ?? {}), CODEX_HOME: this.codexHome() },
+            extraEnv: {
+                ...(extraEnv ?? {}),
+                [profile.homeEnvVar]: this.runtimeHome(runtime),
+            },
         });
         return new CodexAppServerClient({
             channel,
@@ -448,6 +458,7 @@ export class LocalAgentHost {
         if (live?.instructions) {
             configOverrides.push(`developer_instructions=${JSON.stringify(live.instructions)}`);
         }
+        const profile = getRuntimeProfile(runtime);
         return {
             command: resolveRuntimeBinary(runtime),
             args: buildCodexRemoteArgs({
@@ -461,7 +472,7 @@ export class LocalAgentHost {
             // scopes agent-run CLIs (rynx-emulator) to this session at the daemon.
             env: {
                 ...createCodexChildEnv(process.env),
-                CODEX_HOME: this.codexHome(),
+                [profile.homeEnvVar]: this.runtimeHome(runtime),
                 RYNX_SESSION_ID: localThreadId,
             },
         };
@@ -539,7 +550,7 @@ export class LocalAgentHost {
         // session-scoped dir (see resolveLiveAgentConfig); no spec / no `skills` means
         // zero skills — the owner's catalog is never consulted.
         const liveSkills = liveCfg.selectedSkills.map((s) => ({ name: s.name, dir: s.dir }));
-        populateCodexSkills(this.codexHome(), liveSkills);
+        populateCodexSkills(this.runtimeHome(runtime), liveSkills);
         // Apply this agent's sandbox / approval policy to the session's app-server
         // BEFORE it boots (getBackend below lazily creates it). Host is per-session,
         // so these knobs are the agent's own — no cross-session bleed. Set even when
@@ -584,7 +595,7 @@ export class LocalAgentHost {
         // A resumed thread keeps its stored model; otherwise use the agent-spec model (or
         // the runtime default). The model rides a launch `-c model=` on the TUI (see
         // `codexTerminalSpec`) / `turn/start` on injection, since rynx doesn't create the thread.
-        const model = getCodexModel(this.config, record?.model ?? liveCfg.model);
+        const model = resolveRuntimeModel(this.config, runtime, record?.model ?? liveCfg.model);
         const hasCurrentEffortSource = Boolean(opts?.agentName || opts?.agentSpec || opts?.reasoningEffort);
         const reasoningEffort = hasCurrentEffortSource
             ? liveCfg.reasoningEffort
@@ -632,7 +643,10 @@ export class LocalAgentHost {
                 // `turn/started` land on ONE response instead of splitting into random
                 // ids (the DB `resp_codex_<uuid>` doubling). Mirrors reference implementation `_response_id`.
                 responseId,
-                model,
+                // Traex intentionally leaves the launch model empty to use its own
+                // config. Canonical/Direct events still require a printable producer
+                // label, so report the runtime when the exact model is unknown.
+                model: model || runtime,
             });
             return normalizer;
         };
@@ -833,9 +847,9 @@ export class LocalAgentHost {
         };
         const sink = {
             onTurnStart: (turnId) => startNormalizer(turnId),
-            onUserMessage: (text) => {
+            onUserMessage: (content) => {
                 const n = normalizer ?? startNormalizer();
-                for (const se of n.userInput(text))
+                for (const se of n.userInput(content))
                     emit(se);
             },
             onEvent: (event) => {
@@ -859,7 +873,20 @@ export class LocalAgentHost {
                 closeCanonicalInteractions();
                 if (!normalizer)
                     return;
-                for (const se of normalizer.fail({ code: "codex_error", message: error.message, source: "execution" }))
+                const responseStopped = error.message === "Codex turn was interrupted";
+                const providerName = runtime === "traex" ? "Traex" : "Codex";
+                const message = responseStopped
+                    ? "Response stopped"
+                    : runtime === "traex"
+                        ? error.message.replace(/^Codex\b/, providerName)
+                        : error.message;
+                for (const se of normalizer.fail({
+                    code: responseStopped
+                        ? "response_stopped"
+                        : runtime === "traex" ? "traex_error" : "codex_error",
+                    message,
+                    source: "execution",
+                }))
                     emit(se);
                 normalizer = null;
                 currentResponseId = null;
@@ -870,7 +897,16 @@ export class LocalAgentHost {
             onThreadStarted: (threadId) => this.onLiveThreadStarted(live, localThreadId, opts?.agentName ?? record?.agent, threadId),
             onThreadActive: () => live.releaseActive?.(),
         };
-        const forwarder = new CodexSessionForwarder(forwarderClient, sink);
+        const forwarder = new CodexSessionForwarder(forwarderClient, sink, {
+            // Traex 0.200 can publish a final reasoning item immediately after
+            // `turn/completed`; without this grace frame it reopens the response and
+            // leaves Chat permanently running even though the TUI is idle. It also
+            // completes the final message before that preceding reasoning item, so
+            // hold the message over the same window to preserve semantic order.
+            turnCompletionGraceMs: runtime === "traex" ? 150 : 0,
+            assistantMessageGraceMs: runtime === "traex" ? 150 : 0,
+            surfaceQueueStatus: runtime === "traex",
+        });
         live.forwarder = forwarder;
         bindInteractionClient(injectClient);
         bindInteractionClient(forwarderClient);
@@ -901,11 +937,11 @@ export class LocalAgentHost {
         const previousCleanup = live.skillsCleanup;
         try {
             const liveSkills = liveCfg.selectedSkills.map((s) => ({ name: s.name, dir: s.dir }));
-            populateCodexSkills(this.codexHome(), liveSkills);
+            populateCodexSkills(this.runtimeHome(live.runtime), liveSkills);
             void previousCleanup?.().catch(() => undefined);
             this.sessionSandbox = liveCfg.sandbox;
             this.sessionApprovalPolicy = liveCfg.approvalPolicy;
-            live.model = getCodexModel(this.config, liveCfg.model);
+            live.model = resolveRuntimeModel(this.config, live.runtime, liveCfg.model);
             live.reasoningEffort = liveCfg.reasoningEffort;
             live.instructions = liveCfg.instructions;
             live.skillsCleanup = liveCfg.skillsCleanup;
@@ -917,7 +953,7 @@ export class LocalAgentHost {
                 await live.injectClient
                     .threadSettingsUpdate({
                     threadId: live.threadId,
-                    model: live.model,
+                    ...(live.model ? { model: live.model } : {}),
                     effort: live.reasoningEffort ?? null,
                 })
                     .catch(() => undefined);
@@ -1034,10 +1070,25 @@ export class LocalAgentHost {
      * 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.
      */
-    async injectMessage(localThreadId, text) {
+    async injectMessage(localThreadId, input) {
+        const runtimeInput = typeof input === "string"
+            ? { content: [{ type: "text", text: input }] }
+            : input;
         const claude = this.liveClaudeSessions.get(localThreadId);
-        if (claude)
-            return this.injectClaude(claude, localThreadId, text);
+        if (claude) {
+            const text = claudeInputText(runtimeInput);
+            const token = claudeAttachmentToken(text);
+            if (token) {
+                claude.pendingImageInputs.set(token, runtimeUserContent(runtimeInput));
+                const expiry = setTimeout(() => claude.pendingImageInputs.delete(token), 5 * 60_000);
+                expiry.unref?.();
+            }
+            const outcome = await this.injectClaude(claude, localThreadId, text);
+            if (token && (outcome === "notLive" || outcome === "notReady")) {
+                claude.pendingImageInputs.delete(token);
+            }
+            return outcome;
+        }
         const live = this.liveSessions.get(localThreadId);
         if (!live)
             return "notLive";
@@ -1048,13 +1099,17 @@ export class LocalAgentHost {
             const threadId = live.threadId ?? live.forwarder.threadId();
             if (!bound || !threadId)
                 return "notReady";
-            const input = buildTextUserInput(text);
+            const nativeInput = buildRuntimeUserInput(runtimeInput);
             try {
                 // Inject via the BACKEND client (the forwarder connection only observes).
                 if (live.forwarder.isTurnOpen()) {
                     const turnId = live.forwarder.currentTurnId();
                     if (turnId) {
-                        await live.injectClient.turnSteer({ threadId, expectedTurnId: turnId, input });
+                        await live.injectClient.turnSteer({
+                            threadId,
+                            expectedTurnId: turnId,
+                            input: nativeInput,
+                        });
                         return "injected";
                     }
                 }
@@ -1062,9 +1117,9 @@ export class LocalAgentHost {
                 // agent's model even if the TUI's config default differs.
                 await live.injectClient.turnStart({
                     threadId,
-                    input,
+                    input: nativeInput,
                     cwd: live.cwd,
-                    model: live.model,
+                    ...(live.model ? { model: live.model } : {}),
                     ...(live.reasoningEffort ? { effort: live.reasoningEffort } : {}),
                 });
                 return "injected";
@@ -1391,6 +1446,7 @@ export class LocalAgentHost {
             cwd,
             bridgeDir,
             injectLock: Promise.resolve(),
+            pendingImageInputs: new Map(),
             ready,
             markReady,
             discoveredReady: false,
@@ -1405,7 +1461,11 @@ export class LocalAgentHost {
             onTurnStart: (turnId) => startNormalizer(turnId),
             onUserMessage: (text) => {
                 const n = normalizer ?? startNormalizer();
-                for (const se of n.userInput(text))
+                const token = claudeAttachmentToken(text);
+                const content = token ? live.pendingImageInputs.get(token) : undefined;
+                if (token && content)
+                    live.pendingImageInputs.delete(token);
+                for (const se of n.userInput(content ?? text))
                     emit(se);
             },
             onTerminalCommand: (cmd) => {
@@ -1458,10 +1518,14 @@ export class LocalAgentHost {
                     });
                 }
             },
-            onTurnError: (error) => {
+            onTurnError: () => {
                 if (!normalizer)
                     return;
-                for (const se of normalizer.fail({ code: "claude_error", message: error.message, source: "execution" }))
+                for (const se of normalizer.fail({
+                    code: "agent_error",
+                    message: "Agent turn failed",
+                    source: "execution",
+                }))
                     emit(se);
                 normalizer = null;
                 currentResponseId = undefined;
@@ -1559,7 +1623,11 @@ export class LocalAgentHost {
             const abort = new AbortController();
             live.injectAbort = abort;
             try {
-                const ok = await injectViaTerminal(injector, text, { signal: abort.signal });
+                const submissionCheckpoint = live.forwarder.beginSubmissionObservation();
+                const ok = await injectViaTerminal(injector, text, {
+                    signal: abort.signal,
+                    submissionObserved: () => live.forwarder.hasObservedSubmissionAfter(submissionCheckpoint, text),
+                });
                 return ok ? "injected" : "failed";
             }
             catch {
@@ -1739,9 +1807,6 @@ function stableValue(value) {
     }
     return value;
 }
-export function getCodexModel(config, override) {
-    return override?.trim() || config.CODEX_MODEL;
-}
 export { createCodexChildEnv };
 export function isUnsupportedMethodError(error) {
     if (!error || typeof error !== "object") {

package/dist/input-resources.d.ts

@@ -0,0 +1,13 @@
+import type { InputImageContentPart, RuntimeUserInput, UserContentPart } from "@rynx-ai/core";
+import type { UserInput } from "./codex-app-server/protocol.js";
+/** Convert the provider-native user echo back to resource references. Unknown
+ * local paths and remote URLs are deliberately omitted rather than exposed. */
+export declare function codexUserContent(input: readonly UserInput[]): UserContentPart[];
+/** Claude's native TUI has no structured image RPC. The target daemon supplies
+ * only managed local paths and the marker makes the transcript echo reversible. */
+export declare function claudeInputText(input: RuntimeUserInput, attachmentToken?: string): string;
+/** Extract only the one-time token. The host resolves it through its in-memory
+ * pending-injection map; user-authored lookalikes have no entry and remain text. */
+export declare function claudeAttachmentToken(text: string): string | undefined;
+export declare function runtimeUserContent(input: RuntimeUserInput): UserContentPart[];
+export declare function managedImagePart(path: string): InputImageContentPart | undefined;

package/dist/input-resources.js

@@ -0,0 +1,67 @@
+import { randomUUID } from "node:crypto";
+import { basename, extname } from "node:path";
+const CLAUDE_ATTACHMENT_TOKEN = "RYNX_ATTACHMENT_SET";
+const CLAUDE_ATTACHMENT_TOKEN_RE = /^\[RYNX_ATTACHMENT_SET (att_[0-9a-f-]{36}): inspect each RYNX_IMAGE_RESOURCE path with the Read tool before answering\.\]$/m;
+/** Convert the provider-native user echo back to resource references. Unknown
+ * local paths and remote URLs are deliberately omitted rather than exposed. */
+export function codexUserContent(input) {
+    const parts = [];
+    for (const part of input) {
+        if (part.type === "text") {
+            if (part.text)
+                parts.push({ type: "input_text", text: part.text });
+            continue;
+        }
+        if (part.type === "localImage") {
+            const image = managedImagePart(part.path);
+            if (image)
+                parts.push(image);
+        }
+    }
+    return parts;
+}
+/** Claude's native TUI has no structured image RPC. The target daemon supplies
+ * only managed local paths and the marker makes the transcript echo reversible. */
+export function claudeInputText(input, attachmentToken = `att_${randomUUID()}`) {
+    const images = input.content.filter((part) => part.type === "local_image");
+    const text = input.content
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("");
+    if (images.length === 0)
+        return text;
+    if (!/^att_[0-9a-f-]{36}$/.test(attachmentToken)) {
+        throw new Error("Claude attachment token is invalid");
+    }
+    const preamble = `[${CLAUDE_ATTACHMENT_TOKEN} ${attachmentToken}: inspect each RYNX_IMAGE_RESOURCE path with the Read tool before answering.]`;
+    const markers = images.map((part) => `[[RYNX_IMAGE_RESOURCE ${JSON.stringify({ path: part.path })}]]`);
+    return [preamble, ...markers, text]
+        .filter((part, index) => index <= markers.length || part.length > 0)
+        .join("\n");
+}
+/** Extract only the one-time token. The host resolves it through its in-memory
+ * pending-injection map; user-authored lookalikes have no entry and remain text. */
+export function claudeAttachmentToken(text) {
+    return text.match(CLAUDE_ATTACHMENT_TOKEN_RE)?.[1];
+}
+export function runtimeUserContent(input) {
+    return input.content.map((part) => part.type === "text"
+        ? { type: "input_text", text: part.text }
+        : { ...part.resource });
+}
+export function managedImagePart(path) {
+    const extension = extname(path).toLowerCase();
+    const mediaType = extension === ".png"
+        ? "image/png"
+        : extension === ".jpg" || extension === ".jpeg"
+            ? "image/jpeg"
+            : extension === ".webp"
+                ? "image/webp"
+                : undefined;
+    if (!mediaType)
+        return undefined;
+    const resourceId = basename(path, extension);
+    if (!/^res_[0-9a-f-]{36}$/i.test(resourceId))
+        return undefined;
+    return { type: "input_image", resourceId, mediaType };
+}

package/dist/models-catalog.d.ts

@@ -1,18 +1,10 @@
-/**
- * Backend-free model listing for codex/traex.
- *
- * The parent control plane no longer holds an app-server, so `/models` can't be
- * a live `model/list` RPC anymore. Following reference implementation's static-catalog model, we
- * serve a config-derived list: the runtime's configured default model (the one
- * `resolveRuntimeModel` would pick), marked `isDefault`. This is intentionally
- * minimal — a fuller curated catalogue can be added here later without touching
- * any caller. claude already has its own static list ({@link listClaudeModels}).
- */
 import { type AgentRuntimeId, type AppConfig } from "@rynx-ai/core";
 import type { ModelListResponse } from "./codex-app-server/protocol.js";
+export interface RuntimeModelCatalogDeps {
+    readTraexModels?: () => Promise<unknown>;
+}
 /**
  * The model list for a runtime, without an execution backend.
- * Returns `null` when the runtime exposes no resolvable model (e.g. traex with
- * no `TRAEX_MODEL`), matching the prior "unsupported" semantics of `listModels`.
+ * Falls back to the configured model if live Traex discovery is unavailable.
  */
-export declare function listRuntimeModels(config: AppConfig, runtime: AgentRuntimeId): ModelListResponse | null;
+export declare function listRuntimeModels(config: AppConfig, runtime: AgentRuntimeId, deps?: RuntimeModelCatalogDeps): Promise<ModelListResponse | null>;