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

package/dist/daemon.js

@@ -1,5 +1,4 @@
-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";
@@ -23,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";
@@ -51,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";
@@ -61,7 +59,6 @@ import { CLAUDE_CREDIT_BALANCE_LOW, CLAUDE_MODEL_USAGE_LIMIT, CLAUDE_USAGE_LIMIT
 import { t } from "./locale.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";
@@ -1121,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. */
@@ -1800,7 +1796,6 @@ 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();
-    nativeQuotaReplayTaken = false;
     quotaReplay = null;
     paneQuotaPatterns() {
         if (!["codex", "grok"].includes(this.backend?.binaryName ?? ""))
@@ -1836,11 +1831,7 @@ export class Daemon extends EventEmitter {
     }
     /** Before admission, this launch may absorb ONLY rows positively known before its resume. */
     takeQuotaReplayBaseline(pane) {
-        // Native captures carry only a runner-frozen pre-launch proof, revalidated with this capture's owner and seq.
-        const native = !this.nativeQuotaReplayTaken ? this.nativePaneLifecycle?.quotaReplayHistory?.() : null;
-        if (this.nativePaneLifecycle)
-            this.nativeQuotaReplayTaken = true;
-        const history = this.quotaReplay ?? (native ? { ...native, spawn: this.spawnGeneration, fence: this.launchFenceEpoch, attempt: this.launchAttempt } : null);
+        const history = this.quotaReplay;
         if (!history)
             return;
         this.quotaReplay = null;
@@ -1906,15 +1897,6 @@ export class Daemon extends EventEmitter {
     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;
-    /** Coarse status for the representative quota hint; never exports model names or transcript text. */
-    quotaPaused() {
-        if (this.usageLimitHold)
-            return true;
-        const pause = this.usagePauseNotice;
-        return !!pause && (pause.resetAt === null
-            ? performance.now() - pause.at < Daemon.USAGE_PAUSE_NOTICE_WINDOW_MS
-            : Date.now() < pause.resetAt);
-    }
     /**
      * #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
@@ -2081,94 +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; }
-    /** cc3ce4fe: the CLI version this pane's launch actually ran, as its helper recorded it (undefined: not known). */
-    nativePaneCliVersion() { try {
-        return this.nativePaneLifecycle?.snapshot?.()?.cliVersion;
-    }
-    catch {
-        return undefined;
-    } }
-    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;
@@ -2180,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);
@@ -2203,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
@@ -2266,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"
@@ -2294,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),
         };
@@ -2339,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 {
@@ -2399,18 +2278,15 @@ export class Daemon extends EventEmitter {
             : humanVerificationId ? `[agend-human-id:${humanVerificationId}]` : null;
         if (!marker || !formatted.startsWith(marker))
             return;
-        let found = verdict.transcriptCheckpoint ?? null;
-        if (!found) {
+        let checkpoint = verdict.transcriptCheckpoint ?? null;
+        if (!checkpoint) {
             try {
-                found = await this.transcriptMonitor?.reconciliationCheckpoint() ?? null;
+                checkpoint = await this.transcriptMonitor?.reconciliationCheckpoint() ?? null;
             }
             catch (err) {
                 this.logger.debug({ err }, "Could not checkpoint the transcript before a queued hand-off");
             }
         }
-        // main→alpha sync: a hand-off record is judged against a local transcript file. A native or remote runtime's
-        // transcript (no local path) has none: it runs as before (✅ at the hand-off), as with no checkpoint at all.
-        const checkpoint = found && typeof found.path === "string" && typeof found.offset === "number" ? { path: found.path, offset: found.offset } : null;
         if (!checkpoint)
             return; // nothing could judge it later: it runs as before (✅ at the hand-off)
         const entry = {
@@ -2678,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;
@@ -2717,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";
@@ -2910,143 +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 (this.backend?.binaryName === "codex") {
-                        const native = this.nativePaneLifecycle, spawn = this.spawnGeneration, fence = this.launchFenceEpoch, attempt = this.launchAttempt;
-                        try {
-                            const pane = await acquired.pane.capturePane();
-                            this.startupAdmission?.();
-                            if (!this.startupAborted && !this.deliveryWritesStopping && this.nativePaneLifecycle === native && this.tmux === acquired.pane
-                                && spawn === this.spawnGeneration && fence === this.launchFenceEpoch && attempt === this.launchAttempt && native.current())
-                                this.takeQuotaReplayBaseline(pane);
-                        }
-                        catch { /* An old runner or unavailable proof keeps the existing fail-closed scanner. */ }
-                    }
-                }
-                else {
-                    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) {
@@ -3065,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
@@ -3121,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.
         }
@@ -3182,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 });
                 }
             });
         }
@@ -3198,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;
@@ -3291,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)
@@ -3503,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 };
@@ -3569,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) {
@@ -3616,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",
@@ -3771,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;
@@ -3806,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;
@@ -4053,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();
                                 }
                             }
@@ -4201,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,
@@ -4397,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());
@@ -4776,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.
@@ -4855,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;
             }
         }
@@ -4875,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.
@@ -4890,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);
@@ -5052,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;
@@ -5145,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));
@@ -5393,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();
@@ -5415,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) {
@@ -5572,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;
@@ -5610,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())
@@ -5705,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");
@@ -5793,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
@@ -5850,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");
@@ -5859,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,
@@ -5867,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");
@@ -5911,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")
@@ -6049,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 });
@@ -6144,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 });
@@ -6308,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);
             }
@@ -6410,7 +6082,7 @@ export class Daemon extends EventEmitter {
         // writing a marker would re-inject a continuation for a finished turn.
         // #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 (!this.nativePaneLifecycle && !meta.resumedContinuationOf && !armed.completionDelivered && !queuedHandoff) {
+        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, {
@@ -6642,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;
@@ -7019,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);
         }
@@ -7043,7 +6715,7 @@ export class Daemon extends EventEmitter {
                 resolve(delivered);
             });
             try {
-                this.broadcastFleetMessage({
+                this.ipcServer.broadcast({
                     type: "fleet_outbound",
                     tool: "reply",
                     args,
@@ -7614,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,
@@ -7667,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)
@@ -7691,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);
             }
         }
@@ -7771,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,
@@ -7787,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: "" });
         }
     }
     /**
@@ -7954,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,
@@ -9335,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 => {
@@ -9613,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();
@@ -10399,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;
@@ -10486,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;
+        }
+        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 hold("output_changed");
+        return sent;
     }
     async writeMessageToPane(formatted, initialWindowId, handingOffToNativeQueue, status, submissionId, 
     // Last and defaulted so the positional callers that ignore the outcome stay
@@ -10660,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;
@@ -10730,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,
@@ -10807,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) {
@@ -10902,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;
@@ -10943,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)");
@@ -11081,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
@@ -11134,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) {
@@ -11186,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);
@@ -11274,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)
             }
@@ -11494,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";
@@ -11759,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)
@@ -11784,10 +11282,6 @@ export class Daemon extends EventEmitter {
             if (!current() || !guard.accept(pane))
                 return false;
             baseline = this.paneEvidence(pane, signature);
-            if (native && this.backend?.binaryName === "codex") {
-                const counts = this.paneQuotaPatterns().map(ep => ({ key: Daemon.errorPatternKey(ep), count: Daemon.countOccurrences(ep.pattern, pane) }));
-                baseline.quotaHistory = { spawn: ownerGeneration, fence: ownerFence, attempt: this.launchAttempt, tmux: ownerTmux, window: ownerWindow, counts, marker: signature.value, occurrences: baseline.payload };
-            }
         }
         else {
             baseline = await this.capturePaneEvidence(signature);
@@ -11891,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
@@ -11960,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;
         }
@@ -11993,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;
@@ -12049,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)) {
@@ -12103,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);
@@ -12146,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 },
@@ -12172,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") {
@@ -12249,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 },
@@ -12272,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 },
@@ -12299,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: {
@@ -12314,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);
@@ -12330,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,
@@ -12384,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,
@@ -12520,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
@@ -12683,7 +12120,6 @@ export class Daemon extends EventEmitter {
         this.cancelCapacityNudge("the instance was stopped, paused or respawned");
         this.lastErrorEpisode = null;
         this.quotaReplay = null;
-        this.nativeQuotaReplayTaken = false;
         this.quotaInput = null;
         this.nudgeBaselines = null;
         // A relaunch settles any outstanding quit watch: the CLI came back.
@@ -12899,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;
@@ -13487,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");
         }
@@ -13524,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);
@@ -13751,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"];
@@ -13778,8 +13202,6 @@ 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;
@@ -13892,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?.();
@@ -14170,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));
@@ -14192,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 {
@@ -14229,9 +13647,7 @@ 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
@@ -14360,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)