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

package/dist/claude/executor.d.ts

@@ -1,15 +1,29 @@
 import type { SkillMeta } from "@rynx-ai/core";
+export interface MaterializedClaudePlugin {
+    pluginDir: string;
+}
+/** Stable Claude `--plugin-dir` owned by one Rynx Session. */
+export declare function claudePluginDir(sessionId: string): string;
 /**
- * Materialize a selected catalog skill subset into a throwaway claude
+ * Return the existing Session-owned plugin directory as-is. It is the durable
+ * Provider input for this Session, not an immutable shared cache: runtime files
+ * created inside it (for example Python `__pycache__`) remain part of that
+ * Session and do not trigger SkillRef replay.
+ */
+export declare function reuseClaudePlugin(sessionId: string): Promise<MaterializedClaudePlugin | null>;
+/**
+ * Materialize a selected catalog skill subset into a Session-owned Claude
  * `--plugin-dir` (a dir with `skills/<name>/SKILL.md` + a `.claude-plugin/plugin.json`
  * manifest — claude's mechanism for exposing skills outside its host dirs, since
  * it doesn't scan `~/.rynx/skills`). Consumed by the claude-native live launch.
  *
+ * The committed path is deterministic and survives Provider/runner restarts.
+ * An existing directory is returned as-is. The first materialization is built
+ * in a sibling staging directory and renamed into the stable path so a crash
+ * cannot expose a partially copied plugin.
+ *
  * Returns `null` when there's nothing to add. Rynx-managed Claude sessions load
  * no host/project/local setting sources, so this explicit plugin directory is
  * the only native skill channel; the selected subset is enforced exactly.
  */
-export declare function materializeSkillPlugin(selected: SkillMeta[] | null | undefined): Promise<{
-    pluginDir?: string;
-    cleanup?: () => Promise<void>;
-} | null>;
+export declare function materializeClaudePlugin(sessionId: string, selected: SkillMeta[] | null | undefined): Promise<MaterializedClaudePlugin | null>;

package/dist/claude/executor.js

@@ -1,26 +1,70 @@
-import { cp, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
+import { cp, mkdir, mkdtemp, rename, rm, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { runtimeSessionStateDir } from "../runtime-state-paths.js";
+/** Stable Claude `--plugin-dir` owned by one Rynx Session. */
+export function claudePluginDir(sessionId) {
+    return path.join(runtimeSessionStateDir(sessionId), "claude-plugin");
+}
 /**
- * Materialize a selected catalog skill subset into a throwaway claude
+ * Return the existing Session-owned plugin directory as-is. It is the durable
+ * Provider input for this Session, not an immutable shared cache: runtime files
+ * created inside it (for example Python `__pycache__`) remain part of that
+ * Session and do not trigger SkillRef replay.
+ */
+export async function reuseClaudePlugin(sessionId) {
+    const pluginDir = claudePluginDir(sessionId);
+    try {
+        return (await stat(pluginDir)).isDirectory() ? { pluginDir } : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Materialize a selected catalog skill subset into a Session-owned Claude
  * `--plugin-dir` (a dir with `skills/<name>/SKILL.md` + a `.claude-plugin/plugin.json`
  * manifest — claude's mechanism for exposing skills outside its host dirs, since
  * it doesn't scan `~/.rynx/skills`). Consumed by the claude-native live launch.
  *
+ * The committed path is deterministic and survives Provider/runner restarts.
+ * An existing directory is returned as-is. The first materialization is built
+ * in a sibling staging directory and renamed into the stable path so a crash
+ * cannot expose a partially copied plugin.
+ *
  * Returns `null` when there's nothing to add. Rynx-managed Claude sessions load
  * no host/project/local setting sources, so this explicit plugin directory is
  * the only native skill channel; the selected subset is enforced exactly.
  */
-export async function materializeSkillPlugin(selected) {
+export async function materializeClaudePlugin(sessionId, selected) {
     if (selected == null || selected.length === 0)
         return null;
-    const dir = await mkdtemp(path.join(tmpdir(), "rynx-claude-skills-"));
-    const skillsRoot = path.join(dir, "skills");
-    await mkdir(skillsRoot, { recursive: true });
-    for (const skill of selected) {
-        await cp(skill.dir, path.join(skillsRoot, skill.name), { recursive: true });
+    const reused = await reuseClaudePlugin(sessionId);
+    if (reused)
+        return reused;
+    const pluginDir = claudePluginDir(sessionId);
+    const stateDir = runtimeSessionStateDir(sessionId);
+    await mkdir(stateDir, { recursive: true, mode: 0o700 });
+    const stagingDir = await mkdtemp(path.join(stateDir, ".claude-plugin-stage-"));
+    try {
+        const skillsRoot = path.join(stagingDir, "skills");
+        await mkdir(skillsRoot, { recursive: true });
+        for (const skill of selected) {
+            await cp(skill.dir, path.join(skillsRoot, skill.name), { recursive: true });
+        }
+        await mkdir(path.join(stagingDir, ".claude-plugin"), { recursive: true });
+        await writeFile(path.join(stagingDir, ".claude-plugin", "plugin.json"), `${JSON.stringify({ name: "rynx-agent-skills", description: "Per-agent skill subset" }, null, 2)}\n`);
+        try {
+            await rename(stagingDir, pluginDir);
+        }
+        catch (error) {
+            const concurrent = await reuseClaudePlugin(sessionId);
+            if (!concurrent)
+                throw error;
+            return concurrent;
+        }
+        return { pluginDir };
+    }
+    finally {
+        await rm(stagingDir, { recursive: true, force: true });
     }
-    await mkdir(path.join(dir, ".claude-plugin"), { recursive: true });
-    await writeFile(path.join(dir, ".claude-plugin", "plugin.json"), `${JSON.stringify({ name: "rynx-agent-skills", description: "Per-agent skill subset" }, null, 2)}\n`);
-    return { pluginDir: dir, cleanup: () => rm(dir, { recursive: true, force: true }) };
 }

package/dist/host.js

@@ -9,7 +9,7 @@ import { getRuntimeProfile, } from "@rynx-ai/core";
 import { resolveRuntimeBinary, } from "@rynx-ai/core";
 import { createCodexChildEnv } from "./codex-child-env.js";
 import { prepareRuntimeHome, populateCodexSkills, runtimeHomePath, } from "./codex-home.js";
-import { materializeSkillPlugin } from "./claude/executor.js";
+import { materializeClaudePlugin, reuseClaudePlugin, } from "./claude/executor.js";
 import { listClaudeModels } from "./claude/models.js";
 import { CodexAppServerClient, buildRuntimeUserInput, } from "./codex-app-server/client.js";
 import { buildAppServerBaseArgs, CodexTransportError, } from "./codex-app-server/transport.js";
@@ -529,16 +529,21 @@ export class LocalAgentHost {
             return sameSessionSnapshots(existingClaude.workspace, existingClaude.execution, snapshotOpts);
         }
         // Dedupe concurrent triggers so only one forwarder is ever created per
-        // session (two would double-mirror every turn). Check this before the live
-        // map: startLiveCodexSession publishes its partially initialized session
-        // before thread/start completes, so a concurrent Terminal start must await
-        // the thread id instead of launching a bare `codex --remote` pane.
+        // session (two would double-mirror every turn). startLiveCodexSession
+        // publishes its partially initialized session before thread/start completes,
+        // so wait for that startup and then adopt any newer mutable Turn settings.
         const inflight = this.liveEnsuring.get(localThreadId);
-        if (inflight)
-            return inflight;
+        if (inflight) {
+            if (!await inflight)
+                return false;
+            const startedLive = this.liveSessions.get(localThreadId);
+            return startedLive
+                ? updateLiveCodexTurnSettings(startedLive, snapshotOpts)
+                : false;
+        }
         const live = this.liveSessions.get(localThreadId);
         if (live)
-            return sameSessionSnapshots(live.workspace, live.execution, snapshotOpts);
+            return updateLiveCodexTurnSettings(live, snapshotOpts);
         const started = this.startLiveCodexSession(localThreadId, emit, snapshotOpts);
         this.liveEnsuring.set(localThreadId, started);
         try {
@@ -670,6 +675,8 @@ export class LocalAgentHost {
             approvalPolicy,
             model,
             reasoningEffort,
+            appliedModel: model,
+            appliedReasoningEffort: reasoningEffort,
             ...(execution.instructions ? { instructions: execution.instructions } : {}),
             threadId: record?.codexSessionId ?? null,
             ready,
@@ -681,6 +688,8 @@ export class LocalAgentHost {
             injectLock: Promise.resolve(),
             pendingInjectedInputs: [],
             publishInjectedInput: () => undefined,
+            publishTurnAdmission: () => undefined,
+            publishTurnAdmissionFailure: () => undefined,
             publishInterrupted: () => undefined,
             interruptedResponseId: null,
             subscribing: false,
@@ -737,6 +746,21 @@ export class LocalAgentHost {
             for (const se of n.userInput(content))
                 emitCurrent(se);
         };
+        live.publishTurnAdmission = () => {
+            emitCurrent({
+                type: "session.status",
+                sessionId: currentSessionId,
+                status: "running",
+            });
+        };
+        live.publishTurnAdmissionFailure = (message) => {
+            emitCurrent({
+                type: "session.status",
+                sessionId: currentSessionId,
+                status: "failed",
+                note: message,
+            });
+        };
         const clearPendingInputsForResponse = (responseId) => {
             if (!responseId)
                 return;
@@ -1389,6 +1413,13 @@ export class LocalAgentHost {
             };
             live.pendingInjectedInputs.push(pendingInput);
             let injectionMethod = "turn/start";
+            let admissionPublished = false;
+            const publishAdmission = () => {
+                if (admissionPublished)
+                    return;
+                admissionPublished = true;
+                live.publishTurnAdmission();
+            };
             const forgetPendingInput = () => {
                 const index = live.pendingInjectedInputs.indexOf(pendingInput);
                 if (index >= 0)
@@ -1396,6 +1427,12 @@ export class LocalAgentHost {
             };
             const injectionClient = this.injectionClientFactory(live.appServerUrl);
             try {
+                // Omnigent publishes codex-native running only after the native Terminal
+                // is ready and the runner has accepted the message, but before the
+                // short-lived app-server client initializes and starts the Turn. Claude
+                // deliberately has no matching synthesized edge.
+                if (!live.forwarder.isTurnOpen())
+                    publishAdmission();
                 await injectionClient.ensureInitialized();
                 // Match Omnigent's executor: each message uses one initialized client
                 // that closes as soon as turn/start or turn/steer is acknowledged.
@@ -1419,15 +1456,34 @@ export class LocalAgentHost {
                         return { outcome: "steered", responseId: `resp_codex_${steered.turnId}` };
                     }
                 }
-                // Carry the agent-spec model on the turn so a web-injected turn runs the
-                // agent's model even if the TUI's config default differs.
+                // Match Omnigent's turn boundary: change the native thread settings
+                // under the same lock immediately before starting the next Turn. Never
+                // put settings on turn/start or mutate a Turn that is already open.
+                const desiredModel = live.model;
+                const desiredReasoningEffort = live.reasoningEffort;
+                const settings = {
+                    threadId,
+                    ...(desiredModel !== live.appliedModel
+                        ? { model: desiredModel || null }
+                        : {}),
+                    ...(desiredReasoningEffort !== live.appliedReasoningEffort
+                        ? { effort: desiredReasoningEffort ?? null }
+                        : {}),
+                };
+                if (Object.keys(settings).length > 1) {
+                    await injectionClient.threadSettingsUpdate(settings);
+                    // Record exactly what this RPC carried. A concurrent settings save may
+                    // already have advanced the desired fields and must remain pending for
+                    // the following new Turn.
+                    live.appliedModel = desiredModel;
+                    live.appliedReasoningEffort = desiredReasoningEffort;
+                }
+                publishAdmission();
                 const started = await injectionClient.turnStart({
                     threadId,
                     input: nativeInput,
                     ...turnWorkspaceParams(live.runtime, live.workspace, live.sandbox),
                     approvalPolicy: live.approvalPolicy,
-                    ...(live.model ? { model: live.model } : {}),
-                    ...(live.reasoningEffort ? { effort: live.reasoningEffort } : {}),
                 });
                 if (pendingInput.observed) {
                     forgetPendingInput();
@@ -1449,6 +1505,13 @@ export class LocalAgentHost {
                 const baseDetail = codexRpcError(error, injectionMethod);
                 const startupDetail = live.forwarder.mcpStartupDetail();
                 const detail = startupDetail ? `${baseDetail} (${startupDetail})` : baseDetail;
+                // A turn may open on the observer while this short-lived client is
+                // initializing, converting the submission to steer. A rejected steer
+                // does not fail that already-running Turn; only a new-Turn admission
+                // owns the terminal failed edge.
+                if (admissionPublished && injectionMethod === "turn/start") {
+                    live.publishTurnAdmissionFailure(detail);
+                }
                 console.error(`[codex-live] session=${localThreadId} runtime=${live.runtime} injection failed: ${detail}`);
                 throw nativeLiveFailure(live.runtime, "native_message_injection_failed", `message injection via ${injectionMethod} failed`, detail);
             }
@@ -1551,8 +1614,6 @@ export class LocalAgentHost {
                 claude.forwarder.finalizeStop();
             }
             removeManagedClaudeSettings(claude.bridgeDir);
-            // Remove the throwaway skills --plugin-dir temp so it doesn't leak per launch.
-            void claude.skillCleanup?.();
             return;
         }
         const live = this.liveSessions.get(localThreadId);
@@ -1789,17 +1850,27 @@ export class LocalAgentHost {
             throw new CodexRuntimeError(`cannot launch Claude from ${execution.provider} execution snapshot`, 422, "invalid_execution_snapshot");
         }
         const cwd = workspace.cwd;
-        let snapshotSkills;
-        try {
-            snapshotSkills = await this.prepareExecutionSkills(execution);
-        }
-        catch (err) {
-            console.error(`[session-snapshot] session=${localThreadId} skill materialization failed: ${err instanceof Error ? err.message : String(err)}`);
-            return false;
+        const hasSkillSnapshot = execution.skills.length > 0 || execution.pluginSkills.length > 0;
+        let skillPlugin = hasSkillSnapshot
+            ? await reuseClaudePlugin(localThreadId)
+            : null;
+        if (!skillPlugin && hasSkillSnapshot) {
+            let snapshotSkills;
+            try {
+                snapshotSkills = await this.prepareExecutionSkills(execution);
+            }
+            catch (err) {
+                console.error(`[session-snapshot] session=${localThreadId} skill materialization failed: ${err instanceof Error ? err.message : String(err)}`);
+                return false;
+            }
+            try {
+                skillPlugin = await materializeClaudePlugin(localThreadId, snapshotSkills.selectedSkills);
+            }
+            finally {
+                await snapshotSkills.skillsCleanup();
+            }
         }
         const model = execution.model ?? "";
-        const skillPlugin = await materializeSkillPlugin(snapshotSkills.selectedSkills);
-        void snapshotSkills.skillsCleanup();
         const permissionMode = execution.permissionMode;
         const launchExtraArgs = [
             ...(skillPlugin?.pluginDir ? ["--plugin-dir", skillPlugin.pluginDir] : []),
@@ -1876,7 +1947,6 @@ export class LocalAgentHost {
             launchExtraArgs,
             permissionMode,
             ...(forkIntent ? { forkIntent } : {}),
-            ...(skillPlugin?.cleanup ? { skillCleanup: skillPlugin.cleanup } : {}),
         };
         live.publishInterrupted = (responseId) => {
             if (live.interruptedResponseId === responseId)
@@ -2411,6 +2481,21 @@ function sameSessionSnapshots(workspace, execution, opts) {
         execution: opts.execution,
     }));
 }
+function sameImmutableSessionSnapshots(workspace, execution, opts) {
+    const current = { ...execution, model: null, reasoningEffort: null };
+    const requested = { ...opts.execution, model: null, reasoningEffort: null };
+    return JSON.stringify(stableValue({ workspace, execution: current })) ===
+        JSON.stringify(stableValue({ workspace: opts.workspace, execution: requested }));
+}
+function updateLiveCodexTurnSettings(live, opts) {
+    if (!sameImmutableSessionSnapshots(live.workspace, live.execution, opts)) {
+        return false;
+    }
+    live.execution = structuredClone(opts.execution);
+    live.model = opts.execution.model ?? "";
+    live.reasoningEffort = opts.execution.reasoningEffort ?? undefined;
+    return true;
+}
 /** Freeze the Session's permission choice into the explicit managed settings.
  * Host/project settings may still contribute allow/deny rules, but changing
  * their defaultMode cannot silently mutate an existing Session on resume. */

package/dist/runner/manager.d.ts

@@ -340,6 +340,7 @@ export declare class RunnerManager implements AgentCapabilities {
     private isNativePaneBusy;
     private isManagedNativeHandle;
     private failActiveResponses;
+    private interruptActiveResponses;
     /** Track the provider-authoritative response lifecycle. Native-pane busy
      * classification consumes this level directly; output volume is separately
      * grounded in tmux's own activity clock. */

package/dist/runner/manager.js

@@ -1335,6 +1335,7 @@ export class RunnerManager {
                 catch {
                     // The process signal below remains the authoritative shutdown path.
                 }
+                this.interruptActiveResponses(handle);
                 this.failHandle(handle, reason, { failActiveResponses: false });
             }
             this.signalChild(handle.child, "SIGTERM", handle.processGroup);
@@ -1477,6 +1478,18 @@ export class RunnerManager {
             });
         }
     }
+    interruptActiveResponses(handle) {
+        const responseIds = [...handle.activeResponseIds];
+        handle.activeResponseIds.clear();
+        const sessionId = this.currentTerminalSessionId(handle, handle.key);
+        for (const responseId of responseIds) {
+            this.mirrorListener?.(sessionId, {
+                type: "session.interrupted",
+                sessionId,
+                responseId,
+            });
+        }
+    }
     /** Track the provider-authoritative response lifecycle. Native-pane busy
      * classification consumes this level directly; output volume is separately
      * grounded in tmux's own activity clock. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/runtime",
-  "version": "0.1.11-beta.23",
+  "version": "0.1.11-beta.24",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
@@ -27,7 +27,7 @@
     "node-pty": "1.2.0-beta.15",
     "smol-toml": "1.7.1",
     "ws": "^8.21.0",
-    "@rynx-ai/core": "0.1.11-beta.23"
+    "@rynx-ai/core": "0.1.11-beta.24"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"