@rynx-ai/runtime 0.1.11-beta.3 → 0.1.11-beta.31

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/models.d.ts

@@ -1,9 +1,4 @@
 import type { ModelInfo, ModelListResponse } from "../codex-app-server/protocol.js";
-/**
- * Default model for the claude runtime when `CLAUDE_MODEL` is unset. Kept in
- * sync with the `CLAUDE_MODEL` default in {@link import("../config.js")}.
- */
-export declare const CLAUDE_DEFAULT_MODEL = "claude-sonnet-4-6";
 /** Build the `ModelInfo[]` for the claude runtime. */
 export declare function claudeModelInfos(): ModelInfo[];
 /** {@link ModelListResponse} for the claude runtime (broker `listModels`). */

package/dist/claude/models.js

@@ -1,8 +1,3 @@
-/**
- * Default model for the claude runtime when `CLAUDE_MODEL` is unset. Kept in
- * sync with the `CLAUDE_MODEL` default in {@link import("../config.js")}.
- */
-export const CLAUDE_DEFAULT_MODEL = "claude-sonnet-4-6";
 /**
  * Static catalogue of Claude models the `/model` card and `/models` reply offer
  * for the claude runtime. Unlike codex/traex (which query a live app-server),
@@ -12,7 +7,7 @@ export const CLAUDE_DEFAULT_MODEL = "claude-sonnet-4-6";
  */
 const CLAUDE_MODEL_IDS = [
     { id: "claude-opus-4-8", displayName: "Claude Opus 4.8 · 最强" },
-    { id: "claude-sonnet-4-6", displayName: "Claude Sonnet 4.6 · 均衡（默认）" },
+    { id: "claude-sonnet-4-6", displayName: "Claude Sonnet 4.6 · 均衡" },
     { id: "claude-haiku-4-5", displayName: "Claude Haiku 4.5 · 最快" },
     { id: "claude-opus-4-7", displayName: "Claude Opus 4.7" },
     { id: "claude-opus-4-6", displayName: "Claude Opus 4.6" },
@@ -24,7 +19,6 @@ export function claudeModelInfos() {
         id,
         model: id,
         displayName,
-        isDefault: id === CLAUDE_DEFAULT_MODEL,
     }));
 }
 /** {@link ModelListResponse} for the claude runtime (broker `listModels`). */

package/dist/claude/native-bridge.d.ts

@@ -109,6 +109,8 @@ export interface HookEvent {
     /** Claude's session uuid — subagent hooks report a `subagents/…` transcript path. */
     sessionId?: string;
     source?: string;
+    /** Authoritative live background-shell count carried by a Stop hook. */
+    backgroundTaskCount?: number;
     payload: Record<string, unknown>;
 }
 /** Tail `hooks.jsonl` from a byte offset into parsed {@link HookEvent}s. */

package/dist/claude/native-bridge.js

@@ -267,6 +267,25 @@ function readJsonFile(path) {
 function asString(value) {
     return typeof value === "string" && value ? value : undefined;
 }
+const TERMINAL_BACKGROUND_TASK_STATUSES = new Set([
+    "completed",
+    "failed",
+    "stopped",
+    "killed",
+]);
+function backgroundTaskCount(payload) {
+    if (payload.hook_event_name !== "Stop")
+        return undefined;
+    const tasks = payload.background_tasks;
+    if (!Array.isArray(tasks))
+        return 0;
+    return tasks.filter((task) => {
+        if (!task || typeof task !== "object" || Array.isArray(task))
+            return true;
+        const status = task.status;
+        return typeof status !== "string" || !TERMINAL_BACKGROUND_TASK_STATUSES.has(status);
+    }).length;
+}
 export function readClaudeState(bridgeDir) {
     const raw = readJsonFile(join(bridgeDir, STATE_FILE));
     if (!raw || typeof raw !== "object")
@@ -348,11 +367,15 @@ export function readHookEventsFrom(bridgeDir, byteOffset) {
         const payload = rec.payload;
         if (!payload || typeof payload !== "object")
             continue;
+        const liveBackgroundTasks = backgroundTaskCount(payload);
         events.push({
             eventName: asString(payload.hook_event_name),
             transcriptPath: asString(payload.transcript_path),
             sessionId: asString(payload.session_id),
             source: asString(payload.source),
+            ...(liveBackgroundTasks === undefined
+                ? {}
+                : { backgroundTaskCount: liveBackgroundTasks }),
             payload,
         });
     }

package/dist/claude/native-hook-main.js

@@ -176,6 +176,43 @@ function permissionRequest(id, payload, toolInput, suggestions) {
     const toolName = asString(payload.tool_name) ?? "tool";
     const command = asString(toolInput.command) ?? asString(toolInput.file_path);
     const cwd = asString(payload.cwd);
+    if (toolName === "ExitPlanMode") {
+        const plan = asString(toolInput.plan) ?? "Plan details were not provided by Claude.";
+        return {
+            interactionId: id,
+            kind: "permission",
+            title: "Plan review",
+            fields: [{
+                    id: "feedback",
+                    type: "text",
+                    label: "What should change about the plan?",
+                    required: false,
+                    multiline: true,
+                    placeholder: "Revision feedback (optional)",
+                }],
+            actions: [
+                {
+                    id: "allow_auto",
+                    label: "Yes, and use auto mode",
+                    style: "primary",
+                    requiresAnswers: false,
+                },
+                {
+                    id: "allow_manual",
+                    label: "Yes, manually approve edits",
+                    requiresAnswers: false,
+                },
+                {
+                    id: "deny_feedback",
+                    label: "Reject with feedback",
+                    style: "danger",
+                    requiresAnswers: false,
+                },
+            ],
+            context: { toolName, summary: plan },
+            createdAt: Date.now(),
+        };
+    }
     return {
         interactionId: id,
         kind: "permission",
@@ -261,6 +298,31 @@ function nativeVerdict(hookKind, payload, result, suggestions) {
                 },
             };
     }
+    if (toolName === "ExitPlanMode") {
+        const feedback = answerText(resolution.answers?.feedback).trim();
+        const behavior = resolution.actionId === "allow_auto" ||
+            resolution.actionId === "allow_manual"
+            ? "allow"
+            : "deny";
+        return {
+            hookSpecificOutput: {
+                hookEventName: "PermissionRequest",
+                decision: {
+                    behavior,
+                    ...(behavior === "deny" && feedback ? { message: feedback } : {}),
+                    ...(behavior === "allow"
+                        ? {
+                            updatedPermissions: [{
+                                    type: "setMode",
+                                    mode: resolution.actionId === "allow_auto" ? "auto" : "default",
+                                    destination: "session",
+                                }],
+                        }
+                        : {}),
+                },
+            },
+        };
+    }
     const suggestionMatch = /^allow_suggestion_(\d+)$/.exec(resolution.actionId);
     const suggestionIndex = suggestionMatch ? Number(suggestionMatch[1]) : -1;
     const selectedSuggestion = Number.isSafeInteger(suggestionIndex)

package/dist/claude/native-integration.d.ts

@@ -1,5 +1,6 @@
 import type { AgentEvent, SessionInteractionResolution, TerminalCommandData, TodoItem } from "@rynx-ai/core";
 import type { ResolveInteractionResult, RuntimeInteractionEvent } from "../interactions.js";
+import { type ClaudeRunnerStatus } from "./session-status.js";
 /** Mirror sink — the same shape as `CodexForwarderSink` so the host reuses one
  *  per-turn normalizer wiring for both runtimes. */
 export interface ClaudeForwarderSink {
@@ -20,14 +21,22 @@ export interface ClaudeForwarderSink {
     onInteraction(event: RuntimeInteractionEvent): void;
     /** 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 runtime went idle (Stop hook) — surface idle status WITHOUT finalizing
+    onTurnEnd(usage?: Record<string, unknown>, backgroundTaskCount?: number): 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
      *  the turn. claude fires Stop around the same time it flushes the final
      *  assistant record and the two orderings race; finalizing here would split a
      *  late assistant record into its own turn. The turn is finalized by the next
      *  user prompt or the inactivity backstop, so a late record still joins it. */
-    onIdle(): void;
-    /** The current turn failed on the runtime (StopFailure hook). */
+    onIdle(backgroundTaskCount?: number): void;
+    /** Claude's current Turn or native runtime failed (StopFailure/pane exit).
+     * May fire between Turns so Session-level failure can retire stale liveness. */
     onTurnError(error: Error): void;
     /** Fired once SessionStart reveals claude's session id + transcript path, so
      *  the host can persist the id and release its readiness gate. */
@@ -99,12 +108,26 @@ 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;
     private lastActivityAt;
     /** When the Stop hook fired (null = not yet) — drives the grace-period close. */
     private stopPendingAt;
+    /** Authoritative live background-shell count from the pending Stop hook. */
+    private stopBackgroundTaskCount;
+    /** Whether the pending Stop count already rode an immediate idle edge. */
+    private stopBackgroundTaskCountDelivered;
+    /** An idle status from Claude's session metadata. The short delay keeps a
+     * final transcript record in the response without letting stale tool state
+     * override the provider's terminal status. */
+    private providerIdleAt;
+    private statusPoller?;
+    /** A failed hook is authoritative until the next running edge. Claude writes
+     * idle after failures too, so that trailing file update must not erase it. */
+    private providerFailureSticky;
     /** Open tool-call ids (start seen, end not yet) — suppresses the idle backstop. */
     private readonly openToolIds;
     /** Transcript-backed acknowledgements for web→TUI input. A direct idle
@@ -186,6 +209,11 @@ export declare class ClaudeLiveSession {
     /** One poll cycle (hooks → transcript → idle backstop). Exposed for tests to
      *  drive deterministically; the async {@link loop} just calls it on an interval. */
     tick(): void;
+    /** Bind Claude's per-process session metadata after the terminal exists. */
+    attachStatusSource({ panePid, configDir, }: {
+        panePid: () => number | undefined;
+        configDir?: string;
+    }): void;
     private loop;
     private pollHooks;
     private handleHook;
@@ -255,6 +283,8 @@ export declare class ClaudeLiveSession {
     /** Refresh the latest statusLine context/cost snapshot (a last-writer-wins file
      *  the statusLine hook overwrites on every TUI render). */
     private pollStatus;
+    private pollSessionStatus;
+    private handleSessionStatus;
     /** A usage record from the latest statusLine snapshot (snake_case, the keys the
      *  normalizer's `turn_completed` + the web `readUsageTokens` read), or undefined
      *  if the statusLine hook has not fired yet. */
@@ -283,6 +313,10 @@ export declare class ClaudeLiveSession {
      *  sent an Escape — an Escape into idle claude submits an empty turn, which
      *  claude answers with a stray "No response requested." bubble. */
     isTurnOpen(): boolean;
+    /** Fail an open turn exactly once when its native terminal/runner disappears. */
+    failOpenTurn(error: Error): boolean;
+    /** Retire process-scoped metadata before classifying a terminal exit. */
+    noteTerminalExit(error: Error): boolean;
     private closeTurn;
     private closeTurnError;
     private resetMessageCorrelation;
@@ -292,6 +326,8 @@ export declare class ClaudeLiveSession {
  *  {@link import("../terminal/tmux.js").TmuxTerminal}). The runner-child hands
  *  this to the host after launching the pane, since the host doesn't own tmux. */
 export interface TerminalInjector {
+    /** PID of the process owning the tmux pane, when available. */
+    panePid?(): number | undefined;
     capturePane(): string;
     clearInputLine(): void;
     paste(text: string): void;
@@ -303,12 +339,16 @@ export interface InjectViaTerminalOptions {
     promptGlyph?: string;
     promptTimeoutMs?: number;
     settleMs?: number;
+    /** Wait for the pasted draft to become visible before the first Enter. */
+    pasteCommitMs?: number;
     /** Transcript-backed proof that Claude accepted this exact input. When
-     * absent, injection keeps the legacy one-Enter best-effort contract. */
+     * present it takes precedence over pane heuristics. */
     submissionObserved?: () => boolean;
-    /** Per-attempt wait for a transcript acknowledgement. */
+    /** Total post-Enter verification budget. */
     submitConfirmMs?: number;
-    /** Total Enter attempts when transcript confirmation is available. */
+    /** Minimum delay between Enter retries while the draft remains visible. */
+    submitRetryMs?: number;
+    /** Optional safety cap for tests/callers; the time budget remains authoritative. */
     maxSubmitAttempts?: number;
     pollMs?: number;
     now?: () => number;
@@ -324,8 +364,8 @@ export interface InjectViaTerminalOptions {
  *
  * THROWS if the prompt never appears within the ready-gate window (reference implementation
  * `_wait_for_claude_prompt_ready` RAISE) — a not-ready pane is a hard error the
- * caller reports, NOT a signal to fall through to a second output path. With a
- * transcript observer, Enter is retried only when Claude has durably recorded
- * neither a direct user prompt nor a type-ahead enqueue.
+ * caller reports, NOT a signal to fall through to a second output path. Enter
+ * is retried only while the exact draft remains visible and Claude has durably
+ * recorded neither a direct user prompt nor a type-ahead enqueue.
  */
 export declare function injectViaTerminal(injector: TerminalInjector, text: string, opts?: InjectViaTerminalOptions): Promise<boolean>;