@songsid/agend 2.3.5-alpha.4 → 2.3.5-beta.1

package/dist/daemon.js

@@ -1,5 +1,5 @@
-import { nativePaneToolRefusal } from "./native-pane-tools.js";
-import { generalByName } from "./general-instance.js";
+import { quotaNoticeProblem } from "./quota-notice-config.js";
+import { quotaHistoryCount, quotaAfterInput } from "./pane-quota-history.js";
 import { dialogScreenText } from "./dialog-screen-text.js";
 import { readActiveKiroModel } from "./backend/kiro.js";
 import { dashboardAccessOf } from "./dashboard-permissions.js";
@@ -22,7 +22,7 @@ import { assertNoSessionOomStop, readSessionOomStop, writeSessionOomStop, Sessio
 import { mcpServerState } from "./mcp-liveness.js";
 import { clearPausedMarker, writePausedMarker } from "./pause-marker.js";
 import { writeBackgroundWorkEndedMarker } from "./background-work-ended.js";
-import { resolveTmuxLogicalSize } from "./tmux-manager.js";
+import { TmuxManager, resolveTmuxLogicalSize } from "./tmux-manager.js";
 import { TranscriptMonitor } from "./transcript-monitor.js";
 import { createTranscriptSource } from "./transcript-sources.js";
 import { TranscriptTurnLedger } from "./transcript-turns.js";
@@ -35,14 +35,14 @@ import { scopedFleetConfigEnvironment } from "./web-experimental.js";
 import { readAgentFile } from "./agent-file-read.js";
 import { ASSET_UPLOAD_MAX_BYTES, receivePreview, sendAssetInParts, writePreview } from "./web-asset-parts.js";
 import { LOGIN_FLOWS } from "./login-flows.js";
-import { ProgressAccumulator, summarizeProgress } from "./tool-progress.js";
+import { ProgressAccumulator, isSearchProgram, summarizeProgress } from "./tool-progress.js";
 import { assembleSystemPrompt, resolveWorkflowText } from "./prompt-file-ref.js";
 import { isCrossInstanceVisibility } from "./cross-instance-notice.js";
 import { ContextGuardian } from "./context-guardian.js";
 import { IpcServer } from "./channel/ipc-bridge.js";
 import { daemonBudgetMs } from "./channel/ipc-timeouts.js";
 import { MessageBus } from "./channel/message-bus.js";
-import { shellQuote, UnsupportedCliError, ResumeBlockedError } from "./backend/types.js";
+import { shellQuote, KiroCompatibilityError, UnsupportedCliError, ResumeBlockedError } from "./backend/types.js";
 import { getTmuxSession } from "./config.js";
 import { routeToolCall } from "./channel/tool-router.js";
 import { parseReplyButtons, replyButtonsFallbackText } from "./reply-buttons.js";
@@ -50,7 +50,6 @@ import { HangDetector } from "./hang-detector.js";
 import { writeSecretFile } from "./secret-file.js";
 import { PaneWriteLock } from "./pane-write-lock.js";
 import { answerRemoteCard } from "./remote-card-answer.js";
-import { tmuxPaneHost } from "./tmux-pane-host.js";
 import { buildFleetInstructions } from "./instructions.js";
 import { formatHumanInboundMessage, prepareDeliveryWire, steerInboundEnvelope, BTW_INBOUND_PREFIX, humanBodyHash, humanOwnerObjectId } from "./human-delivery-receipts.js";
 import { formatCrossInstanceInboundMessage, renderCrossInstanceHandoffMetadata, } from "./cross-instance-envelope.js";
@@ -58,13 +57,13 @@ import { agendMessageInInput, bottomRowIsReady, inputAreaText, inputShowsPastedT
 import { TurnReplyGuard, formatReplyDropDetection, turnExpectsPersonReply } from "./turn-reply-guard.js";
 import { CLAUDE_CREDIT_BALANCE_LOW, CLAUDE_MODEL_USAGE_LIMIT, CLAUDE_USAGE_LIMIT_PAUSE } from "./backend/claude-transcript-errors.js";
 import { t } from "./locale.js";
-import { claudeResetTime, quotaPausedLine } from "./quota-notice.js";
+import { claudeResetInstant, claudeResetTime, quotaPausedLine } from "./quota-notice.js";
 import { MuseUsageRelay, clearMuseUsageSnapshot } from "./muse-usage-relay.js";
-import { reconcileNativePaneTarget } from "./native-pane-reconciliation.js";
 import { deliveryContentDigest } from "./delivery-outbox.js";
 import { consumedWatches } from "./delivery-consumed-watch.js";
 import { queueResumePolicyForAttempt } from "./delivery-queue-evidence.js";
-import { scanTranscriptForDeliveryMarker } from "./delivery-reconciliation.js";
+import { markerConsumed, scanTranscriptForDeliveryMarker } from "./delivery-reconciliation.js";
+import { QUEUED_HANDOFF_MAX_REDELIVERIES, QueuedHandoffStore } from "./queued-handoffs.js";
 import { measureSyncWork, noteSyncWork } from "./sync-work-attribution.js";
 import { TranscriptDeltaReader } from "./transcript-delta-reader.js";
 import { buildResumeContinuation, clearInFlightTurnMarker, consumeInFlightTurnMarker, decideTurnResume, normalizeResumeBackend, readResumeFingerprint, RESUME_BLOCKING_DELIVERY_STATES, writeInFlightTurnMarker, } from "./turn-resume.js";
@@ -155,6 +154,8 @@ export const HANDOFF_RECHECK_MS = 1_000;
 export const WAIT_STOP_POLL_MS = 250;
 /** #2770: human messages a cancel dropped are told in one notice, this long after the last of them. */
 export const CANCELLED_HUMANS_NOTICE_MS = 1_000;
+/** #3030: a queued hand-off's watch outlives a long turn (the record outlives the watch in any case). */
+export const QUEUED_HANDOFF_WATCH_LIFETIME_MS = 12 * 60 * 60_000;
 /**
  * An instance publishing more than this many execution-state edges inside the
  * window is flapping; its edges stop being logged one by one (#1116). One
@@ -347,7 +348,8 @@ export function shellCommandLabel(command) {
     if (!program)
         return "";
     const isBareWord = (t) => !!t && /^[A-Za-z][A-Za-z0-9_-]*$/.test(t);
-    const label = isBareWord(tokens[1]) ? `${program} ${tokens[1]}` : program;
+    // A search program's next word is what it searches for, not a subcommand: `grep <token>` keeps only `grep`.
+    const label = isBareWord(tokens[1]) && !isSearchProgram(program) ? `${program} ${tokens[1]}` : program;
     return label.length > 40 ? `${label.slice(0, 39)}…` : label;
 }
 export class PaneStateMachine {
@@ -1116,7 +1118,6 @@ export class Daemon extends EventEmitter {
     spawnGate;
     stormWindow;
     backendOutage;
-    paneTransport;
     /** #1314: fleet-directory fallbacks already reported to the topic (once per daemon, per field and path). */
     promptFileFallbackNoticed = new Set();
     /** Identity of this live Daemon object; changes on object stop/restart. */
@@ -1585,6 +1586,12 @@ export class Daemon extends EventEmitter {
     pendingWhatsNew = null;
     pasteQueueDepth = 0;
     /** #2770: a person's messages a cancel dropped before they reached the CLI, told together (noteCancelledHuman). */
+    /** #3030: people's messages a CLI never took (or that a restart left unverifiable), told once per batch. */
+    unsettledHandoffs = { "not-taken": [], unverifiable: [] };
+    unsettledHandoffsTimer = null;
+    /** #3030: since when (monotonic) the CLI has been idle without a break; null while it is not. */
+    instanceIdleSinceMono = null;
+    queuedHandoffStore = null;
     cancelledHumans = [];
     cancelledHumansTimer = null;
     firstDeliveryDelay = new FirstDeliveryDelay();
@@ -1789,6 +1796,80 @@ export class Daemon extends EventEmitter {
     // still booting. Its new tmux window starts empty before resume restores the
     // old transcript, so pre-ready scans must not lower this seeded baseline.
     seededErrorCountBaselines = new Map();
+    quotaReplay = null;
+    paneQuotaPatterns() {
+        if (!["codex", "grok"].includes(this.backend?.binaryName ?? ""))
+            return [];
+        const patterns = this.backend?.getErrorPatterns?.() ?? [];
+        return this.backend?.binaryName === "codex" ? patterns.filter(ep => Daemon.isCodexUsageLimitPause(ep)) : patterns.filter(ep => ep.type === "quota");
+    }
+    async prepareQuotaReplayHistory(reuseWindow) {
+        this.quotaReplay = null;
+        const backend = this.backend, owner = this.tmux, window = owner?.getWindowId?.();
+        const spawn = this.spawnGeneration, fence = this.launchFenceEpoch, attempt = this.launchAttempt;
+        const current = () => backend === this.backend && owner === this.tmux && window === owner?.getWindowId?.()
+            && spawn === this.spawnGeneration && fence === this.launchFenceEpoch && attempt === this.launchAttempt;
+        const replay = backend?.quotaReplayHistory?.();
+        if (replay)
+            this.quotaReplay = { ...replay, spawn, fence, attempt };
+        // A Grok wake keeps its exited pane. The replacement's first ready pane is not history proof.
+        if (reuseWindow && backend?.resumesPreservedQuotaHistory?.()) {
+            let oldPane;
+            try {
+                oldPane = await owner.capturePane();
+            }
+            catch {
+                return;
+            }
+            this.startupAdmission?.();
+            if (!current())
+                return;
+            const patterns = this.paneQuotaPatterns();
+            const messages = oldPane.split(/\r?\n/).filter(row => patterns.some(ep => ep.pattern.test(row)));
+            this.quotaReplay = { messages, current: () => true, spawn, fence, attempt };
+        }
+    }
+    /** Before admission, this launch may absorb ONLY rows positively known before its resume. */
+    takeQuotaReplayBaseline(pane) {
+        const history = this.quotaReplay;
+        if (!history)
+            return;
+        this.quotaReplay = null;
+        if (history.spawn !== this.spawnGeneration || history.fence !== this.launchFenceEpoch || history.attempt !== this.launchAttempt || !history.current())
+            return;
+        for (const ep of this.paneQuotaPatterns()) {
+            const count = Math.min(Daemon.countOccurrences(ep.pattern, pane), quotaHistoryCount(pane, ep.pattern, history.messages));
+            if (!count)
+                continue;
+            const key = Daemon.errorPatternKey(ep);
+            this.lastErrorCount.set(key, Math.max(this.lastErrorCount.get(key) ?? 0, count));
+            this.logger.debug({ backend: this.backend?.binaryName, count, evidence: "before-resume" }, "Quota rows restored from history — not a new incident");
+        }
+    }
+    // Submission makes captured rows history even when no monitor reported them yet. Keep this acknowledged input's
+    // marker as well: a new error can replace an old row in the viewport without increasing the total match count.
+    quotaInput = null;
+    commitPreInputQuotaHistory(evidence) {
+        const history = evidence?.quotaHistory;
+        if (!history || history.spawn !== this.spawnGeneration || history.fence !== this.launchFenceEpoch || history.attempt !== this.launchAttempt
+            || history.tmux !== this.tmux || history.window !== this.tmux?.getWindowId?.() || this.deliveryWritesStopping)
+            return;
+        for (const row of history.counts)
+            this.lastErrorCount.set(row.key, row.count);
+        this.quotaInput = history.marker && history.occurrences === 0 ? { history, reported: new Map() } : null;
+    }
+    quotaOccurrencesAfterInput(pane, ep) {
+        if (!(this.backend?.binaryName === "codex" && Daemon.isCodexUsageLimitPause(ep)
+            || this.backend?.binaryName === "grok" && ep.type === "quota"))
+            return null;
+        const input = this.quotaInput, history = input?.history;
+        if (!input || !history || history.spawn !== this.spawnGeneration || history.fence !== this.launchFenceEpoch
+            || history.attempt !== this.launchAttempt || history.tmux !== this.tmux || history.window !== this.tmux?.getWindowId?.()
+            || this.deliveryWritesStopping)
+            return null;
+        const suffix = quotaAfterInput(pane, history.marker);
+        return suffix === null ? null : { input, count: Daemon.countOccurrences(ep.pattern, suffix) };
+    }
     lastDetectedErrorType = null;
     /**
      * #2822: Claude's per-model usage limit (`You've reached your <model> limit.`), known only from Claude's own record of
@@ -1810,12 +1891,46 @@ export class Daemon extends EventEmitter {
     static CREDIT_BALANCE_LOW = CLAUDE_CREDIT_BALANCE_LOW;
     /** #2834 (#816): Claude's usage-limit auto-continue note, as it records it (`system` / `informational`). */
     static USAGE_LIMIT_PAUSE = CLAUDE_USAGE_LIMIT_PAUSE;
-    /** #2834 (#816): Claude paused itself until its usage window opens — the same notice the screen pattern gave. */
-    noteClaudeInformational(text) {
-        const match = Daemon.USAGE_LIMIT_PAUSE.exec(text.trim());
+    /** Claude's note that its usage window opened again ("Usage limit reset · continuing automatically"). */
+    static USAGE_LIMIT_RESET = /^Usage limit reset\b/i;
+    /** Repeats of one usage pause ("reached again" every few minutes) collapse into the first notice for this long. */
+    static USAGE_PAUSE_NOTICE_WINDOW_MS = 30 * 60_000;
+    /** The usage-pause notice told last: when (monotonic), Claude's words for the reset, and that reset (wall clock). */
+    usagePauseNotice = null;
+    /**
+     * #2834 (#816): Claude paused itself until its usage window opens — the same notice the screen pattern gave. `at`: when
+     * Claude wrote it (its record's timestamp). One notice per pause: a reset time already past is not this pause (an old
+     * note), and its repeats ("reached again") within the window — or naming the same reset, until it comes — say nothing
+     * more. Claude's own "Usage limit reset" ends it.
+     */
+    /** #3186 review: the lifecycle's second opinion dropped the notice (usage has capacity): nothing was told. */
+    clearUsagePauseNotice() { this.usagePauseNotice = null; }
+    noteClaudeInformational(text, at = null) {
+        const line = text.trim();
+        if (Daemon.USAGE_LIMIT_RESET.test(line)) {
+            this.usagePauseNotice = null;
+            return;
+        }
+        const match = Daemon.USAGE_LIMIT_PAUSE.exec(line);
         if (!match)
             return;
         const when = match[1].trim();
+        const wallNow = Date.now(), now = performance.now();
+        const resetAt = claudeResetInstant(when, at ?? wallNow);
+        if (resetAt !== null && resetAt <= wallNow) {
+            this.logger.debug({ when, writtenAt: at }, "Claude usage-limit note names a reset already past — an old note, not told");
+            return;
+        }
+        // A pause told earlier is this one while its own reset has not come (unknown: within the window): its repeats —
+        // "reached again", or a relative time drifting ("in 3h", "in 2h 55m") — within the window, or naming the same reset.
+        // Once its reset has passed, a later note is a new pause even without Claude's "Usage limit reset" (#3186 review).
+        const told = this.usagePauseNotice;
+        const toldOpen = !!told && (told.resetAt === null || wallNow < told.resetAt);
+        if (told && toldOpen && (now - told.at < Daemon.USAGE_PAUSE_NOTICE_WINDOW_MS || (told.when === when && told.resetAt !== null))) {
+            this.logger.debug({ when }, "Claude usage-limit note repeats a pause already told — collapsed");
+            return;
+        }
+        this.usagePauseNotice = { at: now, when, resetAt };
         this.emit("pty_error", { name: this.name, type: "quota", action: "notify", verifyQuota: true, skipCooldown: true, skipRecoveryWait: true,
             message: `Claude Code usage limit reached — paused; continuing automatically ${when}`,
             notice: quotaPausedLine("Claude", "usage", claudeResetTime(when)) });
@@ -1948,87 +2063,9 @@ export class Daemon extends EventEmitter {
         this.errorRecoveryDeadlineAt = 0;
         this.activeErrorPatternKey = null;
     }
-    /** Lazy default also preserves bare-prototype diagnostic/test construction. */
-    get paneHost() { return this.paneTransport ?? tmuxPaneHost; }
-    nativePaneLifecycle;
-    nativeFleetBridge;
-    nativeTranscriptSource;
-    usesNativePane() { return !!this.nativePaneLifecycle; }
-    logNativeInputRefusal(details) {
-        this.logger.warn({ component: "runtime-pane-host", reason: "expected_seq_changed", ...details }, "Native pane input refused before write");
-    }
-    logNativeToolFailure(details) {
-        const turn = this.turnReplyGuard.snapshot();
-        this.logger.warn({ ...details, currentMessageId: turn?.target.messageId ?? null,
-            guardGeneration: turn?.generation ?? null, guardPhase: turn?.phase ?? null }, "Native pane tool operation failed");
-    }
-    nativePaneCurrent() { return this.nativePaneLifecycle?.current() ?? false; }
-    nativeEnterHold = null;
-    /** Per-launch attention for a native delivery whose bounded input attempts were refused or uncertain, including non-outbox input. */
-    nativeDeliveryHold() {
-        const hold = this.nativeEnterHold;
-        return hold && this.nativePaneLifecycle && !this.deliveryWritesStopping && hold.spawn === this.spawnGeneration && hold.fence === this.launchFenceEpoch
-            ? { key: hold.key, since: hold.since } : null;
-    }
-    nativePaneHasExited() {
-        const snapshot = this.nativePaneLifecycle?.snapshot?.();
-        return snapshot?.state === "exited" && snapshot.instance === this.name && this.tmux?.getWindowId() === snapshot.paneId;
-    }
-    /** Positive native exit evidence only, fenced to this exact launch and Daemon owner. */
-    nativePaneExitCurrent(snapshot, owner) {
-        const actual = this.nativePaneLifecycle?.snapshot?.();
-        return !!actual && actual.state === "exited" && snapshot.state === "exited"
-            && sameInteractionOwner(owner, this.interactionOwner()) && !this.runtimeMonitorsFrozen && !this.startupAborted
-            && ["hostBootId", "paneId", "launchId", "agentId", "instance", "sessionId", "commandSequence", "exitCode"].every(key => actual[key] === snapshot[key])
-            && this.tmux?.getWindowId() === snapshot.paneId;
-    }
-    async reconcileNativeDeliveries(outbox, current) {
-        if (!this.nativePaneLifecycle)
-            return false;
-        return reconcileNativePaneTarget(outbox, this.name, this.nativePaneLifecycle, current);
-    }
-    /** Same-process transport for the owned native daemon; never exposed as a runner RPC. */
-    setNativeFleetBridge(bridge) {
-        if (!this.nativePaneLifecycle || this.nativeFleetBridge?.current())
-            throw Error("Native Fleet bridge requires one bound pane owner");
-        this.nativeFleetBridge = bridge;
-    }
-    /** Fleet admission and generation checks happen before this synchronous handoff. */
-    acceptNativeFleetMessage(message) {
-        if (!this.nativePaneLifecycle || !this.nativeFleetBridge?.current() || this.deliveryWritesStopping || this.runtimeMonitorsFrozen)
-            return false;
-        if (typeof message.type === "string" && FLEET_RESPONSE_TYPES.has(message.type)) {
-            this.routeFleetResponse(message);
-            return true;
-        }
-        const bridge = this.nativeFleetBridge;
-        const current = () => this.nativeFleetBridge === bridge && bridge.current() && !this.deliveryWritesStopping && !this.runtimeMonitorsFrozen;
-        return this.handleFleetMessage(message, reply => { if (current())
-            this.broadcastFleetMessage(reply); }, current);
-    }
-    broadcastFleetMessage(message) {
-        if (this.nativePaneLifecycle) {
-            if (this.nativeFleetBridge?.current() && !this.runtimeMonitorsFrozen && !this.deliveryWritesStopping)
-                this.nativeFleetBridge.send(message);
-        }
-        else
-            this.ipcServer?.broadcast(message);
-    }
-    fleetTransportAvailable() {
-        return this.nativePaneLifecycle ? !!this.nativeFleetBridge?.current() && !this.runtimeMonitorsFrozen : !!this.ipcServer;
-    }
-    /** Internal lifecycle injection, before start. Native paths and provider files stay on their runner. */
-    setNativePaneLifecycle(native) {
-        if (this.tmux || this.ipcServer || this.nativePaneLifecycle)
-            throw Error("Native pane adapter must be bound before daemon startup");
-        this.nativePaneLifecycle = native;
-        this.backend = native.backend;
-        this.paneTransport = native.host;
-        this.controlClient = native.observation;
-    }
     constructor(name, config, instanceDir, topicMode = false, backend, controlClient, rootLogger, runtimeIdentity, spawnGate, stormWindow, 
     /** Fleet-level "is this CLI's backend down?" memory — see backend-outage.ts. */
-    backendOutage, paneTransport) {
+    backendOutage) {
         super();
         this.name = name;
         this.config = config;
@@ -2040,7 +2077,6 @@ export class Daemon extends EventEmitter {
         this.spawnGate = spawnGate;
         this.stormWindow = stormWindow;
         this.backendOutage = backendOutage;
-        this.paneTransport = paneTransport;
         // The live process owns its adopted configuration. Fleet defaults may be re-resolved in place after a save;
         // sharing that object would activate cold changes before the normal restart/apply boundary.
         this.config = structuredClone(config);
@@ -2063,8 +2099,7 @@ export class Daemon extends EventEmitter {
         this.messageBus.setLogger(this.logger);
         // General is the dispatcher — it must stay warm to route messages, so it is
         // never auto-paused regardless of auto_pause_after.
-        // #3035 review: the one rule (an agent named general unticked — general_topic: false — is a worker).
-        const isGeneral = config.general_topic === true || generalByName(name, config);
+        const isGeneral = config.general_topic === true || name === "general";
         const autoPauseMinutes = isGeneral ? 0 : (typeof config.auto_pause_after === "number" ? config.auto_pause_after : 0); // default: disabled
         this.autoPauseController = new AutoPauseController(Math.max(0, autoPauseMinutes) * 60_000, readLastInboundAt(instanceDir) ?? Date.now());
         // #1209: every real completion clears the in-flight marker, so a
@@ -2076,6 +2111,9 @@ export class Daemon extends EventEmitter {
             this.publishWorkingState("turn_closed");
         };
     }
+    /** Register each issued HTTP credential with the same-process lifecycle owner. */
+    agentCredentialIssuer;
+    setAgentCredentialIssuer(issue) { this.agentCredentialIssuer = issue; }
     /** FleetManager and this daemon share a process, so durable begin/ACK is a direct synchronous store call. */
     setDeliveryOutboxPort(port) {
         this.deliveryOutbox = port;
@@ -2123,19 +2161,12 @@ export class Daemon extends EventEmitter {
         return outcome === "begun";
     }
     async durableAttemptEvidence(windowId, handingOffToNativeQueue, steer, rawPaste = false) {
-        let checkpoint = null, runtimeTranscript = null;
-        if (this.nativePaneLifecycle) {
-            runtimeTranscript = await this.transcriptMonitor?.reconciliationRuntimeCheckpoint() ?? null;
-            if (!runtimeTranscript || !this.nativePaneLifecycle.current(runtimeTranscript))
-                throw Error("Native transcript checkpoint is not current; no delivery was written");
+        let checkpoint = null;
+        try {
+            checkpoint = await this.transcriptMonitor?.reconciliationCheckpoint() ?? null;
         }
-        else {
-            try {
-                checkpoint = await this.transcriptMonitor?.reconciliationCheckpoint() ?? null;
-            }
-            catch (err) {
-                this.logger.debug({ err }, "Could not checkpoint transcript before durable delivery");
-            }
+        catch (err) {
+            this.logger.debug({ err }, "Could not checkpoint transcript before durable delivery");
         }
         const submissionMode = rawPaste ? "raw_paste" : steer
             ? "steer"
@@ -2151,9 +2182,8 @@ export class Daemon extends EventEmitter {
             backendVersion,
             windowId: windowId ?? this.tmux?.getWindowId() ?? null,
             transcriptPath: checkpoint?.path ?? null,
-            transcriptOffset: runtimeTranscript?.cursor.offset ?? checkpoint?.offset ?? null,
-            transcriptSessionId: runtimeTranscript?.cursor.sessionId ?? checkpoint?.sessionId ?? null,
-            ...(runtimeTranscript ? { runtimeTranscript } : {}),
+            transcriptOffset: checkpoint?.offset ?? null,
+            transcriptSessionId: checkpoint?.sessionId ?? null,
             submissionMode,
             queueResumePolicy: queueResumePolicyForAttempt(backend, backendVersion, submissionMode),
         };
@@ -2196,25 +2226,17 @@ export class Daemon extends EventEmitter {
         const outbox = this.deliveryOutbox;
         if (!checkpoint || !outbox?.markConsumed)
             return;
-        if (this.nativePaneLifecycle && !checkpoint.runtime)
-            return;
         if (verdict.submissionMode !== "steer" && verdict.submissionMode !== "native_queue_handoff")
             return;
         if (!["claude-code", "codex"].includes(checkpoint.backend))
             return;
         const spawn = this.spawnGeneration, fence = this.launchFenceEpoch, boot = this.bootId;
-        let location;
-        try {
-            location = checkpoint.runtime ? { reader: this.nativeTranscriptReader(checkpoint.runtime, delivery.deliveryId) } : { path: checkpoint.path, offset: checkpoint.offset };
-        }
-        catch {
-            return;
-        } // The owner changed; an unavailable consumed watch proves nothing.
         consumedWatches.start({
             deliveryId: delivery.deliveryId,
             attemptNo: delivery.attemptNo,
             backend: checkpoint.backend,
-            ...location,
+            path: checkpoint.path,
+            offset: checkpoint.offset,
             current: () => !this.deliveryWritesStopping && spawn === this.spawnGeneration && fence === this.launchFenceEpoch,
             consumed: (via, evidence) => {
                 try {
@@ -2228,6 +2250,243 @@ export class Daemon extends EventEmitter {
             logger: this.logger,
         });
     }
+    handoffStore() {
+        return this.queuedHandoffStore ??= new QueuedHandoffStore(this.instanceDir);
+    }
+    /** #3030: the CLI that holds a queued hand-off; a record is settled only by a later one. */
+    handoffHolder() { return `${this.bootId}:${this.spawnGeneration}`; }
+    /**
+     * #3030: before the paste. A hand-off into a busy Claude Code / Codex queue gets its record — the transcript
+     * checkpoint before the paste, the unique leading marker and what a redelivery needs — or, for a redelivery written
+     * as an ordinary idle submission, its record moves its checkpoint here, so a crash right after this paste is still
+     * judged from the transcript that will show it. A write that did not keep a record runs as before.
+     */
+    async recordQueuedHandoff(formatted, handingOff, verdict, durableAttempt, humanVerificationId) {
+        const track = verdict.trackHandoff;
+        if (!track)
+            return;
+        if (!handingOff && !track.id) {
+            // An earlier attempt of this delivery was a hand-off; this one is an idle submission.
+            if (verdict.handoff)
+                this.dropQueuedHandoff(verdict);
+            return;
+        }
+        const backend = this.config.backend ?? this.backend?.binaryName ?? "";
+        if (!["claude-code", "codex"].includes(backend))
+            return;
+        const marker = durableAttempt ? `[agend-delivery-id:${durableAttempt.deliveryId}]`
+            : humanVerificationId ? `[agend-human-id:${humanVerificationId}]` : null;
+        if (!marker || !formatted.startsWith(marker))
+            return;
+        let checkpoint = verdict.transcriptCheckpoint ?? null;
+        if (!checkpoint) {
+            try {
+                checkpoint = await this.transcriptMonitor?.reconciliationCheckpoint() ?? null;
+            }
+            catch (err) {
+                this.logger.debug({ err }, "Could not checkpoint the transcript before a queued hand-off");
+            }
+        }
+        if (!checkpoint)
+            return; // nothing could judge it later: it runs as before (✅ at the hand-off)
+        const entry = {
+            id: track.id ?? randomUUID(), marker, backend, path: checkpoint.path, offset: checkpoint.offset,
+            content: track.content, meta: track.meta, holder: this.handoffHolder(), createdAt: Date.now(),
+            redeliveries: track.redeliveries ?? 0,
+        };
+        try {
+            const dropped = this.handoffStore().put(entry);
+            if (handingOff)
+                verdict.handoff = entry;
+            for (const old of dropped)
+                this.logger.warn({ handoff: old.id, createdAt: old.createdAt }, "Queued hand-off record dropped: too many on record");
+        }
+        catch (err) {
+            this.logger.warn({ err }, "Could not record a queued hand-off; it runs as before (✅ at the hand-off)");
+        }
+    }
+    /**
+     * #3030: after pushChannelMessage's write. A hand-off on record whose paste went out is watched (✅ when a turn
+     * takes it); one that was never written goes. A redelivery that ended as an ordinary submission is done; one that a
+     * cancel dropped goes too (a cancel is the person's); one stopped before its write stays for the next CLI.
+     */
+    afterTrackedWrite(meta, verdict, sent, deliveryEpoch) {
+        try {
+            // A stale epoch with writes still allowed is a cancel (the person's); a stop fences writes too, and keeps records.
+            const cancelled = !this.isDeliveryEpochCurrent(deliveryEpoch) && !this.deliveryWritesStopping;
+            if (verdict.handoff) {
+                if (sent || verdict.paneWriteStarted)
+                    this.watchQueuedHandoff(verdict.handoff);
+                else if (!verdict.trackHandoff?.id || cancelled)
+                    this.dropQueuedHandoff(verdict);
+                return;
+            }
+            const id = meta.handoff_redelivery;
+            if (!id)
+                return;
+            if (sent || verdict.paneWriteStarted || cancelled) {
+                this.handoffStore().remove(id);
+                this.logger.info({ handoff: id, sent, proof: verdict.proof ?? null }, "Queued hand-off redelivered as an ordinary submission");
+            }
+        }
+        catch (err) {
+            this.logger.warn({ err }, "Could not update the queued hand-off record after its write");
+        }
+    }
+    redeliveryStillOurs(meta) {
+        const holder = this.handoffHolder();
+        if (meta.handoff_holder !== holder)
+            return false;
+        try {
+            return this.handoffStore().get(meta.handoff_redelivery)?.holder === holder;
+        }
+        catch {
+            return false;
+        }
+    }
+    dropQueuedHandoff(verdict) {
+        const entry = verdict.handoff;
+        verdict.handoff = undefined;
+        if (!entry)
+            return;
+        try {
+            this.handoffStore().remove(entry.id);
+        }
+        catch (err) {
+            this.logger.warn({ err, handoff: entry.id }, "Could not remove a queued hand-off record");
+        }
+    }
+    /**
+     * #3030: the hand-off's CLI is the current one: watch its transcript for the turn that takes it (✅ then), and for an
+     * idle CLI that never did (reported). A stop ends the watch; the record stays for the next CLI to settle.
+     */
+    watchQueuedHandoff(entry) {
+        const spawn = this.spawnGeneration, fence = this.launchFenceEpoch, epoch = this.deliveryEpoch;
+        const started = consumedWatches.start({
+            deliveryId: `handoff:${entry.id}`,
+            attemptNo: entry.redeliveries,
+            backend: entry.backend,
+            path: entry.path,
+            offset: entry.offset,
+            marker: entry.marker,
+            // A cancel or stop moves the epoch: the watch ends quietly (a cancel cleared the record, a stop leaves it).
+            current: () => !this.deliveryWritesStopping && spawn === this.spawnGeneration && fence === this.launchFenceEpoch
+                && epoch === this.deliveryEpoch,
+            consumed: (via) => this.settleQueuedHandoff(entry, "taken", `transcript:${via}`),
+            idleForMs: () => this.instanceIdleSinceMono === null ? null : performance.now() - this.instanceIdleSinceMono,
+            notTaken: () => this.settleQueuedHandoff(entry, "not-taken", "transcript:absent-while-idle"),
+            // A queued message waits for the running turn, however long that is.
+            lifetimeMs: QUEUED_HANDOFF_WATCH_LIFETIME_MS,
+            logger: this.logger,
+        });
+        if (!started) {
+            // No watch (the fleet's cap): ✅ as before; the record still lets a restart judge it.
+            const status = channelStatus(entry.meta);
+            if (status)
+                this.emit("message_confirmed", status);
+        }
+    }
+    /** #3030: a record's end — taken (✅), or never taken / not judgeable (❌, told once per batch). */
+    settleQueuedHandoff(entry, outcome, proof) {
+        try {
+            this.handoffStore().remove(entry.id);
+        }
+        catch (err) {
+            this.logger.warn({ err, handoff: entry.id }, "Could not remove a settled queued hand-off record");
+        }
+        const meta = entry.meta;
+        const status = channelStatus(meta);
+        if (outcome === "taken") {
+            this.logger.info({ handoff: entry.id, proof, redeliveries: entry.redeliveries }, "Queued hand-off taken by the CLI");
+            if (status)
+                this.emit("message_confirmed", status);
+            return;
+        }
+        this.logger.warn({ handoff: entry.id, outcome, proof, redeliveries: entry.redeliveries }, "Queued hand-off was not taken by the CLI");
+        if (meta.from_instance) {
+            this.reportCrossInstanceDeliveryFailure(meta, { reached: true, phase: "handoff-not-consumed", proof: outcome === "not-taken" ? "not-taken" : "unverifiable" });
+            return;
+        }
+        if (!status)
+            return;
+        this.unsettledHandoffs[outcome].push({ chatId: status.chatId, messageId: status.messageId, ...(status.threadId ? { threadId: status.threadId } : {}) });
+        if (this.unsettledHandoffsTimer)
+            clearTimeout(this.unsettledHandoffsTimer);
+        this.unsettledHandoffsTimer = setTimeout(() => {
+            this.unsettledHandoffsTimer = null;
+            for (const reason of ["not-taken", "unverifiable"]) {
+                const messages = this.unsettledHandoffs[reason].splice(0);
+                if (messages.length)
+                    this.emit("human_handoffs_unsettled", { reason, messages });
+            }
+        }, CANCELLED_HUMANS_NOTICE_MS);
+        this.unsettledHandoffsTimer.unref?.();
+    }
+    /**
+     * #3030: right after a CLI came up — the records left by CLIs that are gone. Their queue went with them, so each is
+     * judged by its own transcript from its checkpoint: taken there (✅, nothing pasted); proven not taken (the whole
+     * delta read, the marker absent or only enqueued) → redelivered once, with the same marker, through the ordinary
+     * queue; anything that cannot be judged → never pasted, reported. Ownership is evidence: never pasted twice.
+     */
+    async reconcileQueuedHandoffs() {
+        let entries;
+        try {
+            entries = this.handoffStore().list().filter(e => e.holder !== this.handoffHolder());
+        }
+        catch (err) {
+            this.logger.warn({ err }, "Could not read the queued hand-off records");
+            return;
+        }
+        if (!entries.length)
+            return;
+        // Captured before any await: a reconciliation that outlives its CLI can never claim the next CLI's holder.
+        const holder = this.handoffHolder();
+        const spawn = this.spawnGeneration, fence = this.launchFenceEpoch, epoch = this.deliveryEpoch;
+        const fresh = () => spawn === this.spawnGeneration && fence === this.launchFenceEpoch && epoch === this.deliveryEpoch
+            && !this.deliveryWritesStopping;
+        let redelivered = 0, taken = 0, unverifiable = 0;
+        for (const entry of entries) {
+            const kind = await scanTranscriptForDeliveryMarker(entry.path, entry.offset, entry.backend, { marker: entry.marker });
+            // This CLI is gone already, or a cancel came: the next CLI settles them (a cancel cleared them).
+            if (!fresh())
+                return;
+            // …and the record is still the one that was read (another reconciliation or a cancel did not change it meanwhile).
+            let current;
+            try {
+                current = this.handoffStore().get(entry.id);
+            }
+            catch {
+                current = undefined;
+            }
+            if (!current || current.holder !== entry.holder || current.redeliveries !== entry.redeliveries)
+                continue;
+            if (markerConsumed(kind)) {
+                taken++;
+                this.settleQueuedHandoff(entry, "taken", `restart-transcript:${kind}`);
+                continue;
+            }
+            if (kind === "unavailable" || entry.redeliveries >= QUEUED_HANDOFF_MAX_REDELIVERIES) {
+                unverifiable++;
+                this.settleQueuedHandoff(entry, "unverifiable", kind === "unavailable" ? "restart-transcript:unavailable" : "redelivery-limit");
+                continue;
+            }
+            // Proven not taken: the CLI that queued it is gone and its transcript, read to the end, never took it.
+            const next = { ...entry, holder, redeliveries: entry.redeliveries + 1 };
+            try {
+                this.handoffStore().put(next);
+            }
+            catch (err) {
+                this.logger.warn({ err, handoff: entry.id }, "Could not update a queued hand-off record; not redelivered now");
+                continue;
+            }
+            redelivered++;
+            // The person's receipt was settled by the first write: the redelivery carries its marker, not its receipt binding.
+            const { human_receipt_id: _r, human_owner_key: _o, human_daemon_owner: _d, human_wire_sha256: _w, ...meta } = entry.meta;
+            this.pushChannelMessage(entry.content, { ...meta, handoff_redelivery: entry.id,
+                handoff_redeliveries: String(next.redeliveries), handoff_holder: next.holder }, undefined, epoch);
+        }
+        this.logger.info({ instance: this.name, redelivered, taken, unverifiable, proof: "transcript" }, "Queued hand-offs left by the previous CLI settled");
+    }
     finishDurableSubmission(delivery, verdict) {
         // Legacy backends may accept a pane write without enough pane evidence to
         // claim submission. Keep that row inspectable instead of recording a false
@@ -2295,34 +2554,24 @@ export class Daemon extends EventEmitter {
         const spawn = this.spawnGeneration;
         const fence = this.launchFenceEpoch;
         let last = "unavailable";
-        const native = !!checkpoint.runtime || !!this.nativePaneLifecycle;
-        let outcome = native ? "uncertain" : "delivered";
-        let evidence = native ? "runtime-transcript-unconfirmed" : OUTPUT_EDGE_ONLY_EVIDENCE;
+        let outcome = "delivered";
+        let evidence = OUTPUT_EDGE_ONLY_EVIDENCE;
         // #1647: a raw paste has no marker; its text is the needle, and its pane proof already failed — so without the turn
         // in the transcript it stays uncertain (with the pane's reason), never the output-edge outcome.
         const needle = rawPaste ? { rawText: rawPaste.text } : delivery.deliveryId;
         let found = false;
         try {
-            if (this.nativePaneLifecycle && !checkpoint.runtime)
-                throw Error("Native proof cannot read a coordinator-local transcript path");
-            const nativeReader = checkpoint.runtime ? this.nativeTranscriptReader(checkpoint.runtime, needle) : null;
             for (let polls = 0; polls <= TRANSCRIPT_PROOF_WINDOW_MS / TRANSCRIPT_PROOF_POLL_MS; polls++) {
                 if (this.deliveryWritesStopping)
                     return; // reconciliation owns the row now
-                const look = nativeReader ? await nativeReader.look() : await scanTranscriptForDeliveryMarker(checkpoint.path, checkpoint.offset, checkpoint.backend, needle);
-                if (this.deliveryWritesStopping)
-                    return;
-                if (spawn !== this.spawnGeneration || fence !== this.launchFenceEpoch) {
-                    last = "unavailable";
-                    break;
-                }
+                const look = await scanTranscriptForDeliveryMarker(checkpoint.path, checkpoint.offset, checkpoint.backend, needle);
                 if (look === "user" || look === "absorbed" || look === "queued") {
                     found = true;
                     outcome = "delivered";
                     evidence = transcriptMarkerEvidence(look, !!rawPaste);
                     break;
                 }
-                last = look === "pending" ? "unavailable" : look;
+                last = look;
                 if (spawn !== this.spawnGeneration || fence !== this.launchFenceEpoch) {
                     last = "unavailable";
                     break;
@@ -2334,13 +2583,13 @@ export class Daemon extends EventEmitter {
             // `uncertain`: re-check the same fixed epochs after the last await, before settling (#1207 P2).
             if (spawn !== this.spawnGeneration || fence !== this.launchFenceEpoch)
                 last = "unavailable";
-            if (last === "no-match" && !found) {
+            if (last === "no-match" && evidence === OUTPUT_EDGE_ONLY_EVIDENCE) {
                 outcome = "uncertain";
                 evidence = "unverifiable-no-transcript-marker";
             }
         }
         catch (err) {
-            this.logger.debug({ err }, "Transcript proof unavailable — preserving the conservative outcome");
+            this.logger.debug({ err }, "Transcript proof of a delivery failed — keeping the output-edge outcome");
         }
         if (rawPaste && !found) {
             outcome = "uncertain";
@@ -2527,130 +2776,128 @@ export class Daemon extends EventEmitter {
             }
         }
         catch { /* corrupt/missing — ignore */ }
-        if (!this.nativePaneLifecycle) {
-            // 1. IPC server — bridge between MCP server (Claude's child) and daemon
-            const sockPath = join(this.instanceDir, "channel.sock");
-            this.ipcServer = new IpcServer(sockPath, this.logger);
-            // Forward IPC server errors as daemon events (prevents unhandled 'error' crash).
-            // Guard: only forward post-listen errors — startup errors are handled by listen() rejection.
-            let ipcListening = false;
-            this.ipcServer.on("error", (err) => {
-                if (!ipcListening)
-                    return; // startup errors handled by listen() rejection
-                this.logger.error({ err, name: this.name }, "IPC server error");
-                this.emit("error", err);
-            });
-            await this.ipcServer.listen();
-            this.startupAdmission?.();
-            ipcListening = true;
-            // Permanent IPC dispatcher: routes responses to pending requests by type+id key
-            this.ipcServer.on("message", (msg) => this.routeFleetResponse(msg));
-            // IPC message relay: when daemon wants to push a channel message to Claude,
-            // it broadcasts to all IPC clients (the MCP server is one of them).
-            // When MCP server sends a tool_call, daemon handles it via the messageBus.
-            this.ipcServer.on("message", (msg, socket) => {
-                if (msg.type === "tool_call") {
-                    // MCP server forwarding a Claude tool call (reply, react, edit, download)
-                    this.handleToolCall(msg, socket);
-                }
-                else if (msg.type === "mcp_ready") {
-                    this.handleMcpReady(msg, socket);
-                }
-                else if (msg.type === "pong") {
-                    this.handleMcpPong(msg, socket);
-                }
-                else if (msg.type === "query_sessions") {
-                    // Fleet manager asks for all registered session names (catches sessions
-                    // that sent mcp_ready before fleet manager connected).
-                    const sessions = [];
-                    for (const [s, sessionName] of this.socketSessionNames) {
-                        if (!s.destroyed && sessionName !== this.name) {
-                            // Individual mcp_ready for initial registration path
-                            this.ipcServer?.send(socket, { type: "mcp_ready", sessionName });
-                            sessions.push(sessionName);
-                        }
+        // 1. IPC server — bridge between MCP server (Claude's child) and daemon
+        const sockPath = join(this.instanceDir, "channel.sock");
+        this.ipcServer = new IpcServer(sockPath, this.logger);
+        // Forward IPC server errors as daemon events (prevents unhandled 'error' crash).
+        // Guard: only forward post-listen errors — startup errors are handled by listen() rejection.
+        let ipcListening = false;
+        this.ipcServer.on("error", (err) => {
+            if (!ipcListening)
+                return; // startup errors handled by listen() rejection
+            this.logger.error({ err, name: this.name }, "IPC server error");
+            this.emit("error", err);
+        });
+        await this.ipcServer.listen();
+        this.startupAdmission?.();
+        ipcListening = true;
+        // Permanent IPC dispatcher: routes responses to pending requests by type+id key
+        this.ipcServer.on("message", (msg) => this.routeFleetResponse(msg));
+        // IPC message relay: when daemon wants to push a channel message to Claude,
+        // it broadcasts to all IPC clients (the MCP server is one of them).
+        // When MCP server sends a tool_call, daemon handles it via the messageBus.
+        this.ipcServer.on("message", (msg, socket) => {
+            if (msg.type === "tool_call") {
+                // MCP server forwarding a Claude tool call (reply, react, edit, download)
+                this.handleToolCall(msg, socket);
+            }
+            else if (msg.type === "mcp_ready") {
+                this.handleMcpReady(msg, socket);
+            }
+            else if (msg.type === "pong") {
+                this.handleMcpPong(msg, socket);
+            }
+            else if (msg.type === "query_sessions") {
+                // Fleet manager asks for all registered session names (catches sessions
+                // that sent mcp_ready before fleet manager connected).
+                const sessions = [];
+                for (const [s, sessionName] of this.socketSessionNames) {
+                    if (!s.destroyed && sessionName !== this.name) {
+                        // Individual mcp_ready for initial registration path
+                        this.ipcServer?.send(socket, { type: "mcp_ready", sessionName });
+                        sessions.push(sessionName);
                     }
-                    // Batch response for prune path
-                    this.ipcServer?.send(socket, { type: "query_sessions_response", sessions });
                 }
-                else
-                    this.handleFleetMessage(msg, reply => { this.ipcServer?.send(socket, reply); });
-            });
-        }
-        let nativeDisposition;
-        if (this.nativePaneLifecycle) {
-            this.beginSpawn();
-            try {
-                const acquired = await this.nativePaneLifecycle.acquire(() => {
-                    this.startupAdmission?.();
-                    if (this.startupAborted)
-                        throw Error("Native launch was superseded");
+                // Batch response for prune path
+                this.ipcServer?.send(socket, { type: "query_sessions_response", sessions });
+            }
+            else if (msg.type === "fleet_inbound") {
+                // Fleet manager routed a message to us (topic mode)
+                const meta = msg.meta;
+                const targetSession = msg.targetSession;
+                const deliveryEpoch = this.captureDeliveryEpoch(msg.delivery_epoch);
+                void this.wake().then(() => {
+                    this.pushChannelMessage(msg.content, meta, targetSession, deliveryEpoch);
+                }).catch(err => {
+                    this.deferDurableDelivery(meta, `target wake failed before pane submission: ${err.message}`);
+                    this.logger.error({ err: err.message }, "Wake failed for inbound delivery");
                 });
-                this.tmux = acquired.pane;
-                this.nativeTranscriptSource = acquired.source;
-                nativeDisposition = acquired.disposition;
-                this.lastSpawnAt = Date.now();
-                this.setProcessStatus("running");
-                this.bindInstanceStateOutputListener(this.tmux.getWindowId());
-                this.saveSessionId();
-                // New/resumed native processes can still be painting their first frame. Keep deliveries behind the same
-                // bounded dialog/readiness scan as local startup. An already-running reattachment may be busy: do not
-                // wait for that work to finish or inject a startup key into it.
-                if (acquired.disposition !== "reattached") {
-                    if (!await this.finishStartupScan(120_000))
-                        throw Error("Native CLI exited during startup; retained session was not replaced");
-                    this.startupAdmission?.();
-                    if (this.startupAborted || this.deliveryWritesStopping || !this.nativePaneLifecycle.current())
-                        throw Error("Native launch was superseded");
-                }
             }
-            finally {
-                this.endSpawn();
+            else if (msg.type === "raw_paste") {
+                this.handleRawPasteIpcMessage(msg);
             }
-        }
-        else {
-            // 2. Tmux — ensure session, create window if not alive
-            await this.paneHost.ensureSession(this.tmuxSessionName);
-            this.startupAdmission?.();
-            this.tmux = this.paneHost.bind(this.tmuxSessionName, "", resolveTmuxLogicalSize(this.config.terminal), this.controlClient);
-            // Strategy A: always start fresh Claude window (MCP server has no reconnection)
-            // Kill any existing window from previous run
-            const windowIdFile = join(this.instanceDir, "window-id");
-            if (existsSync(windowIdFile)) {
-                const savedId = readFileSync(windowIdFile, "utf-8").trim();
-                if (savedId) {
-                    const oldTmux = this.paneHost.bind(this.tmuxSessionName, savedId);
-                    if (await oldTmux.isWindowAlive()) {
-                        this.startupAdmission?.();
-                        await this.checkpointSessionId();
-                        this.startupAdmission?.();
-                        await oldTmux.killWindow();
-                        this.startupAdmission?.();
-                        this.logger.info({ savedId }, "Killed old tmux window for fresh start");
-                    }
-                }
+            else if (msg.type === "config_update") {
+                this.applyConfigUpdate(msg.config);
             }
-            const resumed = await this.spawnClaudeWindow();
-            this.startupAdmission?.();
-            this.isNewSession = !resumed;
-            if (!resumed) {
-                await this.injectSnapshotMessage(this.startupAdmission);
-                this.startupAdmission?.();
+            else if (msg.type === "steer") {
+                const meta = (msg.meta ?? {});
+                this.steerMessage(msg.content, meta, this.captureDeliveryEpoch(msg.delivery_epoch));
             }
-            else {
-                // Clean up stale snapshot file — resume restored full context, snapshot not needed
-                try {
-                    unlinkSync(join(this.instanceDir, "rotation-state.json"));
+            else if (msg.type === "btw") {
+                const meta = (msg.meta ?? {});
+                this.btwMessage(msg.content, meta, this.captureDeliveryEpoch(msg.delivery_epoch));
+            }
+            else if (msg.type === "fleet_schedule_trigger") {
+                const payload = msg.payload;
+                const meta = msg.meta;
+                const deliveryEpoch = this.captureDeliveryEpoch(msg.delivery_epoch);
+                void this.wake().then(() => this.pushChannelMessage(payload.message, meta, undefined, deliveryEpoch)).catch(err => {
+                    this.logger.error({ err: err.message }, "Wake failed for scheduled delivery");
+                });
+            }
+            else if (msg.type === "query_instance_state") {
+                void this.respondToInstanceStateQuery(msg, socket);
+            }
+        });
+        // 2. Tmux — ensure session, create window if not alive
+        await TmuxManager.ensureSession(this.tmuxSessionName);
+        this.startupAdmission?.();
+        this.tmux = new TmuxManager(this.tmuxSessionName, "", resolveTmuxLogicalSize(this.config.terminal), this.controlClient);
+        // Strategy A: always start fresh Claude window (MCP server has no reconnection)
+        // Kill any existing window from previous run
+        const windowIdFile = join(this.instanceDir, "window-id");
+        if (existsSync(windowIdFile)) {
+            const savedId = readFileSync(windowIdFile, "utf-8").trim();
+            if (savedId) {
+                const oldTmux = new TmuxManager(this.tmuxSessionName, savedId);
+                if (await oldTmux.isWindowAlive()) {
+                    this.startupAdmission?.();
+                    await this.checkpointSessionId();
+                    this.startupAdmission?.();
+                    await oldTmux.killWindow();
+                    this.startupAdmission?.();
+                    this.logger.info({ savedId }, "Killed old tmux window for fresh start");
                 }
-                catch { /* may not exist */ }
             }
         }
-        if (nativeDisposition)
-            this.isNewSession = nativeDisposition === "fresh";
+        const resumed = await this.spawnClaudeWindow();
+        this.startupAdmission?.();
+        this.isNewSession = !resumed;
+        if (!resumed) {
+            await this.injectSnapshotMessage(this.startupAdmission);
+            this.startupAdmission?.();
+        }
+        else {
+            // Clean up stale snapshot file — resume restored full context, snapshot not needed
+            try {
+                unlinkSync(join(this.instanceDir, "rotation-state.json"));
+            }
+            catch { /* may not exist */ }
+        }
         // #1209: conditional continuation for the turn interrupted by the last
         // restart, if the gates allow. Detached; the gate
         // consumes its one-shot marker first and never throws into boot.
-        const legacyResume = this.nativePaneLifecycle ? Promise.resolve("unknown") : this.maybeResumeInterruptedTurn().catch(() => "unknown");
+        const legacyResume = this.maybeResumeInterruptedTurn().catch(() => "unknown");
         const recoveryOwner = JSON.stringify(this.interactionOwner());
         void Promise.allSettled([legacyResume]).then(() => {
             if (JSON.stringify(this.interactionOwner()) === recoveryOwner) {
@@ -2669,7 +2916,7 @@ export class Daemon extends EventEmitter {
             // (statusline transcript); codex/kiro/opencode read their CLI's own
             // conversation store via a pluggable source. Backends with no known
             // source stay inert exactly as before.
-            this.transcriptMonitor = this.buildTranscriptMonitor(this.nativeTranscriptSource ?? createTranscriptSource(this.config.backend ?? "claude-code", this.config.working_directory, this.credentialProfileStore(), () => this.backend?.transcriptLaunch?.() ?? null));
+            this.transcriptMonitor = this.buildTranscriptMonitor(createTranscriptSource(this.config.backend ?? "claude-code", this.config.working_directory, this.credentialProfileStore(), () => this.backend?.transcriptLaunch?.() ?? null));
             const transcriptMonitor = this.transcriptMonitor;
             const transcriptFence = this.launchFenceEpoch;
             // Baseline in the isolate before this daemon accepts new work. A
@@ -2705,7 +2952,7 @@ export class Daemon extends EventEmitter {
                 this.publishActivity(null);
             });
             this.transcriptMonitor.on("api_error", (text, status, _at, errorKind) => this.noteClaudeApiError(text, status, errorKind));
-            this.transcriptMonitor.on("system_informational", (text) => this.noteClaudeInformational(text));
+            this.transcriptMonitor.on("system_informational", (text, at) => this.noteClaudeInformational(text, at));
             this.transcriptMonitor.on("user_prompt", () => this.noteClaudePrompt());
             this.transcriptMonitor.on("assistant_text", (text) => {
                 this.noteClaudeOutput();
@@ -2725,15 +2972,13 @@ export class Daemon extends EventEmitter {
             if (hangConfig?.enabled !== false) {
                 this.hangDetector = new HangDetector();
             }
-            if (!this.nativePaneLifecycle) {
-                // 8. Context guardian
-                const statusFile = join(this.instanceDir, "statusline.json");
-                this.guardian = new ContextGuardian(this.config.context_guardian ?? {}, this.logger, statusFile);
-                this.guardian.startWatching();
-                this.guardian.on("status_update", () => {
-                    this.saveSessionId();
-                });
-            }
+            // 8. Context guardian
+            const statusFile = join(this.instanceDir, "statusline.json");
+            this.guardian = new ContextGuardian(this.config.context_guardian ?? {}, this.logger, statusFile);
+            this.guardian.startWatching();
+            this.guardian.on("status_update", () => {
+                this.saveSessionId();
+            });
             // Context rotation removed: all CLI backends have built-in auto-compact.
             // Crash recovery (health check + respawn with snapshot) is retained below.
         }
@@ -2750,6 +2995,8 @@ export class Daemon extends EventEmitter {
             this.startErrorMonitor();
         }
         this.startInstanceStateMonitor();
+        // #3030: messages a gone CLI still had queued — judged by its transcript, redelivered once or reported.
+        void this.reconcileQueuedHandoffs().catch(err => this.logger.warn({ err }, "Queued hand-off reconciliation failed"));
         this.logger.info(`${this.name} ready`);
     }
     /**
@@ -2784,7 +3031,7 @@ export class Daemon extends EventEmitter {
                 this.socketPids.delete(socket);
                 // Notify fleet manager so it can clean up sessionRegistry
                 if (sessionName !== this.name) {
-                    this.broadcastFleetMessage({ type: "session_disconnected", sessionName });
+                    this.ipcServer?.broadcast({ type: "session_disconnected", sessionName });
                 }
             });
         }
@@ -2800,16 +3047,11 @@ export class Daemon extends EventEmitter {
             // sub-agent's server may have left a dead pid in the slot).
             this.noteMcpProofOfLife("mcp_ready", typeof msg.pid === "number" ? msg.pid : undefined);
         }
-        this.broadcastFleetMessage({ type: "mcp_ready", sessionName });
+        this.ipcServer?.broadcast({ type: "mcp_ready", sessionName });
     }
     checkMcpServerAlive() {
         if (this.isPaused)
             return;
-        if (this.nativePaneLifecycle) {
-            if (this.nativePaneLifecycle.mcpProof() === "alive")
-                this.noteMcpProofOfLife("connection");
-            return; // No native PID/socket guessing or restart from an unknown helper observation.
-        }
         const status = mcpServerState(this.instanceDir);
         if (status.state === "alive") {
             this.mcpServedGeneration = this.spawnGeneration;
@@ -2893,8 +3135,6 @@ export class Daemon extends EventEmitter {
      * server from a third-party one, and failed the whole launch for either.
      */
     checkFleetMcpNeverConnected() {
-        if (this.nativePaneLifecycle)
-            return; // Native helper presence owns this observation.
         if (this.config.agent_mode === "cli")
             return; // no MCP server by design
         if (this.lastSpawnAt === 0 || this.mcpServedGeneration === this.spawnGeneration)
@@ -3105,8 +3345,6 @@ export class Daemon extends EventEmitter {
      * proof that tools are being served, whatever channel.mcp.pid says.
      */
     mcpServerAlive() {
-        if (this.nativePaneLifecycle)
-            return this.nativePaneLifecycle.mcpProof() === "alive" ? { alive: true, source: "connection" } : { alive: false, source: "none" };
         const status = mcpServerState(this.instanceDir);
         if (status.state === "alive")
             return { alive: true, source: "pid", pid: status.pid };
@@ -3171,7 +3409,7 @@ export class Daemon extends EventEmitter {
         this.mcpDeathNotifiedForPid = null;
         this.mcpDeathDeferredForPid = null;
         this.clearMcpRestartRequest();
-        if (!this.nativePaneLifecycle && pid && mcpServerState(this.instanceDir).state !== "alive")
+        if (pid && mcpServerState(this.instanceDir).state !== "alive")
             this.repairMcpPidSlot(pid, source);
     }
     emitMcpRecovered(source, pid) {
@@ -3218,26 +3456,6 @@ export class Daemon extends EventEmitter {
                 // ended this instance's health loop because scheduleNext() sat after the
                 // throwing code. Catch, log, and keep checking.
                 try {
-                    if (this.nativePaneLifecycle) {
-                        if (this.healthCheckPaused) {
-                            scheduleNext();
-                            return;
-                        }
-                        const native = this.nativePaneLifecycle, pane = this.tmux;
-                        const status = await pane?.getPaneStatus();
-                        if (this.runtimeMonitorsFrozen || native !== this.nativePaneLifecycle || pane !== this.tmux)
-                            return;
-                        const snapshot = native.snapshot?.();
-                        if (status?.alive === false && snapshot?.state === "exited") {
-                            this.healthCheckPaused = true;
-                            this.setProcessStatus(snapshot.exitCode === 0 ? "stopped" : "crashed");
-                            this.emit("native_pane_exited", { name: this.name, snapshot, owner: this.interactionOwner() });
-                        }
-                        else if (status?.alive)
-                            this.checkMcpServerAlive();
-                        scheduleNext();
-                        return;
-                    }
                     // Instance directory removed externally (e.g. `rm -rf ~/.agend/instances/<name>`).
                     // Stop the loop permanently — otherwise every tick triggers a respawn, whose
                     // writeRotationSnapshot fails with ENOENT and gets caught as "Failed to respawn",
@@ -3253,8 +3471,6 @@ export class Daemon extends EventEmitter {
                         scheduleNext();
                         return;
                     }
-                    // The CLI owns the MCP server process, so the daemon can only observe it.
-                    measureSyncWork("daemon.healthCheck", () => this.checkMcpServerAlive());
                     // Human-readable backend label for logs (e.g. "claude", "kiro-cli")
                     const cliLabel = this.backend?.binaryName ?? "CLI";
                     const healthTmux = this.tmux;
@@ -3275,6 +3491,9 @@ export class Daemon extends EventEmitter {
                     if (discardStaleHealth())
                         return;
                     if (paneStatus?.alive) {
+                        // A CLI shutdown also closes its MCP children. Revive tools only for
+                        // a positively live pane, never while its exit is being classified.
+                        measureSyncWork("daemon.healthCheck", () => this.checkMcpServerAlive());
                         // Capture only a known primary while it lives. No extra tmux call: PID comes
                         // from this same status read. Fast/unobserved deaths remain ordinary crashes.
                         const key = this.oomSessionKey();
@@ -3321,6 +3540,29 @@ export class Daemon extends EventEmitter {
                             return;
                         }
                     }
+                    // tmux marks the PTY dead when its fd closes, before SIGCHLD can fill
+                    // pane_dead_status. Claude /exit (and any other CLI) can hit this gap.
+                    // Give the status four bounded re-probes; missing is never exit zero.
+                    if (paneStatus && !paneStatus.alive && paneStatus.exitCode === undefined) {
+                        for (let attempt = 0; attempt < 4; attempt++) {
+                            await new Promise(resolve => setTimeout(resolve, 250));
+                            if (discardStaleHealth())
+                                return;
+                            const observed = await healthTmux.getPaneStatus();
+                            if (discardStaleHealth())
+                                return;
+                            if (observed)
+                                paneStatus = observed;
+                            if (paneStatus.alive || paneStatus.exitCode !== undefined)
+                                break;
+                        }
+                        if (paneStatus.alive) {
+                            this.windowQueryFailureTicks = 0;
+                            this.stormWindow?.noteWindowAlive(this.name);
+                            scheduleNext();
+                            return;
+                        }
+                    }
                     // paneStatus === null → window gone entirely (e.g. tmux server crash)
                     // paneStatus.alive === false → pane dead, exit code available
                     const exitCode = paneStatus?.exitCode;
@@ -3349,13 +3591,13 @@ export class Daemon extends EventEmitter {
                     let inWindowLossBurst = false;
                     let nullReason;
                     if (!paneStatus) {
-                        const serverAlive = await this.paneHost.sessionExists(this.tmuxSessionName);
+                        const serverAlive = await TmuxManager.sessionExists(this.tmuxSessionName);
                         if (discardStaleHealth())
                             return;
                         // A server may have already restarted before this daemon's health
                         // tick. The new PID is the durable generation boundary: treat it as
                         // a fleet storm even though `has-session` is true again.
-                        const serverPid = serverAlive ? await this.paneHost.getServerPid(this.tmuxSessionName) : null;
+                        const serverPid = serverAlive ? await TmuxManager.getServerPid(this.tmuxSessionName) : null;
                         if (discardStaleHealth())
                             return;
                         const generationChanged = serverAlive && this.stormWindow?.observeServerAlive(serverPid) === true;
@@ -3384,7 +3626,7 @@ export class Daemon extends EventEmitter {
                             // the window truly no longer exists vs a transient query glitch.
                             nullReason = "no_window";
                             try {
-                                const windows = await this.paneHost.listWindowsStrict(this.tmuxSessionName, this.controlClient);
+                                const windows = await TmuxManager.listWindowsStrict(this.tmuxSessionName, this.controlClient);
                                 if (discardStaleHealth())
                                     return;
                                 this.windowQueryFailureTicks = 0;
@@ -3504,6 +3746,8 @@ export class Daemon extends EventEmitter {
                             try {
                                 await this.spawnClaudeWindow();
                                 this.setProcessStatus("running");
+                                // #3030: messages a gone CLI still had queued — judged by its transcript, redelivered once or reported.
+                                void this.reconcileQueuedHandoffs().catch(err => this.logger.warn({ err }, "Queued hand-off reconciliation failed"));
                                 this.logger.info("Recovered from background session conflict");
                                 this.emit("crash_respawn", this.name);
                             }
@@ -3629,10 +3873,10 @@ export class Daemon extends EventEmitter {
                         // Wrapped in try-catch: if tmux server is dead, listWindows throws —
                         // must not block spawnClaudeWindow (which calls ensureSession).
                         try {
-                            const windows = await this.paneHost.listWindows(this.tmuxSessionName);
+                            const windows = await TmuxManager.listWindows(this.tmuxSessionName);
                             for (const w of windows) {
                                 if (w.name === this.name) {
-                                    const tm = this.paneHost.bind(this.tmuxSessionName, w.id);
+                                    const tm = new TmuxManager(this.tmuxSessionName, w.id);
                                     await tm.killWindow();
                                 }
                             }
@@ -3663,6 +3907,8 @@ export class Daemon extends EventEmitter {
                             catch { /* may not exist */ }
                         }
                         this.setProcessStatus("running");
+                        // #3030: messages a gone CLI still had queued — judged by its transcript, redelivered once or reported.
+                        void this.reconcileQueuedHandoffs().catch(err => this.logger.warn({ err }, "Queued hand-off reconciliation failed"));
                         this.logger.info({ resumed }, `Respawned ${cliLabel} window after crash`);
                         this.emit("crash_respawn", this.name);
                         // Emit the per-instance audit event while the storm is still active
@@ -3775,7 +4021,7 @@ export class Daemon extends EventEmitter {
             // Force the next ready capture to emit a fresh transition after respawn.
             this.instanceState = "working";
         }
-        this.broadcastFleetMessage({
+        this.ipcServer?.broadcast({
             type: "instance_process_state",
             instanceName: this.name,
             status,
@@ -3971,15 +4217,12 @@ export class Daemon extends EventEmitter {
                         for (const key of dialog.keys) {
                             if (stale())
                                 return;
-                            const keyScreen = this.nativePaneLifecycle ? await pollTmux.capturePane() : currentPane;
-                            if (stale() || !Daemon.dialogMatches(dialog, keyScreen))
-                                return;
                             let sent = false;
                             if (SPECIAL_KEYS.has(key)) {
-                                sent = await (this.nativePaneLifecycle ? pollTmux.sendSpecialKey(key, undefined, { kind: "dialog", screen: keyScreen }) : pollTmux.sendSpecialKey(key));
+                                sent = await pollTmux.sendSpecialKey(key);
                             }
                             else if (dialog.literalKeys) {
-                                sent = await (this.nativePaneLifecycle ? pollTmux.sendKeys(key, { kind: "dialog", screen: keyScreen }) : pollTmux.sendKeys(key)); // typed, no Enter (#2872)
+                                sent = await pollTmux.sendKeys(key); // typed, no Enter (#2872)
                             }
                             else {
                                 sent = await pollTmux.pasteText(key, this.systemPasteOptions());
@@ -4179,7 +4422,13 @@ export class Daemon extends EventEmitter {
         for (const ep of patterns) {
             const key = Daemon.errorPatternKey(ep);
             const count = countMatches(ep.pattern);
-            const seen = this.lastErrorCount.get(key) ?? 0;
+            let seen = this.lastErrorCount.get(key) ?? 0;
+            const afterInput = this.quotaOccurrencesAfterInput(pane, ep);
+            // Only a new echo of our acknowledged input can re-arm a same-count replacement. Old rows before that echo,
+            // an ambiguous/missing marker or a superseded input owner retain the ordinary count-based decision.
+            const newQuotaAfterInput = !!afterInput && afterInput.count > (afterInput.input.reported.get(key) ?? 0);
+            if (newQuotaAfterInput)
+                seen = Math.min(seen, count - 1);
             // #2282: a resumed exhausted429 row is history, not even a new
             // notification/failover incident; so is a resumed codex workspace-limit row
             // (#2844: a wake must not pause again on it). Wait for the first live
@@ -4201,7 +4450,7 @@ export class Daemon extends EventEmitter {
             // the lifecycle, whose usage probe decides (available / reserve / exhausted).
             if (Daemon.isCodexUsageLimitPause(ep)) {
                 const ack = this.codexReserveAck;
-                if (ack && ack.generation === this.spawnGeneration && count <= ack.count) {
+                if (ack && ack.generation === this.spawnGeneration && count <= ack.count && !newQuotaAfterInput) {
                     // The handled incident's lines can scroll out of the capture buffer as
                     // the reserve session talks on. Lower the proof (and the occurrence
                     // baseline) with them: otherwise `count <= ack.count` would keep
@@ -4242,6 +4491,8 @@ export class Daemon extends EventEmitter {
                 continue;
             }
             this.lastErrorCount.set(key, count);
+            if (afterInput)
+                afterInput.input.reported.set(key, Math.max(afterInput.input.reported.get(key) ?? 0, afterInput.count));
             // Kiro's `auto` model picks a concrete model per turn and reroutes around
             // a temporarily unavailable one on its own — telling the user to run
             // /model would ask them to fix something the CLI is already handling.
@@ -4342,20 +4593,7 @@ export class Daemon extends EventEmitter {
      */
     async sendEscape() {
         const cancelKey = this.backend?.getCancelKey() ?? "Escape";
-        const tmux = this.tmux;
-        if (!tmux)
-            return;
-        if (this.nativePaneLifecycle) {
-            // A native pane's composer proof cannot see a permission dialog, so an unproved key is withheld there. The cancel
-            // is the person's own interrupt, keyed on the screen read just before (as the dialog answer path is): what Esc
-            // does on Linux's tmux pane, on the same screen, with the same key.
-            const screen = await tmux.capturePane().catch(() => null);
-            if (screen === null)
-                return;
-            await tmux.sendSpecialKey(cancelKey, undefined, { kind: "dialog", screen });
-            return;
-        }
-        await tmux.sendSpecialKey(cancelKey);
+        await this.tmux?.sendSpecialKey(cancelKey);
     }
     /**
      * Drop every not-yet-started pane delivery which predates a user cancel.
@@ -4375,6 +4613,14 @@ export class Daemon extends EventEmitter {
         // (Completion paths clear via the guard's onComplete; a cancel with no
         // later idle edge would otherwise leave the marker behind.)
         clearInFlightTurnMarker(this.instanceDir);
+        // #3030: what the person cancelled is not kept for a redelivery (nor reported as not taken).
+        try {
+            for (const entry of this.handoffStore().list())
+                this.handoffStore().remove(entry.id);
+        }
+        catch (err) {
+            this.logger.warn({ err }, "Could not clear queued hand-off records on cancel");
+        }
         this.deliveryEpoch = fleetEpoch === undefined
             ? this.deliveryEpoch + 1
             : Math.max(this.deliveryEpoch, fleetEpoch);
@@ -4413,7 +4659,7 @@ export class Daemon extends EventEmitter {
                 return;
             const outcome = follower.look(pane);
             if (outcome) {
-                this.broadcastFleetMessage({ type: "compact_pane_result", id, owner, outcome });
+                this.ipcServer?.broadcast({ type: "compact_pane_result", id, owner, outcome });
                 return;
             }
         }
@@ -4433,7 +4679,7 @@ export class Daemon extends EventEmitter {
         const reportSwitch = (result) => {
             if (!ownSwitch)
                 return;
-            this.broadcastFleetMessage({ type: "runtime_switch_result", id: ownSwitch.id, ...result });
+            this.ipcServer?.broadcast({ type: "runtime_switch_result", id: ownSwitch.id, ...result });
         };
         // Board 003648ac: the fleet follows a web /compact from just before its paste is written: the transcript's end then
         // (taken here, under this launch, before the write) and the launch it was written under ride with the notice — once.
@@ -4448,7 +4694,7 @@ export class Daemon extends EventEmitter {
             if (!notifyWritten || told)
                 return;
             told = true;
-            this.broadcastFleetMessage({ type: "raw_paste_written", id: notifyWritten, outcome: written ? "written" : "not_written",
+            this.ipcServer?.broadcast({ type: "raw_paste_written", id: notifyWritten, outcome: written ? "written" : "not_written",
                 ...(written ? { owner, checkpoint, ...(paneFollower ? { pane: true } : {}) } : {}) });
             if (written && paneFollower)
                 void this.followCompactPane(notifyWritten, owner, paneFollower);
@@ -4610,11 +4856,10 @@ export class Daemon extends EventEmitter {
         const press = (target, cursor, key) => this.paneWriteLock.run(async () => {
             if (this.tmux !== tmux)
                 return false;
-            const screen = await read();
-            const now = claudeSwitchDialog(screen);
+            const now = claudeSwitchDialog(await read());
             if (!now || now.kind !== "model" || now.target !== target || (cursor !== null && now.cursor !== cursor))
                 return false;
-            return this.nativePaneLifecycle ? tmux.sendSpecialKey(key, undefined, { kind: "dialog", screen }) : tmux.sendSpecialKey(key);
+            return tmux.sendSpecialKey(key);
         });
         const gone = async () => {
             const until = performance.now() + OWN_SWITCH_SETTLE_MS;
@@ -4703,12 +4948,9 @@ export class Daemon extends EventEmitter {
                         return false;
                     const specialKeys = new Set(["Up", "Down", "Enter", "Escape", "Right", "Left"]);
                     for (const key of dialog.keys) {
-                        const keyScreen = this.nativePaneLifecycle ? await this.tmux.capturePane() : currentPane;
-                        if (!matches(keyScreen))
-                            return false;
                         const ok = specialKeys.has(key)
-                            ? await (this.nativePaneLifecycle ? this.tmux.sendSpecialKey(key, undefined, { kind: "dialog", screen: keyScreen }) : this.tmux.sendSpecialKey(key))
-                            : await (this.nativePaneLifecycle ? this.tmux.sendKeys(key, { kind: "dialog", screen: keyScreen }) : this.tmux.sendKeys(key));
+                            ? await this.tmux.sendSpecialKey(key)
+                            : await this.tmux.sendKeys(key);
                         if (!ok)
                             return false;
                         await new Promise(resolve => setTimeout(resolve, 100));
@@ -4951,7 +5193,7 @@ export class Daemon extends EventEmitter {
         await this.tmux.sendSpecialKey("Escape").catch(() => false);
         return true;
     }
-    async stop(options = {}) {
+    async stop() {
         this.publishWorkingState("before_stop");
         this.logger.info("Stopping daemon instance");
         this.clearQuitRelaunchWatch();
@@ -4973,18 +5215,8 @@ export class Daemon extends EventEmitter {
         }
         if (this.adapter)
             await this.adapter.stop();
-        if (this.nativePaneLifecycle) {
-            this.healthCheckPaused = true;
-            this.saveSessionId();
-            await this.nativePaneLifecycle.release(options.nativePane ?? "detach");
-            try {
-                unlinkSync(join(this.instanceDir, "daemon.pid"));
-            }
-            catch { /* metadata only */ }
-            return;
-        }
         // Notify MCP servers of graceful shutdown (prevents reconnect attempts)
-        this.broadcastFleetMessage({ type: "shutdown" });
+        this.ipcServer?.broadcast({ type: "shutdown" });
         // Quit CLI FIRST — this kills MCP server child processes cleanly.
         // IPC must stay open during quit so MCP servers receive the shutdown message.
         if (this.tmux) {
@@ -5130,24 +5362,6 @@ export class Daemon extends EventEmitter {
             freshChoice: this.recoveryFreshChoice || this.isNewSession && !this.bootSkippedResume, crashLoopFresh: this.recoveryCrashLoopFresh,
             cancelled: this.recoveryCancelled, background: this.workingBackgroundObservation };
     }
-    /** Observe this host General before its approved switch. No keys, process signals or provider writes. */
-    async generalHostOwner() {
-        const pane = this.tmux, owner = JSON.stringify(this.interactionOwner());
-        if (!this.config.general_topic || this.nativePaneLifecycle || !pane || !/^@\d+$/.test(pane.getWindowId()))
-            throw Error("General host owner is unavailable");
-        const status = await pane.getPaneStatus();
-        if (!status?.alive || !status.pid || status.pid <= 1)
-            throw Error("General host process cannot be proven");
-        const checkpoint = await this.transcriptMonitor?.reconciliationCheckpoint();
-        if (this.tmux !== pane || owner !== JSON.stringify(this.interactionOwner()))
-            throw Error("General host owner changed during observation");
-        const backend = this.config.backend ?? "claude-code";
-        let sessionId = this.backend?.getSessionId() ?? undefined;
-        if (backend === "codex" && checkpoint)
-            sessionId = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i.exec(checkpoint.path)?.[1];
-        return { kind: "tmux", windowId: pane.getWindowId(), pid: status.pid,
-            ...(typeof sessionId === "string" && sessionId.length > 0 && sessionId.length <= 256 && !/[\p{Cc}\p{Cf}]/u.test(sessionId) ? { pin: { backend, sessionId } } : {}) };
-    }
     /** Local system work: no user turn, channel reply target, wake or replay of an original request. */
     async deliverWorkingRecovery(content, delivery, admitted) {
         const tmux = this.tmux, owner = JSON.stringify(this.interactionOwner()), epoch = this.deliveryEpoch;
@@ -5168,11 +5382,7 @@ export class Daemon extends EventEmitter {
                     || !this.paneAuthoritativelyIdle(pane) || this.inputTransientInPane(pane)
                     || this.backend?.backgroundWorkRunning?.(pane) === true)
                     return;
-                if (this.nativePaneLifecycle ? !this.nativePaneLifecycle.current() || this.nativePaneLifecycle.mcpProof() !== "alive"
-                    || !!this.backend?.isDeliveryInputReadyPane && !this.backend.isDeliveryInputReadyPane(pane)
-                    : await tmux.getPaneInputMode?.() !== "raw")
-                    return;
-                if (!current())
+                if (await tmux.getPaneInputMode?.() !== "raw" || !current())
                     return;
                 const evidence = await this.durableAttemptEvidence(tmux.getWindowId(), false, false);
                 if (!current())
@@ -5263,7 +5473,7 @@ export class Daemon extends EventEmitter {
             this.logger.debug({ err }, "Interaction listener failed");
         }
         try {
-            this.broadcastFleetMessage({ type: "instance_interaction", instanceName: this.name, interaction });
+            this.ipcServer?.broadcast({ type: "instance_interaction", instanceName: this.name, interaction });
         }
         catch (err) {
             this.logger.debug({ err }, "Interaction broadcast failed");
@@ -5351,56 +5561,6 @@ export class Daemon extends EventEmitter {
         }
         return true;
     }
-    /** Shared Fleet inputs: socket and native transports retain the same wake, epoch and raw-paste semantics. */
-    handleFleetMessage(msg, send, current = () => true) {
-        if (msg.type === "query_sessions") {
-            send({ type: "query_sessions_response", sessions: [] });
-        }
-        else if (msg.type === "fleet_inbound") {
-            const meta = msg.meta;
-            const targetSession = msg.targetSession;
-            const deliveryEpoch = this.captureDeliveryEpoch(msg.delivery_epoch);
-            void this.wake().then(() => {
-                if (!current()) {
-                    this.deferDurableDelivery(meta, "native channel owner changed before pane submission");
-                    return;
-                }
-                this.pushChannelMessage(msg.content, meta, targetSession, deliveryEpoch);
-            }).catch(err => {
-                this.deferDurableDelivery(meta, `target wake failed before pane submission: ${err.message}`);
-                this.logger.error({ err: err.message }, "Wake failed for inbound delivery");
-            });
-        }
-        else if (msg.type === "raw_paste") {
-            this.handleRawPasteIpcMessage(msg);
-        }
-        else if (msg.type === "config_update") {
-            this.applyConfigUpdate(msg.config);
-        }
-        else if (msg.type === "steer") {
-            const meta = (msg.meta ?? {});
-            this.steerMessage(msg.content, meta, this.captureDeliveryEpoch(msg.delivery_epoch));
-        }
-        else if (msg.type === "btw") {
-            const meta = (msg.meta ?? {});
-            this.btwMessage(msg.content, meta, this.captureDeliveryEpoch(msg.delivery_epoch));
-        }
-        else if (msg.type === "fleet_schedule_trigger") {
-            const payload = msg.payload;
-            const meta = msg.meta;
-            const deliveryEpoch = this.captureDeliveryEpoch(msg.delivery_epoch);
-            void this.wake().then(() => { if (current())
-                this.pushChannelMessage(payload.message, meta, undefined, deliveryEpoch); }).catch(err => {
-                this.logger.error({ err: err.message }, "Wake failed for scheduled delivery");
-            });
-        }
-        else if (msg.type === "query_instance_state") {
-            void this.respondToInstanceStateQuery(msg, undefined, send);
-        }
-        else
-            return false;
-        return true;
-    }
     /**
      * Answer a FleetManager state query. Most callers only need the cached state,
      * but lifecycle decisions such as post-reply Cancel retirement need an
@@ -5408,7 +5568,7 @@ export class Daemon extends EventEmitter {
      * the last transition can stay "working" even though the CLI has since
      * settled without emitting another control-mode output record.
      */
-    async respondToInstanceStateQuery(msg, socket, send) {
+    async respondToInstanceStateQuery(msg, socket) {
         try {
             if (msg.deliveryIdle === true) {
                 await this.captureAndEvaluateInstanceState("delivery_idle_gate");
@@ -5417,7 +5577,7 @@ export class Daemon extends EventEmitter {
                 await this.captureAndEvaluateInstanceState("state_query");
             }
             const snapshot = this.getInstanceStateSnapshot();
-            const reply = {
+            this.ipcServer?.send(socket, {
                 type: "instance_state_response",
                 requestId: msg.requestId,
                 instanceName: this.name,
@@ -5425,11 +5585,7 @@ export class Daemon extends EventEmitter {
                 state: this.isPaused ? "paused" : snapshot.state,
                 processStatus: this.processStatus,
                 pausedAt: this.lastPausedAt,
-            };
-            if (send)
-                send(reply);
-            else if (socket)
-                this.ipcServer?.send(socket, reply);
+            });
         }
         catch (err) {
             this.logger.debug({ err: err.message }, "Instance state query failed");
@@ -5469,49 +5625,7 @@ export class Daemon extends EventEmitter {
     static AUTH_RECONFIRM_ROWS = 15;
     /** Why the deferred pause was requested; what its marker records (Phase 2a). */
     pendingPauseReason = "auth";
-    nativePauseProof = null;
-    /** Consume the exact idle proof synchronously after the lifecycle's await, before fencing and closing. */
-    nativePauseStillReady() {
-        const proof = this.nativePauseProof;
-        this.nativePauseProof = null;
-        if (proof?.())
-            return true;
-        this.pauseRequested = false;
-        return false;
-    }
-    /** Native lifecycle pause uses the ordinary idle/background/admission proof before closing its owned Job. */
-    async nativePauseReady(admission) {
-        this.nativePauseProof = null;
-        const native = this.nativePaneLifecycle, pane = this.tmux, owner = this.interactionOwner();
-        const allowStuck = this.pauseAllowStuck;
-        this.pauseAllowStuck = false;
-        const ready = () => !!native && native === this.nativePaneLifecycle && native.current() && this.tmux === pane
-            && sameInteractionOwner(owner, this.interactionOwner()) && !this.runtimeMonitorsFrozen && !this.spawning
-            && this.processStatus === "running" && this.pasteQueueDepth === 0
-            && (this.instanceState === "idle" || allowStuck && this.instanceState === "stuck") && (!admission || admission.current());
-        if (!pane || !ready()) {
-            this.pauseRequested = false;
-            return false;
-        }
-        let text;
-        try {
-            text = await pane.capturePane();
-        }
-        catch {
-            this.pauseRequested = false;
-            return false;
-        }
-        if (!ready() || admission && !admission.accepts(text) || this.backend?.backgroundWorkRunning?.(text)
-            || !allowStuck && !this.paneAuthoritativelyIdle(text)) {
-            this.pauseRequested = false;
-            return false;
-        }
-        this.nativePauseProof = ready;
-        return true;
-    }
     async pause(reason = "operator", admission) {
-        if (this.nativePaneLifecycle)
-            throw Error("Native pause is owned by its Fleet lifecycle transition");
         if (admission && !admission.current())
             return;
         if (this.pauseWakeState === "paused")
@@ -5607,7 +5721,7 @@ export class Daemon extends EventEmitter {
                 writePausedMarker(this.instanceDir, this.lastPausedAt ?? Date.now(), reason);
                 this.publishWorkingState("execution");
                 this.logger.info({ pausedAt: this.lastPausedAt }, "Instance auto-paused");
-                this.broadcastFleetMessage({
+                this.ipcServer?.broadcast({
                     type: "instance_state", instanceName: this.name, state: "paused", pausedAt: this.lastPausedAt,
                 });
                 this.emit("auto_paused", { name: this.name, pausedAt: this.lastPausedAt });
@@ -5702,7 +5816,7 @@ export class Daemon extends EventEmitter {
                 this.resumeRuntimeMonitors();
                 this.publishWorkingState("execution");
                 this.logger.info("Instance auto-woke");
-                this.broadcastFleetMessage({
+                this.ipcServer?.broadcast({
                     type: "instance_state", instanceName: this.name, state: this.instanceState, pausedAt: null,
                 });
                 this.emit("auto_woke", { name: this.name });
@@ -5803,6 +5917,10 @@ export class Daemon extends EventEmitter {
         if (snapshot.state === "working" && this.recoveryBootSettled
             && this.workingRecoveryInputOwner !== JSON.stringify(this.interactionOwner()))
             this.recoveryNativeWork = true;
+        if (snapshot.state !== "idle")
+            this.instanceIdleSinceMono = null;
+        else if (this.instanceState !== "idle" || this.instanceIdleSinceMono === null)
+            this.instanceIdleSinceMono = performance.now();
         this.instanceState = snapshot.state;
         this.acceptedInstanceSnapshot = { ...snapshot };
         // Reuse an already-captured pane and the backend's pure parser, never capture for the journal.
@@ -5862,7 +5980,7 @@ export class Daemon extends EventEmitter {
             this.logStateEdge(previous, snapshot);
             this.publishWorkingState("execution");
             this.emit("instance_state", { name: this.name, ...snapshot });
-            this.broadcastFleetMessage({ type: "instance_state", instanceName: this.name, ...snapshot });
+            this.ipcServer?.broadcast({ type: "instance_state", instanceName: this.name, ...snapshot });
             if (snapshot.state === "stuck" && pane && this.instanceStateReadyPattern) {
                 this.handleStuckTransition(pane, snapshot, this.instanceStateReadyPattern);
             }
@@ -5914,7 +6032,7 @@ export class Daemon extends EventEmitter {
      * message can arrive mid-turn and sit queued, and marking at arrival would let
      * the PREVIOUS turn's idle edge consume (and reset) the new turn's state.
      */
-    markTurnStarted(meta, deliveredText, deliveryEpoch = this.deliveryEpoch) {
+    markTurnStarted(meta, deliveredText, deliveryEpoch = this.deliveryEpoch, queuedHandoff = false) {
         // Cancel may have interrupted an in-flight paste before its promise settled.
         // Its late success must not re-arm the turn that the user just cancelled.
         if (!this.isDeliveryEpochCurrent(deliveryEpoch))
@@ -5962,7 +6080,9 @@ export class Daemon extends EventEmitter {
         // during the continuation boots clean instead of chaining resumes.
         // #2544: a reply that settled before this arm already answered the person —
         // writing a marker would re-inject a continuation for a finished turn.
-        if (!this.nativePaneLifecycle && !meta.resumedContinuationOf && !armed.completionDelivered) {
+        // #3030: a message only queued in the busy CLI has not started a turn: the interrupted turn is still the running one,
+        // and a queued message lost to a restart is the hand-off record's to redeliver, not a continuation's.
+        if (!meta.resumedContinuationOf && !armed.completionDelivered && !queuedHandoff) {
             const resumeBackend = this.config.backend ?? this.backend?.binaryName ?? this.runtimeIdentity?.backend;
             const resumeCwd = this.config.working_directory ?? "";
             writeInFlightTurnMarker(this.instanceDir, {
@@ -6194,7 +6314,7 @@ export class Daemon extends EventEmitter {
         // outbound action suppresses a duplicate proxy; only a delivered
         // human-facing channel action satisfies the completion guard below.
         if (!turn.outboundDelivered && this.config.mcp_proxy_reply === true
-            && (this.nativePaneLifecycle ? this.nativePaneLifecycle.mcpProof() === "dead" : mcpServerState(this.instanceDir).state === "dead")) {
+            && mcpServerState(this.instanceDir).state === "dead") {
             this.turnReplyGuard.complete(turn.generation);
             void this.sendProxyReply(pane, turn.target);
             return;
@@ -6571,7 +6691,7 @@ export class Daemon extends EventEmitter {
                 }
             });
         }
-        if (!this.fleetTransportAvailable()) {
+        if (!this.ipcServer) {
             this.logger.error(`${logLabel} failed — no adapter or fleet IPC route`);
             return Promise.resolve(false);
         }
@@ -6595,7 +6715,7 @@ export class Daemon extends EventEmitter {
                 resolve(delivered);
             });
             try {
-                this.broadcastFleetMessage({
+                this.ipcServer.broadcast({
                     type: "fleet_outbound",
                     tool: "reply",
                     args,
@@ -7166,7 +7286,7 @@ export class Daemon extends EventEmitter {
         if (next === this.currentActivity)
             return;
         this.currentActivity = next;
-        this.broadcastFleetMessage({
+        this.ipcServer?.broadcast({
             type: "instance_activity",
             instanceName: this.name,
             activity: next,
@@ -7219,6 +7339,10 @@ export class Daemon extends EventEmitter {
         else if (update.reply_completion_guard === null) {
             delete this.config.reply_completion_guard;
         }
+        if (update.quota_notice === null)
+            delete this.config.quota_notice;
+        else if (update.quota_notice !== undefined && !quotaNoticeProblem(update.quota_notice))
+            this.config.quota_notice = structuredClone(update.quota_notice);
         if (typeof update.mcp_proxy_reply === "boolean")
             this.config.mcp_proxy_reply = update.mcp_proxy_reply;
         else if (update.mcp_proxy_reply === null)
@@ -7243,7 +7367,7 @@ export class Daemon extends EventEmitter {
             else
                 this.config.auto_pause_after = nextAutoPause;
             if (nextAutoPause !== previousAutoPause) {
-                const isGeneral = this.config.general_topic === true || generalByName(this.name, this.config);
+                const isGeneral = this.config.general_topic === true || this.name === "general";
                 this.autoPauseController.reconfigure((isGeneral ? 0 : nextAutoPause) * 60_000);
             }
         }
@@ -7323,7 +7447,7 @@ export class Daemon extends EventEmitter {
             return;
         this.lastProgressBroadcast = rendered;
         this.lastProgressBroadcastAt = Date.now();
-        this.broadcastFleetMessage({
+        this.ipcServer?.broadcast({
             type: "instance_progress",
             instanceName: this.name,
             progress: rendered,
@@ -7339,7 +7463,7 @@ export class Daemon extends EventEmitter {
         if (this.lastProgressBroadcast !== "") {
             this.lastProgressBroadcast = "";
             this.lastProgressBroadcastAt = Date.now();
-            this.broadcastFleetMessage({ type: "instance_progress", instanceName: this.name, progress: "" });
+            this.ipcServer?.broadcast({ type: "instance_progress", instanceName: this.name, progress: "" });
         }
     }
     /**
@@ -7367,10 +7491,12 @@ export class Daemon extends EventEmitter {
         // Command name only — never the arguments. See shellCommandLabel.
         if (name === "Bash")
             return `$ ${shellCommandLabel(String(inp.command ?? ""))}`;
+        // The tool name only — never the search pattern: it can be a literal secret someone is looking for, and this label
+        // reaches the channel's progress line.
         if (name === "Glob")
-            return `Glob ${inp.pattern ?? ""}`;
+            return "Glob";
         if (name === "Grep")
-            return `Grep ${inp.pattern ?? ""}`;
+            return "Grep";
         if (name === "Agent")
             return "Agent (subagent)";
         if (name.startsWith("mcp__agend__"))
@@ -7504,7 +7630,7 @@ export class Daemon extends EventEmitter {
     reportCrossInstanceDeliveryFailure(meta, verdict, error) {
         if (!meta.from_instance)
             return;
-        this.broadcastFleetMessage({
+        this.ipcServer?.broadcast({
             type: "cross_instance_delivery_failed",
             senderSession: meta.from_instance,
             targetInstance: this.name,
@@ -7741,6 +7867,13 @@ export class Daemon extends EventEmitter {
                 if (!this.isDeliveryEpochCurrent(deliveryEpoch)) {
                     this.logger.info("Pending channel delivery dropped by user cancel");
                     this.deferDurableDelivery(meta, "delivery epoch changed while queued");
+                    // #3030: a cancel is the person's — a queued redelivery it dropped is not redelivered later.
+                    if (meta.handoff_redelivery && !this.deliveryWritesStopping) {
+                        try {
+                            this.handoffStore().remove(meta.handoff_redelivery);
+                        }
+                        catch { /* the next CLI judges it */ }
+                    }
                     return;
                 }
                 if (this.config.pre_task_command) {
@@ -7751,13 +7884,26 @@ export class Daemon extends EventEmitter {
                 // #2800: with this real message, in the same paste — never a paste or turn of its own: after its delivery marker
                 // (transcript proof anchors on it), before the message. A person's message with a verified receipt is pasted
                 // byte for byte (its proof is the wire's hash), so the notice waits for the next delivery without one.
-                const whatsNew = this.pendingWhatsNew && !meta.human_receipt_id ? this.currentWhatsNew(this.pendingWhatsNew) : null;
+                const whatsNew = this.pendingWhatsNew && !meta.human_receipt_id && !meta.handoff_redelivery
+                    ? this.currentWhatsNew(this.pendingWhatsNew) : null;
                 const pasted = whatsNew ? withWhatsNew(formatted, whatsNew.notice) : formatted;
                 const status = channelStatus(meta);
                 // A fresh delivery begins a fresh turn — its bubble must not inherit
                 // the previous turn's tool list.
                 this.resetToolProgress();
                 verdict = { reached: false, humanReceipt: this.humanReceiptAttempt(meta, formatted) };
+                // #3030: a hand-off into the CLI's own queue stays on record until a turn takes it (redeliveries included).
+                if (!content.startsWith("/raw ") || meta.from_instance) {
+                    const { handoff_redelivery: redeliveryOf, handoff_redeliveries: redeliveries, handoff_holder: _holder, ...kept } = meta;
+                    verdict.trackHandoff = { content, meta: kept,
+                        ...(redeliveryOf ? { id: redeliveryOf, redeliveries: Number(redeliveries) || 0 } : {}) };
+                }
+                // #3030: a redelivery is written only by the CLI it was issued for, and only while its record still says so —
+                // one queued for a CLI that was replaced meanwhile is that next CLI's reconciliation's to judge again.
+                if (meta.handoff_redelivery && !this.redeliveryStillOurs(meta)) {
+                    this.logger.info({ handoff: meta.handoff_redelivery }, "Queued hand-off redelivery dropped: its CLI was replaced before the write");
+                    return;
+                }
                 const durableAttempt = this.durableDeliveryAttempt(meta, content);
                 if (durableAttempt === false) {
                     this.deferDurableDelivery(meta, "invalid durable delivery attempt metadata");
@@ -7780,10 +7926,11 @@ export class Daemon extends EventEmitter {
                     if (whatsNew && (sent || verdict.paneWriteStarted))
                         this.recordWhatsNewSent(whatsNew);
                 }
+                this.afterTrackedWrite(meta, verdict, !!sent, deliveryEpoch);
                 if (sent) {
                     delivered = true;
                     this.finishDurableSubmission(durable, verdict);
-                    this.markTurnStarted(meta, formatted, deliveryEpoch);
+                    this.markTurnStarted(meta, formatted, deliveryEpoch, !!verdict.handoff);
                 }
                 else if (durableAttempt && verdict.paneWriteStarted) {
                     this.finishDurableDelivery(durable, "uncertain", `${verdict.phase ?? "post-submit"}:${verdict.proof ?? "unproven"}`, verdict);
@@ -8864,14 +9011,13 @@ export class Daemon extends EventEmitter {
         if (this.remoteCardAnswering)
             return { outcome: "refused", reason: "another answer to this card is being keyed in" };
         this.remoteCardAnswering = true;
-        let answerScreen = null;
         try {
             const outcome = await answerRemoteCard({
                 locked: fn => this.paneWriteLock.run(fn),
                 // An unreadable screen (a failed capture, another spawn's pane) is unknown — never "the card closed".
-                read: async () => answerScreen = this.tmux === tmux ? await tmux.capturePane().catch(() => null) : null,
-                key: key => this.tmux !== tmux || answerScreen === null ? Promise.resolve(false) : key === "Space" ? (this.nativePaneLifecycle ? tmux.sendKeys(" ", { kind: "dialog", screen: answerScreen }) : tmux.sendKeys(" ")) : (this.nativePaneLifecycle ? tmux.sendSpecialKey(key, undefined, { kind: "dialog", screen: answerScreen }) : tmux.sendSpecialKey(key)),
-                paste: text => this.tmux !== tmux || answerScreen === null ? Promise.resolve(false) : this.nativePaneLifecycle ? tmux.pasteBuffer(text, { proof: { kind: "dialog", screen: answerScreen } }) : tmux.pasteBuffer(text),
+                read: () => this.tmux === tmux ? tmux.capturePane().catch(() => null) : Promise.resolve(null),
+                key: key => this.tmux !== tmux ? Promise.resolve(false) : key === "Space" ? tmux.sendKeys(" ") : tmux.sendSpecialKey(key),
+                paste: text => this.tmux !== tmux ? Promise.resolve(false) : tmux.pasteBuffer(text),
                 sleep: ms => new Promise(resolve => setTimeout(resolve, ms)),
                 now: () => performance.now(),
             }, pane => {
@@ -9142,19 +9288,12 @@ export class Daemon extends EventEmitter {
         if (!check || !this.tmux)
             return !check;
         try {
-            const inputActive = this.nativePaneLifecycle
-                ? this.nativePaneLifecycle.current() && this.nativePaneLifecycle.mcpProof() === "alive"
-                : await this.tmux.getPaneInputMode?.() === "raw";
-            // ConPTY has no POSIX termios mode. Its closed launch plus current helper handshake is the input barrier;
-            // the same strict composer detector below is still required. Never grant native unknown-layout fallback.
-            if (!inputActive) {
+            const mode = await this.tmux.getPaneInputMode?.();
+            if (mode !== "raw") {
                 this.resetFooterFallback();
                 return false;
             }
-            const pane = await this.tmux.capturePane();
-            if (this.nativePaneLifecycle && (!this.nativePaneLifecycle.current() || this.nativePaneLifecycle.mcpProof() !== "alive"))
-                return false;
-            return this.deliveryInputReadyPane(pane);
+            return this.deliveryInputReadyPane(await this.tmux.capturePane());
         }
         catch {
             this.resetFooterFallback();
@@ -9928,86 +10067,34 @@ export class Daemon extends EventEmitter {
         // tmux object and window — so the spawn generation and launch fence are part of the fence too: an Enter meant for
         // the CLI this paste went to is never sent to its successor.
         const tmux = this.tmux;
-        const backend = this.backend;
-        const native = !!this.nativePaneLifecycle;
         const generation = this.spawnGeneration;
         const fence = this.launchFenceEpoch;
-        const windowId = native ? tmux?.getWindowId() : undefined;
-        // M-2290 (#2985 review, Fable): the mode wait can last up to 10 minutes, and a respawn or relaunch reuses the same
-        // tmux object and window — so the spawn generation and launch fence are part of every pane's fence: an Enter meant
-        // for the CLI this paste went to is never sent to its successor. A native Windows pane keeps #2958's full fence too
-        // (its launch can be replaced under the same handle).
         const current = () => this.tmux === tmux && this.spawnGeneration === generation && this.launchFenceEpoch === fence
-            && !this.deliveryWritesStopping && (!stillCurrent || stillCurrent())
-            && (!native || (!!windowId && !!backend && this.backend === backend && tmux.getWindowId() === windowId));
+            && !this.deliveryWritesStopping && (!stillCurrent || stillCurrent());
         if (!current())
             return false;
         // The pasted text may still be in the box: the caller keeps it uncertain (no false failure, no second paste).
-        // S-35: say which check withheld Enter.
-        const hold = (reason) => {
-            onInputHeld?.(reason);
-            if (reason === "output_changed" && current() && !this.nativeDeliveryHold())
-                this.nativeEnterHold = {
-                    key: `${this.bootId}:${generation}:${fence}`, since: Date.now(), spawn: generation, fence,
-                };
-            if (reason === "pane-in-mode")
-                this.logger.warn({ phase, reason }, "The pane stayed in a tmux mode; Enter withheld");
-            else
-                this.logger.warn({ ...tmux?.getLastInputDiagnostic?.(), phase, reason, retryCount: positiveRefusals }, "Native delivery Enter withheld by its safety check");
+        const hold = () => {
+            onInputHeld?.("pane-in-mode");
+            this.logger.warn({ phase }, "The pane stayed in a tmux mode; Enter withheld");
             return false;
         };
         // M-2267 (#2971): a pane in a tmux mode (a person left it in copy-mode) would take this Enter. Wait for the mode to
         // end, then look once more within the same deadline — a pane flickering back into a mode is waited out again, never
-        // past the bound.
-        // Native delivery follows main #2990: only this backend's recognised runtime dialog vetoes Enter.
-        // The fresh capture still binds the native host output sequence; ownership and positive-ACK-only retries remain.
+        // past the bound. (beta.5: #2958's composer proof that used to sit between the two looks is reverted, decision
+        // f57474aa: it rejected Codex's footer after a resume and while busy. #2957 is open again.)
         const modeDeadline = performance.now() + PANE_MODE_ENTER_WAIT_MS;
-        let pane;
-        let positiveRefusals = 0, enterMarked = false, positiveRetryDeadline = Infinity, linuxDialogRead = false;
         for (;;) {
-            const mode = await this.waitWhilePaneInMode(phase, current, Math.min(modeDeadline, positiveRetryDeadline));
+            const mode = await this.waitWhilePaneInMode(phase, current, modeDeadline);
             if (mode === "stale")
                 return false;
             if (mode === "held")
-                return hold("pane-in-mode");
-            if (native) {
-                // S-35: a native pane's capture refuses while output is still arriving ("Pane changed during capture; observe it
-                // again"). Right after a turn the CLI repaints for a moment; one refused read left the message unsent for ever.
-                // Read again a few times — reading types nothing — and still hold if it never settles.
-                let captured;
-                for (let attempt = 0; captured === undefined; attempt++) {
-                    try {
-                        captured = await tmux.capturePane();
-                    }
-                    catch {
-                        if (!current())
-                            return false;
-                        if (attempt >= 4)
-                            return hold("capture_failed");
-                        await new Promise(done => setTimeout(done, 150 * (attempt + 1)));
-                        if (!current())
-                            return false;
-                    }
-                }
-                const screen = captured;
-                pane = screen;
-                if (!current())
-                    return false;
-                try {
-                    if (backend?.getRuntimeDialogs?.().some(dialog => Daemon.dialogMatches(dialog, screen)))
-                        return hold("dialog");
-                }
-                catch {
-                    return hold("check_failed");
-                }
-                if (!current())
-                    return false;
-            }
+                return hold();
             if (await this.paneInTmuxMode(phase)) {
                 if (!current())
                     return false;
                 if (performance.now() >= modeDeadline)
-                    return hold("pane-in-mode");
+                    return hold();
                 await new Promise(r => setTimeout(r, PANE_MODE_POLL_MS));
                 if (!current())
                     return false;
@@ -10015,143 +10102,54 @@ export class Daemon extends EventEmitter {
             }
             if (!current())
                 return false;
-            // M-2290 (the simple half of the #2957 redesign, leader xmsg-1793712561468; main): on a Linux pane, a dialog the
-            // backend RECOGNISES (runtimeDialogs: a permission card, the dangerous-command card, …) that painted between the
-            // paste and this Enter would take the key as its answer. Read the pane once more: such a dialog withholds the
-            // Enter (the caller keeps the delivery uncertain → Needs-you; the dialog scanner parks it for a person). Nothing
-            // else is judged — an unknown or unreadable screen sends: #2958's composer proof (decision f57474aa) is NOT back.
-            // Only a caller that can hold asks (onInputHeld); a native pane read its own screen above, every round.
-            if (!native && onInputHeld && !linuxDialogRead) {
-                linuxDialogRead = true;
-                let finalPane = null;
-                try {
-                    finalPane = await tmux.capturePane();
-                }
-                catch {
-                    finalPane = null;
-                }
-                if (!current())
-                    return false;
-                let dialog;
-                try {
-                    dialog = finalPane === null ? undefined : (this.backend?.getRuntimeDialogs?.() ?? []).find(d => Daemon.dialogMatches(d, finalPane))?.description;
-                }
-                catch {
-                    dialog = undefined;
-                }
-                if (dialog !== undefined) {
-                    onInputHeld("dialog");
-                    this.logger.warn({ phase, dialog }, "A dialog is on the pane; the delivery's Enter is withheld (it would answer it)");
-                    return false;
-                }
-            }
-            if (positiveRefusals && performance.now() >= positiveRetryDeadline)
-                return hold("output_changed");
-            // W1: persist the "Enter may have happened" boundary before tmux receives
-            // the key. A crash after this commit is never auto-replayed without a
-            // positive transcript marker, even if the stale pane still shows composer.
-            if (!enterMarked && durableAttempt && !this.deliveryOutbox?.markEnterStarted(durableAttempt.deliveryId, this.bootId, durableAttempt.attemptNo)) {
-                this.logger.error({ phase, deliveryId: durableAttempt.deliveryId }, "Could not commit durable Enter write-ahead fence");
-                return false;
-            }
-            enterMarked = true;
-            const sent = await (native && pane !== undefined ? tmux.sendSpecialKey("Enter", undefined, { kind: "delivery", screen: pane, retryCount: positiveRefusals }) : tmux.sendSpecialKey("Enter"));
-            // A busy renderer can change seq after our capture. Only a positive zero-input ACK admits a NEW proof/key;
-            // An Enter retry never re-pastes, retries an uncertain write, reuses stale proof or re-commits the durable boundary.
-            if (!sent && native && tmux.lastInputWasNotSent?.() === true
-                && tmux.getLastSendSpecialKeyError() === "Pane changed after observation; input was not sent"
-                && current()) {
-                if (!positiveRefusals)
-                    positiveRetryDeadline = Math.min(modeDeadline, performance.now() + 2000);
-                if (positiveRefusals >= 4 || performance.now() >= positiveRetryDeadline)
-                    return hold("output_changed");
-                positiveRefusals++;
-                await new Promise(done => setTimeout(done, 100));
-                if (!current())
-                    return false;
-                if (performance.now() >= positiveRetryDeadline)
-                    return hold("output_changed");
-                continue;
-            }
-            if (!sent) {
-                const details = { phase, tmuxError: this.tmux.getLastSendSpecialKeyError() ?? "unknown tmux send-keys failure" };
-                if (native)
-                    this.logger.warn({ ...tmux?.getLastInputDiagnostic?.(), ...details, retryCount: positiveRefusals }, "Native delivery Enter gave up");
-                else
-                    this.logger.error(details, "tmux send-keys Enter failed during message delivery");
-            }
-            if (sent && native && current())
-                this.nativeEnterHold = null;
-            return sent;
-        }
-    }
-    /** A pre-existing native busy-paste race: retry bytes only after an exact, owned zero-input acknowledgement. */
-    async sendDeliveryPaste(text, stillCurrent) {
-        const pane = this.tmux, native = this.nativePaneLifecycle;
-        if (!native)
-            return pane.pasteBuffer(text);
-        const backend = this.backend, generation = this.spawnGeneration, fence = this.launchFenceEpoch, windowId = pane.getWindowId();
-        const current = () => !!windowId && this.tmux === pane && this.nativePaneLifecycle === native && this.backend === backend
-            && this.spawnGeneration === generation && this.launchFenceEpoch === fence && pane.getWindowId() === windowId
-            && !this.deliveryWritesStopping && (!stillCurrent || stillCurrent());
-        let retryCount = 0;
-        const hold = (reason) => {
-            if (current() && !this.nativeDeliveryHold())
-                this.nativeEnterHold = { key: `${this.bootId}:${generation}:${fence}`, since: Date.now(), spawn: generation, fence };
-            this.logger.warn({ ...pane.getLastInputDiagnostic?.(), reason, retryCount }, "Native delivery paste held by its safety check");
-            return false;
-        };
-        const deadline = performance.now() + 2000;
-        for (let attempt = 0; attempt < 5; attempt++) {
-            retryCount = attempt;
-            if (!current())
-                return false;
-            if (performance.now() >= deadline)
-                return hold("output_changed");
-            let screen;
-            for (let read = 0; read < 5 && screen === undefined; read++) {
-                try {
-                    screen = await pane.capturePane();
-                }
-                catch { /* Reads do not construct an input operation. */ }
-                if (!current())
-                    return false;
-                if (performance.now() >= deadline)
-                    return hold("capture_failed");
-                if (screen === undefined && read < 4)
-                    await new Promise(done => setTimeout(done, 100));
-            }
-            if (screen === undefined)
-                return hold("capture_failed");
+            break;
+        }
+        // M-2290 (the simple half of the #2957 redesign, leader xmsg-1793712561468): a dialog the backend RECOGNISES
+        // (runtimeDialogs: a permission card, the dangerous-command card, …) that painted between the paste and this Enter
+        // would take the key as its answer. Read the pane once more: such a dialog withholds the Enter, the caller keeps the
+        // delivery uncertain (Needs-you), and the dialog scanner parks the dialog for a person. Nothing else is judged here
+        // — an unknown or unreadable screen sends, exactly as before: #2958's composer proof (decision f57474aa) is NOT back.
+        // Only a caller that can hold (onInputHeld: the delivery's initial submit, settled uncertain → Needs-you) asks: one
+        // that cannot would read `false` as a failure and paste again. Only the backend's OWN dialogs count — not AgEnD's
+        // unrecognised-prompt guess — so an unknown screen still sends.
+        if (onInputHeld) {
+            let finalPane = null;
             try {
-                if (backend?.getRuntimeDialogs?.().some(dialog => Daemon.dialogMatches(dialog, screen)))
-                    return hold("dialog");
+                finalPane = await tmux.capturePane();
             }
             catch {
-                return hold("check_failed");
+                finalPane = null;
             }
             if (!current())
                 return false;
-            if (performance.now() >= deadline)
-                return hold("output_changed");
-            let sent;
+            let dialog;
             try {
-                sent = await pane.pasteBuffer(text, { guard: current, proof: { kind: "composer", screen, retryCount: attempt } });
+                dialog = finalPane === null ? undefined : (this.backend?.getRuntimeDialogs?.() ?? []).find(d => Daemon.dialogMatches(d, finalPane))?.description;
             }
             catch {
-                return hold("unconfirmed");
+                dialog = undefined;
             }
-            if (sent)
-                return true; // Exactly one successful paste ends the loop, before any Enter.
-            if (!current())
+            if (dialog !== undefined) {
+                onInputHeld?.("dialog");
+                this.logger.warn({ phase, dialog }, "A dialog is on the pane; the delivery's Enter is withheld (it would answer it)");
                 return false;
-            if (pane.lastInputWasNotSent?.() !== true || pane.getLastPasteError?.() !== "Pane changed after observation; input was not sent")
-                return hold("unconfirmed");
-            if (attempt >= 4 || performance.now() >= deadline)
-                return hold("output_changed");
-            await new Promise(done => setTimeout(done, 100));
+            }
+        }
+        // W1: persist the "Enter may have happened" boundary before tmux receives
+        // the key. A crash after this commit is never auto-replayed without a
+        // positive transcript marker, even if the stale pane still shows composer.
+        if (durableAttempt && !this.deliveryOutbox?.markEnterStarted(durableAttempt.deliveryId, this.bootId, durableAttempt.attemptNo)) {
+            this.logger.error({ phase, deliveryId: durableAttempt.deliveryId }, "Could not commit durable Enter write-ahead fence");
+            return false;
         }
-        return hold("output_changed");
+        const sent = await tmux.sendSpecialKey("Enter");
+        if (!sent) {
+            this.logger.error({
+                phase,
+                tmuxError: this.tmux.getLastSendSpecialKeyError() ?? "unknown tmux send-keys failure",
+            }, "tmux send-keys Enter failed during message delivery");
+        }
+        return sent;
     }
     async writeMessageToPane(formatted, initialWindowId, handingOffToNativeQueue, status, submissionId, 
     // Last and defaulted so the positional callers that ignore the outcome stay
@@ -10189,9 +10187,6 @@ export class Daemon extends EventEmitter {
         const tmuxAtWrite = this.tmux;
         const steerCurrent = () => (!stillCurrent || stillCurrent()) && !this.deliveryWritesStopping
             && this.tmux === tmuxAtWrite && this.spawnGeneration === spawnAtWrite;
-        // Alpha (S-36, Prism #2989 P2): a NATIVE pane keeps #2958's pre-paste owner fence through the initial Enter and every
-        // retry Enter (a pane replaced while the paste awaits never takes this delivery's Enter); a tmux pane follows main.
-        const nativeOwner = this.nativePaneLifecycle ? steerCurrent : undefined;
         // Bug A: paste with backoff. Transient failures are usually a stale window id
         // after a crash/respawn — recover by name and retry (max 3 attempts, 2s apart).
         const maxAttempts = 3;
@@ -10259,8 +10254,8 @@ export class Daemon extends EventEmitter {
                 }
                 verdict.durableBeginCommitted = true;
                 verdict.submissionMode = attemptEvidence.submissionMode;
-                if (attemptEvidence.runtimeTranscript || attemptEvidence.transcriptPath && attemptEvidence.transcriptOffset !== null) {
-                    verdict.transcriptCheckpoint = attemptEvidence.runtimeTranscript ? { backend: attemptEvidence.backend, runtime: attemptEvidence.runtimeTranscript } : {
+                if (attemptEvidence.transcriptPath && attemptEvidence.transcriptOffset !== null) {
+                    verdict.transcriptCheckpoint = {
                         backend: attemptEvidence.backend,
                         path: attemptEvidence.transcriptPath,
                         offset: attemptEvidence.transcriptOffset,
@@ -10274,6 +10269,17 @@ export class Daemon extends EventEmitter {
                     }
                 }
             }
+            // #3030: a hand-off into a busy CLI's own queue is on record before its paste (write-ahead): that queue lives only
+            // in the CLI process, and a stop before a turn takes it would lose it without a trace.
+            if (verdict.trackHandoff && !rawPaste) {
+                await this.recordQueuedHandoff(formatted, handingOffToNativeQueue, verdict, durableAttempt, humanVerificationId);
+                if (stillCurrent && !stillCurrent()) {
+                    if (!verdict.trackHandoff.id)
+                        this.dropQueuedHandoff(verdict);
+                    verdict.fenced = !verdict.durableBeginCommitted;
+                    return false;
+                }
+            }
             if (lookBeforePaste) {
                 await lookBeforePaste();
                 // The look awaited: this attempt is still this write's — the same fence, tmux and launch — or nothing is written.
@@ -10325,15 +10331,7 @@ export class Daemon extends EventEmitter {
             }
             const pasteGeneration = this.spawnGeneration;
             beforePaste?.();
-            const pasted = await this.sendDeliveryPaste(formatted, nativeOwner);
-            if (!pasted && this.nativePaneLifecycle) {
-                // The native write attempt is retained as uncertain, including exhausted positive refusals. Never route an
-                // unknown/partial write through legacy window recovery or abort it back to an automatically replayable row.
-                verdict.paneWriteStarted = true;
-                verdict.phase = "paste";
-                verdict.proof = "native-paste-held";
-                return false;
-            }
+            const pasted = await this.tmux.pasteBuffer(formatted);
             if (pasted)
                 this.rememberPaste(formatted, pasteGeneration);
             if (!pasted) {
@@ -10420,18 +10418,15 @@ export class Daemon extends EventEmitter {
             const enterMono = performance.now();
             const steerEnterCurrent = () => steerCurrent() && performance.now() <= steerEnterDeadline;
             let inputHeld = null;
-            if (!(await this.sendDeliveryEnter("initial-submit", steerComposerProof || nativeOwner ? steerEnterCurrent : undefined, durableAttempt, (why) => { inputHeld = why; }))) {
+            if (!(await this.sendDeliveryEnter("initial-submit", steerComposerProof ? steerEnterCurrent : undefined, durableAttempt, (why) => { inputHeld = why; }))) {
                 if (inputHeld) {
                     // #2971: held in a tmux mode past the bound; M-2290: a recognised dialog on the pane. The paste may still be in
                     // the CLI: keep it uncertain (Needs-you), never re-paste, never answer the dialog.
                     verdict.phase = "submit-enter";
-                    // The merge of #2957/M-2290 (main) and the alpha's native holds: a tmux mode, a recognised dialog on a Linux pane,
-                    // and each native safety check say which.
-                    verdict.proof = inputHeld === "pane-in-mode" ? "pane-in-mode-held" : nativeOwner ? `native-input-${inputHeld}`
-                        : inputHeld === "dialog" ? "dialog-on-pane" : `input-held-${inputHeld}`;
+                    verdict.proof = inputHeld === "dialog" ? "dialog-on-pane" : "pane-in-mode-held";
                     return false;
                 }
-                if ((steerComposerProof || nativeOwner) && !steerCurrent()) {
+                if (steerComposerProof && !steerCurrent()) {
                     verdict.phase = "submit-enter";
                     verdict.proof = "fenced-before-enter";
                     return false;
@@ -10440,6 +10435,7 @@ export class Daemon extends EventEmitter {
                     return this.failDelivery(verdict, status, "submit-enter", "pre-enter-deadline");
                 return this.failDelivery(verdict, status, "submit-enter", "tmux-send-keys-failed");
             }
+            this.commitPreInputQuotaHistory(pasteBaseline);
             // The proof's whole budget, from the Enter: every capture and dialog probe inside it, a late answer dropped.
             const steerProofDeadline = performance.now() + NATIVE_QUEUE_PASTE_VERIFY_MS + POST_ENTER_PROOF_WINDOW_MS;
             // Kiro's legacy TUI can swallow Enter while it is still processing a large
@@ -10460,7 +10456,7 @@ export class Daemon extends EventEmitter {
             if (!rawPaste && !steerComposerProof && this.backend?.requiresDeliveryEnterRetry?.() === true) {
                 await new Promise(r => setTimeout(r, 1_000));
                 const retryAt = Date.now();
-                if (await this.sendDeliveryEnter("queue-less-defensive-retry", nativeOwner)) {
+                if (await this.sendDeliveryEnter("queue-less-defensive-retry")) {
                     enterAt = retryAt;
                     enterRetry = true;
                     this.logger.debug("Sent defensive Enter retry (queue-less TUI can swallow the first)");
@@ -10521,8 +10517,9 @@ export class Daemon extends EventEmitter {
                 }
                 const proof = await this.confirmSubmitted(signature, pasteBaseline);
                 if (proof === "submitted") {
-                    if (status)
-                        this.emit("message_confirmed", status); // ✅ native queue accepted
+                    // ✅ native queue accepted — unless it is on record (#3030): then ✅ waits for the turn that takes it.
+                    if (status && !verdict.handoff)
+                        this.emit("message_confirmed", status);
                     return true;
                 }
                 if (proof === "unverifiable") {
@@ -10554,8 +10551,8 @@ export class Daemon extends EventEmitter {
                     this.logger.warn("Paste reached the pane but could not be verified as submitted — accepting without proof");
                     verdict.phase = "best-effort-submission";
                     verdict.proof = "unverified";
-                    if (status)
-                        this.emit("message_confirmed", status); // ✅ (best-effort)
+                    if (status && !verdict.handoff)
+                        this.emit("message_confirmed", status); // ✅ (best-effort; on record: when taken, #3030)
                     return true;
                 }
                 // raw_paste has no unique marker and is not allowed to re-paste or
@@ -10570,6 +10567,10 @@ export class Daemon extends EventEmitter {
                 // confirmation ladder. "stranded" is the case that used to be a silent
                 // ✅ — the text was visible, so the old check called it delivered.
                 this.logger.warn({ proof }, "Native-queue paste not confirmed as submitted — retrying via idle-gated delivery");
+                // #3030: what follows is an idle submission (or a failure the caller reports): no longer a queued hand-off.
+                if (verdict.handoff && !verdict.trackHandoff?.id)
+                    this.dropQueuedHandoff(verdict);
+                verdict.handoff = undefined;
                 if (windowId && this.controlClient && !(await this.controlClient.waitUntilIdle(windowId))) {
                     verdict.phase = "native-queue-idle-wait";
                     verdict.proof = "idle-wait-failed";
@@ -10593,7 +10594,7 @@ export class Daemon extends EventEmitter {
                     // again. The prompt is back now, so an Enter can land.
                     this.logger.warn("Message still in the input row after idle — submitting the existing text instead of pasting it again");
                     const strandedAt = Date.now();
-                    if (!(await this.sendDeliveryEnter("native-queue-stranded-submit", nativeOwner))) {
+                    if (!(await this.sendDeliveryEnter("native-queue-stranded-submit"))) {
                         return this.failDelivery(verdict, status, "native-queue-submit", "tmux-send-keys-failed");
                     }
                     // The recovery Enter can be accepted before Codex paints its new
@@ -10646,7 +10647,7 @@ export class Daemon extends EventEmitter {
                 }
                 await new Promise(r => setTimeout(r, NORMAL_ENTER_SETTLE_MS));
                 const retryAt = Date.now();
-                if (!(await this.sendDeliveryEnter("native-queue-idle-redelivery", nativeOwner))) {
+                if (!(await this.sendDeliveryEnter("native-queue-idle-redelivery"))) {
                     return this.failDelivery(verdict, status, "native-queue-redelivery", "tmux-send-keys-failed");
                 }
                 if (windowId && this.controlClient) {
@@ -10698,7 +10699,7 @@ export class Daemon extends EventEmitter {
                     this.logger.warn("Message not submitted after Enter — waiting for the prompt, then re-sending Enter once");
                     const promptBack = await this.waitForPaneReadyForDelivery(windowId, STRANDED_RETRY_READY_WAIT_MS);
                     const retryAt = Date.now();
-                    if (promptBack && !(await this.sendDeliveryEnter("stranded-text-retry", nativeOwner))) {
+                    if (promptBack && !(await this.sendDeliveryEnter("stranded-text-retry"))) {
                         return this.failDelivery(verdict, status, "stranded-text-retry", "tmux-send-keys-failed");
                     }
                     submitted = promptBack && await this.confirmSubmittedAfterEnter(windowId, retryAt, formatted);
@@ -10786,7 +10787,7 @@ export class Daemon extends EventEmitter {
                 }
                 // No control client to observe output: fall back to the legacy double-Enter.
                 await new Promise(r => setTimeout(r, 1000));
-                await this.sendDeliveryEnter("unobserved-defensive-retry", nativeOwner);
+                await this.sendDeliveryEnter("unobserved-defensive-retry");
                 if (status)
                     this.emit("message_confirmed", status); // ✅ (best-effort)
             }
@@ -11006,22 +11007,14 @@ export class Daemon extends EventEmitter {
      * and the caller's own fence — so a look that lands after any of them is never used (#1380 review).
      */
     transcriptProofFor(checkpoint, needle, spawnAtWrite, stillCurrent, onProof) {
-        if (this.nativePaneLifecycle && !checkpoint.runtime)
-            throw Error("Native proof cannot read a coordinator-local transcript path");
         const launchAtWrite = this.launchFenceEpoch;
         return {
-            reader: checkpoint.runtime ? this.nativeTranscriptReader(checkpoint.runtime, needle) : new TranscriptDeltaReader(checkpoint.path, checkpoint.offset, checkpoint.backend, needle),
+            reader: new TranscriptDeltaReader(checkpoint.path, checkpoint.offset, checkpoint.backend, needle),
             current: () => !this.deliveryWritesStopping && this.spawnGeneration === spawnAtWrite
-                && this.launchFenceEpoch === launchAtWrite && (stillCurrent?.() ?? true)
-                && (!checkpoint.runtime || this.nativePaneLifecycle?.current(checkpoint.runtime) === true),
+                && this.launchFenceEpoch === launchAtWrite && (stillCurrent?.() ?? true),
             onProof,
         };
     }
-    nativeTranscriptReader(reference, needle) {
-        if (!this.nativePaneLifecycle || !this.nativePaneLifecycle.current(reference))
-            throw Error("Native delivery transcript owner is unavailable");
-        return this.nativePaneLifecycle.proofReader(reference, needle);
-    }
     /** The CLI this daemon drives, for log lines shared by every backend ("claude-code", "codex", …). */
     cliLabel() {
         return this.config.backend ?? this.backend?.binaryName ?? "CLI";
@@ -11161,12 +11154,18 @@ export class Daemon extends EventEmitter {
     async capturePaneEvidence(signature) {
         if (!this.tmux)
             return null;
+        const owner = this.tmux, window = owner.getWindowId?.(), spawn = this.spawnGeneration, fence = this.launchFenceEpoch, launch = this.launchAttempt;
         // Bounded re-probe: a capture that fails here costs the delivery its only
         // "before" picture, and a momentary failure should not decide anything.
         for (let attempt = 1; attempt <= BASELINE_CAPTURE_ATTEMPTS; attempt++) {
             try {
                 const pane = await this.tmux.capturePane();
                 const evidence = this.paneEvidence(pane, signature);
+                if (owner === this.tmux && window === owner.getWindowId?.() && spawn === this.spawnGeneration && fence === this.launchFenceEpoch && launch === this.launchAttempt) {
+                    const counts = this.paneQuotaPatterns().map(ep => ({ key: Daemon.errorPatternKey(ep), count: Daemon.countOccurrences(ep.pattern, pane) }));
+                    if (counts.length)
+                        evidence.quotaHistory = { spawn, fence, attempt: launch, tmux: owner, window, counts, marker: signature.value, occurrences: evidence.payload };
+                }
                 const input = this.inputRegion(pane);
                 if (input && agendMessageInInput(input.text)) {
                     // Whatever we paste now lands after it, and one Enter submits both as
@@ -11265,14 +11264,7 @@ export class Daemon extends EventEmitter {
      * (the retries included). Without a guard it is exactly the old unconditional path.
      */
     async submitSystemPaste(text, label, guard, admission) {
-        // Alpha (S-36, Prism #2989 P2): a NATIVE pane's system paste keeps the pane owner from before its first await
-        // (#2958's fence, reverted on main for tmux panes) — a pane replaced while the paste awaits never takes its Enter.
-        const native = !!this.nativePaneLifecycle;
-        const ownerTmux = this.tmux, ownerGeneration = this.spawnGeneration, ownerFence = this.launchFenceEpoch;
-        const ownerWindow = native ? ownerTmux?.getWindowId() : undefined;
-        const owner = () => !native || (!!ownerTmux && !!ownerWindow && this.tmux === ownerTmux && ownerTmux.getWindowId() === ownerWindow
-            && this.spawnGeneration === ownerGeneration && this.launchFenceEpoch === ownerFence && !this.deliveryWritesStopping);
-        const current = guard || admission || native ? () => { admission?.(); return owner() && (guard?.current() ?? true); } : undefined;
+        const current = guard || admission ? () => { admission?.(); return guard?.current() ?? true; } : undefined;
         if (current && !current())
             return false;
         if (!this.tmux)
@@ -11308,6 +11300,7 @@ export class Daemon extends EventEmitter {
         await new Promise(r => setTimeout(r, NORMAL_ENTER_SETTLE_MS));
         if (!(await this.sendDeliveryEnter(label, current)))
             return false;
+        this.commitPreInputQuotaHistory(baseline);
         let proof = await this.confirmSubmitted(signature, baseline);
         if (current && !current())
             return false;
@@ -11392,13 +11385,13 @@ export class Daemon extends EventEmitter {
             && sameInteractionOwner(recoveryOwner, this.interactionOwner());
         const previousWindowId = this.tmux?.getWindowId();
         try {
-            const windows = await this.paneHost.listWindows(this.tmuxSessionName, this.controlClient);
+            const windows = await TmuxManager.listWindows(this.tmuxSessionName, this.controlClient);
             if (!recoveryCurrent() || this.tmux !== previousTmux)
                 return undefined;
             const match = windows.find(w => w.name === this.name);
             if (!match)
                 return undefined;
-            this.tmux = this.paneHost.bind(this.tmuxSessionName, match.id, resolveTmuxLogicalSize(this.config.terminal), this.controlClient);
+            this.tmux = new TmuxManager(this.tmuxSessionName, match.id, resolveTmuxLogicalSize(this.config.terminal), this.controlClient);
             const recoveredTmux = this.tmux;
             writeFileSync(join(this.instanceDir, "window-id"), match.id);
             // The window we were talking to is gone; leaving it registered means the
@@ -11461,8 +11454,6 @@ export class Daemon extends EventEmitter {
         return false;
     }
     getWindowId() {
-        if (this.nativePaneLifecycle)
-            return this.nativePaneLifecycle.current() ? this.tmux?.getWindowId() : undefined;
         try {
             return readFileSync(join(this.instanceDir, "window-id"), "utf-8").trim() || undefined;
         }
@@ -11494,55 +11485,7 @@ export class Daemon extends EventEmitter {
      * Handle a tool call from the MCP server (forwarded by Claude).
      * Routes to the channel adapter via MessageBus.
      */
-    /** Internal native-MCP admission. The pane/machine/launch owner supplies a current, dynamically checked tool lease. */
-    handlePaneToolCall(input, lease) {
-        const refusal = nativePaneToolRefusal(input.tool, input.args);
-        if (refusal)
-            return Promise.resolve({ result: null, error: refusal });
-        if (!lease.current() || !lease.allowed(input.tool, input.args) || this.deliveryWritesStopping)
-            return Promise.resolve({ result: null, error: "Pane tool permission is no longer current" });
-        const fence = this.launchFenceEpoch;
-        const current = () => lease.current() && lease.allowed(input.tool, input.args) && !this.deliveryWritesStopping && fence === this.launchFenceEpoch;
-        return new Promise(resolve => {
-            let settled = false;
-            const finish = (value) => { if (settled)
-                return; settled = true; clearTimeout(timer); resolve(value); };
-            const timer = setTimeout(() => finish({ result: null, error: "Pane tool result is unconfirmed; inspect its operation before retrying" }), daemonBudgetMs(input.tool) + 1000);
-            timer.unref?.();
-            try {
-                this.handleToolCall({ ...input, requestId: ++this.fleetRequestSeq }, undefined, {
-                    current,
-                    dispatch: (tool, args, respond) => {
-                        if (!current()) {
-                            respond(null, "Pane tool permission was revoked before dispatch");
-                            return true;
-                        }
-                        const dispatched = lease.dispatch?.(tool, args);
-                        if (!dispatched)
-                            return false;
-                        void dispatched.then(result => respond(result), () => respond(null, "Pane tool operation was refused"));
-                        return true;
-                    },
-                    // Resolving the relay is not proof that its HTTP response reached the provider. No response-written receipt yet.
-                    send: value => {
-                        finish({ result: value.result, ...(typeof value.error === "string" ? { error: value.error } : {}),
-                            ...(typeof value.errorCode === "string" || typeof value.errorCode === "number" ? { errorCode: value.errorCode } : {}) });
-                        return false;
-                    },
-                });
-            }
-            catch {
-                finish({ result: null, error: "Pane tool operation failed" });
-            }
-        });
-    }
-    /** Only the authority lease with a verified helper stdout ACK calls this internal barrier. */
-    paneToolResponseWritten(operationId, current) {
-        if (!current() || this.deliveryWritesStopping || !/^[a-f0-9-]{36}$/i.test(operationId))
-            return;
-        this.emit("mcp_tool_response_written", { operationId, daemonBootId: this.bootId });
-    }
-    handleToolCall(msg, socket, peer) {
+    handleToolCall(msg, socket) {
         const tool = msg.tool;
         const args = (msg.args ?? {});
         const requestId = msg.requestId;
@@ -11550,20 +11493,20 @@ export class Daemon extends EventEmitter {
         this.logger.debug({ tool, requestId }, "Tool call from MCP server");
         // A tool call can only come from a live MCP server of ours — proof of life
         // that outranks whatever the pid slot says.
-        if (peer?.current() || socket && this.socketSessionNames.get(socket) === this.name) {
-            this.noteMcpProofOfLife("tool_call", socket ? this.socketPids.get(socket) : undefined);
+        if (this.socketSessionNames.get(socket) === this.name) {
+            this.noteMcpProofOfLife("tool_call", this.socketPids.get(socket));
         }
         // A tool invocation is not delivery evidence. Capture which obligation it
         // belongs to now, then settle it only after the adapter/fleet responds.
         // Explicitly mapped sibling sessions must not satisfy this instance's turn;
         // an unmapped socket is retained for legacy/tests where mcp_ready was not
         // observed before the first tool call.
-        const sourceSession = peer ? this.name : socket ? this.socketSessionNames.get(socket) : undefined;
+        const sourceSession = this.socketSessionNames.get(socket);
         const replyAttempt = TURN_OUTBOUND_TOOLS.has(tool) && (!sourceSession || sourceSession === this.name)
             ? this.turnReplyGuard.beginToolAttempt(tool === "reply", TURN_COMPLETION_TOOLS.has(tool))
             : null;
         // For now, log and respond. Full adapter routing will be wired in fleet manager.
-        const respond = (result, error, errorCode) => {
+        const respond = (result, error) => {
             // A message that verifiably went out stands down the dead-MCP proxy reply
             // for this turn: the agent proved it can still speak for itself.
             if (!error && result != null && TURN_OUTBOUND_TOOLS.has(tool)) {
@@ -11604,21 +11547,14 @@ export class Daemon extends EventEmitter {
                 // failed" and report unknown immediately rather than starting recovery.
                 this.turnReplyGuard.settleToolAttempt(replyAttempt, false);
             }
-            const packet = { requestId, result, error, operationId, ...(errorCode !== undefined ? { errorCode } : {}) };
-            const sent = peer ? peer.current() && peer.send(packet) : socket ? this.ipcServer?.send(socket, packet) ?? false : false;
+            const sent = this.ipcServer?.send(socket, { requestId, result, error, operationId }) ?? false;
             if (!sent) {
-                if (peer)
-                    this.logger.debug({ tool, requestId }, "Native MCP result awaits transport-written confirmation");
-                else
-                    this.logger.warn({ tool, requestId }, "Tool result could not be returned — originating MCP socket is closed");
+                this.logger.warn({ tool, requestId }, "Tool result could not be returned — originating MCP socket is closed");
             }
             else if (operationId) {
                 this.emit("mcp_tool_response_written", { operationId, daemonBootId: this.bootId });
             }
         };
-        // Native Fleet/task operations carry their lease to the existing dispatcher mutation admission points.
-        if (peer?.dispatch?.(tool, args, respond))
-            return;
         // Repo checkout — handled locally in daemon (no fleet-manager)
         if (tool === "checkout_repo") {
             this.handleCheckoutRepo(args, respond);
@@ -11647,7 +11583,7 @@ export class Daemon extends EventEmitter {
                 clearTimeout(timeout);
                 respond(respMsg.result, respMsg.error);
             });
-            this.broadcastFleetMessage({
+            this.ipcServer?.broadcast({
                 type,
                 payload: args,
                 meta: { instance_name: this.name },
@@ -11673,7 +11609,7 @@ export class Daemon extends EventEmitter {
                     clearTimeout(timeout);
                     resolve({ result: respMsg.result, error: respMsg.error });
                 });
-                this.broadcastFleetMessage({ type: WEB_THEME_IPC[tool], payload, meta: { instance_name: this.name }, fleetRequestId: fleetReqId });
+                this.ipcServer?.broadcast({ type: WEB_THEME_IPC[tool], payload, meta: { instance_name: this.name }, fleetRequestId: fleetReqId });
             });
             void (async () => {
                 if (tool === "preview_web_appearance") {
@@ -11750,7 +11686,7 @@ export class Daemon extends EventEmitter {
                 clearTimeout(timeout);
                 respond(respMsg.result, respMsg.error);
             });
-            this.broadcastFleetMessage({
+            this.ipcServer?.broadcast({
                 type: "fleet_task",
                 payload: args,
                 meta: { instance_name: this.name },
@@ -11773,7 +11709,7 @@ export class Daemon extends EventEmitter {
                 clearTimeout(timeout);
                 respond(respMsg.result, respMsg.error);
             });
-            this.broadcastFleetMessage({
+            this.ipcServer?.broadcast({
                 type: typeMap[tool],
                 payload: args,
                 meta: { instance_name: this.name, working_directory: this.config.working_directory },
@@ -11800,7 +11736,7 @@ export class Daemon extends EventEmitter {
                 clearTimeout(timeout);
                 respond(respMsg.result, respMsg.error);
             });
-            this.broadcastFleetMessage({
+            this.ipcServer?.broadcast({
                 type: typeMap[tool],
                 payload: args,
                 meta: {
@@ -11815,11 +11751,11 @@ export class Daemon extends EventEmitter {
         }
         if (CROSS_INSTANCE_TOOLS.has(tool)) {
             // Route to fleet manager via IPC (topic mode only)
-            if (this.topicMode && this.fleetTransportAvailable()) {
+            if (this.topicMode && this.ipcServer) {
                 // Use fleetRequestId (not requestId) to avoid MCP server resolving the
                 // pending tool call prematurely when it receives the broadcast.
                 const fleetReqId = `xmsg_${++this.fleetRequestSeq}_${requestId}`;
-                const senderSessionName = sourceSession;
+                const senderSessionName = this.socketSessionNames.get(socket);
                 // Shared table, so delete_instance and the deployment tools get the same
                 // budget here as the MCP client expects (the ad-hoc list omitted them).
                 const crossTimeoutMs = daemonBudgetMs(tool);
@@ -11831,7 +11767,7 @@ export class Daemon extends EventEmitter {
                     clearTimeout(timeout);
                     respond(respMsg.result, respMsg.error);
                 });
-                this.broadcastFleetMessage({
+                this.ipcServer.broadcast({
                     type: "fleet_outbound",
                     tool,
                     args,
@@ -11885,12 +11821,12 @@ export class Daemon extends EventEmitter {
             }, daemonBudgetMs(tool));
             this.pendingIpcRequests.set(outboundKey, (respMsg) => {
                 clearTimeout(timeout);
-                respond(respMsg.result, respMsg.error, respMsg.errorCode);
+                respond(respMsg.result, respMsg.error);
             });
             // Register the waiter before broadcasting. A fast/mock adapter can settle
             // immediately; broadcasting first left a response-before-registration
             // window that degraded into a timeout despite a completed POST.
-            this.broadcastFleetMessage({
+            this.ipcServer?.broadcast({
                 type: "fleet_outbound",
                 tool,
                 args,
@@ -12021,7 +11957,7 @@ export class Daemon extends EventEmitter {
         // The daemon used to read `general_topic` alone while `isGeneralInstance`
         // also accepted the name, so an instance called `general` without the flag
         // was a worker here and a general everywhere else.
-        const isGeneral = this.config.general_topic === true || generalByName(this.name, this.config);
+        const isGeneral = this.config.general_topic === true || this.name === "general";
         // No third argument for an ordinary instance: the default is `worker` now,
         // and naming it here would be a second place to change it.
         const toolSet = isGeneral
@@ -12183,6 +12119,8 @@ export class Daemon extends EventEmitter {
         }
         this.cancelCapacityNudge("the instance was stopped, paused or respawned");
         this.lastErrorEpisode = null;
+        this.quotaReplay = null;
+        this.quotaInput = null;
         this.nudgeBaselines = null;
         // A relaunch settles any outstanding quit watch: the CLI came back.
         this.clearQuitRelaunchWatch();
@@ -12397,8 +12335,6 @@ export class Daemon extends EventEmitter {
         catch { /* best effort */ }
     }
     async spawnClaudeWindow() {
-        if (this.nativePaneLifecycle)
-            throw Error("Native panes never enter local resume/fresh fallback");
         this.assertSessionOomAdmission();
         this.beginSpawn();
         let resumedSuccessfully = false;
@@ -12985,14 +12921,6 @@ export class Daemon extends EventEmitter {
             await this.museUsageRelay.stop().catch(() => { });
             this.museUsageRelay = null;
         }
-        if (this.nativePaneLifecycle) {
-            await this.nativePaneLifecycle.release("detach");
-            try {
-                unlinkSync(join(this.instanceDir, "daemon.pid"));
-            }
-            catch { /* metadata only */ }
-            return;
-        }
         try {
             await this.killProcessTree("SIGTERM", "startup aborted");
         }
@@ -13022,15 +12950,13 @@ export class Daemon extends EventEmitter {
     }
     /** Kill the entire process tree of the current tmux pane (CLI + MCP server). */
     async killProcessTree(signal = "SIGTERM", reason = "unspecified") {
-        if (this.nativePaneLifecycle)
-            throw Error("Native processes can only be closed through their owned runtime pane");
         const windowId = this.tmux?.getWindowId();
         // Before createWindow succeeds there is no pane owned by this daemon.
         // tmux interprets an empty selector as the session's active window.
         if (!windowId?.trim())
             return;
         try {
-            const pid = await this.paneHost.getPanePid(this.tmuxSessionName, windowId);
+            const pid = await TmuxManager.getPanePid(this.tmuxSessionName, windowId);
             if (pid) {
                 this.noteStopRequest(signal, reason);
                 process.kill(-pid, signal);
@@ -13052,7 +12978,12 @@ export class Daemon extends EventEmitter {
                 || this.startupAborted || this.deliveryWritesStopping || this.runtimeMonitorsFrozen || this.healthCheckPaused)) {
                 throw new Error("OOM recovery cancelled: the instance was stopped, paused or replaced while memory was unavailable");
             }
-            return this.trySpawnInsideGate(reuseWindow, startupTimeoutMs);
+            return this.trySpawnInsideGate(reuseWindow, startupTimeoutMs).catch(err => {
+                // Includes an in-place binary replacement during asynchronous launch preparation.
+                if (err instanceof KiroCompatibilityError)
+                    this.emit("kiro_compatibility_hold", err.message);
+                throw err;
+            });
         };
         const ready = !this.spawnGate ? await enter() : await this.spawnGate.run({
             instanceName: this.name,
@@ -13244,7 +13175,7 @@ export class Daemon extends EventEmitter {
     whatsNewRoles() {
         if (this.runtimeIdentity?.kind === "classic")
             return ["classic"];
-        if (this.config.general_topic === true || generalByName(this.name, this.config))
+        if (this.config.general_topic === true || this.name === "general")
             return ["general"];
         const set = resolveToolSet(this.config, this.name);
         return set === "coordinator" || set === "full" ? ["worker", "coordinator"] : ["worker"];
@@ -13271,12 +13202,15 @@ export class Daemon extends EventEmitter {
         }
     }
     async trySpawnInsideGate(reuseWindow = false, startupTimeoutMs) {
-        if (this.nativePaneLifecycle)
-            throw Error("Native relaunch requires its owned exit and a new lifecycle reservation");
         this.assertSessionOomAdmission();
         this.startupAdmission?.();
         const launchFence = this.launchFenceEpoch;
         const backendConfig = this.buildBackendConfig();
+        // A compatibility refusal is not a failed resume: no configuration, pin, history or pane may change.
+        if (this.backend?.assertLaunchSupported) {
+            this.backend.assertLaunchSupported(backendConfig);
+            this.emit("kiro_compatibility_hold", null);
+        }
         // #1633: decided before prev-instructions is first written — its absence is what says "never launched before".
         this.prepareWhatsNew(!existsSync(join(this.instanceDir, "prev-instructions")));
         // Record what this launch writes. #2787: a change is never announced in the pane; the CLI takes the new
@@ -13313,6 +13247,7 @@ export class Daemon extends EventEmitter {
         const agentTokenPath = join(this.instanceDir, "agent.token");
         const agentToken = randomBytes(32).toString("hex");
         const tokenWrite = writeSecretFile(agentTokenPath, agentToken);
+        this.agentCredentialIssuer?.(agentToken);
         if (!tokenWrite.ok) {
             // Do not fail the spawn over it — an instance that cannot start is worse
             // than one whose token is readable. But say so, loudly: the whole point of
@@ -13358,6 +13293,8 @@ export class Daemon extends EventEmitter {
         // Every launched command re-arms the passive-transient check, including a
         // retry inside the same spawn: its load is a new one.
         this.launchAttempt++;
+        await this.prepareQuotaReplayHistory(reuseWindow);
+        this.startupAdmission?.();
         this.interactionObservation.reset(this.interactionOwner());
         this.clearInteractionConfirmation();
         // A launch that cannot paint a passive transient (Codex: a fresh start
@@ -13377,8 +13314,8 @@ export class Daemon extends EventEmitter {
             this.emit("backend_launch_warning", { name: this.name, message: note, quiet: true });
         }
         // Ensure tmux session exists (may have been destroyed if all windows died)
-        await this.paneHost.ensureSession(this.tmuxSessionName);
-        if (this.stormWindow?.observeServerAlive(await this.paneHost.getServerPid(this.tmuxSessionName))) {
+        await TmuxManager.ensureSession(this.tmuxSessionName);
+        if (this.stormWindow?.observeServerAlive(await TmuxManager.getServerPid(this.tmuxSessionName))) {
             this.emit("tmux_server_crash", this.name);
         }
         this.startupAdmission?.();
@@ -13514,6 +13451,7 @@ export class Daemon extends EventEmitter {
         let lastDialog = null;
         let lastTransient = null;
         let captureFailures = 0;
+        let lastPane = null;
         let attempts = 0;
         // A safety-critical startup choice is one-shot. If the CLI has not
         // repainted after Enter, let the following hold-only entry report it
@@ -13537,11 +13475,13 @@ export class Daemon extends EventEmitter {
             try {
                 pane = await this.tmux.capturePane();
                 this.startupAdmission?.();
+                lastPane = pane;
             }
             catch (err) {
                 this.startupAdmission?.();
                 // Transient tmux trouble is not evidence about the CLI. Returning false
                 // here would clear the session; retry within the budget instead.
+                lastPane = null;
                 captureFailures++;
                 this.logger.debug({ err, captureFailures }, "capture-pane failed during the startup dialog scan — retrying");
                 // Only a POSITIVE dead pane ends the scan; an unanswerable liveness
@@ -13652,15 +13592,12 @@ export class Daemon extends EventEmitter {
                                 // each have seen a respawn, pause or stop.
                                 if (!owned())
                                     return false;
-                                const keyScreen = this.nativePaneLifecycle ? await this.tmux.capturePane() : answeredPane;
-                                if (!owned() || !Daemon.dialogMatches(dialog, keyScreen))
-                                    return false;
                                 if (key === "Up" || key === "Down" || key === "Enter" || key === "Escape") {
-                                    if (!await (this.nativePaneLifecycle ? this.tmux.sendSpecialKey(key, undefined, { kind: "dialog", screen: keyScreen }) : this.tmux.sendSpecialKey(key)))
+                                    if (!await this.tmux.sendSpecialKey(key))
                                         return false;
                                 }
                                 else {
-                                    if (!await (this.nativePaneLifecycle ? this.tmux.sendKeys(key, { kind: "dialog", screen: keyScreen }) : this.tmux.sendKeys(key)))
+                                    if (!await this.tmux.sendKeys(key))
                                         return false;
                                 }
                                 await new Promise(r => setTimeout(r, 200));
@@ -13674,8 +13611,7 @@ export class Daemon extends EventEmitter {
                         // Wait for next screen to render — bounded by what is left of the budget.
                         const renderWait = Math.max(0, Math.min(10_000, remaining()));
                         if (this.controlClient) {
-                            const wid = this.nativePaneLifecycle ? ownerTmux.getWindowId()
-                                : readFileSync(join(this.instanceDir, "window-id"), "utf-8").trim();
+                            const wid = readFileSync(join(this.instanceDir, "window-id"), "utf-8").trim();
                             await this.controlClient.waitForIdle(wid, renderWait);
                         }
                         else {
@@ -13711,15 +13647,15 @@ export class Daemon extends EventEmitter {
                 // scan parked on the old limit text.
                 const codexReady = this.backend.binaryName !== "codex"
                     || this.isCodexLivePaneSnapshot(pane);
-                const nativeComposerReady = !this.nativePaneLifecycle || (this.backend?.readInputRow
-                    ? this.backend.readInputRow(pane) !== null : this.backend?.isDeliveryInputReadyPane?.(pane) === true);
-                if (readyPatternMatches && codexReady && nativeComposerReady) {
+                if (readyPatternMatches && codexReady) {
                     cleanReadyPolls++;
                     if (cleanReadyPolls >= 2 || remaining() <= 0) {
                         // A real ready prompt (with no fatal dialog on screen — those are
                         // matched above, before this check) means the fatal screen is gone,
                         // e.g. the user fixed the config and the instance respawned.
                         this.fatalStartupBlocked = false;
+                        if (owned())
+                            this.takeQuotaReplayBaseline(pane);
                         return true;
                     }
                     await sleep();
@@ -13758,6 +13694,8 @@ export class Daemon extends EventEmitter {
             this.logger.warn({ attempts, budgetMs, captureFailures }, "Startup scan exhausted without a ready prompt or a known dialog — assuming ready (unknown CLI screen)");
         }
         this.startupAdmission?.();
+        if (owned() && lastPane !== null && !lastDialog && !lastTransient)
+            this.takeQuotaReplayBaseline(lastPane);
         return true;
     }
     /**
@@ -13838,16 +13776,6 @@ export class Daemon extends EventEmitter {
         void refresh.call(this.backend).then(() => this.saveSessionId(), () => { });
     }
     saveSessionId() {
-        if (this.nativePaneLifecycle) {
-            try {
-                this.nativePaneLifecycle.checkpointSession();
-                this.ownedWorkingSession = this.backend?.getSessionId() ?? null;
-            }
-            catch (err) {
-                this.logger.warn({ err }, "Native conversation checkpoint is unconfirmed");
-            }
-            return;
-        }
         // When a resume failure has forced a fresh start, don't persist the stale id
         // back from statusline.json — that would re-arm --continue and re-loop.
         if (this.skipResume)