@rynx-ai/runtime 0.1.0

package/dist/claude/executor.d.ts

@@ -0,0 +1,17 @@
+import type { SkillMeta } from "@rynx-ai/core";
+/**
+ * Materialize a selected catalog skill subset into a throwaway 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.
+ *
+ * Returns `null` when there's nothing to add — no selection (no opinion) OR an
+ * empty selection (`none`). Enforcement on claude is ADDITIVE only: we never
+ * suppress host skills, because the only lever (`--setting-sources ""`) also
+ * drops the user's settings (and any auth env there). Codex/traex still enforce
+ * `none`/subsets exactly via the prompt.
+ */
+export declare function materializeSkillPlugin(selected: SkillMeta[] | null | undefined): Promise<{
+    pluginDir?: string;
+    cleanup?: () => Promise<void>;
+} | null>;

package/dist/claude/executor.js

@@ -0,0 +1,28 @@
+import { cp, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+/**
+ * Materialize a selected catalog skill subset into a throwaway 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.
+ *
+ * Returns `null` when there's nothing to add — no selection (no opinion) OR an
+ * empty selection (`none`). Enforcement on claude is ADDITIVE only: we never
+ * suppress host skills, because the only lever (`--setting-sources ""`) also
+ * drops the user's settings (and any auth env there). Codex/traex still enforce
+ * `none`/subsets exactly via the prompt.
+ */
+export async function materializeSkillPlugin(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 });
+    }
+    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

@@ -0,0 +1,10 @@
+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`). */
+export declare function listClaudeModels(): ModelListResponse;

package/dist/claude/models.js

@@ -0,0 +1,33 @@
+/**
+ * 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),
+ * the Agent SDK has no per-install model-list RPC, so we ship a curated list of
+ * current model ids. `value`/`label` mirror the codex `ModelInfo` shape the
+ * settings card consumes (`model || id`, `displayName || model || id`).
+ */
+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-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" },
+    { id: "claude-fable-5", displayName: "Claude Fable 5" },
+];
+/** Build the `ModelInfo[]` for the claude runtime. */
+export function claudeModelInfos() {
+    return CLAUDE_MODEL_IDS.map(({ id, displayName }) => ({
+        id,
+        model: id,
+        displayName,
+        isDefault: id === CLAUDE_DEFAULT_MODEL,
+    }));
+}
+/** {@link ModelListResponse} for the claude runtime (broker `listModels`). */
+export function listClaudeModels() {
+    return { data: claudeModelInfos() };
+}

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

@@ -0,0 +1,133 @@
+export declare const HOOKS_FILE = "hooks.jsonl";
+export declare const STATE_FILE = "state.json";
+export declare const DELTAS_FILE = "message_deltas.jsonl";
+export declare const PERMISSION_FILE = "permission_hook.json";
+export declare const STATUS_FILE = "status.json";
+export declare const FORWARDER_STATE_FILE = "transcript_forwarder.json";
+/** The deterministic bridge directory for a rynx session id. */
+export declare function claudeBridgeDir(sessionId: string): string;
+export interface PermissionHookConfig {
+    /** The rynx session id (localThreadId) — the hook POSTs to `/api/sessions/:id/...`. */
+    sessionId: string;
+    /** Daemon base URL the PermissionRequest hook POSTs to, e.g. `http://127.0.0.1:3000`. */
+    serverUrl: string;
+}
+/**
+ * Create/refresh the bridge dir: clear stale event files (a re-launched session
+ * must not replay a prior run's hooks) and, when given, write the permission
+ * config. `permission_hook.json` is deliberately NOT cleared elsewhere so a
+ * reattach keeps approval routing. Returns the dir.
+ */
+export declare function prepareClaudeBridgeDir(sessionId: string, permission?: PermissionHookConfig): string;
+export interface ClaudeBridgeState {
+    /** Claude transcript JSONL path (from the SessionStart/any hook payload). */
+    transcriptPath?: string;
+    /** Claude's own session uuid (from the hook payload `session_id`). */
+    claudeSessionId?: string;
+    lastHookEventName?: string;
+}
+export declare function readClaudeState(bridgeDir: string): ClaudeBridgeState;
+export declare function readPermissionHookConfig(bridgeDir: string): PermissionHookConfig | null;
+/**
+ * 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
+ * is Claude's own stdin JSON, so its fields are snake_case (`hook_event_name`,
+ * `transcript_path`, `session_id`). state.json is a lock-free read-modify-write
+ * (last-writer-wins) — the folded fields are idempotent, so a race only re-writes
+ * the same values (matches omnigent's `record_hook_event`).
+ */
+export declare function recordHookEvent(bridgeDir: string, payload: Record<string, unknown>): void;
+export interface JsonlReadResult<T> {
+    records: T[];
+    /** Byte offset immediately after the last COMPLETE record; a partial trailing
+     *  line is left unconsumed so the next poll retries it once its newline lands. */
+    nextOffset: number;
+}
+/** Read complete newline-terminated JSON records appended after `byteOffset`. */
+export declare function readJsonlFrom<T = unknown>(path: string, byteOffset: number): JsonlReadResult<T>;
+/** One parsed Claude hook event (the fields the forwarder acts on + the raw payload). */
+export interface HookEvent {
+    eventName?: string;
+    transcriptPath?: string;
+    /** Claude's session uuid — subagent hooks report a `subagents/…` transcript path. */
+    sessionId?: string;
+    source?: string;
+    payload: Record<string, unknown>;
+}
+/** Tail `hooks.jsonl` from a byte offset into parsed {@link HookEvent}s. */
+export declare function readHookEventsFrom(bridgeDir: string, byteOffset: number): {
+    events: HookEvent[];
+    nextOffset: number;
+};
+/** One streamed assistant-text chunk from `message_deltas.jsonl` (MessageDisplay). */
+export interface MessageDelta {
+    messageId: string;
+    index: number;
+    final: boolean;
+    delta: string;
+}
+/** Tail `message_deltas.jsonl` from a byte offset into {@link MessageDelta}s. */
+export declare function readMessageDeltasFrom(bridgeDir: string, byteOffset: number): {
+    deltas: MessageDelta[];
+    nextOffset: number;
+};
+/** Append one streamed chunk to `message_deltas.jsonl` (the MessageDisplay hook). */
+export declare function recordMessageDelta(bridgeDir: string, delta: MessageDelta): void;
+/**
+ * The latest context-window + cost snapshot from claude's `statusLine` hook — the
+ * ONLY place claude surfaces the running `context_window` size/usage and cumulative
+ * cost. Normalized (camelCase) at write time so the forwarder consumes one shape.
+ */
+export interface ClaudeStatusState {
+    /** Max context tokens (`context_window.context_window_size`). */
+    contextWindowSize?: number;
+    /** Pre-computed fraction used (`context_window.used_percentage`, 0–100). */
+    usedPercentage?: number;
+    /** Context tokens currently in use (total_input + total_output). */
+    totalTokens?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+    /** Cumulative session cost (`cost.total_cost_usd`). */
+    costUsd?: number;
+    /** Live model id (`model.id`) — the only race-free source before the transcript. */
+    model?: string;
+}
+/** Overwrite `status.json` with the latest snapshot (last-writer-wins; statusLine
+ *  fires on every TUI render so a plain write is enough — no append log). */
+export declare function writeClaudeStatus(bridgeDir: string, status: ClaudeStatusState): void;
+/**
+ * The forwarder's durable cursor into a claude transcript. Persisted so a
+ * re-launched forwarder (reconnect / daemon restart) resumes from where it left
+ * off instead of re-tailing from byte 0 and re-mirroring every past turn
+ * (duplicates). Ports omnigent's `TranscriptForwardState` / `transcript_forwarder.json`.
+ * NOT cleared by {@link prepareClaudeBridgeDir} — it must outlive a re-launch.
+ */
+export interface TranscriptForwardState {
+    /** The transcript file this cursor points into (guards against a stale file). */
+    transcriptPath: string;
+    /** Primary dedup: bytes already forwarded. A restart seeks here. */
+    byteOffset: 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;
+}
+/** Cap on `seenSourceIds` (matches omnigent's `_MAX_SEEN_SOURCE_IDS`). */
+export declare const MAX_SEEN_SOURCE_IDS = 2000;
+/** SHA-256 over `byteOffset` (8-byte big-endian) + up to 256 bytes immediately
+ *  before it. Undefined if the file is shorter than `byteOffset` (truncated) or
+ *  unreadable. Mirrors omnigent's `_jsonl_cursor_fingerprint`. */
+export declare function jsonlCursorFingerprint(path: string, byteOffset: number): string | undefined;
+/** Persist the forwarder cursor atomically (temp file + rename); `seenSourceIds`
+ *  is bounded to the most-recent {@link MAX_SEEN_SOURCE_IDS}. */
+export declare function writeForwardState(bridgeDir: string, state: TranscriptForwardState): void;
+/** Read the forwarder cursor, or undefined if absent/malformed. */
+export declare function readForwardState(bridgeDir: string): TranscriptForwardState | undefined;
+/** Drop the forwarder cursor (a `/clear` starts fresh). */
+export declare function resetForwardState(bridgeDir: string): void;
+/** Read the latest `status.json` snapshot, or undefined if absent/malformed. */
+export declare function readClaudeStatus(bridgeDir: string): ClaudeStatusState | undefined;

package/dist/claude/native-bridge.js

@@ -0,0 +1,299 @@
+/**
+ * Claude-native bridge directory — the filesystem rendezvous between the
+ * short-lived Claude Code hook subprocesses (which APPEND events) and the
+ * runner-child forwarder (which TAILS them). Mirrors omnigent's
+ * `claude_native_bridge` file surface:
+ *   - `hooks.jsonl`          append-only hook events (SessionStart / Stop / …)
+ *   - `state.json`           latest transcript_path + claude session id
+ *   - `message_deltas.jsonl` streamed assistant-text chunks (MessageDisplay)
+ *   - `permission_hook.json` server URL + auth for the blocking PermissionRequest hook
+ *
+ * Dependency-light on purpose (node builtins only, no `@rynx-ai/core`) so the
+ * standalone hook entrypoints can import it without pulling the whole runtime
+ * into every hook subprocess.
+ */
+import { appendFileSync, closeSync, mkdirSync, openSync, readFileSync, readSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { createHash } from "node:crypto";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+export const HOOKS_FILE = "hooks.jsonl";
+export const STATE_FILE = "state.json";
+export const DELTAS_FILE = "message_deltas.jsonl";
+export const PERMISSION_FILE = "permission_hook.json";
+export const STATUS_FILE = "status.json";
+export const FORWARDER_STATE_FILE = "transcript_forwarder.json";
+/** Uid-scoped root so other users on a shared host can't read the bridge tree
+ *  (it holds the PermissionRequest bearer headers). */
+function bridgeRoot() {
+    const uid = typeof process.getuid === "function" ? process.getuid() : "nouid";
+    return join(tmpdir(), `rynx-${uid}`, "claude-native");
+}
+/** The deterministic bridge directory for a rynx session id. */
+export function claudeBridgeDir(sessionId) {
+    const digest = createHash("sha256").update(sessionId).digest("hex").slice(0, 32);
+    return join(bridgeRoot(), digest);
+}
+/**
+ * Create/refresh the bridge dir: clear stale event files (a re-launched session
+ * must not replay a prior run's hooks) and, when given, write the permission
+ * config. `permission_hook.json` is deliberately NOT cleared elsewhere so a
+ * reattach keeps approval routing. Returns the dir.
+ */
+export function prepareClaudeBridgeDir(sessionId, permission) {
+    const dir = claudeBridgeDir(sessionId);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    for (const file of [HOOKS_FILE, STATE_FILE, DELTAS_FILE, STATUS_FILE]) {
+        try {
+            rmSync(join(dir, file));
+        }
+        catch {
+            // Absent on a cold start — expected.
+        }
+    }
+    if (permission) {
+        writeFileSync(join(dir, PERMISSION_FILE), JSON.stringify(permission), { mode: 0o600 });
+    }
+    return dir;
+}
+function readJsonFile(path) {
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function asString(value) {
+    return typeof value === "string" && value ? value : undefined;
+}
+export function readClaudeState(bridgeDir) {
+    const raw = readJsonFile(join(bridgeDir, STATE_FILE));
+    if (!raw || typeof raw !== "object")
+        return {};
+    const s = raw;
+    return {
+        transcriptPath: asString(s.transcriptPath),
+        claudeSessionId: asString(s.claudeSessionId),
+        lastHookEventName: asString(s.lastHookEventName),
+    };
+}
+export function readPermissionHookConfig(bridgeDir) {
+    const raw = readJsonFile(join(bridgeDir, PERMISSION_FILE));
+    if (!raw || typeof raw !== "object")
+        return null;
+    const s = raw;
+    const sessionId = asString(s.sessionId);
+    const serverUrl = asString(s.serverUrl);
+    if (!sessionId || !serverUrl)
+        return null;
+    return { sessionId, serverUrl };
+}
+/**
+ * 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
+ * is Claude's own stdin JSON, so its fields are snake_case (`hook_event_name`,
+ * `transcript_path`, `session_id`). state.json is a lock-free read-modify-write
+ * (last-writer-wins) — the folded fields are idempotent, so a race only re-writes
+ * the same values (matches omnigent's `record_hook_event`).
+ */
+export function recordHookEvent(bridgeDir, payload) {
+    mkdirSync(bridgeDir, { recursive: true, mode: 0o700 });
+    const envelope = { recordedAt: Date.now(), payload };
+    appendFileSync(join(bridgeDir, HOOKS_FILE), `${JSON.stringify(envelope)}\n`);
+    const state = readClaudeState(bridgeDir);
+    const eventName = asString(payload.hook_event_name);
+    if (eventName)
+        state.lastHookEventName = eventName;
+    const transcriptPath = asString(payload.transcript_path);
+    if (transcriptPath)
+        state.transcriptPath = transcriptPath;
+    const claudeSessionId = asString(payload.session_id);
+    if (claudeSessionId)
+        state.claudeSessionId = claudeSessionId;
+    writeFileSync(join(bridgeDir, STATE_FILE), JSON.stringify(state));
+}
+/** Read complete newline-terminated JSON records appended after `byteOffset`. */
+export function readJsonlFrom(path, byteOffset) {
+    let info;
+    try {
+        info = statSync(path);
+    }
+    catch {
+        return { records: [], nextOffset: byteOffset };
+    }
+    if (info.size <= byteOffset)
+        return { records: [], nextOffset: byteOffset };
+    const fd = openSync(path, "r");
+    try {
+        const length = info.size - byteOffset;
+        const buf = Buffer.alloc(length);
+        readSync(fd, buf, 0, length, byteOffset);
+        const text = buf.toString("utf8");
+        const lines = text.split("\n");
+        const trailing = lines.pop() ?? ""; // partial (no trailing newline yet)
+        const consumed = length - Buffer.byteLength(trailing, "utf8");
+        const records = [];
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                records.push(JSON.parse(trimmed));
+            }
+            catch {
+                // Skip a malformed complete line; the offset still advances past it.
+            }
+        }
+        return { records, nextOffset: byteOffset + consumed };
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/** Tail `hooks.jsonl` from a byte offset into parsed {@link HookEvent}s. */
+export function readHookEventsFrom(bridgeDir, byteOffset) {
+    const { records, nextOffset } = readJsonlFrom(join(bridgeDir, HOOKS_FILE), byteOffset);
+    const events = [];
+    for (const rec of records) {
+        const payload = rec.payload;
+        if (!payload || typeof payload !== "object")
+            continue;
+        events.push({
+            eventName: asString(payload.hook_event_name),
+            transcriptPath: asString(payload.transcript_path),
+            sessionId: asString(payload.session_id),
+            source: asString(payload.source),
+            payload,
+        });
+    }
+    return { events, nextOffset };
+}
+/** Tail `message_deltas.jsonl` from a byte offset into {@link MessageDelta}s. */
+export function readMessageDeltasFrom(bridgeDir, byteOffset) {
+    const { records, nextOffset } = readJsonlFrom(join(bridgeDir, DELTAS_FILE), byteOffset);
+    const deltas = [];
+    for (const r of records) {
+        const messageId = asString(r.message_id);
+        const delta = typeof r.delta === "string" ? r.delta : undefined;
+        const index = typeof r.index === "number" && !Number.isNaN(r.index) ? r.index : undefined;
+        if (messageId && delta !== undefined && index !== undefined) {
+            deltas.push({ messageId, index, final: Boolean(r.final), delta });
+        }
+    }
+    return { deltas, nextOffset };
+}
+/** Append one streamed chunk to `message_deltas.jsonl` (the MessageDisplay hook). */
+export function recordMessageDelta(bridgeDir, delta) {
+    mkdirSync(bridgeDir, { recursive: true, mode: 0o700 });
+    const row = {
+        message_id: delta.messageId,
+        index: delta.index,
+        final: delta.final,
+        delta: delta.delta,
+    };
+    appendFileSync(join(bridgeDir, DELTAS_FILE), `${JSON.stringify(row)}\n`);
+}
+/** Overwrite `status.json` with the latest snapshot (last-writer-wins; statusLine
+ *  fires on every TUI render so a plain write is enough — no append log). */
+export function writeClaudeStatus(bridgeDir, status) {
+    mkdirSync(bridgeDir, { recursive: true, mode: 0o700 });
+    writeFileSync(join(bridgeDir, STATUS_FILE), JSON.stringify(status));
+}
+function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+/** Cap on `seenSourceIds` (matches omnigent's `_MAX_SEEN_SOURCE_IDS`). */
+export const MAX_SEEN_SOURCE_IDS = 2000;
+const CURSOR_FINGERPRINT_BYTES = 256;
+/** SHA-256 over `byteOffset` (8-byte big-endian) + up to 256 bytes immediately
+ *  before it. Undefined if the file is shorter than `byteOffset` (truncated) or
+ *  unreadable. Mirrors omnigent's `_jsonl_cursor_fingerprint`. */
+export function jsonlCursorFingerprint(path, byteOffset) {
+    let fd;
+    try {
+        if (statSync(path).size < byteOffset)
+            return undefined; // truncated below the cursor
+        fd = openSync(path, "r");
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const start = Math.max(0, byteOffset - CURSOR_FINGERPRINT_BYTES);
+        const len = byteOffset - start;
+        const sample = Buffer.alloc(len);
+        if (len > 0)
+            readSync(fd, sample, 0, len, start);
+        const prefix = Buffer.alloc(8);
+        prefix.writeBigUInt64BE(BigInt(byteOffset));
+        return createHash("sha256").update(prefix).update(sample).digest("hex");
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/** Persist the forwarder cursor atomically (temp file + rename); `seenSourceIds`
+ *  is bounded to the most-recent {@link MAX_SEEN_SOURCE_IDS}. */
+export function writeForwardState(bridgeDir, state) {
+    mkdirSync(bridgeDir, { recursive: true, mode: 0o700 });
+    const bounded = {
+        ...state,
+        seenSourceIds: state.seenSourceIds.slice(-MAX_SEEN_SOURCE_IDS),
+    };
+    const tmp = join(bridgeDir, `${FORWARDER_STATE_FILE}.tmp`);
+    writeFileSync(tmp, JSON.stringify(bounded));
+    renameSync(tmp, join(bridgeDir, FORWARDER_STATE_FILE));
+}
+/** Read the forwarder cursor, or undefined if absent/malformed. */
+export function readForwardState(bridgeDir) {
+    const raw = readJsonFile(join(bridgeDir, FORWARDER_STATE_FILE));
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const s = raw;
+    const transcriptPath = asString(s.transcriptPath);
+    const byteOffset = asNumber(s.byteOffset);
+    if (!transcriptPath || byteOffset === undefined)
+        return undefined;
+    const seenSourceIds = Array.isArray(s.seenSourceIds)
+        ? s.seenSourceIds.filter((x) => typeof x === "string")
+        : [];
+    const cursorFingerprint = asString(s.cursorFingerprint);
+    return { transcriptPath, byteOffset, seenSourceIds, ...(cursorFingerprint ? { cursorFingerprint } : {}) };
+}
+/** Drop the forwarder cursor (a `/clear` starts fresh). */
+export function resetForwardState(bridgeDir) {
+    try {
+        rmSync(join(bridgeDir, FORWARDER_STATE_FILE));
+    }
+    catch {
+        // absent — fine
+    }
+}
+/** Read the latest `status.json` snapshot, or undefined if absent/malformed. */
+export function readClaudeStatus(bridgeDir) {
+    const raw = readJsonFile(join(bridgeDir, STATUS_FILE));
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const s = raw;
+    const out = {};
+    const n = (k) => {
+        const v = asNumber(s[k]);
+        if (v !== undefined)
+            out[k] = v;
+    };
+    n("contextWindowSize");
+    n("usedPercentage");
+    n("totalTokens");
+    n("inputTokens");
+    n("outputTokens");
+    n("cacheReadTokens");
+    n("cacheWriteTokens");
+    n("costUsd");
+    const model = asString(s.model);
+    if (model)
+        out.model = model;
+    return out;
+}

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

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

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

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+/**
+ * Standalone Claude Code hook entrypoint (built to `dist/claude/native-hook-main.js`,
+ * invoked as `node native-hook-main.js --bridge-dir <dir> [permission-request]`).
+ * Claude spawns it per hook event; it reads the hook payload on stdin and:
+ *   - default (observer: SessionStart / Stop / StopFailure) → append it to the
+ *     session's `hooks.jsonl` for the forwarder to tail.
+ *   - `permission-request` → POST the payload to the daemon and RELAY the
+ *     server's verdict JSON to stdout (the `{hookSpecificOutput:{decision:{…}}}`
+ *     Claude reads to allow/deny). Blocks until the web user answers (Claude's
+ *     hook `timeout` is a day). On any failure it writes nothing → Claude falls
+ *     back to its own TUI permission prompt.
+ *
+ * Dependency-light (native-bridge + node builtins) so the per-event subprocess
+ * stays cheap. Never exits non-zero — a crashing hook must not wedge Claude.
+ */
+import { readPermissionHookConfig, recordHookEvent } 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 relayPermission(bridgeDir, payload) {
+    const cfg = readPermissionHookConfig(bridgeDir);
+    if (!cfg)
+        return; // no server configured → empty stdout → claude's own TUI prompt
+    const url = `${cfg.serverUrl.replace(/\/+$/, "")}/api/sessions/${encodeURIComponent(cfg.sessionId)}/hooks/permission-request`;
+    try {
+        const resp = await fetch(url, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(payload),
+        });
+        const text = await resp.text();
+        if (resp.ok && text) {
+            await new Promise((resolve) => process.stdout.write(text, () => resolve()));
+        }
+    }
+    catch {
+        // Server unreachable / hung → empty stdout → claude falls back to its TUI prompt.
+    }
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    const isPermission = argv[0] === "permission-request";
+    const bridgeDir = argValue(argv, "--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; // malformed hook payload — don't block claude
+    }
+    if (isPermission) {
+        await relayPermission(bridgeDir, payload);
+        return;
+    }
+    try {
+        recordHookEvent(bridgeDir, payload);
+    }
+    catch {
+        // Best-effort: a failed append must not fail the hook (would wedge claude).
+    }
+}
+void main();

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

@@ -0,0 +1,41 @@
+interface CommandHook {
+    type: "command";
+    command: string;
+    timeout?: number;
+}
+interface HookMatcher {
+    matcher?: string;
+    hooks: CommandHook[];
+}
+export interface ClaudeHookSettings {
+    hooks: Record<string, HookMatcher[]>;
+    /** Claude's top-level `statusLine` command (a sibling of `hooks`, not a hook) —
+     *  captures the running context_window + cost, only surfaced here. */
+    statusLine?: CommandHook;
+}
+export interface BuildClaudeHookSettingsOptions {
+    /** The session's bridge dir (all hook subprocesses target it). */
+    bridgeDir: string;
+    /** Register the blocking PermissionRequest hook (approvals → web). */
+    permission?: boolean;
+    /** Register the MessageDisplay hook (live assistant-text streaming). */
+    messageDisplay?: boolean;
+    /** Register the statusLine command (context_window + cost capture). */
+    statusLine?: boolean;
+    /** Override the node binary (defaults to the current `process.execPath`). */
+    nodePath?: string;
+    /** Override the hook entrypoint path (defaults to the built sibling module). */
+    hookEntryPath?: string;
+    /** Override the MessageDisplay entrypoint path (tests). */
+    messageDisplayEntryPath?: string;
+    /** Override the statusLine entrypoint path (tests). */
+    statusEntryPath?: string;
+}
+/** Absolute path to the built standalone hook entrypoint (sibling `.js`). */
+export declare function resolveHookEntryPath(): string;
+/** Absolute path to the built MessageDisplay hook entrypoint (sibling `.js`). */
+export declare function resolveMessageDisplayEntryPath(): string;
+/** Absolute path to the built statusLine entrypoint (sibling `.js`). */
+export declare function resolveStatusEntryPath(): string;
+export declare function buildClaudeHookSettings(options: BuildClaudeHookSettingsOptions): ClaudeHookSettings;
+export {};