@rynx-ai/runtime 0.1.0

package/dist/claude/native-integration.js

@@ -0,0 +1,665 @@
+/**
+ * ClaudeLiveSession — the claude-native analogue of the codex
+ * {@link ../codex-app-server/forwarder.ts CodexSessionForwarder}. claude has no
+ * app-server, so instead of subscribing to RPC notifications it tails two files
+ * the Claude Code TUI feeds through its hooks + transcript:
+ *
+ *  - `hooks.jsonl` (bridge) — `SessionStart` reveals the transcript path + claude
+ *    session id (discovery); `Stop`/`StopFailure` CLOSE the turn (authoritative).
+ *  - the transcript JSONL — the turn OPENS on a `role:user` prompt record and its
+ *    assistant/tool records become {@link AgentEvent}s. (Turn framing is
+ *    transcript-open + hook-close, matching the omnigent re-audit; `running` is
+ *    implicit between open and close, so no PTY watcher is needed.)
+ *
+ * The mapped events drive the SAME per-turn {@link SessionNormalizer} sink shape
+ * the codex forwarder uses (see the host), so mirroring is identical downstream.
+ * A turn with no `Stop` (a missed/absent hook) is closed by an inactivity
+ * backstop — but only when no tool call is still open, so a long Bash never trips
+ * a false turn-end.
+ */
+import { statSync } from "node:fs";
+import { parseTerminalCommand, parseTranscriptRecord, readSubagentEvents, subagentTranscriptPath, transcriptHasForkedFrom, } from "./transcript.js";
+import { jsonlCursorFingerprint, readClaudeStatus, readForwardState, readHookEventsFrom, readJsonlFrom, readMessageDeltasFrom, resetForwardState, writeForwardState, } from "./native-bridge.js";
+/** The trimmed string content of a `role:user` record, or undefined for
+ *  tool_result (array-content) records. Keeps XML-marker bookkeeping records
+ *  (`<command-name>…`, `<bash-input>…`, `<caveat>…`) — the caller classifies each. */
+function userStringContent(rec) {
+    if (rec.type !== "user" || rec.message?.role !== "user")
+        return undefined;
+    const content = rec.message.content;
+    if (typeof content !== "string")
+        return undefined; // tool_result records are arrays
+    return content.trim() || undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readId(value) {
+    return isRecord(value) && typeof value.id === "string" && value.id ? value.id : undefined;
+}
+/** Byte size of a file, or 0 if it can't be stat'd (used to start a fork tail at EOF). */
+function fileSize(path) {
+    try {
+        return statSync(path).size;
+    }
+    catch {
+        return 0;
+    }
+}
+function readStr(value) {
+    if (typeof value === "string" && value)
+        return value;
+    if (typeof value === "number")
+        return String(value);
+    return undefined;
+}
+/** A `TaskCreate` tool_result record carries `toolUseResult.task = {id, subject}`. */
+function readTaskCreate(rec) {
+    const result = rec.toolUseResult;
+    if (!isRecord(result) || !isRecord(result.task))
+        return undefined;
+    const id = readStr(result.task.id);
+    if (!id)
+        return undefined;
+    return { id, subject: readStr(result.task.subject) ?? "" };
+}
+/** `TaskUpdate` tool_use blocks in an assistant record: `{ taskId, status?, subject? }`. */
+function readTaskUpdates(rec) {
+    if (rec.type !== "assistant")
+        return [];
+    const content = rec.message?.content;
+    if (!Array.isArray(content))
+        return [];
+    const out = [];
+    for (const block of content) {
+        if (isRecord(block) && block.type === "tool_use" && block.name === "TaskUpdate" && isRecord(block.input)) {
+            const taskId = readStr(block.input.taskId);
+            if (taskId)
+                out.push({ taskId, status: readStr(block.input.status), subject: readStr(block.input.subject) });
+        }
+    }
+    return out;
+}
+function normalizeTodoStatus(status) {
+    return status === "pending" || status === "in_progress" || status === "completed" ? status : undefined;
+}
+/** The `tool_use_id` of a record's tool_result block (the parent call it answers). */
+function toolResultCallId(rec) {
+    const content = rec.message?.content;
+    if (!Array.isArray(content))
+        return undefined;
+    for (const block of content) {
+        if (isRecord(block) && block.type === "tool_result" && typeof block.tool_use_id === "string") {
+            return block.tool_use_id;
+        }
+    }
+    return undefined;
+}
+export class ClaudeLiveSession {
+    bridgeDir;
+    sink;
+    pollMs;
+    idleCloseMs;
+    stopGraceMs;
+    now;
+    started = false;
+    stopped = false;
+    hooksOffset = 0;
+    transcriptOffset = 0;
+    /** Secondary dedup: source ids (record uuids) already forwarded, so a re-read
+     *  (fingerprint reset / mid-poll death) doesn't re-emit. Persisted in the
+     *  forwarder state; bounded there. */
+    seenSourceIds = new Set();
+    transcriptPath;
+    discovered = false;
+    /** claude's current session uuid (changes on `/clear`·`/fork`·resume). */
+    currentClaudeSessionId;
+    /** Every claude session uuid seen — a resume into an UNSEEN id + a forkedFrom
+     *  marker signals a `/fork` (vs. resuming a known branch). */
+    seenClaudeSessionIds = new Set();
+    turnOpen = false;
+    currentTurnId;
+    lastActivityAt = 0;
+    /** When the Stop hook fired (null = not yet) — drives the grace-period close. */
+    stopPendingAt = null;
+    /** Open tool-call ids (start seen, end not yet) — suppresses the idle backstop. */
+    openToolIds = new Set();
+    /** Sub-agent (Task) ids already forwarded — a Task tool_result is processed once. */
+    seenSubagents = new Set();
+    /** The agent's task list, keyed by task id in creation order (claude
+     *  `TaskCreate`/`TaskUpdate`). Emitted whole as a snapshot on any change. */
+    todos = new Map();
+    /** Latest statusLine context/cost snapshot (context_window + cost); attached to
+     *  a turn's usage on close. undefined until the statusLine hook first fires. */
+    latestStatus;
+    deltasOffset = 0;
+    /** MessageDisplay message ids in first-seen order, FIFO-mapped onto the
+     *  transcript's assistant-text records so a streamed message and its final
+     *  item share an itemId (message_id is absent from the transcript). */
+    messageIdQueue = [];
+    seenMessageIds = new Set();
+    constructor(opts) {
+        this.bridgeDir = opts.bridgeDir;
+        this.sink = opts.sink;
+        this.pollMs = opts.pollMs ?? 200;
+        this.idleCloseMs = opts.idleCloseMs ?? 30_000;
+        this.stopGraceMs = opts.stopGraceMs ?? 4_000;
+        this.now = opts.now ?? (() => Date.now());
+        this.transcriptPath = opts.transcriptPath;
+        // Resume path: bind the session id + restore the persisted forwarder cursor so
+        // we continue from where a prior forwarder left off (no re-mirror on relaunch).
+        if (opts.transcriptPath) {
+            if (opts.claudeSessionId) {
+                this.currentClaudeSessionId = opts.claudeSessionId;
+                this.seenClaudeSessionIds.add(opts.claudeSessionId);
+            }
+            this.restoreForwardState(opts.transcriptPath);
+        }
+    }
+    /**
+     * Restore the durable forwarder cursor for `transcriptPath` (omnigent's
+     * `_validated_transcript_state`). A cursor for a DIFFERENT file is ignored (a new
+     * session starts at 0). A matching cursor whose fingerprint still validates
+     * resumes at its `byteOffset`; a MISMATCH (the file was truncated/replaced) skips
+     * to the current EOF — never seek into a stale offset — while preserving
+     * `seenSourceIds` so nothing re-emits.
+     */
+    restoreForwardState(transcriptPath) {
+        const state = readForwardState(this.bridgeDir);
+        if (!state || state.transcriptPath !== transcriptPath)
+            return;
+        for (const id of state.seenSourceIds)
+            this.seenSourceIds.add(id);
+        const fingerprint = jsonlCursorFingerprint(transcriptPath, state.byteOffset);
+        this.transcriptOffset =
+            fingerprint !== undefined && fingerprint === state.cursorFingerprint
+                ? state.byteOffset // cursor valid → resume here
+                : fileSize(transcriptPath); // truncated/replaced → skip to EOF
+    }
+    /** Persist the durable forwarder cursor (byte offset + seen ids + fingerprint). */
+    persistForwardState() {
+        if (!this.transcriptPath)
+            return;
+        const fingerprint = jsonlCursorFingerprint(this.transcriptPath, this.transcriptOffset);
+        writeForwardState(this.bridgeDir, {
+            transcriptPath: this.transcriptPath,
+            byteOffset: this.transcriptOffset,
+            seenSourceIds: [...this.seenSourceIds],
+            ...(fingerprint ? { cursorFingerprint: fingerprint } : {}),
+        });
+    }
+    /** True once SessionStart bound the transcript (or a resume path was given). */
+    isReady() {
+        return this.transcriptPath !== undefined;
+    }
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        void this.loop();
+    }
+    stop() {
+        this.stopped = true;
+    }
+    /** One poll cycle (hooks → transcript → idle backstop). Exposed for tests to
+     *  drive deterministically; the async {@link loop} just calls it on an interval. */
+    tick() {
+        // Order matters: pollDeltas PUSHes a message_id onto the FIFO queue before
+        // pollTranscript SHIFTs it for the final item — else a same-tick delta+record
+        // (claude flushing a short message as one chunk) would miss the correlation.
+        this.pollHooks();
+        this.pollDeltas();
+        this.pollTranscript();
+        this.pollStatus();
+        this.maybeIdleClose();
+    }
+    async loop() {
+        while (!this.stopped) {
+            try {
+                this.tick();
+            }
+            catch (err) {
+                // A single failing poll must NOT kill the whole forwarder — that would
+                // desync chat↔terminal permanently. Log + continue, per omnigent's
+                // per-iteration `except Exception` in the transcript forwarder loop.
+                console.error("[claude-forwarder] tick failed; continuing:", err);
+            }
+            await new Promise((r) => setTimeout(r, this.pollMs));
+        }
+        if (this.turnOpen) {
+            this.turnOpen = false;
+            this.sink.onTurnEnd(this.statusUsage());
+        }
+    }
+    pollHooks() {
+        const { events, nextOffset } = readHookEventsFrom(this.bridgeDir, this.hooksOffset);
+        this.hooksOffset = nextOffset;
+        for (const ev of events)
+            this.handleHook(ev);
+    }
+    handleHook(ev) {
+        if (ev.eventName === "SessionStart") {
+            this.handleSessionStart(ev);
+            return;
+        }
+        if (ev.eventName === "Stop" || ev.eventName === "StopFailure") {
+            // Subagent stops (transcript_path under `subagents/`) don't end the parent turn.
+            if (ev.transcriptPath?.includes("/subagents/"))
+                return;
+            // Stop only signals idle — it does NOT close the turn (see onIdle): closing
+            // here would split a late-flushing assistant record into its own turn.
+            if (ev.eventName === "StopFailure")
+                this.closeTurnError(new Error("claude turn failed"));
+            else {
+                this.sink.onIdle();
+                this.stopPendingAt = this.now(); // close after a short grace (late assistant flush)
+            }
+        }
+    }
+    /** SessionStart drives discovery (first) and rotation (a later one with a NEW
+     *  session id + transcript). `/clear` → source="clear"; `/fork` → source="resume"
+     *  into an unseen id with a forkedFrom marker. Any other new-transcript
+     *  SessionStart (compact/resume/startup) is followed WITHOUT rotating. */
+    handleSessionStart(ev) {
+        if (!ev.transcriptPath)
+            return;
+        // First discovery: bind the transcript + reveal the session id.
+        if (!this.transcriptPath) {
+            this.transcriptPath = ev.transcriptPath;
+            this.transcriptOffset = 0;
+            this.currentClaudeSessionId = ev.sessionId;
+            if (ev.sessionId)
+                this.seenClaudeSessionIds.add(ev.sessionId);
+            // Resume from the persisted cursor so a relaunched forwarder doesn't re-mirror
+            // already-logged turns.
+            this.restoreForwardState(ev.transcriptPath);
+            if (!this.discovered && ev.sessionId) {
+                this.discovered = true;
+                this.sink.onSessionDiscovered?.(ev.sessionId, ev.transcriptPath);
+            }
+            return;
+        }
+        // Same session id (a plain re-announce) → nothing to do.
+        if (!ev.sessionId || ev.sessionId === this.currentClaudeSessionId)
+            return;
+        const wasSeen = this.seenClaudeSessionIds.has(ev.sessionId);
+        this.seenClaudeSessionIds.add(ev.sessionId);
+        let kind;
+        if (ev.source === "clear")
+            kind = "clear";
+        else if (ev.source === "resume" && !wasSeen && transcriptHasForkedFrom(ev.transcriptPath, ev.sessionId)) {
+            kind = "fork";
+        }
+        // A fork copies the source history into the new transcript; start at its END
+        // so those records aren't re-mirrored. A clear starts fresh at byte 0.
+        this.repointTranscript(ev.transcriptPath, kind === "fork");
+        this.currentClaudeSessionId = ev.sessionId;
+        if (kind)
+            this.sink.onSessionRotated?.(kind, ev.sessionId, ev.transcriptPath);
+    }
+    /** Switch the tailed transcript and reset per-session accumulators (the bridge
+     *  files — hooks/deltas/status — are shared by the same claude process across a
+     *  rotation, so their cursors are NOT reset). */
+    repointTranscript(newPath, atEof) {
+        this.closeTurn(); // finalize the prior session's last turn before switching
+        this.transcriptPath = newPath;
+        this.transcriptOffset = atEof ? fileSize(newPath) : 0;
+        this.seenSubagents.clear();
+        this.todos.clear();
+        this.seenMessageIds.clear();
+        this.messageIdQueue.length = 0;
+        this.latestStatus = undefined;
+        // Fresh transcript → drop the old cursor + seen ids (a new session has fresh
+        // record uuids, so no collision); the next poll seeds a new forwarder state.
+        this.seenSourceIds.clear();
+        resetForwardState(this.bridgeDir);
+        this.persistForwardState();
+    }
+    pollTranscript() {
+        if (!this.transcriptPath)
+            return;
+        const { records, nextOffset } = readJsonlFrom(this.transcriptPath, this.transcriptOffset);
+        this.transcriptOffset = nextOffset;
+        for (const rec of records)
+            this.handleRecord(rec);
+        // Persist the durable cursor after consuming records so a relaunch resumes here.
+        if (records.length > 0)
+            this.persistForwardState();
+    }
+    handleRecord(rec) {
+        if (rec.isSidechain === true)
+            return; // sub-agent turns (Phase 9 forwards them)
+        // Secondary dedup: skip a record whose source id was already forwarded (a
+        // re-read after a fingerprint reset). rynx emits a record's items atomically,
+        // so the record uuid is the source key (vs omnigent's per-block key for its
+        // per-item POST). Records without a uuid fall through undeduped (rare).
+        const sourceId = typeof rec.uuid === "string" && rec.uuid ? rec.uuid : undefined;
+        if (sourceId) {
+            if (this.seenSourceIds.has(sourceId))
+                return;
+            this.seenSourceIds.add(sourceId);
+        }
+        const content = userStringContent(rec);
+        if (content !== undefined) {
+            // A local `!` command records its input+output as `<bash-*>` markers — mirror
+            // it as a self-contained terminal_command turn (before the prompt check, as
+            // it too is `<`-prefixed).
+            const term = parseTerminalCommand(content);
+            if (term) {
+                this.emitTerminalCommand(rec, term);
+                return;
+            }
+            // A real prompt (not an XML-marker bookkeeping record) opens a new turn.
+            if (!content.startsWith("<")) {
+                this.closeTurn();
+                this.currentTurnId = typeof rec.uuid === "string" ? rec.uuid : undefined;
+                this.turnOpen = true;
+                this.openToolIds.clear();
+                this.stopPendingAt = null;
+                this.sink.onTurnStart(this.currentTurnId);
+                this.sink.onUserMessage(content);
+                this.lastActivityAt = this.now();
+            }
+            return; // string-content user record: prompt, terminal_command, or skipped marker
+        }
+        const events = parseTranscriptRecord(rec);
+        if (events.length === 0)
+            return;
+        this.ensureTurn();
+        for (const event of events) {
+            const mapped = this.remapMessageItem(event);
+            this.trackTool(mapped);
+            this.sink.onEvent(mapped);
+        }
+        // A Task tool_result carries `toolUseResult.agentId` — replay the (now
+        // complete) sub-agent transcript nested under this parent Task call.
+        this.maybeForwardSubagent(rec);
+        // TaskCreate/TaskUpdate records also refresh the task-list snapshot.
+        this.maybeUpdateTodos(rec);
+        this.lastActivityAt = this.now();
+    }
+    /** Fold a `TaskCreate` (new pending task) or `TaskUpdate` (status/subject/delete)
+     *  record into the task list; on any change emit the whole list as a snapshot. */
+    maybeUpdateTodos(rec) {
+        let changed = false;
+        const created = readTaskCreate(rec);
+        if (created) {
+            this.todos.set(created.id, { id: created.id, subject: created.subject, status: "pending" });
+            changed = true;
+        }
+        for (const update of readTaskUpdates(rec)) {
+            const existing = this.todos.get(update.taskId);
+            if (update.status === "deleted") {
+                if (this.todos.delete(update.taskId))
+                    changed = true;
+                continue;
+            }
+            this.todos.set(update.taskId, {
+                id: update.taskId,
+                subject: update.subject ?? existing?.subject ?? "",
+                status: normalizeTodoStatus(update.status) ?? existing?.status ?? "pending",
+            });
+            changed = true;
+        }
+        if (changed)
+            this.sink.onTodos([...this.todos.values()]);
+    }
+    /** On a `Task` tool_result, replay the sub-agent's own transcript
+     *  (`subagents/agent-<agentId>.jsonl`) as events tagged with the parent Task
+     *  tool-use id, so the canonical layer nests them under that call. Fired once
+     *  per sub-agent (at tool_result time the file is complete — no live race). */
+    maybeForwardSubagent(rec) {
+        if (!this.transcriptPath)
+            return;
+        const result = rec.toolUseResult;
+        const agentId = isRecord(result) && typeof result.agentId === "string" ? result.agentId : undefined;
+        if (!agentId || this.seenSubagents.has(agentId))
+            return;
+        const parentToolUseId = toolResultCallId(rec);
+        if (!parentToolUseId)
+            return;
+        this.seenSubagents.add(agentId);
+        const file = subagentTranscriptPath(this.transcriptPath, agentId);
+        // Emit raw (no remap/track): sub-agent messages have their own itemIds and
+        // must not consume the parent's MessageDisplay FIFO, and their tool pairs are
+        // already complete so they need no open-tool tracking.
+        for (const event of readSubagentEvents(file, parentToolUseId))
+            this.sink.onEvent(event);
+    }
+    /** Tail streamed assistant-text chunks (MessageDisplay) into live `token`
+     *  events. Guarded on an open turn — deltas belong to the turn the user record
+     *  opened; the offset advances only once processed. */
+    pollDeltas() {
+        if (!this.turnOpen)
+            return;
+        const { deltas, nextOffset } = readMessageDeltasFrom(this.bridgeDir, this.deltasOffset);
+        this.deltasOffset = nextOffset;
+        for (const d of deltas) {
+            if (!this.seenMessageIds.has(d.messageId)) {
+                this.seenMessageIds.add(d.messageId);
+                this.messageIdQueue.push(d.messageId);
+            }
+            this.sink.onEvent({ type: "token", text: d.delta, metadata: { itemId: d.messageId } });
+        }
+        if (deltas.length)
+            this.lastActivityAt = this.now();
+    }
+    /** Refresh the latest statusLine context/cost snapshot (a last-writer-wins file
+     *  the statusLine hook overwrites on every TUI render). */
+    pollStatus() {
+        const status = readClaudeStatus(this.bridgeDir);
+        if (status)
+            this.latestStatus = status;
+    }
+    /** A usage record from the latest statusLine snapshot (snake_case, the keys the
+     *  normalizer's `turn_completed` + the web `readUsageTokens` read), or undefined
+     *  if the statusLine hook has not fired yet. */
+    statusUsage() {
+        const s = this.latestStatus;
+        if (!s)
+            return undefined;
+        const usage = {};
+        if (s.inputTokens !== undefined)
+            usage.input_tokens = s.inputTokens;
+        if (s.outputTokens !== undefined)
+            usage.output_tokens = s.outputTokens;
+        if (s.totalTokens !== undefined)
+            usage.total_tokens = s.totalTokens;
+        if (s.cacheReadTokens !== undefined)
+            usage.cache_read_input_tokens = s.cacheReadTokens;
+        if (s.cacheWriteTokens !== undefined)
+            usage.cache_creation_input_tokens = s.cacheWriteTokens;
+        if (s.contextWindowSize !== undefined)
+            usage.context_window = s.contextWindowSize;
+        if (s.usedPercentage !== undefined)
+            usage.used_percentage = s.usedPercentage;
+        if (s.costUsd !== undefined)
+            usage.total_cost_usd = s.costUsd;
+        return Object.keys(usage).length ? usage : undefined;
+    }
+    /** Remap an assistant-text `message_completed` onto the FIFO-matched
+     *  MessageDisplay message_id, so its streamed deltas and this final item share
+     *  an itemId. No queued delta (MessageDisplay didn't fire) → keep the transcript id. */
+    remapMessageItem(event) {
+        if (event.type !== "message_completed")
+            return event;
+        const messageId = this.messageIdQueue.shift();
+        return messageId ? { ...event, itemId: messageId } : event;
+    }
+    trackTool(event) {
+        if (event.type !== "tool")
+            return;
+        if (event.event === "on_tool_start") {
+            const id = readId(event.input) ?? readId(event.data);
+            if (id)
+                this.openToolIds.add(id);
+        }
+        else if (event.event === "on_tool_end") {
+            const data = isRecord(event.data) ? event.data : {};
+            const id = readId(event.output) ?? (typeof data.tool_use_id === "string" ? data.tool_use_id : undefined);
+            if (id)
+                this.openToolIds.delete(id);
+        }
+    }
+    ensureTurn() {
+        if (this.turnOpen)
+            return;
+        this.turnOpen = true;
+        this.sink.onTurnStart(this.currentTurnId);
+    }
+    /** Mirror a local `!` command as its own mini-turn: close any open turn, then
+     *  open→emit→close so it groups as one response with a stable id (the record
+     *  uuid) and never lingers "running" (input+output are complete in one record). */
+    emitTerminalCommand(rec, cmd) {
+        this.closeTurn();
+        const turnId = typeof rec.uuid === "string" ? rec.uuid : undefined;
+        this.sink.onTurnStart(turnId);
+        this.sink.onTerminalCommand(cmd);
+        this.sink.onTurnEnd();
+    }
+    /** The web Stop button interrupted this session (host sent Escape). claude
+     *  records the interrupt in its own transcript but may not fire a Stop hook when
+     *  the response was cancelled before it produced output — leaving the turn open
+     *  and the UI spinner stuck until the long inactivity backstop. Treat the
+     *  interrupt like a Stop: surface idle now (clears the spinner) and schedule the
+     *  turn's close via the same short grace. The Escape has stopped claude, so this
+     *  does not race a still-running response. */
+    noteInterrupted() {
+        if (!this.turnOpen)
+            return;
+        this.sink.onIdle();
+        this.stopPendingAt = this.now();
+    }
+    /** Whether a claude turn is currently open (a response is running / pending).
+     *  The web Stop button gates its interrupt on this so an idle pane is never
+     *  sent an Escape — an Escape into idle claude submits an empty turn, which
+     *  claude answers with a stray "No response requested." bubble. */
+    isTurnOpen() {
+        return this.turnOpen;
+    }
+    closeTurn() {
+        if (!this.turnOpen)
+            return;
+        this.turnOpen = false;
+        this.currentTurnId = undefined;
+        this.openToolIds.clear();
+        this.stopPendingAt = null;
+        this.sink.onTurnEnd(this.statusUsage());
+    }
+    closeTurnError(error) {
+        if (!this.turnOpen)
+            return;
+        this.turnOpen = false;
+        this.currentTurnId = undefined;
+        this.openToolIds.clear();
+        this.stopPendingAt = null;
+        this.sink.onTurnError(error);
+    }
+    maybeIdleClose() {
+        if (!this.turnOpen || this.openToolIds.size > 0)
+            return;
+        const now = this.now();
+        // Primary close: a short grace after the Stop hook, so a late assistant record
+        // flush still joins the turn. Fallback: a long inactivity backstop closes a
+        // turn whose Stop never fired (so it can't hang open forever).
+        if (this.stopPendingAt !== null) {
+            if (now - this.stopPendingAt >= this.stopGraceMs)
+                this.closeTurn();
+        }
+        else if (now - this.lastActivityAt >= this.idleCloseMs) {
+            this.closeTurn();
+        }
+    }
+}
+/** Claude Code renders this glyph once the input box is mounted (ready-gate). */
+const CLAUDE_PROMPT_GLYPH = "❯";
+const DRAFT_NEEDLE_MAX = 24;
+function submitNeedle(text) {
+    return (text.split("\n")[0] ?? "").slice(0, DRAFT_NEEDLE_MAX);
+}
+/** Whether the pasted draft is visibly sitting in the input box (the last line
+ *  carrying the prompt glyph). Mirrors omnigent's `_draft_in_input_box`. */
+function draftInBox(pane, glyph, needle) {
+    const glyphLines = pane.split("\n").filter((l) => l.includes(glyph));
+    if (glyphLines.length === 0)
+        return false;
+    const tail = glyphLines[glyphLines.length - 1].split(glyph).pop() ?? "";
+    if (tail.includes("[Pasted text"))
+        return true; // claude's large-paste placeholder
+    return needle.length > 0 && tail.includes(needle);
+}
+async function pollUntil(pred, timeoutMs, pollMs, now, sleep, signal) {
+    const deadline = now() + timeoutMs;
+    while (now() < deadline) {
+        if (signal?.aborted)
+            return false;
+        if (pred())
+            return true;
+        await sleep(pollMs);
+    }
+    return pred();
+}
+/**
+ * Deliver `text` into a claude TUI pane, the omnigent recipe:
+ *   ready-gate (poll for `❯`) → clear leftover → bracketed paste (+ trailing
+ *   newline) → wait for the draft to land → settle → submit Enter → verify the
+ *   draft left the box (re-send Enter while it hasn't).
+ *
+ * THROWS if the prompt never appears within the ready-gate window (omnigent
+ * `_wait_for_claude_prompt_ready` RAISE) — a not-ready pane is a hard error the
+ * caller reports, NOT a signal to fall through to a second output path. Returns
+ * `true` once the message is submitted (best-effort even if submit-verify times out).
+ */
+export async function injectViaTerminal(injector, text, opts = {}) {
+    const glyph = opts.promptGlyph ?? CLAUDE_PROMPT_GLYPH;
+    const pollMs = opts.pollMs ?? 150;
+    const now = opts.now ?? (() => Date.now());
+    const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const signal = opts.signal;
+    // Cancelled by the web Stop button (interruptLive.abort). Clear the half-typed
+    // draft so the message isn't left stuck in the input box, and bail without
+    // submitting — the caller (host) also sends Escape for any active response.
+    const cancelled = () => {
+        if (!signal?.aborted)
+            return false;
+        injector.clearInputLine();
+        return true;
+    };
+    // 1. Ready-gate. No prompt within the window → THROW (omnigent RAISE): a
+    //    not-ready pane is a hard error, never a fall-through-to-run signal.
+    const ready = await pollUntil(() => injector.capturePane().includes(glyph), opts.promptTimeoutMs ?? 20_000, pollMs, now, sleep, signal);
+    if (cancelled())
+        return false;
+    if (!ready) {
+        const tail = injector.capturePane().split("\n").slice(-5).join("\n");
+        throw new Error(`claude prompt not ready (no "${glyph}" within timeout)\npane tail:\n${tail}`);
+    }
+    // 2. Clear leftover, then bracketed-paste the draft (+\n absorbs a trailing "\").
+    injector.clearInputLine();
+    injector.paste(`${text}\n`);
+    // 3. Wait for the draft to visibly land, then a short settle.
+    const needle = submitNeedle(text);
+    const draftSeen = await pollUntil(() => draftInBox(injector.capturePane(), glyph, needle), opts.pasteCommitMs ?? 5_000, pollMs, now, sleep, signal);
+    await sleep(opts.settleMs ?? 100);
+    if (cancelled())
+        return false; // Stop pressed mid-paste → don't submit
+    // 4. Submit.
+    injector.sendEnter();
+    if (!draftSeen)
+        return true; // draft never identifiable → submit blind (omnigent)
+    // 5. Verify the submit took; re-send Enter while the draft is still boxed.
+    const deadline = now() + (opts.submitVerifyMs ?? 10_000);
+    let lastEnter = now();
+    while (now() < deadline) {
+        if (cancelled())
+            return false; // Stop pressed → stop re-submitting, clear the box
+        await sleep(pollMs);
+        if (!draftInBox(injector.capturePane(), glyph, needle))
+            return true;
+        if (now() - lastEnter >= (opts.submitRetryMs ?? 1_000)) {
+            injector.sendEnter();
+            lastEnter = now();
+        }
+    }
+    return true;
+}

package/dist/claude/native-message-display-main.d.ts

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