@rynx-ai/runtime 0.1.11-beta.3 → 0.1.11-beta.30

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,10 +22,15 @@ 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;
 const INTERACTION_ACK_TIMEOUT_MS = 5_000;
+// Claude writes this synthetic user record after Escape (including a tool-use
+// interruption). It is lifecycle, not a new prompt. Kept aligned with
+// reference implementation's `_CLAUDE_INTERRUPT_RECORD_RE`.
+const CLAUDE_INTERRUPT_RECORD_RE = /^\[Request interrupted by user(?: for tool use)?\]$/;
 const INTERACTION_LEASE_TIMEOUT_MS = 30_000;
 function processIsAlive(pid) {
     try {
@@ -163,12 +169,26 @@ export class ClaudeLiveSession {
     seenClaudeSessionIds = new Set();
     turnOpen = false;
     currentTurnId;
+    /** The open turn received an explicit Escape/Stop and must close cancelled. */
+    turnInterrupted = false;
     /** The Turn opened from a pre-transcript interaction. Its unique provisional
      * id keeps responses distinct until the real prompt uuid can be adopted. */
     syntheticTurn = false;
     lastActivityAt = 0;
     /** When the Stop hook fired (null = not yet) — drives the grace-period close. */
     stopPendingAt = null;
+    /** Authoritative live background-shell count from the pending Stop hook. */
+    stopBackgroundTaskCount;
+    /** Whether the pending Stop count already rode an immediate idle edge. */
+    stopBackgroundTaskCountDelivered = false;
+    /** 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 +348,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 +386,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 {
@@ -408,11 +440,15 @@ export class ClaudeLiveSession {
             if (ev.eventName === "StopFailure") {
                 this.stopSignalPending = false;
                 this.stopPendingAt = null;
+                this.stopBackgroundTaskCount = undefined;
+                this.stopBackgroundTaskCountDelivered = false;
                 this.turnFailurePending = new Error("claude turn failed");
             }
             else {
                 this.stopSignalPending = true;
                 this.stopPendingAt = this.now(); // close after a short grace (late assistant flush)
+                this.stopBackgroundTaskCount = ev.backgroundTaskCount ?? 0;
+                this.stopBackgroundTaskCountDelivered = false;
             }
         }
     }
@@ -423,7 +459,11 @@ export class ClaudeLiveSession {
         if (!error)
             return;
         this.turnFailurePending = null;
-        this.closeTurnError(error);
+        this.providerFailureSticky = true;
+        if (this.turnOpen)
+            this.closeTurnError(error);
+        else
+            this.sink.onTurnError(error);
     }
     /** Emit the Stop idle signal only after this tick has discovered native
      *  interactions. A pending question/permission is active execution, not idle. */
@@ -431,8 +471,10 @@ export class ClaudeLiveSession {
         if (!this.stopSignalPending)
             return;
         this.stopSignalPending = false;
-        if (this.pendingInteractions.size === 0)
-            this.sink.onIdle();
+        if (this.pendingInteractions.size === 0) {
+            this.sink.onIdle(this.stopBackgroundTaskCount);
+            this.stopBackgroundTaskCountDelivered = true;
+        }
     }
     /** SessionStart drives discovery (first) and rotation (a later one with a NEW
      *  session id + transcript). `/clear` → source="clear"; `/fork` → source="resume"
@@ -821,6 +863,12 @@ export class ClaudeLiveSession {
         }
         const content = userStringContent(rec);
         if (content !== undefined) {
+            const firstLine = content.trim().split("\n", 1)[0] ?? "";
+            if (CLAUDE_INTERRUPT_RECORD_RE.test(firstLine)) {
+                this.noteInterrupted();
+                this.lastActivityAt = this.now();
+                return;
+            }
             const candidates = submissionCandidates(content);
             const queuedPromotion = rec.promptSource !== "typed" &&
                 candidates.some((candidate) => this.consumeQueuedPromotion(candidate));
@@ -844,6 +892,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
@@ -856,9 +913,13 @@ export class ClaudeLiveSession {
                     this.closeTurn();
                     this.currentTurnId = turnId;
                     this.turnOpen = true;
+                    this.turnInterrupted = false;
                     this.syntheticTurn = false;
+                    this.providerIdleAt = null;
                     this.openToolIds.clear();
                     this.stopPendingAt = null;
+                    this.stopBackgroundTaskCount = undefined;
+                    this.stopBackgroundTaskCountDelivered = false;
                     this.sink.onTurnStart(this.currentTurnId);
                 }
                 this.sink.onUserMessage(content);
@@ -978,6 +1039,32 @@ 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;
+            // A new native busy interval supersedes the prior Stop snapshot. The
+            // Session running edge clears its sticky tally; do not re-emit that old
+            // count if the previous transcript Turn closes a moment later.
+            this.stopBackgroundTaskCount = undefined;
+            this.stopBackgroundTaskCountDelivered = 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,7 +1129,11 @@ export class ClaudeLiveSession {
             this.currentTurnId = provisionalTurnId;
             this.syntheticTurn = true;
         }
+        this.providerIdleAt = null;
         this.turnOpen = true;
+        this.turnInterrupted = false;
+        this.stopBackgroundTaskCount = undefined;
+        this.stopBackgroundTaskCountDelivered = false;
         this.sink.onTurnStart(this.currentTurnId);
     }
     /** Mirror a local `!` command as its own mini-turn: close any open turn, then
@@ -1063,10 +1154,14 @@ export class ClaudeLiveSession {
      *  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)
+        if (!this.turnOpen || this.turnInterrupted)
             return;
+        this.turnInterrupted = true;
+        this.sink.onTurnInterruptRequested?.();
         this.cancelPendingInteractions("turn_interrupted");
         this.stopSignalPending = false;
+        if (this.statusPoller?.active)
+            return;
         this.sink.onIdle();
         this.stopPendingAt = this.now();
     }
@@ -1077,6 +1172,21 @@ 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();
+        const failedOpenTurn = this.failOpenTurn(error);
+        if (!failedOpenTurn)
+            this.sink.onTurnError(error);
+        return failedOpenTurn;
+    }
     closeTurn() {
         if (!this.turnOpen)
             return;
@@ -1089,7 +1199,18 @@ export class ClaudeLiveSession {
         this.stopSignalPending = false;
         this.stopPendingAt = null;
         this.resetMessageCorrelation();
-        this.sink.onTurnEnd(this.statusUsage());
+        const interrupted = this.turnInterrupted;
+        this.turnInterrupted = false;
+        const usage = this.statusUsage();
+        const backgroundTaskCount = this.stopBackgroundTaskCountDelivered
+            ? undefined
+            : this.stopBackgroundTaskCount;
+        this.stopBackgroundTaskCount = undefined;
+        this.stopBackgroundTaskCountDelivered = false;
+        if (interrupted && this.sink.onTurnInterrupted)
+            this.sink.onTurnInterrupted(usage);
+        else
+            this.sink.onTurnEnd(usage, backgroundTaskCount);
     }
     closeTurnError(error) {
         if (!this.turnOpen)
@@ -1100,8 +1221,11 @@ export class ClaudeLiveSession {
         this.currentTurnId = undefined;
         this.syntheticTurn = false;
         this.openToolIds.clear();
+        this.turnInterrupted = false;
         this.stopSignalPending = false;
         this.stopPendingAt = null;
+        this.stopBackgroundTaskCount = undefined;
+        this.stopBackgroundTaskCountDelivered = false;
         this.resetMessageCorrelation();
         this.sink.onTurnError(error);
     }
@@ -1112,6 +1236,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 +1264,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 +1356,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 +1377,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 +1401,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;
+}