@openrig/cli 0.6.14 → 0.7.0

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

@@ -1,3 +1,4 @@
+import { physicalSessionName } from "./session-registry.js";
 import { currentClaudeMcpMenu } from "./claude-mcp-menu.js";
 import stringWidth from "string-width";
 import { CODEX_TURN_STATUS_PATTERN } from "./codex-pane-patterns.js";
@@ -604,7 +605,7 @@ export function classifyPaneActivity(paneContent, options = {}) {
 export async function probeSessionActivity(input) {
     // Capture routing and observation labels must share the entry context. The
     // caller may reuse/mutate its input while hasSession is pending.
-    const { sessionName, runtime, attachmentType, tmuxAdapter, now, captureObserver, binding } = input;
+    const { sessionName, runtime, attachmentType, tmuxAdapter, now, captureObserver, binding, visibleScreenOnly } = input;
     const sampledAt = (now ?? new Date()).toISOString();
     // P2: attempt identity frozen at entry, before any await. Early returns below
     // take no capture and are not observed.
@@ -709,8 +710,11 @@ export async function probeSessionActivity(input) {
     };
     const captureSeq = observed ? nextCaptureSeq++ : 0;
     try {
+        const capture = (opts) => visibleScreenOnly
+            ? opts ? tmuxAdapter.capturePaneScreen(sessionName, opts) : tmuxAdapter.capturePaneScreen(sessionName)
+            : opts ? tmuxAdapter.capturePaneContent(sessionName, 20, opts) : tmuxAdapter.capturePaneContent(sessionName, 20);
         const snapshot = input.composerSnapshot ? await input.composerSnapshot().catch(() => null) : null;
-        const paneContent = snapshot?.screen ?? await tmuxAdapter.capturePaneContent(sessionName, 20);
+        const paneContent = snapshot?.screen ?? await capture();
         const capturedAt = new Date().toISOString();
         const classifyOptions = { timerlessStatusIsLive: input.timerlessStatusIsLive === true };
         let classification = communityHarnessPaneActivity(classifyPaneActivity(paneContent ?? "", { ...classifyOptions,
@@ -721,7 +725,7 @@ export async function probeSessionActivity(input) {
         // 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 styled = await capture({ 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
@@ -1546,6 +1550,7 @@ export class SessionTransport {
     }
     /** Freeze the registration and binding before asking tmux about this name. */
     absenceProbeTarget(sessionName) {
+        sessionName = physicalSessionName(this.db, sessionName);
         return this.db
             .prepare(`
         SELECT s.id AS session_id, n.id AS node_id, s.session_name AS session_name, b.tmux_pane AS tmux_pane
@@ -1578,6 +1583,7 @@ export class SessionTransport {
         });
     }
     getSessionMeta(sessionName) {
+        sessionName = physicalSessionName(this.db, sessionName);
         // One existing statement; P2 reads the binding columns it already joins plus the
         // same current-occupant subselect the delivery guard uses. No extra query.
         const row = this.db.prepare(`
@@ -1646,6 +1652,9 @@ export class SessionTransport {
         return { ok: true, sessions };
     }
     resolveBySessionName(sessionName) {
+        const current = this.sessionRegistry.resolveAddress(sessionName);
+        if (current)
+            return { ok: true, sessions: [{ sessionName, rigName: current.rigName, nodeLogicalId: current.logicalId }] };
         const sessionRows = this.db
             .prepare("SELECT node_id, session_name FROM sessions WHERE session_name = ? ORDER BY id DESC")
             .all(sessionName);
@@ -1700,9 +1709,10 @@ export class SessionTransport {
         const sessions = [];
         const seen = new Set();
         for (const name of sessionNames) {
-            if (seen.has(name))
+            const identity = this.sessionRegistry.resolveAddress(name)?.nodeId ?? name;
+            if (seen.has(identity))
                 continue;
-            seen.add(name);
+            seen.add(identity);
             const resolved = this.resolveBySessionName(name);
             if (!resolved.ok)
                 return resolved;
@@ -1827,7 +1837,32 @@ export class SessionTransport {
     /** 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. */
+    /** The managed compaction state OpenRig has recorded for a seat (the compaction enforcer's), for the sender's notice. */
+    compactionObserver;
+    setCompactionObserver(observer) {
+        this.compactionObserver = observer;
+    }
+    /**
+     * Deliver as always; when the seat was in a managed compaction or restore OpenRig had recorded, before or after the
+     * send, add a notice saying so. The notice is context beside the send's own result, which it never changes.
+     */
     async send(sessionName, text, opts) {
+        const observe = () => { try {
+            return this.compactionObserver?.(sessionName) ?? null;
+        }
+        catch {
+            return null;
+        } };
+        const before = observe();
+        const result = await this.sendWithoutCompactionNotice(sessionName, text, opts);
+        const seen = before ? { observed: "before_send", ...before } : (() => { const after = observe(); return after ? { observed: "after_send", ...after } : null; })();
+        if (!seen)
+            return result;
+        const when = seen.observed === "before_send" ? "when this send started" : "when this send finished";
+        return { ...result, managedCompaction: { stage: seen.stage, observed: seen.observed,
+                notice: `${sessionName} was ${seen.detail} (${when}, as OpenRig's managed compaction recorded it). This doesn't mean the restore has finished; if this message matters, check the reply and follow up.` } };
+    }
+    async sendWithoutCompactionNotice(sessionName, text, opts) {
         const guard = this.tmuxAdapter.deliveryGuard;
         if (!guard) {
             // No guard, so no recorded delivery to read back: a caller already gone ends the send here.
@@ -1855,23 +1890,6 @@ export class SessionTransport {
                     }
                 }
             }
-            const existing = this.guardedDelivery?.existing(sessionName, text, opts ?? {}, ids);
-            if (existing)
-                return existing;
-            // Idempotent readback also after disabling: an old retained ID never becomes a new send.
-            // (P2: this readback is NOT a new retention and is outside the retained_no_write seam.)
-            if (!opts?.committedOutboxIds && opts?.deliveryId) {
-                const prior = outbox.getById(opts.deliveryId);
-                if (prior?.guardBinding) {
-                    if (prior.body !== text || prior.destinationSession !== sessionName || prior.senderSession !== (opts.actorSession ?? "unknown")) {
-                        return { ok: false, sessionName, sent: false, reason: "delivery_identity_conflict", error: "Delivery ID names different content/identity." };
-                    }
-                    if (prior.deliveryState === "retained" || prior.deliveryState === "retired")
-                        return retainedResult();
-                }
-            }
-            // A recorded delivery has answered with its own outcome above; with nothing recorded, a caller already gone
-            // ends the send here.
             if (callerSignal(opts)?.aborted)
                 return callerCancelled(sessionName);
             // #1084 — the idle wait must not occupy the seat's serial lease: a long
@@ -1913,21 +1931,12 @@ export class SessionTransport {
             }
             const result = await guard.operation(sessionName, async () => {
                 if (this.guardedDelivery && !sendOpts?.submitOnly && guard.needsInputCheck(sessionName)) {
-                    // Up to its durable record a draft-aware send is still the caller's: one that went away while this send
-                    // waited for the lease ends here, unless a record for this delivery already exists. DraftAwareDelivery.send
-                    // commits that record synchronously before its first await, so no cancellation lands between this check
-                    // and the commit; after the commit a caller going away doesn't cancel it.
-                    if (callerSignal(sendOpts)?.aborted && !this.guardedDelivery.existing(sessionName, text, sendOpts ?? {}, ids)) {
+                    if (callerSignal(sendOpts)?.aborted)
                         return callerCancelled(sessionName);
-                    }
-                    return this.guardedDelivery.send(sessionName, text, { ...sendOpts, signal: undefined }, ids);
+                    return this.guardedDelivery.send(sessionName, text, sendOpts ?? {}, sendOpts?.committedOutboxIds ?? [`guard-send-${randomUUID()}`]);
                 }
-                const prior = this.guardedDelivery?.existing(sessionName, text, sendOpts ?? {}, ids);
-                return prior ?? this.sendUnguarded(sessionName, text, sendOpts);
+                return this.sendUnguarded(sessionName, text, sendOpts);
             }, async (target) => {
-                const prior = this.guardedDelivery?.existing(sessionName, text, sendOpts ?? {}, ids);
-                if (prior)
-                    return prior;
                 if (opts?.submitOnly)
                     return { ok: false, sessionName, sent: false, reason: "typing_guard_enabled", error: "Typing guard prevents submit-only; no Enter was sent." };
                 // Nothing is retained yet: a caller that went away while this send waited for the lease ends it here.
@@ -2011,6 +2020,7 @@ export class SessionTransport {
                 return null;
             meta = this.getSessionMeta(sessionName);
             bound = guard.target(sessionName);
+            sessionName = bound.session;
         }
         catch {
             return null;
@@ -2113,6 +2123,7 @@ export class SessionTransport {
         return { ok: true, evidence: { activity: preWait.activity, waitedMs: preWait.waitedMs, attempts: preWait.attempts, deadlineAt }, bound };
     }
     async sendUnguarded(sessionName, text, opts) {
+        sessionName = physicalSessionName(this.db, sessionName);
         let preVerifyContent = null;
         const sessionMeta = this.getSessionMeta(sessionName);
         const runtime = sessionMeta.runtime;
@@ -2620,13 +2631,13 @@ export class SessionTransport {
         }
         if (!textResult.ok) {
             // A draft refusal is the guard holding the write before any input; it is not an attempted write.
-            const policyRefusal = typeof textResult.code === "string" && textResult.code.startsWith("draft_");
+            const policyRefusal = typeof textResult.code === "string" && (textResult.code.startsWith("draft_") || textResult.code === "managed_compaction_pending");
             return observe({
                 ok: false,
                 sessionName,
                 reason: policyRefusal ? textResult.code : "send_failed",
                 outcome: "failed",
-                ...(policyRefusal ? {} : { inputPhase: "attempted" }),
+                ...(policyRefusal ? (textResult.code === "managed_compaction_pending" ? { inputPhase: "not_reached" } : {}) : { inputPhase: "attempted" }),
                 error: `Failed to send text to '${sessionName}': ${textResult.message}`,
                 ...(waitMode || policyRefusal ? { sent: false, ...waitEvidence } : {}),
             });
@@ -2670,14 +2681,14 @@ export class SessionTransport {
             // 5. Submit (Enter)
             submitResult = await this.runStage("session_transport.submit", () => { opts?.beforeWrite?.(); enterIssued = true; return opts?.beforeWrite ? this.tmuxAdapter.sendKeys(sessionName, ["Enter"], opts.beforeWrite) : this.tmuxAdapter.sendKeys(sessionName, ["Enter"]); }, (result) => result.ok ? "ok" : "failed");
             if (!submitResult.ok) {
-                const policyRefusal = typeof submitResult.code === "string" && submitResult.code.startsWith("draft_");
+                const policyRefusal = typeof submitResult.code === "string" && (submitResult.code.startsWith("draft_") || submitResult.code === "managed_compaction_pending");
                 return observe({
                     ok: false,
                     sessionName,
                     reason: policyRefusal ? submitResult.code : "submit_failed",
                     outcome: "failed",
                     inputPhase: "written",
-                    error: `Text is in '${sessionName}', but the Enter reported a failure, so the submission outcome is unconfirmed. The agent may need manual attention.`,
+                    error: `Text is in '${sessionName}', but the Enter reported a failure, so the submission outcome is unconfirmed. The agent may need manual attention.${submitResult.code === "managed_compaction_pending" ? ` ${submitResult.message}` : ""}`,
                     ...(waitMode || policyRefusal ? { sent: true, ...waitEvidence } : {}),
                 });
             }
@@ -3195,6 +3206,7 @@ export class SessionTransport {
      *  use it: the capture route asks when its request does (`rig capture`, the MCP tool). `inputBoxBudget` is the time
      *  those reads may still take, shared across a fan-out; a single capture gets its own CAPTURE_INPUT_BOX_DEADLINE_MS. */
     async capture(sessionName, opts) {
+        sessionName = physicalSessionName(this.db, sessionName);
         const sessionMeta = this.getSessionMeta(sessionName);
         if (sessionMeta.attachmentType === "external_cli") {
             return {
@@ -3344,7 +3356,7 @@ export class SessionTransport {
         return this.db.prepare(`
       SELECT n.id as node_id, r.id as rig_id, s.id as session_id, s.session_name, n.runtime, n.cwd,
              s.startup_status, s.status as session_status, s.startup_completed_at,
-             s.resume_type, s.resume_token,
+             s.resume_type, s.resume_token, s.resume_provenance, s.resume_rotated_from, s.resume_rotated_process, s.resume_launch_process,
              b.tmux_session as binding_session, b.tmux_window as binding_window, b.tmux_pane as binding_pane,
              b.updated_at as binding_updated_at,
              (SELECT generation_uuid FROM occupant_tenures WHERE node_id = n.id ORDER BY generation_ordinal DESC LIMIT 1) as occupant_generation,
@@ -3365,6 +3377,7 @@ export class SessionTransport {
      * re-check readiness via the runtime adapter with currentness verification and atomic commit.
      */
     async reconcileStartupReadiness(sessionName) {
+        sessionName = physicalSessionName(this.db, sessionName);
         const existing = this.inFlightReconciliations.get(sessionName);
         if (existing)
             return existing;
@@ -3401,17 +3414,21 @@ export class SessionTransport {
             }
             return hasClaudeResumeIdentityWork(this.sessionRegistry, sessionId, runtime, failedEvent.requestedResumeToken, failedEvent.requestedResumeType);
         };
+        // A Claude seat is checked with its real pane, occupant and recorded conversation (#1477); others keep the stand-in.
+        const claude = snapshot.runtime === "claude-code";
+        const rotation = claude ? claudeResumeRotation(snapshot) : null;
         const probeBinding = {
             id: `session-transport:${snapshot.session_id}`,
             nodeId: snapshot.node_id,
             attachmentType: "tmux",
             tmuxSession: sessionName,
             tmuxWindow: null,
-            tmuxPane: null,
+            tmuxPane: claude ? snapshot.binding_pane : null,
             cmuxWorkspace: null,
             cmuxSurface: null,
             updatedAt: "",
             cwd: snapshot.cwd ?? "",
+            ...(claude && snapshot.occupant_generation ? { launchGeneration: snapshot.occupant_generation } : {}),
         };
         let timeoutTimer;
         const timeoutPromise = new Promise((_, reject) => {
@@ -3419,7 +3436,7 @@ export class SessionTransport {
         });
         let readiness;
         try {
-            readiness = await Promise.race([checker.checkReady(probeBinding), timeoutPromise]);
+            readiness = await Promise.race([checker.checkReady(probeBinding, ...(claude && snapshot.resume_token ? [{ resumeToken: snapshot.resume_token, ...(rotation ? { resumeRotation: rotation } : {}) }] : [])), timeoutPromise]);
         }
         catch {
             return false;