@rynx-ai/runtime 0.1.11-beta.37 → 0.1.11-beta.39

package/dist/claude/transcript.js

@@ -15,6 +15,7 @@
 import { readFileSync } from "node:fs";
 import { open, stat } from "node:fs/promises";
 import { join } from "node:path";
+import { setTimeout as sleep } from "node:timers/promises";
 /** A sub-agent (Task) writes its own transcript to
  *  `<project>/<sessionId>/subagents/agent-<agentId>.jsonl`, alongside the parent
  *  `<sessionId>.jsonl`. Derive that path from the parent transcript path. */
@@ -60,6 +61,21 @@ function stringifyToolContent(content) {
 const BASH_INPUT_RE = /<bash-input>([\s\S]*?)<\/bash-input>/;
 const BASH_STDOUT_RE = /<bash-stdout>([\s\S]*?)<\/bash-stdout>/;
 const BASH_STDERR_RE = /<bash-stderr>([\s\S]*?)<\/bash-stderr>/;
+/** Parse either half of Claude's shell-mode record. Newer and older Claude
+ * builds may split `<bash-input>` from the later stdout/stderr record. */
+export function parseTerminalCommandFragments(content) {
+    const input = BASH_INPUT_RE.exec(content);
+    const stdout = BASH_STDOUT_RE.exec(content);
+    const stderr = BASH_STDERR_RE.exec(content);
+    if (!input && !stdout && !stderr)
+        return undefined;
+    return {
+        ...(input ? { command: input[1].trim() } : {}),
+        ...(stdout ? { stdout: stdout[1] } : {}),
+        ...(stderr ? { stderr: stderr[1] } : {}),
+        hasOutput: Boolean(stdout || stderr),
+    };
+}
 /**
  * Parse a claude local-command (`!` bash mode) user record's string content into
  * a {@link TerminalCommandData}. Claude records the command and its captured
@@ -69,16 +85,14 @@ const BASH_STDERR_RE = /<bash-stderr>([\s\S]*?)<\/bash-stderr>/;
  * `<system-reminder>`) are bookkeeping, not terminal commands.
  */
 export function parseTerminalCommand(content) {
-    const input = BASH_INPUT_RE.exec(content);
-    if (!input)
+    const fragments = parseTerminalCommandFragments(content);
+    if (!fragments || fragments.command === undefined)
         return undefined;
-    const data = { command: input[1].trim() };
-    const stdout = BASH_STDOUT_RE.exec(content)?.[1];
-    const stderr = BASH_STDERR_RE.exec(content)?.[1];
-    if (stdout)
-        data.stdout = stdout;
-    if (stderr)
-        data.stderr = stderr;
+    const data = { command: fragments.command };
+    if (fragments.stdout)
+        data.stdout = fragments.stdout;
+    if (fragments.stderr)
+        data.stderr = fragments.stderr;
     return data;
 }
 /**
@@ -113,26 +127,42 @@ export function parseTranscriptRecord(record, opts) {
     if (rec.isSidechain && !parent)
         return []; // sub-agent turns are replayed separately
     const message = rec.message;
-    if (!message || !Array.isArray(message.content))
+    if (!message)
         return [];
     const out = [];
     if (rec.type === "assistant" && message.role === "assistant") {
+        const content = typeof message.content === "string"
+            ? [{ type: "text", text: message.content }]
+            : message.content;
+        if (!Array.isArray(content))
+            return [];
         // Claude writes this zero-token synthetic filler after an accidental empty
         // submit. It is transcript bookkeeping, not an assistant response. Filter
         // by provider provenance and exact shape here, before normalization loses
         // `model: "<synthetic>"`; a UI string filter could hide legitimate output.
         if (!rec.isApiErrorMessage &&
             message.model === "<synthetic>" &&
-            message.content.length === 1 &&
-            message.content[0]?.type === "text" &&
-            message.content[0].text === "No response requested.") {
+            content.length === 1 &&
+            content[0]?.type === "text" &&
+            content[0].text === "No response requested.") {
             return [];
         }
         const itemId = message.id;
-        const texts = [];
-        for (const block of message.content) {
+        const textBlockCount = content.filter((block) => block.type === "text" && block.text).length;
+        for (const [blockIndex, block] of content.entries()) {
             if (block.type === "text" && block.text) {
-                texts.push(block.text);
+                // Preserve Claude's block order. Keep a single text block's
+                // native message id for MessageDisplay correlation; only derive an id
+                // when one record contains multiple independently ordered text blocks.
+                const textItemId = itemId && textBlockCount > 1
+                    ? `${itemId}:text:${blockIndex}`
+                    : itemId;
+                out.push({
+                    type: "message_completed",
+                    text: block.text,
+                    ...(textItemId ? { itemId: textItemId } : {}),
+                    ...parentTag,
+                });
             }
             else if (block.type === "thinking" && block.thinking) {
                 out.push({ type: "reasoning_completed", summary: [block.thinking], ...(itemId ? { itemId } : {}), ...parentTag });
@@ -143,17 +173,19 @@ export function parseTranscriptRecord(record, opts) {
                     event: "on_tool_start",
                     name: block.name,
                     input: { ...(isObject(block.input) ? block.input : {}), id: block.id },
-                    data: { id: block.id },
+                    // A transcript tool_use is already a completed Provider record. Live
+                    // runtimes still omit this marker and remain in_progress until their
+                    // completion event arrives.
+                    data: { id: block.id, itemStatus: "completed" },
                     ...parentTag,
                 });
             }
         }
-        if (texts.length) {
-            out.push({ type: "message_completed", text: texts.join(""), ...(itemId ? { itemId } : {}), ...parentTag });
-        }
         return out;
     }
     if (rec.type === "user" && message.role === "user") {
+        if (!Array.isArray(message.content))
+            return [];
         for (const block of message.content) {
             if (block.type === "tool_result") {
                 out.push({
@@ -166,7 +198,7 @@ export function parseTranscriptRecord(record, opts) {
                         exitCode: null,
                     },
                     ...(block.is_error ? { error: "tool_error" } : {}),
-                    data: { tool_use_id: block.tool_use_id },
+                    data: { tool_use_id: block.tool_use_id, itemStatus: "completed" },
                     ...parentTag,
                 });
             }
@@ -179,13 +211,14 @@ function isObject(value) {
 }
 /**
  * Whether a transcript is a `/fork` (branch) of another session: claude stamps a
- * `forkedFrom: { sessionId }` marker in an early record pointing at the source
+ * `forkedFrom: { sessionId }` marker on copied records pointing at the source
  * session (reference implementation's `transcript_has_forked_from_marker`). Used to distinguish a
  * fork from an ordinary `resume` (both arrive as `SessionStart source="resume"`).
- * Scans only the head of the file (the marker lands up front). NOTE: unverified on
- * this host — no local transcript carries the marker — so it follows reference implementation's shape.
+ * The marker must belong to the announced target and expected source; sample
+ * the first and last 200 records because long copied histories can place it at
+ * either edge.
  */
-export function transcriptHasForkedFrom(path, currentSessionId) {
+export function transcriptHasForkedFrom(path, claudeSessionId, sourceClaudeSessionId) {
     let text;
     try {
         text = readFileSync(path, "utf8");
@@ -193,17 +226,60 @@ export function transcriptHasForkedFrom(path, currentSessionId) {
     catch {
         return false;
     }
-    let scanned = 0;
-    for (const line of text.split("\n")) {
-        if (++scanned > 200)
-            break;
+    const lines = text.split("\n");
+    const sampled = lines.length <= 400
+        ? lines
+        : [...lines.slice(0, 200), ...lines.slice(-200)];
+    for (const line of sampled) {
         const trimmed = line.trim();
         if (!trimmed || !trimmed.includes("forkedFrom"))
             continue;
         try {
             const rec = JSON.parse(trimmed);
+            if (rec.sessionId !== claudeSessionId)
+                continue;
             const from = rec.forkedFrom?.sessionId;
-            if (typeof from === "string" && from && from !== currentSessionId)
+            if (typeof from === "string" &&
+                from &&
+                from !== claudeSessionId &&
+                (sourceClaudeSessionId === undefined || from === sourceClaudeSessionId))
+                return true;
+        }
+        catch {
+            // skip malformed
+        }
+    }
+    return false;
+}
+const RECENT_LOCAL_COMMAND_LINE_LIMIT = 200;
+const RECENT_LOCAL_COMMAND_WINDOW_MS = 10_000;
+/** Claude versions without a copied-record marker still persist `/fork` and
+ * `/branch` as a recent top-level local command. Match only the new native
+ * Session and the hook's narrow time window. */
+export function transcriptHasRecentLocalCommand(path, claudeSessionId, recordedAtMs, commandNames = new Set(["/fork", "/branch"])) {
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch {
+        return false;
+    }
+    for (const line of text.split("\n").slice(-RECENT_LOCAL_COMMAND_LINE_LIMIT)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const rec = JSON.parse(trimmed);
+            if (rec.sessionId !== claudeSessionId || rec.subtype !== "local_command")
+                continue;
+            const timestamp = transcriptTimestampMs(rec.timestamp);
+            if (timestamp === undefined ||
+                Math.abs(timestamp - recordedAtMs) > RECENT_LOCAL_COMMAND_WINDOW_MS ||
+                typeof rec.content !== "string")
+                continue;
+            const command = /<command-name>([\s\S]*?)<\/command-name>/
+                .exec(rec.content)?.[1]?.trim();
+            if (command && commandNames.has(command))
                 return true;
         }
         catch {
@@ -212,6 +288,31 @@ export function transcriptHasForkedFrom(path, currentSessionId) {
     }
     return false;
 }
+/** Wait briefly for Claude to flush either fork signal after SessionStart.
+ * The observer hook calls this before recording the edge, allowing a
+ * one-second late-marker window without delaying ordinary transcript polling. */
+export async function waitForTranscriptForkSignal(path, claudeSessionId, sourceClaudeSessionId, recordedAtMs, options = {}) {
+    const timeoutMs = Math.max(0, options.timeoutMs ?? 1_000);
+    const pollMs = Math.max(1, options.pollMs ?? 50);
+    const deadline = Date.now() + timeoutMs;
+    do {
+        if (transcriptHasForkedFrom(path, claudeSessionId, sourceClaudeSessionId) ||
+            transcriptHasRecentLocalCommand(path, claudeSessionId, recordedAtMs))
+            return true;
+        if (Date.now() >= deadline)
+            return false;
+        await sleep(Math.min(pollMs, Math.max(1, deadline - Date.now())));
+    } while (true);
+}
+function transcriptTimestampMs(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value < 10_000_000_000 ? value * 1_000 : value;
+    }
+    if (typeof value !== "string" || !value)
+        return undefined;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
 /**
  * Read a sub-agent (Task) transcript in full and map it to {@link AgentEvent}s
  * tagged with `parentToolUseId`. Called once the parent Task tool_result arrives

package/dist/codex-session-store.d.ts

@@ -8,6 +8,23 @@ export interface CodexSessionRecord {
      * metadata remains self-contained; this only tells a runner where the
      * Provider persisted its rollout/state. */
     runtimeHomeOwnerSessionId?: string;
+    /** Claude hook/forwarder rendezvous ownership. A rotated target keeps the
+     * physical pane's bridge while the retired logical source is re-keyed to an
+     * isolated bridge; both may still share one Provider runtime home. */
+    bridgeOwnerSessionId?: string;
+    /** Durable recovery edge for a Claude-native `/clear`·`/fork`. The target
+     * binding is written before IPC publication; `published` is flipped only
+     * after the parent durably creates the logical target. */
+    nativeRotationSourceSessionId?: string;
+    /** Authoritative latest published target when this record is the source.
+     * Avoids choosing an arbitrary historical edge after repeated rotations. */
+    nativeRotationTargetSessionId?: string;
+    nativeRotationKind?: "clear" | "fork";
+    nativeRotationPublished?: boolean;
+    /** Stable transcript boundary captured by the rotating forwarder at the
+     * target SessionStart. Clear starts at zero; fork starts after the copied
+     * source prefix. Recovery must not replace this with a later file EOF. */
+    nativeRotationInitialTranscriptOffset?: number;
     updatedAt: string;
 }
 export interface ClaudeForkIntent {
@@ -15,6 +32,12 @@ export interface ClaudeForkIntent {
     sourceSessionId: string;
     sourceClaudeSessionId: string;
     targetClaudeSessionId: string;
+    /** Target transcript atomically cloned before the target runner starts. Its
+     * presence means recovery must resume this exact file, never re-clone a
+     * source that may have advanced since the fork boundary. */
+    forkTranscriptPath?: string;
+    /** Exact byte length of the cloned prefix, measured before Claude starts. */
+    forkTranscriptPrefixBytes?: number;
     updatedAt: string;
 }
 export interface CodexSessionStore {

package/dist/codex-session-store.js

@@ -107,6 +107,27 @@ export class FileCodexSessionStore {
                         ...(record.runtimeHomeOwnerSessionId
                             ? { runtimeHomeOwnerSessionId: record.runtimeHomeOwnerSessionId }
                             : {}),
+                        ...(record.bridgeOwnerSessionId
+                            ? { bridgeOwnerSessionId: record.bridgeOwnerSessionId }
+                            : {}),
+                        ...(record.nativeRotationSourceSessionId
+                            ? { nativeRotationSourceSessionId: record.nativeRotationSourceSessionId }
+                            : {}),
+                        ...(record.nativeRotationTargetSessionId
+                            ? { nativeRotationTargetSessionId: record.nativeRotationTargetSessionId }
+                            : {}),
+                        ...(record.nativeRotationKind
+                            ? { nativeRotationKind: record.nativeRotationKind }
+                            : {}),
+                        ...(record.nativeRotationPublished
+                            ? { nativeRotationPublished: true }
+                            : {}),
+                        ...(Number.isSafeInteger(record.nativeRotationInitialTranscriptOffset) &&
+                            record.nativeRotationInitialTranscriptOffset >= 0
+                            ? {
+                                nativeRotationInitialTranscriptOffset: record.nativeRotationInitialTranscriptOffset,
+                            }
+                            : {}),
                         updatedAt: record.updatedAt,
                     };
                 }

package/dist/host.d.ts

@@ -9,6 +9,27 @@ import type { ModelListResponse, ThreadGoal } from "./codex-app-server/protocol.
 import { type TerminalInjector } from "./claude/native-integration.js";
 import { FileCodexSessionStore, resolveCodexSessionStorePath, type ClaudeForkIntent, type CodexSessionRecord, type CodexSessionStore } from "./codex-session-store.js";
 import { AgentRuntimeError as CodexRuntimeError } from "@rynx-ai/core";
+/** Delivery policy carried only inside the runner process. It is not part of
+ * the public SessionEvent protocol: the same canonical event has different
+ * retry semantics depending on whether it came from a transcript item, a
+ * terminal hook, or a best-effort live snapshot. */
+export type MirrorDeliveryPolicy = "ordinary" | "terminal-status" | "best-effort" | "compaction" | "compaction-hook";
+export type MirrorDeliveryOutcome = "confirmed" | "ambiguous" | "dropped" | "superseded";
+export interface MirrorDeliveryOptions {
+    policy: MirrorDeliveryPolicy;
+    /** Stable local source key used by the Claude forwarder to checkpoint one
+     * item only after this delivery is handled. It is not sent to SQLite. */
+    sourceId?: string;
+    /** Independent retry lane. Claude native sub-agents use one lane each so a
+     * blocked child cannot stop its siblings or the parent transcript. */
+    lane?: string;
+    /** Claude-local write-only dead letter for an exhausted permanent ordinary
+     * item. No startup path replays this file automatically. */
+    deadLetterPath?: string;
+    /** Internal completion detail for state machines (not part of the wire). */
+    onOutcome?: (outcome: MirrorDeliveryOutcome) => void;
+}
+export type MirrorEmitter = (event: SessionEvent, delivery?: MirrorDeliveryOptions) => void | Promise<void>;
 export { FileCodexSessionStore, resolveCodexSessionStorePath, type CodexSessionRecord, type CodexSessionStore, type ClaudeForkIntent, };
 export interface CodexRuntimeStatus {
     codex_available: boolean;
@@ -99,7 +120,10 @@ export type RetargetMirror = (newSessionId: string, meta: {
     workspace: SessionWorkspaceSnapshot;
     execution: ResolvedExecutionSnapshot;
     parentSessionId?: string;
-}) => void;
+    /** Runs after parent target persistence + child resource transfer, but
+     * before the child proves `rotate.applied` to the parent. */
+    beforeApplied?: () => void | Promise<void>;
+}) => void | Promise<void>;
 export interface LiveSessionOpts {
     /** Immutable Session-owned snapshots. Provider launch/resume never re-opens a
      * Project or Agent template. */
@@ -212,7 +236,7 @@ export declare class LocalAgentHost implements CodexCapabilities {
      * existing session, the app-server resumes the persisted id. Rynx never writes
      * or repairs Codex's private rollout files.
      */
-    ensureLiveCodexSession(localThreadId: string, emit: (event: SessionEvent) => void, opts: LiveSessionOpts): Promise<boolean>;
+    ensureLiveCodexSession(localThreadId: string, emit: MirrorEmitter, opts: LiveSessionOpts): Promise<boolean>;
     private startLiveCodexSession;
     /** Bind a session's codex thread id once known (TUI broadcast or store): persist
      *  it, unblock injection, and kick off the resume-subscribe loop (once). */
@@ -301,6 +325,11 @@ export declare class LocalAgentHost implements CodexCapabilities {
      * Provider startup never re-opens an Agent template or process-level plugin
      * snapshot. */
     private prepareExecutionSkills;
+    /** Repair the only cross-process crash window in native rotation. A target
+     * started through the Session registry proves that logical publication is
+     * durable; a published target in turn proves its source must no longer own
+     * the shared live bridge. */
+    private reconcileClaudeNativeRotation;
     private startLiveClaudeSession;
     /** Persist claude's discovered session id (reusing the `codexSessionId` store
      *  field, as the claude executor already does) and release the readiness gate. */