@rynx-ai/runtime 0.1.11-beta.4 → 0.1.11-beta.40

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

@@ -4,6 +4,10 @@ export declare const STATE_FILE = "state.json";
 export declare const DELTAS_FILE = "message_deltas.jsonl";
 export declare const STATUS_FILE = "status.json";
 export declare const FORWARDER_STATE_FILE = "transcript_forwarder.json";
+export declare const HOOK_FORWARDER_STATE_FILE = "hook_forwarder.json";
+export declare const SUBAGENT_FORWARDER_STATE_FILE = "subagent_forwarder.json";
+export declare const DELTA_FORWARDER_STATE_FILE = "message_deltas_forwarder.json";
+export declare const COMPACTION_FORWARDER_STATE_FILE = "compaction_forwarder.json";
 export declare const INTERACTIONS_FILE = "interactions.jsonl";
 export declare const INTERACTION_ACKS_FILE = "interaction-acks.jsonl";
 export declare const INTERACTION_RESULTS_DIR = "interaction-results";
@@ -82,9 +86,15 @@ export interface ClaudeBridgeState {
     transcriptPath?: string;
     /** Claude's own session uuid (from the hook payload `session_id`). */
     claudeSessionId?: string;
+    /** Native Session ids already observed by this stable bridge owner. */
+    seenClaudeSessionIds?: string[];
     lastHookEventName?: string;
 }
 export declare function readClaudeState(bridgeDir: string): ClaudeBridgeState;
+/** Capture the pre-SessionStart identity before state.json is advanced. The
+ * observer hook and forwarder use these stable facts to distinguish a new
+ * branch from a later resume into an already-seen native Session. */
+export declare function annotateClaudeResumeContext(bridgeDir: string, payload: Record<string, unknown>): void;
 /**
  * Append one Claude hook payload to `hooks.jsonl` and fold its key fields into
  * `state.json` (transcript path + claude session id + last event). The payload
@@ -100,22 +110,53 @@ export interface JsonlReadResult<T> {
      *  line is left unconsumed so the next poll retries it once its newline lands. */
     nextOffset: number;
 }
+export interface JsonlRecordEntry<T> {
+    record: T;
+    /** Byte offset at which this complete record begins. */
+    byteOffset: number;
+    /** One-based physical line number, including blank/malformed lines. */
+    lineNumber: number;
+}
+export interface JsonlEntryReadResult<T> extends JsonlReadResult<T> {
+    entries: JsonlRecordEntry<T>[];
+    nextLineCursor: number;
+}
 /** Read complete newline-terminated JSON records appended after `byteOffset`. */
 export declare function readJsonlFrom<T = unknown>(path: string, byteOffset: number): JsonlReadResult<T>;
+/** Read complete records with their stable byte/line source positions. */
+export declare function readJsonlEntriesFrom<T = unknown>(path: string, byteOffset: number, startLineCursor?: number): JsonlEntryReadResult<T>;
 /** One parsed Claude hook event (the fields the forwarder acts on + the raw payload). */
 export interface HookEvent {
+    /** One-based record position in the append-only hook stream. */
+    eventCursor: number;
+    /** Byte offset immediately after this complete JSONL record. */
+    byteOffset: number;
+    /** Wall-clock time when the hook observer captured this payload. */
+    recordedAt?: number;
     eventName?: string;
     transcriptPath?: string;
     /** 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. */
-export declare function readHookEventsFrom(bridgeDir: string, byteOffset: number): {
+export declare function readHookEventsFrom(bridgeDir: string, byteOffset: number, startEventCursor?: number): {
     events: HookEvent[];
     nextOffset: number;
 };
+export interface HookForwardState {
+    eventCursor: number;
+    byteOffset: number;
+    cursorFingerprint?: string;
+}
+/** Read and validate the durable hook cursor. A replaced/truncated hook stream
+ * restarts at zero; event handlers provide their own stable deduplication. */
+export declare function readHookForwardState(bridgeDir: string): HookForwardState | undefined;
+/** Persist one consumed hook record before another poll can observe it. */
+export declare function writeHookForwardState(bridgeDir: string, state: HookForwardState): void;
 /** One streamed assistant-text chunk from `message_deltas.jsonl` (MessageDisplay). */
 export interface MessageDelta {
     messageId: string;
@@ -123,6 +164,31 @@ export interface MessageDelta {
     final: boolean;
     delta: string;
 }
+export interface DeltaForwardState {
+    byteOffset: number;
+}
+export interface PendingCompactionState {
+    sequence: number;
+    claudeSessionId?: string;
+    transcriptPath?: string;
+}
+export interface CompactionForwardState {
+    /** Logical Provider generation. clear/fork starts a fresh reconciliation
+     * domain even though the bridge directory remains stable. */
+    generation: string;
+    lastSequence: number;
+    persistedSequences: number[];
+    lastPrecompactCursor: number;
+    pending?: PendingCompactionState;
+    expectCompletionAckSequence?: number;
+}
+export declare function readCompactionForwardState(bridgeDir: string, generation: string): CompactionForwardState;
+export declare function writeCompactionForwardState(bridgeDir: string, state: CompactionForwardState): void;
+/** Read the process-wide MessageDisplay cursor. It deliberately survives
+ * logical Session rotation; if the append log was truncated by a fresh Claude
+ * process, restart at zero. */
+export declare function readDeltaForwardState(bridgeDir: string): DeltaForwardState;
+export declare function writeDeltaForwardState(bridgeDir: string, state: DeltaForwardState): void;
 /** Tail `message_deltas.jsonl` from a byte offset into {@link MessageDelta}s. */
 export declare function readMessageDeltasFrom(bridgeDir: string, byteOffset: number): {
     deltas: MessageDelta[];
@@ -166,12 +232,26 @@ export interface TranscriptForwardState {
     transcriptPath: string;
     /** Primary dedup: bytes already forwarded. A restart seeks here. */
     byteOffset: number;
+    /** Complete physical JSONL lines consumed at `byteOffset`. */
+    lineCursor?: number;
     /** Secondary dedup: recently-forwarded record source ids (a bounded ring), so a
      *  re-read (fingerprint reset / mid-poll death) doesn't re-emit. */
     seenSourceIds: string[];
     /** SHA-256 of `byteOffset` (8-byte BE) + up to 256 bytes before it. On restart a
      *  mismatch means the file was truncated/replaced → don't seek into a stale offset. */
     cursorFingerprint?: string;
+    /** Open Claude turn restored across a runner restart so later records remain
+     * grouped under the same canonical response. */
+    currentTurnId?: string;
+    currentResponseId?: string;
+    turnOpen?: boolean;
+    /** Split local-command input awaiting its later output record. Rynx stores a
+     * combined terminal item, so the command text and owning turn must survive a
+     * runner restart between those two native transcript records. */
+    activeTerminalCommand?: {
+        command: string;
+        turnId?: string;
+    };
 }
 /** Cap on `seenSourceIds` (matches reference implementation's `_MAX_SEEN_SOURCE_IDS`). */
 export declare const MAX_SEEN_SOURCE_IDS = 2000;
@@ -186,5 +266,27 @@ export declare function writeForwardState(bridgeDir: string, state: TranscriptFo
 export declare function readForwardState(bridgeDir: string): TranscriptForwardState | undefined;
 /** Drop the forwarder cursor (a `/clear` starts fresh). */
 export declare function resetForwardState(bridgeDir: string): void;
+export interface NativeSubagentForwardState {
+    agentId: string;
+    parentToolCallId: string;
+    /** Canonical parent response retained after the parent transcript cursor has
+     * advanced, so a runner restart keeps late child items in the same Turn. */
+    parentResponseId?: string;
+    transcriptPath: string;
+    byteOffset: number;
+    lineCursor?: number;
+    seenSourceIds: string[];
+    /** Split local-command input represented by the latest handled child item. */
+    terminalCommand?: string;
+}
+/** Parent Task/tool ids already consumed by the main transcript cursor. Kept
+ * independently of concrete child agents because Claude may create the child
+ * meta file only after the parent record was durably acknowledged. */
+export declare function readSubagentParentResponses(bridgeDir: string, parentTranscriptPath: string): Map<string, string>;
+/** Read independent Claude native sub-agent cursors for one parent transcript. */
+export declare function readSubagentForwardStates(bridgeDir: string, parentTranscriptPath: string): NativeSubagentForwardState[];
+/** Atomically persist every native sub-agent's independent delivery cursor. */
+export declare function writeSubagentForwardStates(bridgeDir: string, parentTranscriptPath: string, states: readonly NativeSubagentForwardState[], parentResponses?: ReadonlyMap<string, string>): void;
+export declare function resetSubagentForwardStates(bridgeDir: string): void;
 /** Read the latest `status.json` snapshot, or undefined if absent/malformed. */
 export declare function readClaudeStatus(bridgeDir: string): ClaudeStatusState | undefined;