@rynx-ai/runtime 0.1.0

package/dist/claude/native-message-display-main.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+/**
+ * Standalone Claude Code `MessageDisplay` hook (built to
+ * `dist/claude/native-message-display.js`). claude fires it per streamed
+ * assistant-text chunk; this appends the chunk to the session's
+ * `message_deltas.jsonl` for the forwarder to tail into live
+ * `response.output_text.delta` events. Kept dependency-light + fast (Claude
+ * blocks on the hook, so the per-chunk subprocess must stay cheap).
+ *
+ * Payload: `{ hook_event_name:"MessageDisplay", message_id, index, final, delta }`
+ * — `message_id` is stable per assistant message; consecutive `index` values
+ * carry disjoint text. `message_id` does NOT appear in the transcript, so the
+ * forwarder correlates the live buffer to the final item positionally (FIFO).
+ */
+import { recordMessageDelta } from "./native-bridge.js";
+function argValue(argv, flag) {
+    const i = argv.indexOf(flag);
+    return i >= 0 && i + 1 < argv.length ? argv[i + 1] : undefined;
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(chunk);
+    return Buffer.concat(chunks).toString("utf8");
+}
+async function main() {
+    const bridgeDir = argValue(process.argv.slice(2), "--bridge-dir");
+    if (!bridgeDir)
+        return;
+    const raw = await readStdin();
+    let payload;
+    try {
+        const parsed = JSON.parse(raw || "{}");
+        payload = parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return;
+    }
+    const messageId = typeof payload.message_id === "string" ? payload.message_id : undefined;
+    const delta = typeof payload.delta === "string" ? payload.delta : undefined;
+    const index = typeof payload.index === "number" && !Number.isNaN(payload.index) ? payload.index : undefined;
+    if (!messageId || delta === undefined || index === undefined)
+        return; // common no-op
+    try {
+        recordMessageDelta(bridgeDir, { messageId, index, final: Boolean(payload.final), delta });
+    }
+    catch {
+        // Best-effort: a failed append must not fail the hook (would wedge claude).
+    }
+}
+void main();

package/dist/claude/native-status-main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

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

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+/**
+ * Standalone Claude Code `statusLine` command (built to
+ * `dist/claude/native-status.js`). claude invokes it on every TUI render with a
+ * JSON status snapshot on stdin — the ONLY place it surfaces the running
+ * `context_window` size/usage and cumulative `cost`. This normalizes those
+ * fields into `status.json` for the forwarder to pick up (→ turn usage +
+ * context-threshold banner), then prints a compact line back to stdout so the
+ * co-driven TUI's status bar still shows something.
+ *
+ * stdin (claude v2.1.x, snake_case): `{ model:{id,display_name}, cost:{total_cost_usd},
+ *   context_window:{ context_window_size, used_percentage, total_input_tokens,
+ *   total_output_tokens, current_usage:{ input_tokens, output_tokens,
+ *   cache_creation_input_tokens, cache_read_input_tokens } } }`.
+ */
+import { writeClaudeStatus } from "./native-bridge.js";
+function argValue(argv, flag) {
+    const i = argv.indexOf(flag);
+    return i >= 0 && i + 1 < argv.length ? argv[i + 1] : undefined;
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(chunk);
+    return Buffer.concat(chunks).toString("utf8");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function num(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function parseStatus(payload) {
+    const status = {};
+    const ctx = isRecord(payload.context_window) ? payload.context_window : {};
+    const usage = isRecord(ctx.current_usage) ? ctx.current_usage : {};
+    const cost = isRecord(payload.cost) ? payload.cost : {};
+    const model = isRecord(payload.model) ? payload.model : {};
+    const size = num(ctx.context_window_size);
+    if (size !== undefined)
+        status.contextWindowSize = size;
+    const used = num(ctx.used_percentage);
+    if (used !== undefined)
+        status.usedPercentage = used;
+    const totalIn = num(ctx.total_input_tokens);
+    const totalOut = num(ctx.total_output_tokens);
+    if (totalIn !== undefined || totalOut !== undefined)
+        status.totalTokens = (totalIn ?? 0) + (totalOut ?? 0);
+    const inTok = num(usage.input_tokens);
+    if (inTok !== undefined)
+        status.inputTokens = inTok;
+    const outTok = num(usage.output_tokens);
+    if (outTok !== undefined)
+        status.outputTokens = outTok;
+    const cacheRead = num(usage.cache_read_input_tokens);
+    if (cacheRead !== undefined)
+        status.cacheReadTokens = cacheRead;
+    const cacheWrite = num(usage.cache_creation_input_tokens);
+    if (cacheWrite !== undefined)
+        status.cacheWriteTokens = cacheWrite;
+    const costUsd = num(cost.total_cost_usd);
+    if (costUsd !== undefined)
+        status.costUsd = costUsd;
+    const modelId = typeof model.id === "string" ? model.id : undefined;
+    if (modelId)
+        status.model = modelId;
+    return status;
+}
+/** A compact one-line status for the TUI bar (claude renders stdout verbatim). */
+function statusLine(status) {
+    const parts = [];
+    if (status.model)
+        parts.push(status.model);
+    if (status.usedPercentage !== undefined)
+        parts.push(`ctx ${Math.round(status.usedPercentage)}%`);
+    if (status.costUsd !== undefined)
+        parts.push(`$${status.costUsd.toFixed(4)}`);
+    return parts.join("  ·  ");
+}
+async function main() {
+    const bridgeDir = argValue(process.argv.slice(2), "--bridge-dir");
+    const raw = await readStdin();
+    let payload = {};
+    try {
+        const parsed = JSON.parse(raw || "{}");
+        if (parsed && typeof parsed === "object")
+            payload = parsed;
+    }
+    catch {
+        return;
+    }
+    const status = parseStatus(payload);
+    if (bridgeDir) {
+        try {
+            writeClaudeStatus(bridgeDir, status);
+        }
+        catch {
+            // Best-effort: a failed write must not fail the status hook (would wedge the TUI).
+        }
+    }
+    const line = statusLine(status);
+    if (line)
+        process.stdout.write(line);
+}
+void main();

package/dist/claude/status.d.ts

@@ -0,0 +1,23 @@
+import type { CodexRuntimeStatus } from "../host.js";
+import type { CodexSessionStore } from "../codex-session-store.js";
+/**
+ * Whether the `claude` CLI is runnable — used by the status probe. Resolves a
+ * bare name against `PATH`; an absolute/relative path is checked directly.
+ */
+export declare function isClaudeCliAvailable(binary?: string): Promise<boolean>;
+export interface ReadClaudeStatusDeps {
+    sessionStore: CodexSessionStore;
+    /** Process env (injectable for tests). */
+    env?: NodeJS.ProcessEnv;
+    /** Whether the `claude` CLI is runnable (injectable for tests). */
+    sdkAvailable?: () => Promise<boolean>;
+    /** Path-exists probe (injectable for tests). */
+    pathExists?: (target: string) => Promise<boolean>;
+}
+/**
+ * Compute the runtime status for the claude runtime. Mirrors the
+ * {@link CodexRuntimeStatus} shape the host's status probe produces, but probes
+ * the local `claude` CLI + Anthropic credentials instead of a codex app-server /
+ * `<bin> login status`.
+ */
+export declare function readClaudeStatus({ sessionStore, env, sdkAvailable, pathExists, }: ReadClaudeStatusDeps): Promise<CodexRuntimeStatus>;

package/dist/claude/status.js

@@ -0,0 +1,118 @@
+import { access, stat } from "node:fs/promises";
+import { accessSync, constants as fsConstants } from "node:fs";
+import path from "node:path";
+import { getRuntimeProfile, resolveRuntimeHome, resolveRuntimeSessionsRoot, } from "@rynx-ai/core";
+/**
+ * Whether the `claude` CLI is runnable — used by the status probe. Resolves a
+ * bare name against `PATH`; an absolute/relative path is checked directly.
+ */
+export async function isClaudeCliAvailable(binary = "claude") {
+    if (binary.includes("/")) {
+        try {
+            accessSync(binary, fsConstants.X_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    for (const dir of (process.env.PATH ?? "").split(path.delimiter)) {
+        if (!dir)
+            continue;
+        try {
+            accessSync(path.join(dir, binary), fsConstants.X_OK);
+            return true;
+        }
+        catch {
+            /* keep scanning */
+        }
+    }
+    return false;
+}
+/**
+ * Compute the runtime status for the claude runtime. Mirrors the
+ * {@link CodexRuntimeStatus} shape the host's status probe produces, but probes
+ * the local `claude` CLI + Anthropic credentials instead of a codex app-server /
+ * `<bin> login status`.
+ */
+export async function readClaudeStatus({ sessionStore, env = process.env, sdkAvailable = isClaudeCliAvailable, pathExists = defaultPathExists, }) {
+    const issues = [];
+    const profile = getRuntimeProfile("claude");
+    const codexAvailable = await sdkAvailable();
+    if (!codexAvailable) {
+        issues.push("未找到 `claude` CLI：请安装 Claude Code 并确保 `claude` 在 PATH 上。");
+    }
+    const { loggedIn, authMode } = await resolveClaudeAuth(env, profile, pathExists);
+    if (!authMode) {
+        // We couldn't positively confirm auth (oauth creds may live in the OS
+        // keychain, or a gateway token may be injected later). Don't block the
+        // runtime on this — a genuinely-unauthenticated run surfaces a clear auth
+        // error from the SDK at turn time. Surface it as an informational note.
+        issues.push("未确认 Claude 鉴权：若运行报鉴权错误，请设置 ANTHROPIC_API_KEY / ANTHROPIC_AUTH_TOKEN 或运行 `claude /login`。");
+    }
+    const sessionStoreWritable = await sessionStore.isWritable();
+    if (!sessionStoreWritable) {
+        issues.push(`Session store is not writable: ${sessionStore.filePath}`);
+    }
+    const sessionsAccessible = await checkClaudeHomeAccessible(pathExists);
+    if (!sessionsAccessible) {
+        issues.push(`${profile.displayName} home ${resolveRuntimeHome(profile)} 不可访问。`);
+    }
+    return {
+        codex_available: codexAvailable,
+        logged_in: loggedIn,
+        auth_mode: authMode,
+        session_store_writable: sessionStoreWritable,
+        codex_sessions_accessible: sessionsAccessible,
+        issues,
+    };
+}
+async function resolveClaudeAuth(env, profile, pathExists) {
+    if (env.ANTHROPIC_API_KEY?.trim()) {
+        return { loggedIn: true, authMode: "api_key" };
+    }
+    if (env.ANTHROPIC_AUTH_TOKEN?.trim()) {
+        return { loggedIn: true, authMode: "auth_token" };
+    }
+    // Fall back to a stored Claude Code login (oauth). The credentials file lives
+    // under the claude home; on some platforms it may be in the OS keychain
+    // instead, so a miss here is "unknown", surfaced as not-logged-in.
+    const home = resolveRuntimeHome(profile, env);
+    const credentialsFile = path.join(home, ".credentials.json");
+    if (await pathExists(credentialsFile)) {
+        return { loggedIn: true, authMode: "oauth" };
+    }
+    // Uncertain — be lenient (don't block); auth_mode null signals "unconfirmed".
+    return { loggedIn: true, authMode: null };
+}
+async function checkClaudeHomeAccessible(pathExists) {
+    const profile = getRuntimeProfile("claude");
+    const home = resolveRuntimeHome(profile);
+    const sessionsRoot = resolveRuntimeSessionsRoot(profile);
+    try {
+        if (await pathExists(sessionsRoot)) {
+            await access(sessionsRoot, fsConstants.R_OK | fsConstants.W_OK);
+            return true;
+        }
+        if (await pathExists(home)) {
+            await access(home, fsConstants.R_OK | fsConstants.W_OK);
+            return true;
+        }
+        // Home not created yet — the SDK will create it on first run. Treat the
+        // parent (HOME) being writable as accessible.
+        await access(path.dirname(home), fsConstants.R_OK | fsConstants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function defaultPathExists(target) {
+    try {
+        await stat(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/claude/transcript.d.ts

@@ -0,0 +1,79 @@
+import type { AgentEvent, TerminalCommandData } from "@rynx-ai/core";
+/** Claude Code encodes a cwd into a project-dir name by replacing `/` and `.`
+ *  with `-` (e.g. `/Users/x/Workspace/rynx` → `-Users-x-Workspace-rynx`). */
+export declare function encodeClaudeProjectDir(cwd: string): string;
+/** The directory Claude Code writes this cwd's session transcripts into. */
+export declare function claudeProjectDir(cwd: string, home?: string): string;
+/** The transcript file for a specific claude session id. */
+export declare function claudeTranscriptPath(cwd: string, sessionId: string, home?: string): string;
+/** 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. */
+export declare function subagentTranscriptPath(parentTranscriptPath: string, agentId: string): string;
+/**
+ * Parse a claude local-command (`!` bash mode) user record's string content into
+ * a {@link TerminalCommandData}. Claude records the command and its captured
+ * output together as `<bash-input>` / `<bash-stdout>` / `<bash-stderr>` markers
+ * inside one `role:user` string message. Returns undefined when no `<bash-input>`
+ * is present — other `<…>`-marker user records (slash commands, `<caveat>`,
+ * `<system-reminder>`) are bookkeeping, not terminal commands.
+ */
+export declare function parseTerminalCommand(content: string): TerminalCommandData | undefined;
+/** Options for {@link parseTranscriptRecord} / {@link parseTranscriptLine}. */
+export interface ParseTranscriptOptions {
+    /** When set, the record is a sub-agent (Task) record: sidechains are kept
+     *  (not skipped) and every emitted event is tagged with this parent Task
+     *  tool-use id, so the canonical layer nests them under that call. */
+    parentToolUseId?: string;
+}
+/**
+ * Parse one transcript JSONL line into zero or more {@link AgentEvent}s. Returns
+ * `[]` for blank lines, malformed JSON, sidechains, and non-content records.
+ */
+export declare function parseTranscriptLine(line: string, opts?: ParseTranscriptOptions): AgentEvent[];
+/**
+ * Map an already-parsed transcript record into {@link AgentEvent}s — identical
+ * semantics to {@link parseTranscriptLine}, which is a thin JSON wrapper over
+ * this. Exposed so the claude-native forwarder can dispatch a record it already
+ * parsed (to first detect a `role:user` prompt) without re-stringifying it.
+ *
+ * In the main transcript, sub-agent sidechain records are skipped — they live in
+ * `subagents/agent-<id>.jsonl` and are replayed with {@link opts.parentToolUseId}
+ * set (which keeps them and tags each event with the parent Task's id).
+ */
+export declare function parseTranscriptRecord(record: unknown, opts?: ParseTranscriptOptions): AgentEvent[];
+/**
+ * Whether a transcript is a `/fork` (branch) of another session: claude stamps a
+ * `forkedFrom: { sessionId }` marker in an early record pointing at the source
+ * session (omnigent'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 omnigent's shape.
+ */
+export declare function transcriptHasForkedFrom(path: string, currentSessionId?: string): boolean;
+/**
+ * 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
+ * (the sub-agent file is complete by then), so a plain synchronous read is enough
+ * and there is no live-correlation race. The sub-agent's leading string-content
+ * user record is its task prompt (already shown in the Task tool's arguments) and
+ * is naturally skipped by {@link parseTranscriptLine} (non-array content).
+ * Returns `[]` if the file is missing/unreadable (best-effort enrichment).
+ */
+export declare function readSubagentEvents(path: string, parentToolUseId: string): AgentEvent[];
+export interface TailOptions {
+    /** Byte offset to resume from (persist across restarts for `--resume`). */
+    fromOffset?: number;
+    /** Poll interval; the JSONL is append-only so polling is simplest/robust. */
+    pollMs?: number;
+    signal?: AbortSignal;
+    /** Called with the current byte offset after each read (cursor persistence). */
+    onOffset?: (offset: number) => void;
+}
+/**
+ * Tail a Claude transcript JSONL, yielding {@link AgentEvent}s for each new
+ * complete line. Append-only, so a byte-offset cursor + polling is enough; a
+ * partial trailing line is buffered until its newline arrives. Ends when the
+ * signal aborts.
+ */
+export declare function tailTranscript(path: string, opts?: TailOptions): AsyncGenerator<AgentEvent>;

package/dist/claude/transcript.js

@@ -0,0 +1,272 @@
+/**
+ * Claude Code transcript reader (Phase E, claude-native). Claude Code appends a
+ * JSONL transcript per session at
+ * `~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl`; the interactive TUI's
+ * stdout is a full-screen UI, so — like omnigent's claude-native — we take the
+ * structured story from this file, not the PTY. Each `user`/`assistant` record
+ * wraps an Anthropic message (`{ role, content: [blocks] }`), so we map its
+ * blocks to the same typed {@link AgentEvent}s the headless executor emits.
+ *
+ * Records are full messages (not deltas), so text → a completed message,
+ * thinking → completed reasoning, tool_use → tool start, tool_result → tool end.
+ * Non-content records (attachment/system/mode/…) and sub-agent sidechains are
+ * skipped.
+ */
+import { readFileSync } from "node:fs";
+import { open, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/** Claude Code encodes a cwd into a project-dir name by replacing `/` and `.`
+ *  with `-` (e.g. `/Users/x/Workspace/rynx` → `-Users-x-Workspace-rynx`). */
+export function encodeClaudeProjectDir(cwd) {
+    return cwd.replace(/[/.]/g, "-");
+}
+/** The directory Claude Code writes this cwd's session transcripts into. */
+export function claudeProjectDir(cwd, home = homedir()) {
+    return join(home, ".claude", "projects", encodeClaudeProjectDir(cwd));
+}
+/** The transcript file for a specific claude session id. */
+export function claudeTranscriptPath(cwd, sessionId, home = homedir()) {
+    return join(claudeProjectDir(cwd, home), `${sessionId}.jsonl`);
+}
+/** 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. */
+export function subagentTranscriptPath(parentTranscriptPath, agentId) {
+    const dir = parentTranscriptPath.replace(/\.jsonl$/, "");
+    return join(dir, "subagents", `agent-${agentId}.jsonl`);
+}
+function stringifyToolContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => part && typeof part === "object" && "text" in part
+            ? String(part.text ?? "")
+            : typeof part === "string"
+                ? part
+                : JSON.stringify(part))
+            .join("");
+    }
+    return content == null ? "" : JSON.stringify(content);
+}
+function toolLabel(name, input) {
+    if (input && typeof input === "object") {
+        const rec = input;
+        for (const key of ["command", "cmd", "path", "file_path", "pattern", "query"]) {
+            const v = rec[key];
+            if (typeof v === "string" && v)
+                return v;
+        }
+    }
+    return name ?? "tool";
+}
+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 a claude local-command (`!` bash mode) user record's string content into
+ * a {@link TerminalCommandData}. Claude records the command and its captured
+ * output together as `<bash-input>` / `<bash-stdout>` / `<bash-stderr>` markers
+ * inside one `role:user` string message. Returns undefined when no `<bash-input>`
+ * is present — other `<…>`-marker user records (slash commands, `<caveat>`,
+ * `<system-reminder>`) are bookkeeping, not terminal commands.
+ */
+export function parseTerminalCommand(content) {
+    const input = BASH_INPUT_RE.exec(content);
+    if (!input)
+        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;
+    return data;
+}
+/**
+ * Parse one transcript JSONL line into zero or more {@link AgentEvent}s. Returns
+ * `[]` for blank lines, malformed JSON, sidechains, and non-content records.
+ */
+export function parseTranscriptLine(line, opts) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return [];
+    try {
+        return parseTranscriptRecord(JSON.parse(trimmed), opts);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Map an already-parsed transcript record into {@link AgentEvent}s — identical
+ * semantics to {@link parseTranscriptLine}, which is a thin JSON wrapper over
+ * this. Exposed so the claude-native forwarder can dispatch a record it already
+ * parsed (to first detect a `role:user` prompt) without re-stringifying it.
+ *
+ * In the main transcript, sub-agent sidechain records are skipped — they live in
+ * `subagents/agent-<id>.jsonl` and are replayed with {@link opts.parentToolUseId}
+ * set (which keeps them and tags each event with the parent Task's id).
+ */
+export function parseTranscriptRecord(record, opts) {
+    const rec = record;
+    const parent = opts?.parentToolUseId;
+    const parentTag = parent ? { parentToolUseId: parent } : {};
+    if (rec.isSidechain && !parent)
+        return []; // sub-agent turns are replayed separately
+    const message = rec.message;
+    if (!message || !Array.isArray(message.content))
+        return [];
+    const out = [];
+    if (rec.type === "assistant" && message.role === "assistant") {
+        const itemId = message.id;
+        const texts = [];
+        for (const block of message.content) {
+            if (block.type === "text" && block.text) {
+                texts.push(block.text);
+            }
+            else if (block.type === "thinking" && block.thinking) {
+                out.push({ type: "reasoning_completed", summary: [block.thinking], ...(itemId ? { itemId } : {}), ...parentTag });
+            }
+            else if (block.type === "tool_use") {
+                out.push({
+                    type: "tool",
+                    event: "on_tool_start",
+                    name: block.name,
+                    input: { ...(isObject(block.input) ? block.input : {}), id: block.id, command: toolLabel(block.name, block.input) },
+                    data: { id: block.id },
+                    ...parentTag,
+                });
+            }
+        }
+        if (texts.length) {
+            out.push({ type: "message_completed", text: texts.join(""), ...(itemId ? { itemId } : {}), ...parentTag });
+        }
+        return out;
+    }
+    if (rec.type === "user" && message.role === "user") {
+        for (const block of message.content) {
+            if (block.type === "tool_result") {
+                out.push({
+                    type: "tool",
+                    event: "on_tool_end",
+                    output: {
+                        id: block.tool_use_id,
+                        status: block.is_error ? "failed" : "completed",
+                        aggregatedOutput: stringifyToolContent(block.content),
+                        exitCode: null,
+                    },
+                    ...(block.is_error ? { error: "tool_error" } : {}),
+                    data: { tool_use_id: block.tool_use_id },
+                    ...parentTag,
+                });
+            }
+        }
+    }
+    return out;
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(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
+ * session (omnigent'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 omnigent's shape.
+ */
+export function transcriptHasForkedFrom(path, currentSessionId) {
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch {
+        return false;
+    }
+    let scanned = 0;
+    for (const line of text.split("\n")) {
+        if (++scanned > 200)
+            break;
+        const trimmed = line.trim();
+        if (!trimmed || !trimmed.includes("forkedFrom"))
+            continue;
+        try {
+            const rec = JSON.parse(trimmed);
+            const from = rec.forkedFrom?.sessionId;
+            if (typeof from === "string" && from && from !== currentSessionId)
+                return true;
+        }
+        catch {
+            // skip malformed
+        }
+    }
+    return false;
+}
+/**
+ * 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
+ * (the sub-agent file is complete by then), so a plain synchronous read is enough
+ * and there is no live-correlation race. The sub-agent's leading string-content
+ * user record is its task prompt (already shown in the Task tool's arguments) and
+ * is naturally skipped by {@link parseTranscriptLine} (non-array content).
+ * Returns `[]` if the file is missing/unreadable (best-effort enrichment).
+ */
+export function readSubagentEvents(path, parentToolUseId) {
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of text.split("\n")) {
+        for (const event of parseTranscriptLine(line, { parentToolUseId }))
+            out.push(event);
+    }
+    return out;
+}
+async function readFrom(path, offset, end) {
+    const fh = await open(path, "r");
+    try {
+        const length = end - offset;
+        const buf = Buffer.alloc(length);
+        await fh.read(buf, 0, length, offset);
+        return buf.toString("utf8");
+    }
+    finally {
+        await fh.close();
+    }
+}
+/**
+ * Tail a Claude transcript JSONL, yielding {@link AgentEvent}s for each new
+ * complete line. Append-only, so a byte-offset cursor + polling is enough; a
+ * partial trailing line is buffered until its newline arrives. Ends when the
+ * signal aborts.
+ */
+export async function* tailTranscript(path, opts = {}) {
+    const pollMs = opts.pollMs ?? 200;
+    let offset = opts.fromOffset ?? 0;
+    let buffer = "";
+    while (!opts.signal?.aborted) {
+        const info = await stat(path).catch(() => null);
+        if (info && info.size > offset) {
+            buffer += await readFrom(path, offset, info.size);
+            offset = info.size;
+            opts.onOffset?.(offset);
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                for (const event of parseTranscriptLine(line)) {
+                    yield event;
+                }
+            }
+        }
+        if (opts.signal?.aborted)
+            break;
+        await new Promise((r) => setTimeout(r, pollMs));
+    }
+}

package/dist/claude/trust.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Ensure `cwd` is pre-trusted in `~/.claude.json`. Idempotent; throws (rather
+ * than clobbering) if an existing config isn't shaped as expected. Opt out with
+ * `RYNX_CLAUDE_PRESEED_TRUST=0`.
+ */
+export declare function ensureProjectTrusted(cwd: string, configPath?: string): void;