@rynx-ai/runtime 0.1.11-beta.22 → 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/claude/native-integration.d.ts

@@ -22,6 +22,11 @@ export interface ClaudeForwarderSink {
     /** The current turn finished (a new user prompt, or the inactivity backstop).
      *  `usage` carries the latest statusLine context/cost snapshot, when captured. */
     onTurnEnd(usage?: Record<string, unknown>): void;
+    /** The current turn ended because the user explicitly interrupted it. */
+    onTurnInterrupted?(usage?: Record<string, unknown>): void;
+    /** Escape was sent for the open Turn. Publish cancelled UI state immediately;
+     *  the final close remains delayed so a late transcript record can join it. */
+    onTurnInterruptRequested?(): void;
     /** The runtime status changed according to Claude's session metadata. */
     onStatus?(status: ClaudeRunnerStatus, blockedOn?: string): void;
     /** The runtime went idle on the legacy hook fallback — surface idle WITHOUT finalizing
@@ -102,6 +107,8 @@ export declare class ClaudeLiveSession {
     private readonly seenClaudeSessionIds;
     private turnOpen;
     private currentTurnId?;
+    /** The open turn received an explicit Escape/Stop and must close cancelled. */
+    private turnInterrupted;
     /** The Turn opened from a pre-transcript interaction. Its unique provisional
      * id keeps responses distinct until the real prompt uuid can be adopted. */
     private syntheticTurn;

package/dist/claude/native-integration.js

@@ -27,6 +27,10 @@ const MAX_SETTLED_INTERACTIONS = 512;
 const MAX_MESSAGE_CORRELATION_BACKLOG = 64;
 const MAX_SUBMISSION_OBSERVATIONS = 64;
 const INTERACTION_ACK_TIMEOUT_MS = 5_000;
+// Claude writes this synthetic user record after Escape (including a tool-use
+// interruption). It is lifecycle, not a new prompt. Kept aligned with
+// Omnigent's `_CLAUDE_INTERRUPT_RECORD_RE`.
+const CLAUDE_INTERRUPT_RECORD_RE = /^\[Request interrupted by user(?: for tool use)?\]$/;
 const INTERACTION_LEASE_TIMEOUT_MS = 30_000;
 function processIsAlive(pid) {
     try {
@@ -165,6 +169,8 @@ export class ClaudeLiveSession {
     seenClaudeSessionIds = new Set();
     turnOpen = false;
     currentTurnId;
+    /** The open turn received an explicit Escape/Stop and must close cancelled. */
+    turnInterrupted = false;
     /** The Turn opened from a pre-transcript interaction. Its unique provisional
      * id keeps responses distinct until the real prompt uuid can be adopted. */
     syntheticTurn = false;
@@ -846,6 +852,12 @@ export class ClaudeLiveSession {
         }
         const content = userStringContent(rec);
         if (content !== undefined) {
+            const firstLine = content.trim().split("\n", 1)[0] ?? "";
+            if (CLAUDE_INTERRUPT_RECORD_RE.test(firstLine)) {
+                this.noteInterrupted();
+                this.lastActivityAt = this.now();
+                return;
+            }
             const candidates = submissionCandidates(content);
             const queuedPromotion = rec.promptSource !== "typed" &&
                 candidates.some((candidate) => this.consumeQueuedPromotion(candidate));
@@ -890,6 +902,7 @@ export class ClaudeLiveSession {
                     this.closeTurn();
                     this.currentTurnId = turnId;
                     this.turnOpen = true;
+                    this.turnInterrupted = false;
                     this.syntheticTurn = false;
                     this.providerIdleAt = null;
                     this.openToolIds.clear();
@@ -1100,6 +1113,7 @@ export class ClaudeLiveSession {
         }
         this.providerIdleAt = null;
         this.turnOpen = true;
+        this.turnInterrupted = false;
         this.sink.onTurnStart(this.currentTurnId);
     }
     /** Mirror a local `!` command as its own mini-turn: close any open turn, then
@@ -1120,8 +1134,10 @@ export class ClaudeLiveSession {
      *  turn's close via the same short grace. The Escape has stopped claude, so this
      *  does not race a still-running response. */
     noteInterrupted() {
-        if (!this.turnOpen)
+        if (!this.turnOpen || this.turnInterrupted)
             return;
+        this.turnInterrupted = true;
+        this.sink.onTurnInterruptRequested?.();
         this.cancelPendingInteractions("turn_interrupted");
         this.stopSignalPending = false;
         if (this.statusPoller?.active)
@@ -1160,7 +1176,13 @@ export class ClaudeLiveSession {
         this.stopSignalPending = false;
         this.stopPendingAt = null;
         this.resetMessageCorrelation();
-        this.sink.onTurnEnd(this.statusUsage());
+        const interrupted = this.turnInterrupted;
+        this.turnInterrupted = false;
+        const usage = this.statusUsage();
+        if (interrupted && this.sink.onTurnInterrupted)
+            this.sink.onTurnInterrupted(usage);
+        else
+            this.sink.onTurnEnd(usage);
     }
     closeTurnError(error) {
         if (!this.turnOpen)
@@ -1171,6 +1193,7 @@ export class ClaudeLiveSession {
         this.currentTurnId = undefined;
         this.syntheticTurn = false;
         this.openToolIds.clear();
+        this.turnInterrupted = false;
         this.stopSignalPending = false;
         this.stopPendingAt = null;
         this.resetMessageCorrelation();

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

@@ -39,6 +39,8 @@ export interface CodexForwarderSink {
     onStatus?(note: string | undefined, statusKind?: "startup"): void;
     /** The current turn finished; `usage` is the runtime's raw snapshot if any. */
     onTurnEnd(usage?: Record<string, unknown>, reason?: "superseded"): void;
+    /** The provider confirmed that the active turn was explicitly interrupted. */
+    onTurnInterrupted?(usage?: Record<string, unknown>): void;
     /** Resume proved that the newest turn is terminal even though its live edge
      * was missed. This updates session state without replaying historical items. */
     onRecoveredTurnStatus?(status: "idle" | "failed", turnId: string | undefined, error?: Error): void;

package/dist/codex-app-server/forwarder.js

@@ -299,7 +299,9 @@ export class CodexSessionForwarder {
             }
             this.scheduleCompletion(mapped.fatalError
                 ? { kind: "error", error: mapped.fatalError }
-                : { kind: "end", ...(mapped.usage ? { usage: mapped.usage } : {}) });
+                : mapped.turnInterrupted
+                    ? { kind: "interrupted", ...(mapped.usage ? { usage: mapped.usage } : {}) }
+                    : { kind: "end", ...(mapped.usage ? { usage: mapped.usage } : {}) });
             return;
         }
         // A late event from an older turn must not replace the app-server's active
@@ -359,7 +361,9 @@ export class CodexSessionForwarder {
             return;
         }
         if (mapped.turnCompleted) {
-            this.scheduleCompletion({ kind: "end", ...(mapped.usage ? { usage: mapped.usage } : {}) });
+            this.scheduleCompletion(mapped.turnInterrupted
+                ? { kind: "interrupted", ...(mapped.usage ? { usage: mapped.usage } : {}) }
+                : { kind: "end", ...(mapped.usage ? { usage: mapped.usage } : {}) });
         }
         else {
             this.refreshCompletionGrace();
@@ -401,6 +405,12 @@ export class CodexSessionForwarder {
         this.pendingCompletionTurnId = null;
         if (completion.kind === "error")
             this.sink.onTurnError(completion.error);
+        else if (completion.kind === "interrupted") {
+            if (this.sink.onTurnInterrupted)
+                this.sink.onTurnInterrupted(completion.usage);
+            else
+                this.sink.onTurnEnd(completion.usage);
+        }
         else
             this.sink.onTurnEnd(completion.usage);
     }

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

@@ -11,6 +11,7 @@ export interface CodexMapResult {
     finalText?: string;
     usage?: Record<string, unknown>;
     turnCompleted?: boolean;
+    turnInterrupted?: boolean;
     fatalError?: Error;
 }
 export declare function codexTurnStatus(turn: unknown): string | undefined;

package/dist/codex-app-server/mapping.js

@@ -241,7 +241,14 @@ export function mapCodexNotification(method, params) {
         case "turn/failed": {
             const turnPayload = typed.params?.turn;
             const fatalError = terminalTurnError(turnPayload, typed.method);
-            return { events, ...(fatalError ? { fatalError } : {}), turnCompleted: true };
+            const turnInterrupted = typed.method === "turn/completed" &&
+                ["interrupted", "cancelled", "canceled"].includes(codexTurnStatus(turnPayload) ?? "");
+            return {
+                events,
+                ...(fatalError ? { fatalError } : {}),
+                turnCompleted: true,
+                ...(turnInterrupted ? { turnInterrupted: true } : {}),
+            };
         }
         case "turn/plan/updated": {
             const planParams = typed.params;

package/dist/host.d.ts

@@ -2,7 +2,7 @@ import { type ResolvedExecutionSnapshot, type ResolvedExecutionBudget, type Runt
 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 { InjectResult } 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";
@@ -267,13 +267,13 @@ export declare class LocalAgentHost implements CodexCapabilities {
      * resumed from the persisted native id. Serialized per session so two
      * injects can't double-open a turn.
      *
-     * Returns an {@link InjectOutcome}: `notLive` when this session has no live
+     * Returns an {@link InjectResult}: `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 reference implementation's executor waiting for
      * the bridge instead of a short race that falls back to a second output path.
      */
-    injectMessage(localThreadId: string, input: RuntimeUserInput | string): Promise<InjectOutcome>;
+    injectMessage(localThreadId: string, input: RuntimeUserInput | string): Promise<InjectResult>;
     /**
      * Interrupt the session's active turn — the web Stop button. codex: the
      * app-server `turn/interrupt` on the active `{threadId, turnId}` (exactly what
@@ -287,6 +287,11 @@ export declare class LocalAgentHost implements CodexCapabilities {
     stopLiveCodexSession(localThreadId: string, opts?: {
         deferClaudeInteractionCleanup?: boolean;
     }): void;
+    /** Tear down one codex-lineage native runtime without deleting its durable
+     * session-store binding. Omnigent couples its auxiliary Terminal, observer,
+     * forwarder and per-session app-server as one disposable runtime envelope;
+     * the next message recreates that envelope and cold-resumes the native id. */
+    teardownLiveCodexSession(localThreadId: string, error?: Error): boolean;
     /** 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;
@@ -308,7 +313,7 @@ export declare class LocalAgentHost implements CodexCapabilities {
      *  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 (reference implementation RAISE), so a not-ready pane is a hard error — NOT a
-     *  fall-through-to-run signal. Returns {@link InjectOutcome}. */
+     *  fall-through-to-run signal. Returns {@link InjectResult}. */
     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