@openrig/cli 0.6.9 → 0.6.11

package/daemon/dist/domain/session-transport.js

@@ -1,7 +1,9 @@
+import { CODEX_TURN_STATUS_PATTERN } from "./codex-pane-patterns.js";
 import { randomUUID } from "node:crypto";
 import { inspectStartupStagedText, startupSubmissionEvidence } from "./startup-submission-evidence.js";
 export { inspectStartupStagedText } from "./startup-submission-evidence.js";
 import { OutboxHandler } from "./outbox-handler.js";
+import { claudeResumeRotation } from "./session-registry.js";
 import { latestHookWaitsOnPerson } from "./agent-activity-store.js";
 import { wrapPaneEnvelope, appendDeliveredSegment } from "../lib/pane-envelope.js";
 import { SeatIdentityStore } from "./seat-identity-store.js";
@@ -36,10 +38,6 @@ const MID_WORK_PATTERNS = [
 // placeholder counts as idle only through MID_WORK_PATTERNS here, and classifySendReadiness
 // never lets a placeholder-only verdict override a display-fresh running/needs_input hook.
 const CODEX_EMPTY_COMPOSER_PATTERN = /^›\s+Ask Codex to do anything\s*$/;
-// Codex's live turn-status row: a bullet, a header ("Working", or the reasoning summary Codex shows in its place),
-// then the elapsed time and "esc to interrupt" in parentheses, e.g. "• Working (1h 09m 39s • esc to interrupt)".
-// Completed output that merely says "Working directory: …" or "Working tree is clean." never matches.
-const CODEX_TURN_STATUS_PATTERN = /^[•◦]\s+\S.*\((?:\d+[hms]\s*)+•\s*esc to interrupt\)/;
 const IDLE_PROMPT_PATTERNS = [
     /^[❯›]\s*$/, // prompt char + optional whitespace + end-of-line only
     CODEX_EMPTY_COMPOSER_PATTERN,
@@ -47,11 +45,19 @@ const IDLE_PROMPT_PATTERNS = [
 const PROMPT_DRAFT_PATTERNS = [
     /^[❯›]\s+\S/,
 ];
+// Claude's permission-mode footers: default, accept edits, bypass, auto and plan, optionally after a
+// vim-mode marker such as "-- INSERT --" (#808). A suffix such as "· 1 shell" can follow the mode.
+const CLAUDE_MODE_FOOTER = /^(?:-- [A-Z]+ -- )?(?:⏵⏵ (?:accept edits|bypass permissions|auto mode) on\b|⏸ plan mode on\b|\? for shortcuts\b)/;
+// Sibling pattern identical to CLAUDE_MODE_FOOTER except that it ends in \? for shortcuts$,
+// keeping unframed-composer and selectionLines checks anchored on the default footer (#808).
+const CLAUDE_ANCHORED_MODE_FOOTER = /^(?:-- [A-Z]+ -- )?(?:⏵⏵ (?:accept edits|bypass permissions|auto mode) on\b|⏸ plan mode on\b|\? for shortcuts$)/;
+// Permission mode status footers specifically (excluding shortcuts hint that appears in Codex footers).
+const CLAUDE_PERMISSION_MODE_FOOTER = /(?:-- [A-Z]+ -- )?(?:⏵⏵ (?:accept edits|bypass permissions|auto mode) on\b|⏸ plan mode on\b)/;
 // Footer hints, not proof of inactivity: Claude also renders its mode bar
 // during a turn. Current live-status evidence must take precedence below.
 const IDLE_STATUS_BAR_PATTERNS = [
     /gpt-\d[\d.]* .+ · Context \[/, // Codex model/context footer
-    /⏵⏵ accept edits/, // Claude Code edit-accept bar
+    CLAUDE_PERMISSION_MODE_FOOTER, // Claude Code mode footers (#808)
 ];
 const IDLE_TERMINAL_COMMANDS = new Set(["zsh", "bash", "sh", "fish", "nu", "tmux"]);
 // OPR.0.4.1.10 — permission / confirmation question signatures. The numbered-selector pattern
@@ -118,9 +124,6 @@ const CLAUDE_STATUS_WARNINGS = [
     /^tmux focus-events off · add 'set -g focus-events on' to ~\/\.tmux\.conf and re…$/,
     /^You've used (?:\d|[1-9]\d)% of your weekly limit · resets \d{1,2}(?::\d{2})?(?:am|pm) \(UTC\)$/,
 ];
-// Claude's permission-mode footers: default, accept edits, bypass, auto and plan, optionally after a
-// vim-mode marker such as "-- INSERT --" (#808). A suffix such as "· 1 shell" can follow the mode.
-const CLAUDE_MODE_FOOTER = /^(?:-- [A-Z]+ -- )?(?:⏵⏵ (?:accept edits|bypass permissions|auto mode) on\b|⏸ plan mode on\b|\? for shortcuts\b)/;
 // Current Claude status rows need not end in "thinking)" or show "esc to interrupt".
 // Completed summaries such as "✻ Crunched for 2s" lack the live ellipsis/timer shape.
 // While a hook runs, the timer follows its label: "(running PostToolUse hook · 3m 12s · …)".
@@ -148,7 +151,7 @@ function findClaudeComposer(paneContent, options = {}) {
     if (indent === undefined) {
         // The unframed Claude prompt has the same current status/task block.
         // Keep Codex footers and a bare prompt with no visible block on their old path.
-        if (bar < 2 || !/^(?:⏵⏵ (?:accept edits|bypass permissions) on\b|⏸ plan mode on\b|\? for shortcuts$)/.test(lines[bar].trim()))
+        if (bar < 2 || !CLAUDE_ANCHORED_MODE_FOOTER.test(lines[bar].trim()))
             return null;
         prompt = lines[bar - 1] ?? "";
         indent = /^([ \t]*)❯\s*$/.exec(prompt)?.[1];
@@ -207,6 +210,78 @@ function findPromptDraftBeforeFooter(paneContent) {
         return null;
     return truncateEvidence(priorTrimmed);
 }
+/** A capture taken with escape sequences, as lines of cells that know whether they're faint (SGR 2).
+ *  Color parameters (38/48/58 with 5;n or 2;r;g;b) are skipped, so a color value of 2 isn't faint.
+ *  Other escape sequences carry no text. */
+function styledLines(styledPane) {
+    let faint = false;
+    return styledPane.replace(/\r\n/g, "\n").split("\n").map((raw) => {
+        const cells = [];
+        let offset = 0;
+        for (const match of raw.matchAll(/\x1b\[([0-9;:?]*)[ -\/]*([@-~])|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b./g)) {
+            for (const ch of raw.slice(offset, match.index))
+                cells.push({ ch, faint });
+            offset = match.index + match[0].length;
+            if (match[2] !== "m")
+                continue;
+            const codes = match[1].split(";");
+            for (let i = 0; i < codes.length; i++) {
+                const code = codes[i];
+                if (code === "38" || code === "48" || code === "58") {
+                    i += codes[i + 1] === "5" ? 2 : codes[i + 1] === "2" ? 4 : 0;
+                    continue;
+                }
+                if (code === "2")
+                    faint = true;
+                else if (code === "" || code === "0" || code === "22")
+                    faint = false;
+            }
+        }
+        for (const ch of raw.slice(offset))
+            cells.push({ ch, faint });
+        return cells;
+    });
+}
+/** The last line that starts with a prompt glyph (`❯` or `›`), or -1. */
+function lastPromptLine(lines) {
+    for (let i = lines.length - 1; i >= 0; i--)
+        if (/^\s*[❯›]/.test(lines[i]))
+            return i;
+    return -1;
+}
+/** True only when the last prompt line has text and all of it is faint, as Claude renders its
+ *  suggestion. An empty last prompt, or a capture without escape sequences, never proves faint. */
+export function promptTextIsFaint(styledPane) {
+    const lines = styledLines(styledPane);
+    const last = lastPromptLine(lines.map((cells) => cells.map((cell) => cell.ch).join("")));
+    if (last < 0)
+        return false;
+    const glyph = lines[last].findIndex((cell) => cell.ch === "❯" || cell.ch === "›");
+    const text = lines[last].slice(glyph + 1).filter((cell) => !/\s/.test(cell.ch));
+    return text.length > 0 && text.every((cell) => cell.faint);
+}
+/** Classifies one Claude capture taken with escape sequences, as a single frame. `suggestion` is set
+ *  only when that frame's own draft is its last prompt line and all of that text is faint: it's then
+ *  the frame classified as an empty composer. */
+export function classifyStyledFrame(styledPane, options = {}) {
+    const lines = styledLines(styledPane).map((cells) => cells.map((cell) => cell.ch).join(""));
+    const frame = lines.join("\n");
+    const asIs = classifyPaneActivity(frame, options);
+    const composer = draftComposerLine(lines, asIs);
+    if (composer === null || !promptTextIsFaint(styledPane))
+        return { frame, asIs, composer, suggestion: null };
+    const last = lastPromptLine(lines);
+    lines[last] = /^\s*[❯›]/.exec(lines[last])[0];
+    return { frame, asIs, composer, suggestion: classifyPaneActivity(lines.join("\n"), options) };
+}
+/** The full text of the line a `prompt_draft` verdict read as the draft, when that's the last prompt
+ *  line; otherwise null. Evidence is compacted and truncated, so callers compare this instead. */
+function draftComposerLine(lines, verdict) {
+    const last = lastPromptLine(lines);
+    if (verdict.reason !== "prompt_draft" || last < 0 || verdict.evidence !== truncateEvidence(lines[last]))
+        return null;
+    return lines[last].trim();
+}
 export function classifyPaneActivity(paneContent, options = {}) {
     const lastNonBlank = trimPaneLines(paneContent);
     if (lastNonBlank.length === 0) {
@@ -227,7 +302,7 @@ export function classifyPaneActivity(paneContent, options = {}) {
     // A complete later empty composer with a recognized Claude bar makes the preceding question history.
     // Keep draft handling and selectors without this dialog boundary unchanged.
     const selectionLines = claudeComposer?.framed &&
-        /^(?:⏵⏵ (?:accept edits|bypass permissions|auto mode) on\b|⏸ plan mode on\b|\? for shortcuts$)/.test(claudeComposer.bar) &&
+        CLAUDE_ANCHORED_MODE_FOOTER.test(claudeComposer.bar) &&
         IDLE_PROMPT_PATTERNS.some(pattern => pattern.test(claudeComposer.text)) &&
         oldQuestionEnd >= 0 && oldQuestionEnd < promptScanLines.length - 1
         ? promptScanLines.slice(oldQuestionEnd + 1) : promptScanLines;
@@ -281,7 +356,8 @@ export function classifyPaneActivity(paneContent, options = {}) {
         CLAUDE_LIVE_STATUS_PATTERN,
         ...(options.timerlessStatusIsLive ? [CLAUDE_TIMERLESS_STATUS_PATTERN] : []),
     ]);
-    if (idleStatusBarLine && (!idleStatusBarLine.includes("⏵⏵ accept edits") || !midWorkEvidence)) {
+    const isClaudeStatusBar = CLAUDE_PERMISSION_MODE_FOOTER.test(idleStatusBarLine ?? "");
+    if (idleStatusBarLine && (!isClaudeStatusBar || !midWorkEvidence)) {
         return {
             state: "agent_idle",
             reason: "idle_status_bar",
@@ -440,8 +516,26 @@ export async function probeSessionActivity(input) {
     try {
         const paneContent = await tmuxAdapter.capturePaneContent(sessionName, 20);
         const capturedAt = new Date().toISOString();
-        const classification = classifyPaneActivity(paneContent ?? "", { timerlessStatusIsLive: input.timerlessStatusIsLive === true });
-        return observeProbe(captureSlot(paneContent, capturedAt, captureSeq), {
+        const classifyOptions = { timerlessStatusIsLive: input.timerlessStatusIsLive === true };
+        let classification = classifyPaneActivity(paneContent ?? "", classifyOptions);
+        // Claude renders its prompt suggestion faint, which the plain capture loses. When a Claude pane reads
+        // as a draft, one capture with styling is classified on its own. Newer attention or work there is
+        // kept. A faint suggestion counts only when it's the same composer text this capture read as a draft;
+        // the verdict is then the styled frame's, as an empty composer. Anything else leaves the draft standing.
+        let slot = captureSlot(paneContent, capturedAt, captureSeq);
+        if (classification.reason === "prompt_draft" && runtime === "claude-code" && paneContent) {
+            const styled = await tmuxAdapter.capturePaneContent(sessionName, 20, { escapeSequences: true }).catch(() => null);
+            const later = styled ? classifyStyledFrame(styled, classifyOptions) : null;
+            const newer = !later ? null
+                : later.asIs.state === "agent_active" || (later.asIs.state === "attention" && later.asIs.reason !== "prompt_draft") ? later.asIs
+                    : later.suggestion && later.composer === draftComposerLine(paneContent.split("\n"), classification) ? later.suggestion
+                        : null;
+            if (later && newer) {
+                classification = newer;
+                slot = captureSlot(later.frame, new Date().toISOString(), captureSeq);
+            }
+        }
+        return observeProbe(slot, {
             state: mapPaneState(classification.state),
             reason: classification.reason,
             evidence: classification.evidence,
@@ -513,6 +607,98 @@ function countOccurrences(haystack, needle) {
     }
     return count;
 }
+/**
+ * Claude indents continuation lines in submitted prompts. Compare the same
+ * line content in the sent text and both captures, retaining line breaks and
+ * within-line spacing rather than allowing unrelated words to match.
+ */
+function normalizeVerificationText(text) {
+    return text.replace(/\r?\n[ \t]*/g, "\n");
+}
+/** Match the full envelope with whitespace collapsed, including body and recipient.
+ * Raw sends retain their normalized 40-character prefix and spacing. */
+function verificationSnippet(text) {
+    const normalized = normalizeVerificationText(text);
+    const header = /^From: [^\n]+\nTo: [^\n]+\n(?:Sent: [^\n]+\n)?---\n/.exec(normalized);
+    return { snippet: header ? normalized.replace(/\s+/g, " ").trim() : normalized.slice(0, 40), envelope: !!header };
+}
+/** Count whole visible envelope blocks, not prefixes of longer messages.
+ * A new envelope, prompt or same-column output ends an indented user block.
+ * Whitespace is compared only after retaining boundaries and quote indentation. */
+function countEnvelopeOccurrences(transcript, expected) {
+    const lines = transcript.split("\n");
+    let count = 0;
+    let block = null;
+    let blockIndent = 0;
+    let blockPrompted = false;
+    let inAgentOutput = false;
+    const finish = () => {
+        if (block?.join("\n").replace(/\s+/g, " ").trim() === expected)
+            count++;
+        block = null;
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const indent = /^[ \t]*/.exec(line)[0].length;
+        const prompted = /^[❯›]\s+/.test(line.slice(indent));
+        const header = line.slice(indent).replace(/^[❯›]\s+/, "");
+        const atBoundary = (!block && !inAgentOutput) || indent <= blockIndent;
+        const candidate = normalizeVerificationText([header, ...lines.slice(i + 1, i + 5)].join("\n"));
+        const envelopeHeader = /^From: [^\n]+\nTo: [^\n]+\n(?:Sent: [^\n]+\n)?---\n/.test(candidate);
+        if (atBoundary && envelopeHeader && (!inAgentOutput || prompted)) {
+            finish();
+            block = [header];
+            blockIndent = indent;
+            // Flat historical captures have no role columns; retain whole-block
+            // equality there instead of treating their own header/body as output.
+            blockPrompted = prompted && /^[ \t]*/.exec(lines[i + 1] ?? "")[0].length > indent;
+            inAgentOutput = false;
+        }
+        else if (atBoundary && blockPrompted && line.trim().length > 0) {
+            // Any nonblank boundary line is outside an indented user block. Deeper
+            // quotes stay in the body, and blank separators do not change its text.
+            finish();
+            inAgentOutput = true;
+        }
+        else if (atBoundary && /^[❯›](?:\s|$)/.test(line.slice(indent))) {
+            finish();
+        }
+        else if (block) {
+            block.push(line);
+        }
+    }
+    finish();
+    return count;
+}
+/** The last prompt marker owns the current input region. Never count it or its
+ * continuation lines as submitted transcript, in either capture. If a capture
+ * ends at a historical prompt with no later input marker, leave it unconfirmed. */
+function verificationTranscript(content) {
+    const lines = (content ?? "").replace(/\r\n/g, "\n").split("\n");
+    let inputAt = lastPromptLine(lines);
+    if (inputAt >= 0) {
+        let indent = /^[ \t]*/.exec(lines[inputAt])[0].length;
+        // Claude indents draft continuation lines. A quoted prompt on one of them
+        // belongs to the enclosing input, not a new transcript/composer boundary.
+        for (let i = inputAt - 1; i >= 0; i--) {
+            const prompt = /^([ \t]*)[❯›]/.exec(lines[i]);
+            if (prompt && prompt[1].length < indent) {
+                inputAt = i;
+                indent = prompt[1].length;
+            }
+        }
+    }
+    // A visible framed composer starts at its upper rule, not its prompt.
+    // Keep quoted/indented rules in the message; require a matching lower frame.
+    if (inputAt > 0) {
+        const indent = /^[ \t]*/.exec(lines[inputAt])[0];
+        const frame = (line) => line.startsWith(indent) &&
+            /^─{3,}(?: .+ ─+)?$/.test(line.slice(indent.length).trimEnd());
+        if (frame(lines[inputAt - 1]) && lines.slice(inputAt + 1).some(frame))
+            inputAt--;
+    }
+    return (inputAt < 0 ? lines : lines.slice(0, inputAt)).join("\n");
+}
 /** Map a resolved fan-out target + its recipient list → the EnvelopeScope (ruling 03c35295). The
  *  transport knows the target shape + resolved seats, so it builds the honest scale daemon-side:
  *  DM / multi (full list) / rig- or pod-scoped broadcast (with seat count) / topology. */
@@ -718,6 +904,10 @@ export class SessionTransport {
         b.tmux_session AS binding_session,
         b.tmux_pane AS pane,
         s.resume_token AS resume_token,
+        s.resume_provenance AS resume_provenance,
+        s.resume_rotated_from AS resume_rotated_from,
+        s.resume_rotated_process AS resume_rotated_process,
+        s.resume_launch_process AS resume_launch_process,
         (SELECT generation_uuid FROM occupant_tenures t WHERE t.node_id = n.id ORDER BY generation_ordinal DESC LIMIT 1) AS occupant
       FROM sessions s
       JOIN nodes n ON s.node_id = n.id
@@ -735,6 +925,7 @@ export class SessionTransport {
             pane: row?.binding_session === sessionName ? row?.pane ?? null : null,
             occupant: row?.binding_session === sessionName ? row?.occupant ?? null : null,
             resumeToken: row?.resume_token ?? null,
+            rotation: claudeResumeRotation(row),
         };
     }
     async resolveSessions(target) {
@@ -941,6 +1132,9 @@ export class SessionTransport {
         const pref = guard.preference(target.nodeId);
         return pref.desired || pref.effective ? target : null;
     }
+    /** Deliver text and Enter to the resolved recipient under the send guards.
+     * With verification requested, compare rendered message counts, excluding
+     * agent input; a confirmed render does not prove agent consumption. */
     async send(sessionName, text, opts) {
         const guard = this.tmuxAdapter.deliveryGuard;
         if (!guard)
@@ -973,7 +1167,44 @@ export class SessionTransport {
                         return retainedResult();
                 }
             }
-            return await guard.operation(sessionName, () => this.sendUnguarded(sessionName, text, opts), async (target) => {
+            // #1084 — the idle wait must not occupy the seat's serial lease: a long
+            // --wait-for-idle inside guard.operation holds up other sends and queue
+            // creates to this seat for the whole wait. The lease-free wait, main's
+            // quick refusals ahead of it, and the occupant binding all live in
+            // preWaitForIdle; the lease is entered only for the idle re-check +
+            // write. A null return means go through guard.operation exactly as on
+            // main (guard held, target unresolvable, or a quick refusal).
+            let sendOpts = opts;
+            if (opts?.waitForIdleMs !== undefined && !opts.submitOnly && !opts.preWaitedIdle) {
+                const pre = await this.preWaitForIdle(sessionName, opts, guard);
+                if (pre === null) {
+                    // Fall through with today's path (in-lease wait / retain / throw).
+                }
+                else if (!pre.ok) {
+                    return pre.failure;
+                }
+                else {
+                    // Occupant check (review round 3): the lease starts only after the
+                    // pre-wait, so refuse here when the seat changed hands meanwhile —
+                    // exactly as main refuses with guard_target_changed. Retention must
+                    // not adopt the new occupant either, so this runs before operation.
+                    const current = guard.target(sessionName);
+                    if (JSON.stringify(pre.bound) !== JSON.stringify(current)) {
+                        return {
+                            ok: false,
+                            sessionName,
+                            sent: false,
+                            reason: "guard_target_changed",
+                            error: "Input target/occupant changed; no input written.",
+                            activity: pre.evidence.activity,
+                            waitedMs: pre.evidence.waitedMs,
+                            attempts: pre.evidence.attempts,
+                        };
+                    }
+                    sendOpts = { ...opts, preWaitedIdle: pre.evidence, preWaitBound: pre.bound };
+                }
+            }
+            return await guard.operation(sessionName, () => this.sendUnguarded(sessionName, text, sendOpts), async (target) => {
                 if (opts?.submitOnly)
                     return { ok: false, sessionName, sent: false, reason: "typing_guard_enabled", error: "Typing guard prevents submit-only; no Enter was sent." };
                 this.db.transaction(() => {
@@ -1008,6 +1239,131 @@ export class SessionTransport {
             return { ok: false, sessionName, sent: false, reason: error.code ?? "guard_unavailable", error: error.message };
         }
     }
+    /**
+     * #1084/#1103: lease-free idle wait before the serial lease, so a long
+     * --wait-for-idle holds up no other send or queue create to this seat.
+     * Returns the wait evidence plus the occupant bound before the wait (both
+     * threaded into the leased send), a failure result using main's exact
+     * reasons, or null when the send must go through guard.operation exactly
+     * as on main. Order matters: typing-guard decision first, then main's
+     * quick refusals (runtime identity, wait validations, session probe),
+     * then the wait. Only the lookups sit inside try: a late throw surfaces
+     * instead of silently running a second full wait inside the lease.
+     */
+    async preWaitForIdle(sessionName, opts, guard) {
+        const timeoutMs = opts.waitForIdleMs;
+        if (timeoutMs === undefined)
+            return null;
+        let meta;
+        let bound;
+        try {
+            const preTarget = guard.maybeTarget(sessionName);
+            if (!preTarget)
+                return null;
+            const prePref = guard.preference(preTarget.nodeId);
+            if (prePref.effective || prePref.desired)
+                return null;
+            meta = this.getSessionMeta(sessionName);
+            bound = guard.target(sessionName);
+        }
+        catch {
+            return null;
+        }
+        // External CLI seats never wait: main refuses them before anything else,
+        // and a probe or wait would only delay that refusal (or mistake it for
+        // an absent session).
+        if (meta.attachmentType === "external_cli") {
+            return { ok: false, failure: {
+                    ok: false,
+                    sessionName,
+                    reason: "transport_unavailable",
+                    error: `Session '${sessionName}' is attached as an external CLI node. Inbound tmux transport is unavailable for this target.`,
+                } };
+        }
+        const runtime = meta.runtime;
+        if (runtime && runtime !== "terminal" && runtime !== "claude-code") {
+            const unverified = await this.unverifiedShellForeground(sessionName, runtime, meta.pane, meta.resumeToken);
+            if (unverified) {
+                return { ok: false, failure: {
+                        ok: false,
+                        sessionName,
+                        sent: false,
+                        reason: "target_runtime_unverified",
+                        error: `Refused: '${sessionName}' reports ${unverified} as the foreground command, but OpenRig could not verify its expected ${runtime} agent in the bound pane. The agent may still be running behind a wrapper. No text was sent.`,
+                    } };
+            }
+        }
+        if (opts.force) {
+            return { ok: false, failure: {
+                    ok: false,
+                    sessionName,
+                    reason: "invalid_wait_for_idle",
+                    error: "--wait-for-idle cannot be combined with force. No text was sent.",
+                    sent: false,
+                } };
+        }
+        if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+            return { ok: false, failure: {
+                    ok: false,
+                    sessionName,
+                    reason: "invalid_wait_for_idle",
+                    error: "waitForIdleMs must be a positive number. No text was sent.",
+                    sent: false,
+                } };
+        }
+        try {
+            const target = this.absenceProbeTarget(sessionName);
+            const observedAt = this.now().toISOString();
+            const probe = await this.tmuxAdapter.probeSession(sessionName);
+            if (probe.state === "absent") {
+                this.recordSessionMissingVerdict(target, observedAt);
+                return { ok: false, failure: {
+                        ok: false,
+                        sessionName,
+                        reason: "session_missing",
+                        error: `Session '${sessionName}' not found: tmux reports no session with this name. No text was sent. Check available sessions with: rig ps --nodes`,
+                    } };
+            }
+            if (probe.state === "transport_unavailable") {
+                return { ok: false, failure: {
+                        ok: false,
+                        sessionName,
+                        reason: "tmux_unavailable",
+                        error: `The tmux server could not be reached (${probe.cause}). Whether session '${sessionName}' exists was not determined. No text was sent.`,
+                    } };
+            }
+        }
+        catch (err) {
+            return { ok: false, failure: {
+                    ok: false,
+                    sessionName,
+                    reason: "tmux_unavailable",
+                    error: `The tmux session probe failed unexpectedly (${err instanceof Error ? err.message : String(err)}). Whether session '${sessionName}' exists was not determined. No text was sent.`,
+                } };
+        }
+        const deadlineAt = Date.now() + timeoutMs;
+        const preWait = await this.waitForIdle({
+            sessionName,
+            runtime: meta.runtime,
+            attachmentType: meta.attachmentType,
+            timeoutMs,
+            binding: { sessionName, nodeId: meta.nodeId, occupant: meta.occupant, pane: meta.pane },
+            readinessFromPaneOnly: opts.readinessFromPaneOnly === true,
+        });
+        if (!preWait.ok) {
+            return { ok: false, failure: {
+                    ok: false,
+                    sessionName,
+                    reason: preWait.reason,
+                    error: preWait.error,
+                    sent: false,
+                    activity: preWait.activity,
+                    waitedMs: preWait.waitedMs,
+                    attempts: preWait.attempts,
+                } };
+        }
+        return { ok: true, evidence: { activity: preWait.activity, waitedMs: preWait.waitedMs, attempts: preWait.attempts, deadlineAt }, bound };
+    }
     async sendUnguarded(sessionName, text, opts) {
         let preVerifyContent = null;
         const sessionMeta = this.getSessionMeta(sessionName);
@@ -1021,7 +1377,7 @@ export class SessionTransport {
                 return null;
             if (bindingChanged())
                 return changedRecipient();
-            const observation = await this.claudeDeliveryObservation(sessionName, sessionMeta.pane, sessionMeta.resumeToken);
+            const observation = await this.claudeDeliveryObservation(sessionName, sessionMeta.pane, sessionMeta.resumeToken, sessionMeta.rotation);
             if (bindingChanged())
                 return changedRecipient();
             if (observation.state === "idle_shell" || observation.state === "conflict") {
@@ -1186,7 +1542,10 @@ export class SessionTransport {
             }
             return observe({ ok: true, sessionName, outcome: "rendered-unconfirmed", submitOnly: true });
         }
-        if (waitForIdleMs !== undefined) {
+        // #1084: when send() already waited lease-free (preWaitedIdle), the wait
+        // below is skipped; otherwise wait here, exactly as before
+        // (typing-guard flip and unresolvable-target races keep today's behavior).
+        if (waitForIdleMs !== undefined && !opts?.preWaitedIdle) {
             const waitResult = await this.waitForIdle({
                 sessionName,
                 runtime,
@@ -1211,6 +1570,104 @@ export class SessionTransport {
                 };
             }
         }
+        else if (opts?.preWaitedIdle && waitForIdleMs !== undefined) {
+            // Occupant check (review round 3): the lease started only after the
+            // pre-wait, so refuse when the seat changed hands meanwhile, exactly
+            // as main refuses with guard_target_changed. No new refusal.
+            const preGuard = this.tmuxAdapter.deliveryGuard;
+            if (preGuard && opts.preWaitBound) {
+                const current = preGuard.target(sessionName);
+                if (JSON.stringify(opts.preWaitBound) !== JSON.stringify(current)) {
+                    return {
+                        ok: false,
+                        sessionName,
+                        sent: false,
+                        reason: "guard_target_changed",
+                        error: "Input target/occupant changed; no input written.",
+                        activity: opts.preWaitedIdle.activity,
+                        waitedMs: opts.preWaitedIdle.waitedMs,
+                        attempts: opts.preWaitedIdle.attempts,
+                    };
+                }
+            }
+            // Idle re-check (review round 1 + bot round 2): the wait-mode contract
+            // holds at type time too — only idle types. The budget is measured
+            // from the ORIGINAL deadline (lease-queue time counts too), so the
+            // total wait never exceeds what the caller asked for. Below one poll
+            // interval, waiting buys nothing: one unraced observation decides, so
+            // an idle seat at a dead budget still sends instead of losing a race
+            // against a zero timer.
+            const preEvidence = opts.preWaitedIdle;
+            const deadlineRemainingMs = preEvidence.deadlineAt - Date.now();
+            if (deadlineRemainingMs > this.waitForIdlePollMs) {
+                const rewait = await this.waitForIdle({
+                    sessionName,
+                    runtime,
+                    attachmentType: sessionMeta.attachmentType,
+                    timeoutMs: deadlineRemainingMs,
+                    // Message-only: the re-wait runs on the leftover budget, but the
+                    // timeout names the configured --wait-for-idle value.
+                    timeoutLabelMs: waitForIdleMs,
+                    binding: observed?.binding,
+                    readinessFromPaneOnly: opts.readinessFromPaneOnly === true,
+                });
+                waitEvidence = {
+                    activity: rewait.activity,
+                    waitedMs: preEvidence.waitedMs + rewait.waitedMs,
+                    attempts: preEvidence.attempts + rewait.attempts,
+                };
+                if (!rewait.ok) {
+                    return {
+                        ok: false,
+                        sessionName,
+                        reason: rewait.reason,
+                        error: rewait.error,
+                        sent: false,
+                        ...waitEvidence,
+                    };
+                }
+            }
+            else {
+                const recheck = await this.classifySendReadiness({
+                    sessionName,
+                    runtime,
+                    attachmentType: sessionMeta.attachmentType,
+                    binding: observed?.binding,
+                    readinessFromPaneOnly: opts.readinessFromPaneOnly === true,
+                });
+                if (recheck.state !== "idle") {
+                    const late = recheck.state === "needs_input"
+                        ? {
+                            reason: "target_needs_input",
+                            error: `Refused: '${sessionName}' is at an interactive prompt (${recheck.reason}). A message must not select or approve it. To deliberately drive the prompt: rig send ${sessionName} "<text>" --dangerously-interact --reason "<why>". No text was sent.`,
+                        }
+                        : recheck.state === "unknown"
+                            ? {
+                                reason: "target_activity_unknown",
+                                error: `Target activity could not be determined (${recheck.reason}) when the ${waitForIdleMs}ms wait ended. No text was sent.`,
+                            }
+                            : {
+                                reason: "wait_for_idle_timeout",
+                                error: `Target was still busy (${recheck.reason}) when the ${waitForIdleMs}ms wait ended. No text was sent.`,
+                            };
+                    return {
+                        ok: false,
+                        sessionName,
+                        sent: false,
+                        reason: late.reason,
+                        error: late.error,
+                        activity: recheck,
+                        waitedMs: preEvidence.waitedMs,
+                        attempts: preEvidence.attempts + 1,
+                    };
+                }
+                waitEvidence = {
+                    activity: recheck,
+                    waitedMs: preEvidence.waitedMs,
+                    attempts: preEvidence.attempts + 1,
+                };
+            }
+        }
         // 2. OPR.0.4.1.10 — robust prompt/permission + mid-work guard on the DEFAULT path.
         // Runs the same detector previously reachable only via --wait-for-idle: fresh runtime-hook primary
         // (within the send-readiness window) + hardened capture-pane fallback. This closes the rig-send
@@ -1301,7 +1758,8 @@ export class SessionTransport {
         if (opts?.verify) {
             const captureSeq = observed ? nextCaptureSeq++ : 0;
             try {
-                preVerifyContent = await this.runStage("session_transport.pre_capture", () => this.tmuxAdapter.capturePaneContent(sessionName, 30));
+                preVerifyContent = await this.runStage("session_transport.pre_capture", () => runtime === "terminal" || !verificationSnippet(text).envelope ? this.tmuxAdapter.capturePaneContent(sessionName, 30)
+                    : this.tmuxAdapter.capturePaneContent(sessionName, 30, { joinWrappedLines: true }));
                 if (observed)
                     observed.pre = captureSlot(preVerifyContent, this.now().toISOString(), captureSeq);
             }
@@ -1376,12 +1834,19 @@ export class SessionTransport {
             await this.sleep(500);
             const captureSeq = observed ? nextCaptureSeq++ : 0;
             try {
-                const content = await this.runStage("session_transport.post_capture", () => this.tmuxAdapter.capturePaneContent(sessionName, 30));
+                const content = await this.runStage("session_transport.post_capture", () => runtime === "terminal" || !verificationSnippet(text).envelope ? this.tmuxAdapter.capturePaneContent(sessionName, 30)
+                    : this.tmuxAdapter.capturePaneContent(sessionName, 30, { joinWrappedLines: true }));
                 if (observed)
                     observed.post = captureSlot(content, this.now().toISOString(), captureSeq);
-                const snippet = text.substring(0, Math.min(text.length, 40));
-                const preCount = countOccurrences(preVerifyContent ?? "", snippet);
-                const postCount = countOccurrences(content ?? "", snippet);
+                // A terminal prompt is command history, not an agent composer. Preserve
+                // its original prefix-count verification even while a command is running.
+                const terminal = runtime === "terminal";
+                const { snippet, envelope } = terminal ? { snippet: text.slice(0, 40), envelope: false } : verificationSnippet(text);
+                const transcript = terminal ? (pane) => pane ?? ""
+                    : envelope ? verificationTranscript : (pane) => normalizeVerificationText(verificationTranscript(pane));
+                const count = envelope ? countEnvelopeOccurrences : countOccurrences;
+                const preCount = count(transcript(preVerifyContent), snippet);
+                const postCount = count(transcript(content), snippet);
                 const verified = postCount > preCount;
                 return observe({ ok: true, sessionName, ...interaction, verified, outcome: verified ? "delivered" : "rendered-unconfirmed", ...(sendAdvisory ? { warning: sendAdvisory } : {}), ...(waitMode ? { sent: true, ...waitEvidence } : {}) });
             }
@@ -1414,6 +1879,7 @@ export class SessionTransport {
         const deadline = Date.now() + input.timeoutMs;
         let attempts = 0;
         let last = null;
+        const labelMs = input.timeoutLabelMs ?? input.timeoutMs;
         const expire = () => {
             const count = `${attempts} observation${attempts === 1 ? "" : "s"}`;
             const activity = last ?? {
@@ -1425,14 +1891,14 @@ export class SessionTransport {
                     ok: false,
                     reason: "target_activity_unknown",
                     error: last
-                        ? `Target activity could not be determined (${activity.reason}) when the ${input.timeoutMs}ms wait ended (${count}). No text was sent.`
-                        : `Target activity could not be determined: no observation completed within the ${input.timeoutMs}ms wait. No text was sent.`,
+                        ? `Target activity could not be determined (${activity.reason}) when the ${labelMs}ms wait ended (${count}). No text was sent.`
+                        : `Target activity could not be determined: no observation completed within the ${labelMs}ms wait. No text was sent.`,
                     activity, waitedMs: input.timeoutMs, attempts,
                 }
                 : {
                     ok: false,
                     reason: "wait_for_idle_timeout",
-                    error: `Target was still busy (${activity.reason}) when the ${input.timeoutMs}ms wait ended (${count}). No text was sent.`,
+                    error: `Target was still busy (${activity.reason}) when the ${labelMs}ms wait ended (${count}). No text was sent.`,
                     activity, waitedMs: input.timeoutMs, attempts,
                 };
         };
@@ -1496,7 +1962,7 @@ export class SessionTransport {
                 clearTimeout(timer);
         }
     }
-    async claudeDeliveryObservation(sessionName, pane, resumeToken) {
+    async claudeDeliveryObservation(sessionName, pane, resumeToken, rotation = null) {
         const unknown = { state: "unknown", detail: "Claude runtime observation or older launch binding is unavailable" };
         try {
             const panes = await this.tmuxAdapter.listPanes(sessionName);
@@ -1508,7 +1974,7 @@ export class SessionTransport {
             const [sessionPid, panePid] = await Promise.all([this.tmuxAdapter.getPanePid(sessionName), this.tmuxAdapter.getPanePid(pane)]);
             if (sessionPid && panePid && sessionPid !== panePid)
                 return { state: "conflict", detail: "The session and bound pane name different processes" };
-            const observation = await observeClaudeDelivery({ target: pane, tmux: this.tmuxAdapter, listProcesses: this.listProcesses, expectedToken: resumeToken });
+            const observation = await observeClaudeDelivery({ target: pane, tmux: this.tmuxAdapter, listProcesses: this.listProcesses, expectedToken: resumeToken, rotation });
             // Refusal already has positive evidence; a later failed read cannot erase it.
             if (observation.state === "conflict" || observation.state === "idle_shell")
                 return observation;