@rynx-ai/runtime 0.1.11-beta.2 → 0.1.11-beta.21

package/dist/claude/models.d.ts

@@ -1,9 +1,4 @@
 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`). */

package/dist/claude/models.js

@@ -1,8 +1,3 @@
-/**
- * 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),
@@ -12,7 +7,7 @@ export const CLAUDE_DEFAULT_MODEL = "claude-sonnet-4-6";
  */
 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-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" },
@@ -24,7 +19,6 @@ export function claudeModelInfos() {
         id,
         model: id,
         displayName,
-        isDefault: id === CLAUDE_DEFAULT_MODEL,
     }));
 }
 /** {@link ModelListResponse} for the claude runtime (broker `listModels`). */

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

@@ -1,5 +1,6 @@
 import type { AgentEvent, SessionInteractionResolution, TerminalCommandData, TodoItem } from "@rynx-ai/core";
 import type { ResolveInteractionResult, RuntimeInteractionEvent } from "../interactions.js";
+import { type ClaudeRunnerStatus } from "./session-status.js";
 /** Mirror sink — the same shape as `CodexForwarderSink` so the host reuses one
  *  per-turn normalizer wiring for both runtimes. */
 export interface ClaudeForwarderSink {
@@ -21,7 +22,9 @@ export interface ClaudeForwarderSink {
     /** The current turn finished (a new user prompt, or the inactivity backstop).
      *  `usage` carries the latest statusLine context/cost snapshot, when captured. */
     onTurnEnd(usage?: Record<string, unknown>): void;
-    /** The runtime went idle (Stop hook) — surface idle status WITHOUT finalizing
+    /** The runtime status changed according to Claude's session metadata. */
+    onStatus?(status: ClaudeRunnerStatus, blockedOn?: string): void;
+    /** The runtime went idle on the legacy hook fallback — surface idle WITHOUT finalizing
      *  the turn. claude fires Stop around the same time it flushes the final
      *  assistant record and the two orderings race; finalizing here would split a
      *  late assistant record into its own turn. The turn is finalized by the next
@@ -105,6 +108,14 @@ export declare class ClaudeLiveSession {
     private lastActivityAt;
     /** When the Stop hook fired (null = not yet) — drives the grace-period close. */
     private stopPendingAt;
+    /** An idle status from Claude's session metadata. The short delay keeps a
+     * final transcript record in the response without letting stale tool state
+     * override the provider's terminal status. */
+    private providerIdleAt;
+    private statusPoller?;
+    /** A failed hook is authoritative until the next running edge. Claude writes
+     * idle after failures too, so that trailing file update must not erase it. */
+    private providerFailureSticky;
     /** Open tool-call ids (start seen, end not yet) — suppresses the idle backstop. */
     private readonly openToolIds;
     /** Transcript-backed acknowledgements for web→TUI input. A direct idle
@@ -186,6 +197,11 @@ export declare class ClaudeLiveSession {
     /** One poll cycle (hooks → transcript → idle backstop). Exposed for tests to
      *  drive deterministically; the async {@link loop} just calls it on an interval. */
     tick(): void;
+    /** Bind Claude's per-process session metadata after the terminal exists. */
+    attachStatusSource({ panePid, configDir, }: {
+        panePid: () => number | undefined;
+        configDir?: string;
+    }): void;
     private loop;
     private pollHooks;
     private handleHook;
@@ -255,6 +271,8 @@ export declare class ClaudeLiveSession {
     /** Refresh the latest statusLine context/cost snapshot (a last-writer-wins file
      *  the statusLine hook overwrites on every TUI render). */
     private pollStatus;
+    private pollSessionStatus;
+    private handleSessionStatus;
     /** 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. */
@@ -283,6 +301,10 @@ export declare class ClaudeLiveSession {
      *  sent an Escape — an Escape into idle claude submits an empty turn, which
      *  claude answers with a stray "No response requested." bubble. */
     isTurnOpen(): boolean;
+    /** Fail an open turn exactly once when its native terminal/runner disappears. */
+    failOpenTurn(error: Error): boolean;
+    /** Retire process-scoped metadata before classifying a terminal exit. */
+    noteTerminalExit(error: Error): boolean;
     private closeTurn;
     private closeTurnError;
     private resetMessageCorrelation;
@@ -292,6 +314,8 @@ export declare class ClaudeLiveSession {
  *  {@link import("../terminal/tmux.js").TmuxTerminal}). The runner-child hands
  *  this to the host after launching the pane, since the host doesn't own tmux. */
 export interface TerminalInjector {
+    /** PID of the process owning the tmux pane, when available. */
+    panePid?(): number | undefined;
     capturePane(): string;
     clearInputLine(): void;
     paste(text: string): void;
@@ -303,12 +327,16 @@ export interface InjectViaTerminalOptions {
     promptGlyph?: string;
     promptTimeoutMs?: number;
     settleMs?: number;
+    /** Wait for the pasted draft to become visible before the first Enter. */
+    pasteCommitMs?: number;
     /** Transcript-backed proof that Claude accepted this exact input. When
-     * absent, injection keeps the legacy one-Enter best-effort contract. */
+     * present it takes precedence over pane heuristics. */
     submissionObserved?: () => boolean;
-    /** Per-attempt wait for a transcript acknowledgement. */
+    /** Total post-Enter verification budget. */
     submitConfirmMs?: number;
-    /** Total Enter attempts when transcript confirmation is available. */
+    /** Minimum delay between Enter retries while the draft remains visible. */
+    submitRetryMs?: number;
+    /** Optional safety cap for tests/callers; the time budget remains authoritative. */
     maxSubmitAttempts?: number;
     pollMs?: number;
     now?: () => number;
@@ -324,8 +352,8 @@ export interface InjectViaTerminalOptions {
  *
  * THROWS if the prompt never appears within the ready-gate window (reference implementation
  * `_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. With a
- * transcript observer, Enter is retried only when Claude has durably recorded
- * neither a direct user prompt nor a type-ahead enqueue.
+ * caller reports, NOT a signal to fall through to a second output path. Enter
+ * is retried only while the exact draft remains visible and Claude has durably
+ * recorded neither a direct user prompt nor a type-ahead enqueue.
  */
 export declare function injectViaTerminal(injector: TerminalInjector, text: string, opts?: InjectViaTerminalOptions): Promise<boolean>;

package/dist/claude/native-integration.js

@@ -5,11 +5,12 @@
  * 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).
+ *    session id; `StopFailure` supplies the failure edge and `Stop` carries the
+ *    legacy fallback boundary.
  *  - 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 reference implementation re-audit; `running` is
- *    implicit between open and close, so no PTY watcher is needed.)
+ *    assistant/tool records become {@link AgentEvent}s.
+ *  - Claude's per-process session file — while readable, it is the source of
+ *    truth for running/idle and supersedes the hook/pane heuristics.
  *
  * The mapped events drive the SAME per-turn {@link SessionNormalizer} sink shape
  * the codex forwarder uses (see the host), so mirroring is identical downstream.
@@ -21,6 +22,7 @@ import { statSync } from "node:fs";
 import { parseTerminalCommand, parseTranscriptRecord, readSubagentEvents, subagentTranscriptPath, transcriptHasForkedFrom, } from "./transcript.js";
 import { jsonlCursorFingerprint, interactionLeaseUpdatedAt, readClaimedInteractionResult, readClaudeStatus, readForwardState, readInteractionAcksFrom, readHookEventsFrom, readInteractionRequestsFrom, readJsonlFrom, readMessageDeltasFrom, resetForwardState, removeClaimedInteractionResult, removeInteractionLease, removeInteractionResult, scrubClaudeInteractionArtifacts, writeInteractionResult, writeForwardState, } from "./native-bridge.js";
 import { boundInteractionRequest, redactInteractionResolution, validateInteractionResolution, } from "../interactions.js";
+import { ClaudeSessionStatusPoller, } from "./session-status.js";
 const MAX_SETTLED_INTERACTIONS = 512;
 const MAX_MESSAGE_CORRELATION_BACKLOG = 64;
 const MAX_SUBMISSION_OBSERVATIONS = 64;
@@ -169,6 +171,14 @@ export class ClaudeLiveSession {
     lastActivityAt = 0;
     /** When the Stop hook fired (null = not yet) — drives the grace-period close. */
     stopPendingAt = null;
+    /** An idle status from Claude's session metadata. The short delay keeps a
+     * final transcript record in the response without letting stale tool state
+     * override the provider's terminal status. */
+    providerIdleAt = null;
+    statusPoller;
+    /** A failed hook is authoritative until the next running edge. Claude writes
+     * idle after failures too, so that trailing file update must not erase it. */
+    providerFailureSticky = false;
     /** Open tool-call ids (start seen, end not yet) — suppresses the idle backstop. */
     openToolIds = new Set();
     /** Transcript-backed acknowledgements for web→TUI input. A direct idle
@@ -328,6 +338,7 @@ export class ClaudeLiveSession {
         if (this.stopped)
             return;
         this.stopped = true;
+        this.statusPoller?.retire();
         // A hook may have appended its request just before shutdown but not yet
         // reached a scheduled poll. Drain it so the subprocess receives cancellation
         // instead of remaining blocked until Claude's one-day hook timeout.
@@ -365,9 +376,20 @@ export class ClaudeLiveSession {
         this.pollAbandonedInteractions();
         this.flushTurnFailure();
         this.pollStatus();
+        this.pollSessionStatus();
         this.flushStopSignal();
         this.maybeIdleClose();
     }
+    /** Bind Claude's per-process session metadata after the terminal exists. */
+    attachStatusSource({ panePid, configDir, }) {
+        this.statusPoller?.retire();
+        this.statusPoller = new ClaudeSessionStatusPoller({
+            panePid,
+            sessionId: () => this.currentClaudeSessionId,
+            onStatus: (status) => this.handleSessionStatus(status),
+            ...(configDir ? { configDir } : {}),
+        });
+    }
     async loop() {
         while (!this.stopped) {
             try {
@@ -423,6 +445,7 @@ export class ClaudeLiveSession {
         if (!error)
             return;
         this.turnFailurePending = null;
+        this.providerFailureSticky = true;
         this.closeTurnError(error);
     }
     /** Emit the Stop idle signal only after this tick has discovered native
@@ -431,6 +454,8 @@ export class ClaudeLiveSession {
         if (!this.stopSignalPending)
             return;
         this.stopSignalPending = false;
+        if (this.statusPoller?.active)
+            return;
         if (this.pendingInteractions.size === 0)
             this.sink.onIdle();
     }
@@ -844,6 +869,15 @@ export class ClaudeLiveSession {
             }
             // A real prompt (not an XML-marker bookkeeping record) opens a new turn.
             if (!content.startsWith("<")) {
+                const queuedIntoOpenTurn = this.turnOpen && (queuedPromotion || rec.promptSource === "queued" || rec.promptSource === "sdk");
+                if (queuedIntoOpenTurn) {
+                    // Claude type-ahead is one native busy interval: enqueue now, promote
+                    // later, and emit one final Stop. Do not close/re-open the canonical
+                    // response when the promoted user record arrives mid-turn.
+                    this.sink.onUserMessage(content);
+                    this.lastActivityAt = this.now();
+                    return;
+                }
                 const turnId = typeof rec.uuid === "string" ? rec.uuid : undefined;
                 if (this.turnOpen && this.syntheticTurn) {
                     // A hook can flush just before the transcript's user record. The
@@ -857,6 +891,7 @@ export class ClaudeLiveSession {
                     this.currentTurnId = turnId;
                     this.turnOpen = true;
                     this.syntheticTurn = false;
+                    this.providerIdleAt = null;
                     this.openToolIds.clear();
                     this.stopPendingAt = null;
                     this.sink.onTurnStart(this.currentTurnId);
@@ -978,6 +1013,27 @@ export class ClaudeLiveSession {
         if (status)
             this.latestStatus = status;
     }
+    pollSessionStatus() {
+        const poller = this.statusPoller;
+        if (!poller)
+            return;
+        const wasActive = poller.active;
+        poller.tick();
+        if (wasActive && !poller.active)
+            this.providerIdleAt = null;
+    }
+    handleSessionStatus(status) {
+        this.stopSignalPending = false;
+        this.stopPendingAt = null;
+        if (status.runnerStatus === "running") {
+            this.providerFailureSticky = false;
+        }
+        else if (this.providerFailureSticky) {
+            return;
+        }
+        this.sink.onStatus?.(status.runnerStatus, status.blockedOn);
+        this.providerIdleAt = status.runnerStatus === "idle" ? this.now() : null;
+    }
     /** 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. */
@@ -1042,6 +1098,7 @@ export class ClaudeLiveSession {
             this.currentTurnId = provisionalTurnId;
             this.syntheticTurn = true;
         }
+        this.providerIdleAt = null;
         this.turnOpen = true;
         this.sink.onTurnStart(this.currentTurnId);
     }
@@ -1067,6 +1124,8 @@ export class ClaudeLiveSession {
             return;
         this.cancelPendingInteractions("turn_interrupted");
         this.stopSignalPending = false;
+        if (this.statusPoller?.active)
+            return;
         this.sink.onIdle();
         this.stopPendingAt = this.now();
     }
@@ -1077,6 +1136,18 @@ export class ClaudeLiveSession {
     isTurnOpen() {
         return this.turnOpen;
     }
+    /** Fail an open turn exactly once when its native terminal/runner disappears. */
+    failOpenTurn(error) {
+        if (!this.turnOpen)
+            return false;
+        this.closeTurnError(error);
+        return true;
+    }
+    /** Retire process-scoped metadata before classifying a terminal exit. */
+    noteTerminalExit(error) {
+        this.statusPoller?.retire();
+        return this.failOpenTurn(error);
+    }
     closeTurn() {
         if (!this.turnOpen)
             return;
@@ -1112,6 +1183,14 @@ export class ClaudeLiveSession {
         this.streamedMessageText.clear();
     }
     maybeIdleClose() {
+        if (this.statusPoller?.active) {
+            if (this.turnOpen &&
+                this.providerIdleAt !== null &&
+                this.now() - this.providerIdleAt >= this.stopGraceMs) {
+                this.closeTurn();
+            }
+            return;
+        }
         if (!this.turnOpen ||
             this.openToolIds.size > 0 ||
             this.pendingInteractions.size > 0)
@@ -1132,14 +1211,79 @@ export class ClaudeLiveSession {
 /** Claude Code renders this glyph once the input box is mounted (ready-gate). */
 const CLAUDE_PROMPT_GLYPH = "❯";
 const CLAUDE_PROMPT_SCAN_TAIL_LINES = 5;
+const CLAUDE_BOX_RULE_CHARS = new Set([..."─━╭╮╰╯│┃╌╍"]);
+const CLAUDE_PASTED_PLACEHOLDER_PREFIX = "[Pasted text";
+const CLAUDE_DRAFT_NEEDLE_MAX_CHARS = 24;
+/** Claude-native readiness window: tmux may exist well before the
+ * first interactive composer mounts on a cold start. */
+const CLAUDE_PROMPT_READY_TIMEOUT_MS = 30_000;
+const CLAUDE_PASTE_COMMIT_TIMEOUT_MS = 5_000;
+const CLAUDE_PASTE_SETTLE_MS = 100;
+const CLAUDE_SUBMIT_CONFIRM_TIMEOUT_MS = 10_000;
+const CLAUDE_SUBMIT_RETRY_MS = 1_000;
+function selectedMenuRow(line, glyph) {
+    const index = line.indexOf(glyph);
+    if (index < 0)
+        return false;
+    return /^\d+\.\s/.test(line.slice(index + glyph.length).trimStart());
+}
+function boxRule(line) {
+    const text = line.trim();
+    return text.length >= 3 && [...text].every((character) => CLAUDE_BOX_RULE_CHARS.has(character));
+}
 /** The live composer sits at the bottom of the pane. Restricting readiness to
  * its trailing non-empty lines prevents an old prompt glyph in scrollback from
  * accepting input while Claude is still booting or showing another screen. */
 function claudePromptRendered(pane, glyph) {
     const nonEmpty = pane.split(/\r?\n/).filter((line) => line.trim());
-    return nonEmpty
-        .slice(-CLAUDE_PROMPT_SCAN_TAIL_LINES)
-        .some((line) => line.includes(glyph));
+    const tailStart = Math.max(0, nonEmpty.length - CLAUDE_PROMPT_SCAN_TAIL_LINES);
+    for (let index = tailStart; index < nonEmpty.length; index += 1) {
+        const line = nonEmpty[index] ?? "";
+        if (!line.includes(glyph))
+            continue;
+        const framed = nonEmpty.slice(index + 1).some(boxRule);
+        if (framed)
+            return true;
+        if (!selectedMenuRow(line, glyph))
+            return true;
+    }
+    // A fan-out of subagents can make the running footer arbitrarily tall. Above
+    // the fixed tail, only a prompt framed by the composer's closing rule counts.
+    for (let index = 0; index < tailStart; index += 1) {
+        const line = nonEmpty[index] ?? "";
+        if (line.includes(glyph) && nonEmpty.slice(index + 1).some(boxRule))
+            return true;
+    }
+    return false;
+}
+function draftNeedle(content) {
+    const normalized = content.replace(/\r\n?/g, "\n");
+    for (const rawLine of normalized.split("\n")) {
+        const control = rawLine.search(/[\x00-\x1f]/);
+        const line = (control >= 0 ? rawLine.slice(0, control) : rawLine).trim();
+        if (line)
+            return line.slice(0, CLAUDE_DRAFT_NEEDLE_MAX_CHARS);
+    }
+    return "";
+}
+function draftInInputBox(pane, glyph, needle) {
+    const lines = pane.split(/\r?\n/).filter((line) => line.includes(glyph));
+    const line = lines.at(-1);
+    if (!line)
+        return false;
+    const tail = line.slice(line.lastIndexOf(glyph) + glyph.length);
+    if (tail.includes(CLAUDE_PASTED_PLACEHOLDER_PREFIX))
+        return true;
+    return Boolean(needle) && tail.includes(needle);
+}
+function terminalFailureTail(pane) {
+    const lines = pane.split(/\r?\n/).filter((line) => line.trim()).slice(-12);
+    if (lines.length === 0)
+        return "";
+    let tail = lines.join("\n");
+    if (tail.length > 800)
+        tail = `…${tail.slice(-800)}`;
+    return `\nlast terminal output:\n${tail}`;
 }
 async function pollUntil(pred, timeoutMs, pollMs, now, sleep, signal) {
     const deadline = now() + timeoutMs;
@@ -1159,9 +1303,9 @@ async function pollUntil(pred, timeoutMs, pollMs, now, sleep, signal) {
  *
  * THROWS if the prompt never appears within the ready-gate window (reference implementation
  * `_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. With a
- * transcript observer, Enter is retried only when Claude has durably recorded
- * neither a direct user prompt nor a type-ahead enqueue.
+ * caller reports, NOT a signal to fall through to a second output path. Enter
+ * is retried only while the exact draft remains visible and Claude has durably
+ * recorded neither a direct user prompt nor a type-ahead enqueue.
  */
 export async function injectViaTerminal(injector, text, opts = {}) {
     const glyph = opts.promptGlyph ?? CLAUDE_PROMPT_GLYPH;
@@ -1180,12 +1324,23 @@ export async function injectViaTerminal(injector, text, opts = {}) {
     };
     // 1. Ready-gate. No prompt within the window → THROW (reference implementation RAISE): a
     //    not-ready pane is a hard error, never a fall-through-to-run signal.
-    const ready = await pollUntil(() => claudePromptRendered(injector.capturePane(), glyph), opts.promptTimeoutMs ?? 20_000, pollMs, now, sleep, signal);
+    let promptPolls = 0;
+    let emptyPromptPolls = 0;
+    let lastPromptPane = "";
+    const ready = await pollUntil(() => {
+        const pane = injector.capturePane();
+        promptPolls += 1;
+        if (pane.trim())
+            lastPromptPane = pane;
+        else
+            emptyPromptPolls += 1;
+        return claudePromptRendered(pane, glyph);
+    }, opts.promptTimeoutMs ?? CLAUDE_PROMPT_READY_TIMEOUT_MS, 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}`);
+        throw new Error(`claude prompt not ready (no input composer within timeout; ${promptPolls} polls, ` +
+            `${emptyPromptPolls} empty captures)${terminalFailureTail(lastPromptPane)}`);
     }
     // 2. Clear leftover, then bracketed-paste the draft. A final "\" is Claude's
     // documented soft-newline escape: a bare submit Enter would consume it and
@@ -1193,30 +1348,47 @@ export async function injectViaTerminal(injector, text, opts = {}) {
     // the bracketed paste; normal messages must not gain an empty input row.
     injector.clearInputLine();
     injector.paste(text.endsWith("\\") ? `${text}\n` : text);
-    // 3. `paste-buffer` returns after tmux wrote the bracketed-paste frame. Give
-    // Claude a short, fixed settle window before the separate submit key; screen
-    // text is not used as an acknowledgement because submitted prompts remain in
-    // scrollback and are indistinguishable from an editable draft.
-    await sleep(opts.settleMs ?? 500);
+    // 3. tmux accepting `paste-buffer` does not mean Claude consumed it. Wait for
+    // the draft (or its large-paste placeholder) to appear in the live composer;
+    // otherwise Enter can be coalesced into the paste as a newline.
+    const needle = draftNeedle(text);
+    const draftSeen = await pollUntil(() => draftInInputBox(injector.capturePane(), glyph, needle), opts.pasteCommitMs ?? CLAUDE_PASTE_COMMIT_TIMEOUT_MS, pollMs, now, sleep, signal);
+    await sleep(opts.settleMs ?? CLAUDE_PASTE_SETTLE_MS);
     if (cancelled())
         return false; // Stop pressed mid-paste → don't submit
-    // 4. Submit. Without a transcript observer this remains a one-Enter
-    // best-effort operation. With one, a bounded retry handles an Enter swallowed
-    // by the TUI without ever consulting stale pane text. A direct prompt or
-    // queue enqueue ends the loop immediately.
+    // 4. Submit and verify. Retry only while this exact draft is still visible;
+    // once it leaves the composer, another Enter could hit a permission dialog or
+    // an empty prompt. Transcript acknowledgement is the strongest success proof.
     const observed = opts.submissionObserved;
-    const attempts = observed
-        ? Math.max(1, Math.floor(opts.maxSubmitAttempts ?? 2))
-        : 1;
-    for (let attempt = 0; attempt < attempts; attempt += 1) {
-        injector.sendEnter();
-        if (!observed)
+    let attempts = 1;
+    const maxAttempts = Math.max(1, Math.floor(opts.maxSubmitAttempts ?? Number.MAX_SAFE_INTEGER));
+    injector.sendEnter();
+    // Preserve the old blind-submit fallback when capture-pane cannot
+    // identify the draft; its absence would otherwise "prove" success trivially.
+    if (!draftSeen)
+        return true;
+    const deadline = now() + (opts.submitConfirmMs ?? CLAUDE_SUBMIT_CONFIRM_TIMEOUT_MS);
+    const retryMs = opts.submitRetryMs ?? CLAUDE_SUBMIT_RETRY_MS;
+    let lastEnterAt = now();
+    while (now() < deadline) {
+        if (cancelled())
+            return false;
+        if (observed?.())
             return true;
-        if (await pollUntil(observed, opts.submitConfirmMs ?? 2_000, pollMs, now, sleep, signal)) {
+        if (!draftInInputBox(injector.capturePane(), glyph, needle))
             return true;
+        if (now() - lastEnterAt >= retryMs && attempts < maxAttempts) {
+            injector.sendEnter();
+            attempts += 1;
+            lastEnterAt = now();
         }
-        if (cancelled())
-            return false;
+        await sleep(pollMs);
     }
-    return false;
+    if (observed?.())
+        return true;
+    if (!draftInInputBox(injector.capturePane(), glyph, needle))
+        return true;
+    throw new Error(`Claude Code did not accept the submitted message within ` +
+        `${opts.submitConfirmMs ?? CLAUDE_SUBMIT_CONFIRM_TIMEOUT_MS}ms ` +
+        "(the draft is still in the input box). The message was not delivered.");
 }

package/dist/claude/session-status.d.ts

@@ -0,0 +1,39 @@
+export type ClaudeRunnerStatus = "running" | "idle";
+export interface ClaudeSessionStatus {
+    runnerStatus: ClaudeRunnerStatus;
+    rawStatus: string;
+    statusUpdatedAt?: number;
+    blockedOn?: string;
+}
+export declare function claudeSessionsDir(configDir?: string): string;
+export declare function resolveClaudeSessionStatusFile({ panePid, expectedSessionId, configDir, now, }: {
+    panePid?: number;
+    expectedSessionId?: string;
+    configDir?: string;
+    now?: number;
+}): string | undefined;
+export declare function readClaudeSessionStatus(path: string): ClaudeSessionStatus | undefined;
+export declare class ClaudeSessionStatusPoller {
+    private readonly options;
+    private path?;
+    private attempts;
+    private exhausted;
+    private lastMtime?;
+    private lastEdge?;
+    private lastStatus?;
+    constructor(options: {
+        onStatus: (status: ClaudeSessionStatus) => void;
+        panePid: () => number | undefined;
+        sessionId: () => string | undefined;
+        configDir?: string;
+        maxResolveAttempts?: number;
+        now?: () => number;
+    });
+    get active(): boolean;
+    get status(): ClaudeSessionStatus | undefined;
+    tick(): void;
+    retire(): void;
+    resync(): void;
+    private tryResolve;
+    private readAndPublish;
+}