@songsid/agend 2.3.4-beta.6 → 2.3.5-alpha.2

package/dist/daemon.js

@@ -1,3 +1,4 @@
+import { nativePaneToolRefusal } from "./native-pane-tools.js";
 import { dialogScreenText } from "./dialog-screen-text.js";
 import { readActiveKiroModel } from "./backend/kiro.js";
 import { dashboardAccessOf } from "./dashboard-permissions.js";
@@ -20,7 +21,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 { TmuxManager, resolveTmuxLogicalSize } from "./tmux-manager.js";
+import { resolveTmuxLogicalSize } from "./tmux-manager.js";
 import { TranscriptMonitor } from "./transcript-monitor.js";
 import { createTranscriptSource } from "./transcript-sources.js";
 import { TranscriptTurnLedger } from "./transcript-turns.js";
@@ -48,6 +49,7 @@ 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";
@@ -57,6 +59,7 @@ import { CLAUDE_CREDIT_BALANCE_LOW, CLAUDE_MODEL_USAGE_LIMIT, CLAUDE_USAGE_LIMIT
 import { t } from "./locale.js";
 import { 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";
@@ -1112,6 +1115,7 @@ 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. */
@@ -1943,9 +1947,79 @@ 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; }
+    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) {
+    backendOutage, paneTransport) {
         super();
         this.name = name;
         this.config = config;
@@ -1957,6 +2031,7 @@ 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);
@@ -2038,12 +2113,19 @@ export class Daemon extends EventEmitter {
         return outcome === "begun";
     }
     async durableAttemptEvidence(windowId, handingOffToNativeQueue, steer, rawPaste = false) {
-        let checkpoint = null;
-        try {
-            checkpoint = await this.transcriptMonitor?.reconciliationCheckpoint() ?? null;
+        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");
         }
-        catch (err) {
-            this.logger.debug({ err }, "Could not checkpoint transcript before durable delivery");
+        else {
+            try {
+                checkpoint = await this.transcriptMonitor?.reconciliationCheckpoint() ?? null;
+            }
+            catch (err) {
+                this.logger.debug({ err }, "Could not checkpoint transcript before durable delivery");
+            }
         }
         const submissionMode = rawPaste ? "raw_paste" : steer
             ? "steer"
@@ -2059,8 +2141,9 @@ export class Daemon extends EventEmitter {
             backendVersion,
             windowId: windowId ?? this.tmux?.getWindowId() ?? null,
             transcriptPath: checkpoint?.path ?? null,
-            transcriptOffset: checkpoint?.offset ?? null,
-            transcriptSessionId: checkpoint?.sessionId ?? null,
+            transcriptOffset: runtimeTranscript?.cursor.offset ?? checkpoint?.offset ?? null,
+            transcriptSessionId: runtimeTranscript?.cursor.sessionId ?? checkpoint?.sessionId ?? null,
+            ...(runtimeTranscript ? { runtimeTranscript } : {}),
             submissionMode,
             queueResumePolicy: queueResumePolicyForAttempt(backend, backendVersion, submissionMode),
         };
@@ -2103,17 +2186,25 @@ 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,
-            path: checkpoint.path,
-            offset: checkpoint.offset,
+            ...location,
             current: () => !this.deliveryWritesStopping && spawn === this.spawnGeneration && fence === this.launchFenceEpoch,
             consumed: (via, evidence) => {
                 try {
@@ -2194,24 +2285,34 @@ export class Daemon extends EventEmitter {
         const spawn = this.spawnGeneration;
         const fence = this.launchFenceEpoch;
         let last = "unavailable";
-        let outcome = "delivered";
-        let evidence = OUTPUT_EDGE_ONLY_EVIDENCE;
+        const native = !!checkpoint.runtime || !!this.nativePaneLifecycle;
+        let outcome = native ? "uncertain" : "delivered";
+        let evidence = native ? "runtime-transcript-unconfirmed" : 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 = await scanTranscriptForDeliveryMarker(checkpoint.path, checkpoint.offset, checkpoint.backend, needle);
+                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;
+                }
                 if (look === "user" || look === "absorbed" || look === "queued") {
                     found = true;
                     outcome = "delivered";
                     evidence = transcriptMarkerEvidence(look, !!rawPaste);
                     break;
                 }
-                last = look;
+                last = look === "pending" ? "unavailable" : look;
                 if (spawn !== this.spawnGeneration || fence !== this.launchFenceEpoch) {
                     last = "unavailable";
                     break;
@@ -2223,13 +2324,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" && evidence === OUTPUT_EDGE_ONLY_EVIDENCE) {
+            if (last === "no-match" && !found) {
                 outcome = "uncertain";
                 evidence = "unverifiable-no-transcript-marker";
             }
         }
         catch (err) {
-            this.logger.debug({ err }, "Transcript proof of a delivery failed — keeping the output-edge outcome");
+            this.logger.debug({ err }, "Transcript proof unavailable — preserving the conservative outcome");
         }
         if (rawPaste && !found) {
             outcome = "uncertain";
@@ -2416,128 +2517,130 @@ export class Daemon extends EventEmitter {
             }
         }
         catch { /* corrupt/missing — ignore */ }
-        // 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);
+        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);
+                        }
                     }
+                    // Batch response for prune path
+                    this.ipcServer?.send(socket, { type: "query_sessions_response", sessions });
                 }
-                // 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");
-                });
-            }
-            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(() => 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();
+                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?.();
-                    await oldTmux.killWindow();
+                    if (this.startupAborted)
+                        throw Error("Native launch was superseded");
+                });
+                this.tmux = acquired.pane;
+                this.nativeTranscriptSource = acquired.source;
+                nativeDisposition = acquired.disposition;
+                this.lastSpawnAt = Date.now();
+                this.setProcessStatus("running");
+                this.bindInstanceStateOutputListener(this.tmux.getWindowId());
+                this.saveSessionId();
+                // New/resumed native processes can still be painting their first frame. Keep deliveries behind the same
+                // bounded dialog/readiness scan as local startup. An already-running reattachment may be busy: do not
+                // wait for that work to finish or inject a startup key into it.
+                if (acquired.disposition !== "reattached") {
+                    if (!await this.finishStartupScan(120_000))
+                        throw Error("Native CLI exited during startup; retained session was not replaced");
                     this.startupAdmission?.();
-                    this.logger.info({ savedId }, "Killed old tmux window for fresh start");
+                    if (this.startupAborted || this.deliveryWritesStopping || !this.nativePaneLifecycle.current())
+                        throw Error("Native launch was superseded");
                 }
             }
-        }
-        const resumed = await this.spawnClaudeWindow();
-        this.startupAdmission?.();
-        this.isNewSession = !resumed;
-        if (!resumed) {
-            await this.injectSnapshotMessage(this.startupAdmission);
-            this.startupAdmission?.();
+            finally {
+                this.endSpawn();
+            }
         }
         else {
-            // Clean up stale snapshot file — resume restored full context, snapshot not needed
-            try {
-                unlinkSync(join(this.instanceDir, "rotation-state.json"));
+            // 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");
+                    }
+                }
+            }
+            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 */ }
             }
-            catch { /* may not exist */ }
         }
+        if (nativeDisposition)
+            this.isNewSession = nativeDisposition === "fresh";
         // #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.maybeResumeInterruptedTurn().catch(() => "unknown");
+        const legacyResume = this.nativePaneLifecycle ? Promise.resolve("unknown") : this.maybeResumeInterruptedTurn().catch(() => "unknown");
         const recoveryOwner = JSON.stringify(this.interactionOwner());
         void Promise.allSettled([legacyResume]).then(() => {
             if (JSON.stringify(this.interactionOwner()) === recoveryOwner) {
@@ -2556,7 +2659,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(createTranscriptSource(this.config.backend ?? "claude-code", this.config.working_directory, this.credentialProfileStore(), () => this.backend?.transcriptLaunch?.() ?? null));
+            this.transcriptMonitor = this.buildTranscriptMonitor(this.nativeTranscriptSource ?? 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
@@ -2612,13 +2715,15 @@ export class Daemon extends EventEmitter {
             if (hangConfig?.enabled !== false) {
                 this.hangDetector = new HangDetector();
             }
-            // 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();
-            });
+            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();
+                });
+            }
             // Context rotation removed: all CLI backends have built-in auto-compact.
             // Crash recovery (health check + respawn with snapshot) is retained below.
         }
@@ -2669,7 +2774,7 @@ export class Daemon extends EventEmitter {
                 this.socketPids.delete(socket);
                 // Notify fleet manager so it can clean up sessionRegistry
                 if (sessionName !== this.name) {
-                    this.ipcServer?.broadcast({ type: "session_disconnected", sessionName });
+                    this.broadcastFleetMessage({ type: "session_disconnected", sessionName });
                 }
             });
         }
@@ -2685,11 +2790,16 @@ 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.ipcServer?.broadcast({ type: "mcp_ready", sessionName });
+        this.broadcastFleetMessage({ 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;
@@ -2773,6 +2883,8 @@ 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)
@@ -2983,6 +3095,8 @@ 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 };
@@ -3047,7 +3161,7 @@ export class Daemon extends EventEmitter {
         this.mcpDeathNotifiedForPid = null;
         this.mcpDeathDeferredForPid = null;
         this.clearMcpRestartRequest();
-        if (pid && mcpServerState(this.instanceDir).state !== "alive")
+        if (!this.nativePaneLifecycle && pid && mcpServerState(this.instanceDir).state !== "alive")
             this.repairMcpPidSlot(pid, source);
     }
     emitMcpRecovered(source, pid) {
@@ -3094,6 +3208,26 @@ 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",
@@ -3205,13 +3339,13 @@ export class Daemon extends EventEmitter {
                     let inWindowLossBurst = false;
                     let nullReason;
                     if (!paneStatus) {
-                        const serverAlive = await TmuxManager.sessionExists(this.tmuxSessionName);
+                        const serverAlive = await this.paneHost.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 TmuxManager.getServerPid(this.tmuxSessionName) : null;
+                        const serverPid = serverAlive ? await this.paneHost.getServerPid(this.tmuxSessionName) : null;
                         if (discardStaleHealth())
                             return;
                         const generationChanged = serverAlive && this.stormWindow?.observeServerAlive(serverPid) === true;
@@ -3240,7 +3374,7 @@ export class Daemon extends EventEmitter {
                             // the window truly no longer exists vs a transient query glitch.
                             nullReason = "no_window";
                             try {
-                                const windows = await TmuxManager.listWindowsStrict(this.tmuxSessionName, this.controlClient);
+                                const windows = await this.paneHost.listWindowsStrict(this.tmuxSessionName, this.controlClient);
                                 if (discardStaleHealth())
                                     return;
                                 this.windowQueryFailureTicks = 0;
@@ -3485,10 +3619,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 TmuxManager.listWindows(this.tmuxSessionName);
+                            const windows = await this.paneHost.listWindows(this.tmuxSessionName);
                             for (const w of windows) {
                                 if (w.name === this.name) {
-                                    const tm = new TmuxManager(this.tmuxSessionName, w.id);
+                                    const tm = this.paneHost.bind(this.tmuxSessionName, w.id);
                                     await tm.killWindow();
                                 }
                             }
@@ -3631,7 +3765,7 @@ export class Daemon extends EventEmitter {
             // Force the next ready capture to emit a fresh transition after respawn.
             this.instanceState = "working";
         }
-        this.ipcServer?.broadcast({
+        this.broadcastFleetMessage({
             type: "instance_process_state",
             instanceName: this.name,
             status,
@@ -3827,12 +3961,15 @@ 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 pollTmux.sendSpecialKey(key);
+                                sent = await (this.nativePaneLifecycle ? pollTmux.sendSpecialKey(key, undefined, { kind: "dialog", screen: keyScreen }) : pollTmux.sendSpecialKey(key));
                             }
                             else if (dialog.literalKeys) {
-                                sent = await pollTmux.sendKeys(key); // typed, no Enter (#2872)
+                                sent = await (this.nativePaneLifecycle ? pollTmux.sendKeys(key, { kind: "dialog", screen: keyScreen }) : pollTmux.sendKeys(key)); // typed, no Enter (#2872)
                             }
                             else {
                                 sent = await pollTmux.pasteText(key, this.systemPasteOptions());
@@ -4195,7 +4332,20 @@ export class Daemon extends EventEmitter {
      */
     async sendEscape() {
         const cancelKey = this.backend?.getCancelKey() ?? "Escape";
-        await this.tmux?.sendSpecialKey(cancelKey);
+        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);
     }
     /**
      * Drop every not-yet-started pane delivery which predates a user cancel.
@@ -4253,7 +4403,7 @@ export class Daemon extends EventEmitter {
                 return;
             const outcome = follower.look(pane);
             if (outcome) {
-                this.ipcServer?.broadcast({ type: "compact_pane_result", id, owner, outcome });
+                this.broadcastFleetMessage({ type: "compact_pane_result", id, owner, outcome });
                 return;
             }
         }
@@ -4273,7 +4423,7 @@ export class Daemon extends EventEmitter {
         const reportSwitch = (result) => {
             if (!ownSwitch)
                 return;
-            this.ipcServer?.broadcast({ type: "runtime_switch_result", id: ownSwitch.id, ...result });
+            this.broadcastFleetMessage({ 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.
@@ -4288,7 +4438,7 @@ export class Daemon extends EventEmitter {
             if (!notifyWritten || told)
                 return;
             told = true;
-            this.ipcServer?.broadcast({ type: "raw_paste_written", id: notifyWritten, outcome: written ? "written" : "not_written",
+            this.broadcastFleetMessage({ 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);
@@ -4450,10 +4600,11 @@ export class Daemon extends EventEmitter {
         const press = (target, cursor, key) => this.paneWriteLock.run(async () => {
             if (this.tmux !== tmux)
                 return false;
-            const now = claudeSwitchDialog(await read());
+            const screen = await read();
+            const now = claudeSwitchDialog(screen);
             if (!now || now.kind !== "model" || now.target !== target || (cursor !== null && now.cursor !== cursor))
                 return false;
-            return tmux.sendSpecialKey(key);
+            return this.nativePaneLifecycle ? tmux.sendSpecialKey(key, undefined, { kind: "dialog", screen }) : tmux.sendSpecialKey(key);
         });
         const gone = async () => {
             const until = performance.now() + OWN_SWITCH_SETTLE_MS;
@@ -4542,9 +4693,12 @@ 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.tmux.sendSpecialKey(key)
-                            : await this.tmux.sendKeys(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));
                         if (!ok)
                             return false;
                         await new Promise(resolve => setTimeout(resolve, 100));
@@ -4787,7 +4941,7 @@ export class Daemon extends EventEmitter {
         await this.tmux.sendSpecialKey("Escape").catch(() => false);
         return true;
     }
-    async stop() {
+    async stop(options = {}) {
         this.publishWorkingState("before_stop");
         this.logger.info("Stopping daemon instance");
         this.clearQuitRelaunchWatch();
@@ -4809,8 +4963,18 @@ 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.ipcServer?.broadcast({ type: "shutdown" });
+        this.broadcastFleetMessage({ 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) {
@@ -4976,7 +5140,11 @@ export class Daemon extends EventEmitter {
                     || !this.paneAuthoritativelyIdle(pane) || this.inputTransientInPane(pane)
                     || this.backend?.backgroundWorkRunning?.(pane) === true)
                     return;
-                if (await tmux.getPaneInputMode?.() !== "raw" || !current())
+                if (this.nativePaneLifecycle ? !this.nativePaneLifecycle.current() || this.nativePaneLifecycle.mcpProof() !== "alive"
+                    || !!this.backend?.isDeliveryInputReadyPane && !this.backend.isDeliveryInputReadyPane(pane)
+                    : await tmux.getPaneInputMode?.() !== "raw")
+                    return;
+                if (!current())
                     return;
                 const evidence = await this.durableAttemptEvidence(tmux.getWindowId(), false, false);
                 if (!current())
@@ -5067,7 +5235,7 @@ export class Daemon extends EventEmitter {
             this.logger.debug({ err }, "Interaction listener failed");
         }
         try {
-            this.ipcServer?.broadcast({ type: "instance_interaction", instanceName: this.name, interaction });
+            this.broadcastFleetMessage({ type: "instance_interaction", instanceName: this.name, interaction });
         }
         catch (err) {
             this.logger.debug({ err }, "Interaction broadcast failed");
@@ -5155,6 +5323,56 @@ 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
@@ -5162,7 +5380,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) {
+    async respondToInstanceStateQuery(msg, socket, send) {
         try {
             if (msg.deliveryIdle === true) {
                 await this.captureAndEvaluateInstanceState("delivery_idle_gate");
@@ -5171,7 +5389,7 @@ export class Daemon extends EventEmitter {
                 await this.captureAndEvaluateInstanceState("state_query");
             }
             const snapshot = this.getInstanceStateSnapshot();
-            this.ipcServer?.send(socket, {
+            const reply = {
                 type: "instance_state_response",
                 requestId: msg.requestId,
                 instanceName: this.name,
@@ -5179,7 +5397,11 @@ 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");
@@ -5219,7 +5441,49 @@ 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")
@@ -5315,7 +5579,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.ipcServer?.broadcast({
+                this.broadcastFleetMessage({
                     type: "instance_state", instanceName: this.name, state: "paused", pausedAt: this.lastPausedAt,
                 });
                 this.emit("auto_paused", { name: this.name, pausedAt: this.lastPausedAt });
@@ -5410,7 +5674,7 @@ export class Daemon extends EventEmitter {
                 this.resumeRuntimeMonitors();
                 this.publishWorkingState("execution");
                 this.logger.info("Instance auto-woke");
-                this.ipcServer?.broadcast({
+                this.broadcastFleetMessage({
                     type: "instance_state", instanceName: this.name, state: this.instanceState, pausedAt: null,
                 });
                 this.emit("auto_woke", { name: this.name });
@@ -5570,7 +5834,7 @@ export class Daemon extends EventEmitter {
             this.logStateEdge(previous, snapshot);
             this.publishWorkingState("execution");
             this.emit("instance_state", { name: this.name, ...snapshot });
-            this.ipcServer?.broadcast({ type: "instance_state", instanceName: this.name, ...snapshot });
+            this.broadcastFleetMessage({ type: "instance_state", instanceName: this.name, ...snapshot });
             if (snapshot.state === "stuck" && pane && this.instanceStateReadyPattern) {
                 this.handleStuckTransition(pane, snapshot, this.instanceStateReadyPattern);
             }
@@ -5670,7 +5934,7 @@ export class Daemon extends EventEmitter {
         // during the continuation boots clean instead of chaining resumes.
         // #2544: a reply that settled before this arm already answered the person —
         // writing a marker would re-inject a continuation for a finished turn.
-        if (!meta.resumedContinuationOf && !armed.completionDelivered) {
+        if (!this.nativePaneLifecycle && !meta.resumedContinuationOf && !armed.completionDelivered) {
             const resumeBackend = this.config.backend ?? this.backend?.binaryName ?? this.runtimeIdentity?.backend;
             const resumeCwd = this.config.working_directory ?? "";
             writeInFlightTurnMarker(this.instanceDir, {
@@ -5902,7 +6166,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
-            && mcpServerState(this.instanceDir).state === "dead") {
+            && (this.nativePaneLifecycle ? this.nativePaneLifecycle.mcpProof() === "dead" : mcpServerState(this.instanceDir).state === "dead")) {
             this.turnReplyGuard.complete(turn.generation);
             void this.sendProxyReply(pane, turn.target);
             return;
@@ -6279,7 +6543,7 @@ export class Daemon extends EventEmitter {
                 }
             });
         }
-        if (!this.ipcServer) {
+        if (!this.fleetTransportAvailable()) {
             this.logger.error(`${logLabel} failed — no adapter or fleet IPC route`);
             return Promise.resolve(false);
         }
@@ -6303,7 +6567,7 @@ export class Daemon extends EventEmitter {
                 resolve(delivered);
             });
             try {
-                this.ipcServer.broadcast({
+                this.broadcastFleetMessage({
                     type: "fleet_outbound",
                     tool: "reply",
                     args,
@@ -6874,7 +7138,7 @@ export class Daemon extends EventEmitter {
         if (next === this.currentActivity)
             return;
         this.currentActivity = next;
-        this.ipcServer?.broadcast({
+        this.broadcastFleetMessage({
             type: "instance_activity",
             instanceName: this.name,
             activity: next,
@@ -7031,7 +7295,7 @@ export class Daemon extends EventEmitter {
             return;
         this.lastProgressBroadcast = rendered;
         this.lastProgressBroadcastAt = Date.now();
-        this.ipcServer?.broadcast({
+        this.broadcastFleetMessage({
             type: "instance_progress",
             instanceName: this.name,
             progress: rendered,
@@ -7047,7 +7311,7 @@ export class Daemon extends EventEmitter {
         if (this.lastProgressBroadcast !== "") {
             this.lastProgressBroadcast = "";
             this.lastProgressBroadcastAt = Date.now();
-            this.ipcServer?.broadcast({ type: "instance_progress", instanceName: this.name, progress: "" });
+            this.broadcastFleetMessage({ type: "instance_progress", instanceName: this.name, progress: "" });
         }
     }
     /**
@@ -7212,7 +7476,7 @@ export class Daemon extends EventEmitter {
     reportCrossInstanceDeliveryFailure(meta, verdict, error) {
         if (!meta.from_instance)
             return;
-        this.ipcServer?.broadcast({
+        this.broadcastFleetMessage({
             type: "cross_instance_delivery_failed",
             senderSession: meta.from_instance,
             targetInstance: this.name,
@@ -8572,13 +8836,14 @@ 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: () => 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),
+                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),
                 sleep: ms => new Promise(resolve => setTimeout(resolve, ms)),
                 now: () => performance.now(),
             }, pane => {
@@ -8849,12 +9114,19 @@ export class Daemon extends EventEmitter {
         if (!check || !this.tmux)
             return !check;
         try {
-            const mode = await this.tmux.getPaneInputMode?.();
-            if (mode !== "raw") {
+            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) {
                 this.resetFooterFallback();
                 return false;
             }
-            return this.deliveryInputReadyPane(await this.tmux.capturePane());
+            const pane = await this.tmux.capturePane();
+            if (this.nativePaneLifecycle && (!this.nativePaneLifecycle.current() || this.nativePaneLifecycle.mcpProof() !== "alive"))
+                return false;
+            return this.deliveryInputReadyPane(pane);
         }
         catch {
             this.resetFooterFallback();
@@ -9624,38 +9896,84 @@ export class Daemon extends EventEmitter {
     async sendDeliveryEnterAfterAvailability(phase, stillCurrent, durableAttempt, onInputHeld) {
         // A recovery Enter may have waited for a transient while cancel or spawn replaced the delivery: check here, and
         // again after every wait below, at the last point before the tmux write.
-        // 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 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 current = () => this.tmux === tmux && this.spawnGeneration === generation && this.launchFenceEpoch === fence
-            && !this.deliveryWritesStopping && (!stillCurrent || stillCurrent());
+        const windowId = native ? tmux?.getWindowId() : undefined;
+        // A native Windows pane keeps #2958's full fence (its launch can be replaced under the same handle).
+        const current = () => this.tmux === tmux && !this.deliveryWritesStopping && (!stillCurrent || stillCurrent())
+            && (!native || (!!windowId && !!backend && this.backend === backend && this.spawnGeneration === generation
+                && this.launchFenceEpoch === fence && tmux.getWindowId() === windowId));
         if (!current())
             return false;
         // The pasted text may still be in the box: the caller keeps it uncertain (no false failure, no second paste).
-        const hold = () => {
-            onInputHeld?.("pane-in-mode");
-            this.logger.warn({ phase }, "The pane stayed in a tmux mode; Enter withheld");
+        // 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_mode")
+                this.logger.warn({ phase, reason }, "The pane stayed in a tmux mode; Enter withheld");
+            else
+                this.logger.warn({ phase, reason }, "Native delivery Enter withheld by its safety check");
             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. (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.)
+        // 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.
         const modeDeadline = performance.now() + PANE_MODE_ENTER_WAIT_MS;
+        let pane;
+        let positiveRefusals = 0, enterMarked = false, positiveRetryDeadline = Infinity;
         for (;;) {
-            const mode = await this.waitWhilePaneInMode(phase, current, modeDeadline);
+            const mode = await this.waitWhilePaneInMode(phase, current, Math.min(modeDeadline, positiveRetryDeadline));
             if (mode === "stale")
                 return false;
             if (mode === "held")
-                return hold();
+                return hold("pane_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;
+            }
             if (await this.paneInTmuxMode(phase)) {
                 if (!current())
                     return false;
                 if (performance.now() >= modeDeadline)
-                    return hold();
+                    return hold("pane_mode");
                 await new Promise(r => setTimeout(r, PANE_MODE_POLL_MS));
                 if (!current())
                     return false;
@@ -9663,54 +9981,110 @@ export class Daemon extends EventEmitter {
             }
             if (!current())
                 return false;
-            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;
+            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 }) : 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) {
+                this.logger.error({
+                    phase,
+                    tmuxError: this.tmux.getLastSendSpecialKeyError() ?? "unknown tmux send-keys failure",
+                }, "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());
+        const hold = (reason) => {
+            if (current() && !this.nativeDeliveryHold())
+                this.nativeEnterHold = { key: `${this.bootId}:${generation}:${fence}`, since: Date.now(), spawn: generation, fence };
+            this.logger.warn({ reason }, "Native delivery paste held by its safety check");
+            return false;
+        };
+        const deadline = performance.now() + 2000;
+        for (let attempt = 0; attempt < 5; 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");
             try {
-                finalPane = await tmux.capturePane();
+                if (backend?.getRuntimeDialogs?.().some(dialog => Daemon.dialogMatches(dialog, screen)))
+                    return hold("dialog");
             }
             catch {
-                finalPane = null;
+                return hold("check_failed");
             }
             if (!current())
                 return false;
-            let dialog;
+            if (performance.now() >= deadline)
+                return hold("output_changed");
+            let sent;
             try {
-                dialog = finalPane === null ? undefined : (this.backend?.getRuntimeDialogs?.() ?? []).find(d => Daemon.dialogMatches(d, finalPane))?.description;
+                sent = await pane.pasteBuffer(text, { guard: current, proof: { kind: "composer", screen } });
             }
             catch {
-                dialog = undefined;
+                return hold("unconfirmed");
             }
-            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)");
+            if (sent)
+                return true; // Exactly one successful paste ends the loop, before any Enter.
+            if (!current())
                 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 sent;
+        return hold("output_changed");
     }
     async writeMessageToPane(formatted, initialWindowId, handingOffToNativeQueue, status, submissionId, 
     // Last and defaulted so the positional callers that ignore the outcome stay
@@ -9748,6 +10122,9 @@ 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;
@@ -9815,8 +10192,8 @@ export class Daemon extends EventEmitter {
                 }
                 verdict.durableBeginCommitted = true;
                 verdict.submissionMode = attemptEvidence.submissionMode;
-                if (attemptEvidence.transcriptPath && attemptEvidence.transcriptOffset !== null) {
-                    verdict.transcriptCheckpoint = {
+                if (attemptEvidence.runtimeTranscript || attemptEvidence.transcriptPath && attemptEvidence.transcriptOffset !== null) {
+                    verdict.transcriptCheckpoint = attemptEvidence.runtimeTranscript ? { backend: attemptEvidence.backend, runtime: attemptEvidence.runtimeTranscript } : {
                         backend: attemptEvidence.backend,
                         path: attemptEvidence.transcriptPath,
                         offset: attemptEvidence.transcriptOffset,
@@ -9881,7 +10258,15 @@ export class Daemon extends EventEmitter {
             }
             const pasteGeneration = this.spawnGeneration;
             beforePaste?.();
-            const pasted = await this.tmux.pasteBuffer(formatted);
+            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;
+            }
             if (pasted)
                 this.rememberPaste(formatted, pasteGeneration);
             if (!pasted) {
@@ -9967,16 +10352,15 @@ export class Daemon extends EventEmitter {
             let enterAt = Date.now();
             const enterMono = performance.now();
             const steerEnterCurrent = () => steerCurrent() && performance.now() <= steerEnterDeadline;
-            let inputHeld = null;
-            if (!(await this.sendDeliveryEnter("initial-submit", steerComposerProof ? steerEnterCurrent : undefined, durableAttempt, (why) => { inputHeld = why; }))) {
+            let inputHeld = "";
+            if (!(await this.sendDeliveryEnter("initial-submit", steerComposerProof || nativeOwner ? steerEnterCurrent : undefined, durableAttempt, reason => { inputHeld = reason; }))) {
                 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.
+                    // #2971: held in a tmux mode past the bound. The paste may still be in the CLI: keep it uncertain, never re-paste.
                     verdict.phase = "submit-enter";
-                    verdict.proof = inputHeld === "dialog" ? "dialog-on-pane" : "pane-in-mode-held";
+                    verdict.proof = inputHeld === "pane_mode" ? "pane-in-mode-held" : `native-input-${inputHeld}`;
                     return false;
                 }
-                if (steerComposerProof && !steerCurrent()) {
+                if ((steerComposerProof || nativeOwner) && !steerCurrent()) {
                     verdict.phase = "submit-enter";
                     verdict.proof = "fenced-before-enter";
                     return false;
@@ -10005,7 +10389,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")) {
+                if (await this.sendDeliveryEnter("queue-less-defensive-retry", nativeOwner)) {
                     enterAt = retryAt;
                     enterRetry = true;
                     this.logger.debug("Sent defensive Enter retry (queue-less TUI can swallow the first)");
@@ -10136,7 +10520,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"))) {
+                    if (!(await this.sendDeliveryEnter("native-queue-stranded-submit", nativeOwner))) {
                         return this.failDelivery(verdict, status, "native-queue-submit", "tmux-send-keys-failed");
                     }
                     // The recovery Enter can be accepted before Codex paints its new
@@ -10189,7 +10573,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"))) {
+                if (!(await this.sendDeliveryEnter("native-queue-idle-redelivery", nativeOwner))) {
                     return this.failDelivery(verdict, status, "native-queue-redelivery", "tmux-send-keys-failed");
                 }
                 if (windowId && this.controlClient) {
@@ -10241,7 +10625,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"))) {
+                    if (promptBack && !(await this.sendDeliveryEnter("stranded-text-retry", nativeOwner))) {
                         return this.failDelivery(verdict, status, "stranded-text-retry", "tmux-send-keys-failed");
                     }
                     submitted = promptBack && await this.confirmSubmittedAfterEnter(windowId, retryAt, formatted);
@@ -10329,7 +10713,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");
+                await this.sendDeliveryEnter("unobserved-defensive-retry", nativeOwner);
                 if (status)
                     this.emit("message_confirmed", status); // ✅ (best-effort)
             }
@@ -10549,14 +10933,22 @@ 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: new TranscriptDeltaReader(checkpoint.path, checkpoint.offset, checkpoint.backend, needle),
+            reader: checkpoint.runtime ? this.nativeTranscriptReader(checkpoint.runtime, needle) : new TranscriptDeltaReader(checkpoint.path, checkpoint.offset, checkpoint.backend, needle),
             current: () => !this.deliveryWritesStopping && this.spawnGeneration === spawnAtWrite
-                && this.launchFenceEpoch === launchAtWrite && (stillCurrent?.() ?? true),
+                && this.launchFenceEpoch === launchAtWrite && (stillCurrent?.() ?? true)
+                && (!checkpoint.runtime || this.nativePaneLifecycle?.current(checkpoint.runtime) === 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";
@@ -10800,7 +11192,14 @@ export class Daemon extends EventEmitter {
      * (the retries included). Without a guard it is exactly the old unconditional path.
      */
     async submitSystemPaste(text, label, guard, admission) {
-        const current = guard || admission ? () => { admission?.(); return guard?.current() ?? true; } : undefined;
+        // 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;
         if (current && !current())
             return false;
         if (!this.tmux)
@@ -10920,13 +11319,13 @@ export class Daemon extends EventEmitter {
             && sameInteractionOwner(recoveryOwner, this.interactionOwner());
         const previousWindowId = this.tmux?.getWindowId();
         try {
-            const windows = await TmuxManager.listWindows(this.tmuxSessionName, this.controlClient);
+            const windows = await this.paneHost.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 = new TmuxManager(this.tmuxSessionName, match.id, resolveTmuxLogicalSize(this.config.terminal), this.controlClient);
+            this.tmux = this.paneHost.bind(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
@@ -10989,6 +11388,8 @@ 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;
         }
@@ -11020,7 +11421,51 @@ export class Daemon extends EventEmitter {
      * Handle a tool call from the MCP server (forwarded by Claude).
      * Routes to the channel adapter via MessageBus.
      */
-    handleToolCall(msg, socket) {
+    /** 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 } : {}) }); 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) {
         const tool = msg.tool;
         const args = (msg.args ?? {});
         const requestId = msg.requestId;
@@ -11028,15 +11473,15 @@ 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 (this.socketSessionNames.get(socket) === this.name) {
-            this.noteMcpProofOfLife("tool_call", this.socketPids.get(socket));
+        if (peer?.current() || socket && this.socketSessionNames.get(socket) === this.name) {
+            this.noteMcpProofOfLife("tool_call", socket ? this.socketPids.get(socket) : undefined);
         }
         // 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 = this.socketSessionNames.get(socket);
+        const sourceSession = peer ? this.name : socket ? this.socketSessionNames.get(socket) : undefined;
         const replyAttempt = TURN_OUTBOUND_TOOLS.has(tool) && (!sourceSession || sourceSession === this.name)
             ? this.turnReplyGuard.beginToolAttempt(tool === "reply", TURN_COMPLETION_TOOLS.has(tool))
             : null;
@@ -11082,14 +11527,21 @@ export class Daemon extends EventEmitter {
                 // failed" and report unknown immediately rather than starting recovery.
                 this.turnReplyGuard.settleToolAttempt(replyAttempt, false);
             }
-            const sent = this.ipcServer?.send(socket, { requestId, result, error, operationId }) ?? false;
+            const packet = { requestId, result, error, operationId };
+            const sent = peer ? peer.current() && peer.send(packet) : socket ? this.ipcServer?.send(socket, packet) ?? false : false;
             if (!sent) {
-                this.logger.warn({ tool, requestId }, "Tool result could not be returned — originating MCP socket is closed");
+                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");
             }
             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);
@@ -11118,7 +11570,7 @@ export class Daemon extends EventEmitter {
                 clearTimeout(timeout);
                 respond(respMsg.result, respMsg.error);
             });
-            this.ipcServer?.broadcast({
+            this.broadcastFleetMessage({
                 type,
                 payload: args,
                 meta: { instance_name: this.name },
@@ -11144,7 +11596,7 @@ export class Daemon extends EventEmitter {
                     clearTimeout(timeout);
                     resolve({ result: respMsg.result, error: respMsg.error });
                 });
-                this.ipcServer?.broadcast({ type: WEB_THEME_IPC[tool], payload, meta: { instance_name: this.name }, fleetRequestId: fleetReqId });
+                this.broadcastFleetMessage({ type: WEB_THEME_IPC[tool], payload, meta: { instance_name: this.name }, fleetRequestId: fleetReqId });
             });
             void (async () => {
                 if (tool === "preview_web_appearance") {
@@ -11221,7 +11673,7 @@ export class Daemon extends EventEmitter {
                 clearTimeout(timeout);
                 respond(respMsg.result, respMsg.error);
             });
-            this.ipcServer?.broadcast({
+            this.broadcastFleetMessage({
                 type: "fleet_task",
                 payload: args,
                 meta: { instance_name: this.name },
@@ -11244,7 +11696,7 @@ export class Daemon extends EventEmitter {
                 clearTimeout(timeout);
                 respond(respMsg.result, respMsg.error);
             });
-            this.ipcServer?.broadcast({
+            this.broadcastFleetMessage({
                 type: typeMap[tool],
                 payload: args,
                 meta: { instance_name: this.name, working_directory: this.config.working_directory },
@@ -11271,7 +11723,7 @@ export class Daemon extends EventEmitter {
                 clearTimeout(timeout);
                 respond(respMsg.result, respMsg.error);
             });
-            this.ipcServer?.broadcast({
+            this.broadcastFleetMessage({
                 type: typeMap[tool],
                 payload: args,
                 meta: {
@@ -11286,11 +11738,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.ipcServer) {
+            if (this.topicMode && this.fleetTransportAvailable()) {
                 // 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 = this.socketSessionNames.get(socket);
+                const senderSessionName = sourceSession;
                 // 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);
@@ -11302,7 +11754,7 @@ export class Daemon extends EventEmitter {
                     clearTimeout(timeout);
                     respond(respMsg.result, respMsg.error);
                 });
-                this.ipcServer.broadcast({
+                this.broadcastFleetMessage({
                     type: "fleet_outbound",
                     tool,
                     args,
@@ -11361,7 +11813,7 @@ export class Daemon extends EventEmitter {
             // 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.ipcServer?.broadcast({
+            this.broadcastFleetMessage({
                 type: "fleet_outbound",
                 tool,
                 args,
@@ -11868,6 +12320,8 @@ 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;
@@ -12454,6 +12908,14 @@ 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");
         }
@@ -12483,13 +12945,15 @@ 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 TmuxManager.getPanePid(this.tmuxSessionName, windowId);
+            const pid = await this.paneHost.getPanePid(this.tmuxSessionName, windowId);
             if (pid) {
                 this.noteStopRequest(signal, reason);
                 process.kill(-pid, signal);
@@ -12730,6 +13194,8 @@ 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;
@@ -12834,8 +13300,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 TmuxManager.ensureSession(this.tmuxSessionName);
-        if (this.stormWindow?.observeServerAlive(await TmuxManager.getServerPid(this.tmuxSessionName))) {
+        await this.paneHost.ensureSession(this.tmuxSessionName);
+        if (this.stormWindow?.observeServerAlive(await this.paneHost.getServerPid(this.tmuxSessionName))) {
             this.emit("tmux_server_crash", this.name);
         }
         this.startupAdmission?.();
@@ -13109,12 +13575,15 @@ 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.tmux.sendSpecialKey(key))
+                                    if (!await (this.nativePaneLifecycle ? this.tmux.sendSpecialKey(key, undefined, { kind: "dialog", screen: keyScreen }) : this.tmux.sendSpecialKey(key)))
                                         return false;
                                 }
                                 else {
-                                    if (!await this.tmux.sendKeys(key))
+                                    if (!await (this.nativePaneLifecycle ? this.tmux.sendKeys(key, { kind: "dialog", screen: keyScreen }) : this.tmux.sendKeys(key)))
                                         return false;
                                 }
                                 await new Promise(r => setTimeout(r, 200));
@@ -13128,7 +13597,8 @@ 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 = readFileSync(join(this.instanceDir, "window-id"), "utf-8").trim();
+                            const wid = this.nativePaneLifecycle ? ownerTmux.getWindowId()
+                                : readFileSync(join(this.instanceDir, "window-id"), "utf-8").trim();
                             await this.controlClient.waitForIdle(wid, renderWait);
                         }
                         else {
@@ -13164,7 +13634,9 @@ export class Daemon extends EventEmitter {
                 // scan parked on the old limit text.
                 const codexReady = this.backend.binaryName !== "codex"
                     || this.isCodexLivePaneSnapshot(pane);
-                if (readyPatternMatches && codexReady) {
+                const nativeComposerReady = !this.nativePaneLifecycle || (this.backend?.readInputRow
+                    ? this.backend.readInputRow(pane) !== null : this.backend?.isDeliveryInputReadyPane?.(pane) === true);
+                if (readyPatternMatches && codexReady && nativeComposerReady) {
                     cleanReadyPolls++;
                     if (cleanReadyPolls >= 2 || remaining() <= 0) {
                         // A real ready prompt (with no fatal dialog on screen — those are
@@ -13289,6 +13761,16 @@ 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)