@rynx-ai/runtime 0.1.0 → 0.1.10-beta.2

package/dist/claude/executor.d.ts

@@ -5,11 +5,9 @@ import type { SkillMeta } from "@rynx-ai/core";
  * 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.
+ * 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;

package/dist/claude/executor.js

@@ -7,11 +7,9 @@ import path from "node:path";
  * 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.
+ * 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) {
     if (selected == null || selected.length === 0)

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

@@ -1,24 +1,82 @@
+import type { SessionInteractionRequest, SessionInteractionResolution } from "@rynx-ai/core";
 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";
+export declare const INTERACTIONS_FILE = "interactions.jsonl";
+export declare const INTERACTION_ACKS_FILE = "interaction-acks.jsonl";
+export declare const INTERACTION_RESULTS_DIR = "interaction-results";
+export declare const INTERACTION_CLAIMS_DIR = "interaction-claims";
+export declare const INTERACTION_LEASES_DIR = "interaction-leases";
+export declare const MANAGED_SETTINGS_FILE = "managed-settings.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.
+ * Create/refresh the bridge dir and clear stale files. Native interactions use
+ * this local rendezvous directly; no Control Plane URL or provider-specific
+ * server callback is part of the runtime adapter.
  */
-export declare function prepareClaudeBridgeDir(sessionId: string, permission?: PermissionHookConfig): string;
+export declare function prepareClaudeBridgeDir(sessionId: string): string;
+/** Remove every one-shot interaction handoff after the Claude terminal and its
+ * hook subprocesses have stopped. Result and claim files may contain the raw
+ * user answer, so runner shutdown must call this synchronously before exit. */
+export declare function scrubClaudeInteractionArtifacts(bridgeDir: string): void;
+/** Persist the effective Claude settings outside argv (it can contain auth env
+ * inherited from the user's settings). The bridge directory is uid-private. */
+export declare function writeManagedClaudeSettings(bridgeDir: string, settings: Record<string, unknown>): string;
+export declare function removeManagedClaudeSettings(bridgeDir: string): void;
+export interface ClaudeBridgeInteractionRequest {
+    interactionId: string;
+    hookKind: "permission" | "pre_tool_use";
+    /** PID of the blocking hook process that owns this request. The forwarder
+     * uses it as a lease: once the waiter exits, no response can be delivered. */
+    waiterPid?: number;
+    request: SessionInteractionRequest;
+}
+export type ClaudeBridgeInteractionResult = {
+    status: "resolved";
+    resolution: SessionInteractionResolution;
+} | {
+    status: "cancelled";
+    reason?: string;
+};
+/** Public receipt written after the hook has consumed the one-shot answer and
+ * before it returns the native verdict. Secret answers are redacted before this
+ * append-only record is created. */
+export type ClaudeBridgeInteractionAck = {
+    interactionId: string;
+    status: "resolved";
+    resolution: SessionInteractionResolution;
+} | {
+    interactionId: string;
+    status: "cancelled";
+    reason?: string;
+};
+export declare function recordInteractionRequest(bridgeDir: string, request: ClaudeBridgeInteractionRequest): void;
+export declare function readInteractionRequestsFrom(bridgeDir: string, byteOffset: number): {
+    requests: ClaudeBridgeInteractionRequest[];
+    nextOffset: number;
+};
+export declare function writeInteractionResult(bridgeDir: string, interactionId: string, result: ClaudeBridgeInteractionResult): boolean;
+export declare function readInteractionResult(bridgeDir: string, interactionId: string): ClaudeBridgeInteractionResult | null;
+/** Atomically transfer a one-shot response from the forwarder to its hook. Once
+ * this succeeds, terminal cleanup must not overwrite that in-flight decision. */
+export declare function claimInteractionResult(bridgeDir: string, interactionId: string): ClaudeBridgeInteractionResult | null;
+export declare function readClaimedInteractionResult(bridgeDir: string, interactionId: string): ClaudeBridgeInteractionResult | null;
+export declare function removeClaimedInteractionResult(bridgeDir: string, interactionId: string): void;
+/** Refresh the hook waiter's lease. Its mtime is an identity-independent
+ * liveness signal, so PID reuse cannot keep a dead request pending forever. */
+export declare function touchInteractionLease(bridgeDir: string, interactionId: string): void;
+export declare function interactionLeaseUpdatedAt(bridgeDir: string, interactionId: string): number | undefined;
+export declare function removeInteractionLease(bridgeDir: string, interactionId: string): void;
+/** Delete the one-shot answer after the hook has consumed it. */
+export declare function removeInteractionResult(bridgeDir: string, interactionId: string): void;
+export declare function recordInteractionAck(bridgeDir: string, ack: ClaudeBridgeInteractionAck): void;
+export declare function readInteractionAcksFrom(bridgeDir: string, byteOffset: number): {
+    acks: ClaudeBridgeInteractionAck[];
+    nextOffset: number;
+};
 export interface ClaudeBridgeState {
     /** Claude transcript JSONL path (from the SessionStart/any hook payload). */
     transcriptPath?: string;
@@ -27,14 +85,13 @@ export interface ClaudeBridgeState {
     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`).
+ * the same values (matches reference implementation's `record_hook_event`).
  */
 export declare function recordHookEvent(bridgeDir: string, payload: Record<string, unknown>): void;
 export interface JsonlReadResult<T> {
@@ -101,7 +158,7 @@ export declare function writeClaudeStatus(bridgeDir: string, status: ClaudeStatu
  * 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`.
+ * (duplicates). Ports reference implementation's `TranscriptForwardState` / `transcript_forwarder.json`.
  * NOT cleared by {@link prepareClaudeBridgeDir} — it must outlive a re-launch.
  */
 export interface TranscriptForwardState {
@@ -116,11 +173,11 @@ export interface TranscriptForwardState {
      *  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`). */
+/** Cap on `seenSourceIds` (matches reference implementation'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`. */
+ *  unreadable. Mirrors reference implementation'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}. */

package/dist/claude/native-bridge.js

@@ -1,16 +1,15 @@
 /**
  * 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
+ * runner-child forwarder (which TAILS them). Mirrors reference implementation'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
+ *   - `interactions.jsonl` + `interaction-results/` blocking native interactions
  *
- * 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.
+ * Dependency-light on purpose (node builtins plus erased protocol types) so the
+ * standalone hook entrypoints do not pull the whole runtime into every process.
  */
 import { appendFileSync, closeSync, mkdirSync, openSync, readFileSync, readSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { createHash } from "node:crypto";
@@ -19,11 +18,15 @@ 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). */
+export const INTERACTIONS_FILE = "interactions.jsonl";
+export const INTERACTION_ACKS_FILE = "interaction-acks.jsonl";
+export const INTERACTION_RESULTS_DIR = "interaction-results";
+export const INTERACTION_CLAIMS_DIR = "interaction-claims";
+export const INTERACTION_LEASES_DIR = "interaction-leases";
+export const MANAGED_SETTINGS_FILE = "managed-settings.json";
+/** Uid-scoped root so other users on a shared host cannot read interaction data. */
 function bridgeRoot() {
     const uid = typeof process.getuid === "function" ? process.getuid() : "nouid";
     return join(tmpdir(), `rynx-${uid}`, "claude-native");
@@ -34,15 +37,22 @@ export function claudeBridgeDir(sessionId) {
     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.
+ * Create/refresh the bridge dir and clear stale files. Native interactions use
+ * this local rendezvous directly; no Control Plane URL or provider-specific
+ * server callback is part of the runtime adapter.
  */
-export function prepareClaudeBridgeDir(sessionId, permission) {
+export function prepareClaudeBridgeDir(sessionId) {
     const dir = claudeBridgeDir(sessionId);
     mkdirSync(dir, { recursive: true, mode: 0o700 });
-    for (const file of [HOOKS_FILE, STATE_FILE, DELTAS_FILE, STATUS_FILE]) {
+    for (const file of [
+        HOOKS_FILE,
+        STATE_FILE,
+        DELTAS_FILE,
+        STATUS_FILE,
+        INTERACTIONS_FILE,
+        INTERACTION_ACKS_FILE,
+        MANAGED_SETTINGS_FILE,
+    ]) {
         try {
             rmSync(join(dir, file));
         }
@@ -50,11 +60,207 @@ export function prepareClaudeBridgeDir(sessionId, permission) {
             // Absent on a cold start — expected.
         }
     }
-    if (permission) {
-        writeFileSync(join(dir, PERMISSION_FILE), JSON.stringify(permission), { mode: 0o600 });
+    for (const child of [
+        INTERACTION_RESULTS_DIR,
+        INTERACTION_CLAIMS_DIR,
+        INTERACTION_LEASES_DIR,
+    ]) {
+        rmSync(join(dir, child), { recursive: true, force: true });
     }
+    mkdirSync(join(dir, INTERACTION_RESULTS_DIR), { recursive: true, mode: 0o700 });
+    mkdirSync(join(dir, INTERACTION_CLAIMS_DIR), { recursive: true, mode: 0o700 });
+    mkdirSync(join(dir, INTERACTION_LEASES_DIR), { recursive: true, mode: 0o700 });
     return dir;
 }
+/** Remove every one-shot interaction handoff after the Claude terminal and its
+ * hook subprocesses have stopped. Result and claim files may contain the raw
+ * user answer, so runner shutdown must call this synchronously before exit. */
+export function scrubClaudeInteractionArtifacts(bridgeDir) {
+    for (const child of [
+        INTERACTION_RESULTS_DIR,
+        INTERACTION_CLAIMS_DIR,
+        INTERACTION_LEASES_DIR,
+    ]) {
+        rmSync(join(bridgeDir, child), { recursive: true, force: true });
+    }
+}
+/** Persist the effective Claude settings outside argv (it can contain auth env
+ * inherited from the user's settings). The bridge directory is uid-private. */
+export function writeManagedClaudeSettings(bridgeDir, settings) {
+    mkdirSync(bridgeDir, { recursive: true, mode: 0o700 });
+    const path = join(bridgeDir, MANAGED_SETTINGS_FILE);
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify(settings), { mode: 0o600 });
+    renameSync(tmp, path);
+    return path;
+}
+export function removeManagedClaudeSettings(bridgeDir) {
+    rmSync(join(bridgeDir, MANAGED_SETTINGS_FILE), { force: true });
+}
+function safeInteractionId(interactionId) {
+    return /^[a-zA-Z0-9_-]{1,128}$/.test(interactionId);
+}
+function interactionResultPath(bridgeDir, interactionId) {
+    return safeInteractionId(interactionId)
+        ? join(bridgeDir, INTERACTION_RESULTS_DIR, `${interactionId}.json`)
+        : null;
+}
+function interactionClaimPath(bridgeDir, interactionId) {
+    return safeInteractionId(interactionId)
+        ? join(bridgeDir, INTERACTION_CLAIMS_DIR, `${interactionId}.json`)
+        : null;
+}
+function interactionLeasePath(bridgeDir, interactionId) {
+    return safeInteractionId(interactionId)
+        ? join(bridgeDir, INTERACTION_LEASES_DIR, `${interactionId}.lease`)
+        : null;
+}
+export function recordInteractionRequest(bridgeDir, request) {
+    mkdirSync(bridgeDir, { recursive: true, mode: 0o700 });
+    appendFileSync(join(bridgeDir, INTERACTIONS_FILE), `${JSON.stringify({ recordedAt: Date.now(), request })}\n`);
+}
+export function readInteractionRequestsFrom(bridgeDir, byteOffset) {
+    const { records, nextOffset } = readJsonlFrom(join(bridgeDir, INTERACTIONS_FILE), byteOffset);
+    const requests = records
+        .map((row) => row.request)
+        .filter((request) => Boolean(request &&
+        safeInteractionId(request.interactionId) &&
+        (request.hookKind === "permission" || request.hookKind === "pre_tool_use") &&
+        (request.waiterPid === undefined ||
+            (Number.isSafeInteger(request.waiterPid) && request.waiterPid > 0)) &&
+        request.request?.interactionId === request.interactionId));
+    return { requests, nextOffset };
+}
+export function writeInteractionResult(bridgeDir, interactionId, result) {
+    const path = interactionResultPath(bridgeDir, interactionId);
+    if (!path)
+        return false;
+    mkdirSync(join(bridgeDir, INTERACTION_RESULTS_DIR), { recursive: true, mode: 0o700 });
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify(result), { mode: 0o600 });
+    renameSync(tmp, path);
+    return true;
+}
+export function readInteractionResult(bridgeDir, interactionId) {
+    const path = interactionResultPath(bridgeDir, interactionId);
+    if (!path)
+        return null;
+    return parseInteractionResult(readJsonFile(path));
+}
+function parseInteractionResult(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const value = raw;
+    if (value.status === "resolved" && value.resolution && typeof value.resolution === "object") {
+        return {
+            status: "resolved",
+            resolution: value.resolution,
+        };
+    }
+    if (value.status === "cancelled") {
+        return {
+            status: "cancelled",
+            ...(typeof value.reason === "string" ? { reason: value.reason } : {}),
+        };
+    }
+    return null;
+}
+/** Atomically transfer a one-shot response from the forwarder to its hook. Once
+ * this succeeds, terminal cleanup must not overwrite that in-flight decision. */
+export function claimInteractionResult(bridgeDir, interactionId) {
+    const source = interactionResultPath(bridgeDir, interactionId);
+    const claim = interactionClaimPath(bridgeDir, interactionId);
+    if (!source || !claim)
+        return null;
+    mkdirSync(join(bridgeDir, INTERACTION_CLAIMS_DIR), { recursive: true, mode: 0o700 });
+    try {
+        renameSync(source, claim);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    const result = parseInteractionResult(readJsonFile(claim));
+    if (!result)
+        throw new Error("Invalid claimed Claude interaction result");
+    return result;
+}
+export function readClaimedInteractionResult(bridgeDir, interactionId) {
+    const path = interactionClaimPath(bridgeDir, interactionId);
+    return path ? parseInteractionResult(readJsonFile(path)) : null;
+}
+export function removeClaimedInteractionResult(bridgeDir, interactionId) {
+    const path = interactionClaimPath(bridgeDir, interactionId);
+    if (path)
+        rmSync(path, { force: true });
+}
+/** Refresh the hook waiter's lease. Its mtime is an identity-independent
+ * liveness signal, so PID reuse cannot keep a dead request pending forever. */
+export function touchInteractionLease(bridgeDir, interactionId) {
+    const path = interactionLeasePath(bridgeDir, interactionId);
+    if (!path)
+        return;
+    mkdirSync(join(bridgeDir, INTERACTION_LEASES_DIR), { recursive: true, mode: 0o700 });
+    writeFileSync(path, "", { mode: 0o600 });
+}
+export function interactionLeaseUpdatedAt(bridgeDir, interactionId) {
+    const path = interactionLeasePath(bridgeDir, interactionId);
+    if (!path)
+        return undefined;
+    try {
+        return statSync(path).mtimeMs;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function removeInteractionLease(bridgeDir, interactionId) {
+    const path = interactionLeasePath(bridgeDir, interactionId);
+    if (path)
+        rmSync(path, { force: true });
+}
+/** Delete the one-shot answer after the hook has consumed it. */
+export function removeInteractionResult(bridgeDir, interactionId) {
+    const path = interactionResultPath(bridgeDir, interactionId);
+    if (!path)
+        return;
+    rmSync(path, { force: true });
+}
+export function recordInteractionAck(bridgeDir, ack) {
+    if (!safeInteractionId(ack.interactionId)) {
+        throw new Error("Invalid Claude interaction acknowledgement id");
+    }
+    mkdirSync(bridgeDir, { recursive: true, mode: 0o700 });
+    appendFileSync(join(bridgeDir, INTERACTION_ACKS_FILE), `${JSON.stringify({ recordedAt: Date.now(), ack })}\n`, { mode: 0o600 });
+}
+export function readInteractionAcksFrom(bridgeDir, byteOffset) {
+    const { records, nextOffset } = readJsonlFrom(join(bridgeDir, INTERACTION_ACKS_FILE), byteOffset);
+    const acks = [];
+    for (const row of records) {
+        if (!row.ack || typeof row.ack !== "object" || Array.isArray(row.ack))
+            continue;
+        const value = row.ack;
+        if (!safeInteractionId(String(value.interactionId ?? "")))
+            continue;
+        if (value.status === "resolved" && value.resolution && typeof value.resolution === "object") {
+            acks.push({
+                interactionId: value.interactionId,
+                status: "resolved",
+                resolution: value.resolution,
+            });
+            continue;
+        }
+        if (value.status === "cancelled") {
+            acks.push({
+                interactionId: value.interactionId,
+                status: "cancelled",
+                ...(typeof value.reason === "string" ? { reason: value.reason } : {}),
+            });
+        }
+    }
+    return { acks, nextOffset };
+}
 function readJsonFile(path) {
     try {
         return JSON.parse(readFileSync(path, "utf8"));
@@ -77,24 +283,13 @@ export function readClaudeState(bridgeDir) {
         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`).
+ * the same values (matches reference implementation's `record_hook_event`).
  */
 export function recordHookEvent(bridgeDir, payload) {
     mkdirSync(bridgeDir, { recursive: true, mode: 0o700 });
@@ -202,12 +397,12 @@ export function writeClaudeStatus(bridgeDir, status) {
 function asNumber(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
-/** Cap on `seenSourceIds` (matches omnigent's `_MAX_SEEN_SOURCE_IDS`). */
+/** Cap on `seenSourceIds` (matches reference implementation'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`. */
+ *  unreadable. Mirrors reference implementation's `_jsonl_cursor_fingerprint`. */
 export function jsonlCursorFingerprint(path, byteOffset) {
     let fd;
     try {