@geohar/un-bien 0.20.16 → 0.20.18

package/dist/index.js

@@ -35,28 +35,26 @@ import { createExtensionUiBridge, } from "./extension_ui_bridge.js";
 import { createPanelBridge } from "./panel_bridge.js";
 import { initSubagentRooms, subagentRoomsEnabled, } from "./subagent_rooms.js";
 import { createRpcEnvelope, } from "./session/rpc_envelope.js";
-import { dispatchRpcCommand } from "./session/rpc_inbound.js";
 import { envLog } from "./session/debug_log.js";
 import { chainUiNotify, notifyOwners, setOwnerNotifyHook } from "./session/owner_notify.js";
 import { roomIdForSession } from "./rooms.js";
 import { registerAgentTools } from "./session/tools.js";
 import { formatPeerInventory } from "./session/peer_inventory.js";
 import { ensureGlobalDirs, LOCAL_SESSION_NAME, sessionSockPath, skillsDir, } from "./session/global_config.js";
-import { effectiveAutoStartRelay, effectiveAllowRemoteLaunch, effectiveAllowRemoteTerminate, loadLocalConfig, localConfigExists, piSessionName, resolveAgentName, saveLocalConfig, } from "./session/local_config.js";
+import { effectiveAutoStartRelay, loadLocalConfig, localConfigExists, piSessionName, resolveAgentName, saveLocalConfig, } from "./session/local_config.js";
 import { updateFooter } from "./ui/footer.js";
 import { fileURLToPath } from "node:url";
 import { realpathSync } from "node:fs";
-import { loadConfig, saveConfig, isValidRelayUrl, isWebSocketScheme, } from "./config.js";
-import { _expandTilde, _launchSession, launchDirAllowed } from "./launch.js";
+import { saveConfig, isValidRelayUrl, isWebSocketScheme, } from "./config.js";
 import { _enrichToolArgs } from "./enrich_tool_args.js";
 import { _inspectPeerRecord, _runtimeOwnerFingerprint, } from "./pairing/peer_trust.js";
 import { _flushPendingReceivedImagePreviews, _isReceivedImageContextMessage, _registerReceivedImageRenderer, } from "./session/received_images.js";
 import { _cmdRoot, _cmdStart, } from "./commands/lifecycle.js";
 import { _cmdClaudeCli, _cmdInstallTarget, _cmdUninstallTarget, parseInstallTarget, _deployAgentNetworkSkill, } from "./commands/housekeeping.js";
 import { registerUnbienCommands } from "./commands/register.js";
-import { takeForkLink } from "./commands/fork_link.js";
+import { makeTestBusEmitter, runTestScenario } from "./commands/test_scenarios.js";
+import { routeRpcCommand, routeUnBienPlane } from "./routing.js";
 import { createTestHooks } from "./test_hooks.js";
-import { createRpcHandlers, } from "./session/rpc_handlers.js";
 import { CTRL_PREFIX, _anyPeerActive, _broadcastEnvelope, _broadcastEnvelopeFlushed, _controlCtx, _detachPeerChannel, _emitRelayState, _getReconnectTimer, _getRelayLifecycleGeneration, _goIdle, _handleControl as _handleControlImpl, _headlessUi, _onPeerDisconnect as _onPeerDisconnectImpl, _onRelayClose, _panelBroadcast, _pushPairingAllowList, _relayStatus, _setupRelayConnection, _setRelayLifecycleGeneration, _uiBroadcast, } from "./session/relay_lifecycle.js";
 // Relay-lifecycle seam re-exports: the control-channel sentinel + the
 // connectivity type moved to ./session/relay_lifecycle.ts; these keep the
@@ -79,7 +77,6 @@ let _relayUrl = null; // URL used by current _relay connection
  */
 const _activePeers = new Map();
 let _peerShort = ""; // shortid of the most recently attached peer (UX hint only)
-let _myRoomId = null; // this Pi's room id (derived from the session id)
 /** True when a relay start was DEFERRED because no session id existed yet
  *  (design 01M1CAW0). The root session_start handler re-runs the start once
  *  the session id becomes available. */
@@ -98,14 +95,6 @@ function _deriveRoomId(_cwd, _name) {
     const sid = _rootState().sessionManager?.getSessionId();
     return sid ? roomIdForSession(sid) : null;
 }
-// Plan/28 Wave D.1: `thinking` published alongside `model` so the app's
-// Quick Actions sheet hydrates the thinking segmented control on first
-// open instead of starting null. The SDK fires `thinking_level_select`
-// on every change (initial load + user toggle), mirrored to room_meta
-// the same way model is — apps subscribe to one channel for both.
-let _myRoomMeta = null;
-let _currentModel; // last-known model name
-let _currentThinking; // last-known thinking level
 // ── Agent-network session (plano 19) ──────────────────────────────────────────
 // MeshNode owns both the local UDS mesh (SessionPeer) and the optional
 // cross-PC relay bridge (BrokerRemote + PiForwardClient). The bridge is
@@ -170,7 +159,7 @@ function _refreshSessionPeerCount(peer, ctx) {
 }
 /** Friendly model name for room_meta (plano 18). undefined when SDK has none yet. */
 function _currentModelName() {
-    return _currentModel;
+    return _rootState().currentModel ?? undefined;
 }
 /**
  * Cache the active model name and fan it out to subscribed apps via a
@@ -182,13 +171,14 @@ function _currentModelName() {
  * otherwise never surface their model.
  */
 function _setCurrentModel(name) {
-    _currentModel = name;
-    if (_myRoomMeta)
-        _myRoomMeta = { ..._myRoomMeta, model: name };
-    if (_relay && _myRoomId) {
+    const st = _rootState();
+    st.currentModel = name;
+    if (st.myRoomMeta)
+        st.myRoomMeta = { ...st.myRoomMeta, model: name };
+    if (_relay && st.myRoomId) {
         _relay.sendControl({
             type: "room_meta_update",
-            room_id: _myRoomId,
+            room_id: st.myRoomId,
             meta: { model: name },
         });
     }
@@ -201,12 +191,13 @@ function _setCurrentModel(name) {
  * so room_meta.working must be bracketed manually around compaction.
  */
 function _publishWorking(working) {
-    if (_myRoomMeta)
-        _myRoomMeta = { ..._myRoomMeta, working };
-    if (_relay && _myRoomId) {
+    const st = _rootState();
+    if (st.myRoomMeta)
+        st.myRoomMeta = { ...st.myRoomMeta, working };
+    if (_relay && st.myRoomId) {
         _relay.sendControl({
             type: "room_meta_update",
-            room_id: _myRoomId,
+            room_id: st.myRoomId,
             meta: { working },
         });
     }
@@ -276,13 +267,13 @@ function _attachBridgeIfReady() {
 }
 /**
  * Prefer an explicit ctx, else the always-fresh session_start ctx
- * (`_lastEventCtx`, re-captured on every session_start so it is never a stale
+ * (the root record's baseCtx, re-captured on every session_start so it is never stale
  * capture). Relay/async paths reach the ctx-only surfaces (ui/abort/compact)
  * through this, since they fire outside any live pi event.
  * @see https://github.com/jacobaraujo7/remote_pi/issues/55
  */
 function _liveCtx(preferred) {
-    return preferred ?? _lastEventCtx ?? null;
+    return preferred ?? _rootState().baseCtx ?? null;
 }
 /**
  * Read `ctx.ui` without letting a stale-ctx getter become an uncaughtException.
@@ -351,14 +342,41 @@ function _refreshFooter(ctx) {
         // setStatus/setTitle can also throw if the runner went stale mid-call.
     }
 }
-// Epoch ms when the state machine entered 'started' (last /unbien start).
-// Used by session_sync to let the app detect Pi restarts (and force a full
-// replay). Cleared on _goIdle.
-let _sessionStartedAt = null;
 let _pendingMeshMessages = [];
 // agent-run active/generation now live PER-SESSION in _stateFor(sid).agentRun;
 // mesh delivery targets the ROOT run, so the drain reads _rootState().agentRun.
 let _meshDrainScheduled = false;
+/** A freshly-zeroed session record (root or subagent child). */
+function _freshSessionState() {
+    return {
+        turnId: null,
+        working: false,
+        agentRun: { active: false, generation: 0 },
+        sessionManager: null,
+        model: null,
+        thinking: null,
+        currentModel: null,
+        myRoomId: null,
+        myRoomMeta: null,
+        sessionStartedAt: null,
+        baseCtx: null,
+    };
+}
+// The ROOT session's state — a SINGLE stable record for the process lifetime,
+// NOT an entry keyed by the (rotating) session id. The relay-room projection
+// fields (myRoomId/myRoomMeta/sessionStartedAt) outlive a session replacement
+// by contract: _goIdle preserves them across stop/start, and session_shutdown
+// does not clear them — the relay room survives a New/Fork/Reload within the
+// same process. Keying them on _rootSessionId (as the prior refactor did) reset
+// them to null on every sid rotation, opening a window between session_start
+// and the async _cmdStart where a reconnect/sync announced a NAMELESS room —
+// the relay filled the absent room_meta.name with its default placeholder.
+// session_start now POPULATES the per-session fields (sessionManager/baseCtx/
+// model/thinking/…) in place; session_shutdown clears exactly those. The record
+// itself is never recreated, so the projection rides through a replacement.
+let _rootRecord = _freshSessionState();
+// Subagent (non-root) child records, keyed by their own session id. The root
+// is never an entry here — root access routes through _rootRecord.
 const _sessions = new Map();
 // The session bound to the app room. null until the ROOT session_start fires;
 // while null, everything is treated as root (single-session / test harness).
@@ -368,23 +386,24 @@ function _rootKey() {
     return _rootSessionId ?? "__root__";
 }
 function _stateFor(sid) {
+    if (sid === _rootKey())
+        return _rootRecord; // root → stable singleton
     let st = _sessions.get(sid);
     if (!st) {
-        st = {
-            turnId: null,
-            working: false,
-            agentRun: { active: false, generation: 0 },
-            sessionManager: null,
-            model: null,
-            thinking: null,
-        };
+        st = _freshSessionState();
         _sessions.set(sid, st);
     }
     return st;
 }
-/** The root session's record (always defined; lazily created). */
+/** The root session's record (stable for the process lifetime). */
 function _rootState() {
-    return _stateFor(_rootKey());
+    return _rootRecord;
+}
+/** Test-only: replace the root record with a fresh slate (projection fields
+ *  included) so tests don't leak state across boundaries. Production never
+ *  calls this — session_shutdown clears per-session fields in place instead. */
+function _resetRootRecordForTest() {
+    _rootRecord = _freshSessionState();
 }
 /** sessionId of the firing handler's ctx, defaulting to the root key. */
 function _sidOf(ctx) {
@@ -460,19 +479,6 @@ export function _getState() {
 // underlying BUS events and lets the REAL bridges produce the frames (faithful);
 // the simple ExtensionUIPromptView methods (select/confirm/input/editor) + media
 // have no bus producer, so they're broadcast directly. See design 01M152YD….
-const _TEST_SVG_B64 = Buffer.from('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 120 60">' +
-    '<rect width="120" height="60" rx="8" fill="#4c8bf5"/>' +
-    '<text x="60" y="37" font-size="16" fill="white" text-anchor="middle"' +
-    ' font-family="sans-serif">un-bien</text></svg>').toString("base64");
-function _emitTestBus(channel, data) {
-    try {
-        ;
-        _pi?.events?.emit(channel, data);
-    }
-    catch {
-        /* bus absent — best effort */
-    }
-}
 // Owner-notify bridge (transient toasts on the app): /unbien command handlers
 // report through notifyOwners() - this broadcasts the notice to every attached
 // owner as extension_ui_request {method:"notify"}, the same shape the ask-flow
@@ -488,628 +494,34 @@ setOwnerNotifyHook((message, level) => {
         },
     });
 });
-/** Run one canned UI-test scenario. Returns a short status for the notify. */
-function _runTestScenario(scenario) {
-    const s = (scenario.trim().split(/\s+/)[0] || "help").toLowerCase();
-    const id = `test-${Date.now()}`;
-    switch (s) {
-        case "ask-select":
-            _broadcastEnvelope(relayDeps, {
-                rpc: {
-                    type: "extension_ui_request",
-                    id,
-                    method: "select",
-                    title: "Pick one (test)",
-                    options: ["Alpha", "Beta", "Gamma"],
-                },
-            });
-            return "sent ask-select";
-        case "ask-confirm":
-            _broadcastEnvelope(relayDeps, {
-                rpc: {
-                    type: "extension_ui_request",
-                    id,
-                    method: "confirm",
-                    title: "Confirm (test)",
-                    message: "Proceed with the test action?",
-                },
-            });
-            return "sent ask-confirm";
-        case "ask-input":
-            _broadcastEnvelope(relayDeps, {
-                rpc: {
-                    type: "extension_ui_request",
-                    id,
-                    method: "input",
-                    title: "Input (test)",
-                    placeholder: "Type something…",
-                },
-            });
-            return "sent ask-input";
-        case "ask-editor":
-            _broadcastEnvelope(relayDeps, {
-                rpc: {
-                    type: "extension_ui_request",
-                    id,
-                    method: "editor",
-                    title: "Editor (test)",
-                    prefill: "edit me",
-                },
-            });
-            return "sent ask-editor";
-        case "ask-notify":
-            _broadcastEnvelope(relayDeps, {
-                rpc: {
-                    type: "extension_ui_request",
-                    id,
-                    method: "notify",
-                    message: "This is a test notice.",
-                    notify_type: "info",
-                },
-            });
-            return "sent ask-notify";
-        case "ask-rich":
-            _emitTestBus("@eko24ive/pi-ask:started", {
-                version: 1,
-                flowId: `test-flow-${Date.now()}`,
-                source: "test",
-                title: "Rich ask (test)",
-                questions: [
-                    {
-                        id: "q1",
-                        prompt: "Which approach?",
-                        type: "single",
-                        options: [
-                            { value: "a", label: "Approach A", description: "the safe one" },
-                            { value: "b", label: "Approach B", preview: "preview text here" },
-                        ],
-                    },
-                    {
-                        id: "q2",
-                        prompt: "Anything to add?",
-                        type: "single",
-                        options: [{ value: "ok", label: "Looks good", freeform: true }],
-                    },
-                ],
-            });
-            return "emitted pi-ask:started (rich)";
-        case "plan":
-            _emitTestBus("plan:snapshot", {
-                ns: "test",
-                seq: 1,
-                items: [
-                    {
-                        id: "t1",
-                        kind: "plan",
-                        title: "Design the thing",
-                        status: "done",
-                        deps: [],
-                    },
-                    {
-                        id: "t2",
-                        kind: "plan",
-                        title: "Build the thing",
-                        status: "in_progress",
-                        deps: ["t1"],
-                    },
-                    {
-                        id: "t3",
-                        kind: "plan",
-                        title: "Test the thing",
-                        status: "pending",
-                        deps: ["t2"],
-                    },
-                ],
-            });
-            return "emitted plan:snapshot";
-        case "subagents":
-            _emitTestBus("subagents:created", {
-                id: "sa1",
-                type: "explore",
-                description: "Explore the codebase",
-            });
-            _emitTestBus("subagents:started", { id: "sa1" });
-            _emitTestBus("subagents:created", {
-                id: "sa2",
-                type: "plan",
-                description: "Draft an implementation plan",
-            });
-            _emitTestBus("subagents:completed", { id: "sa2" });
-            return "emitted subagents lifecycle";
-        case "svg": {
-            // A TOOL card renders standalone; the app pulls tool-emitted images from
-            // INSIDE the tool_execution_end `result` (imagesFromToolResult unwraps
-            // `{content:[{type:"image",data,mimeType}]}`) and renders them below the
-            // card (WireImageView -> SVGImageView). Deliver the SVG that way.
-            const tc = `tc-svg-${Date.now()}`;
-            _broadcastEnvelope(relayDeps, { rpc: { type: "turn_start" } });
-            _broadcastEnvelope(relayDeps, {
-                rpc: {
-                    type: "tool_execution_start",
-                    toolCallId: tc,
-                    toolName: "render_svg",
-                    args: { note: "test svg" },
-                },
-            });
-            _broadcastEnvelope(relayDeps, {
-                rpc: {
-                    type: "tool_execution_end",
-                    toolCallId: tc,
-                    result: {
-                        content: [
-                            { type: "text", text: "rendered a test SVG" },
-                            {
-                                type: "image",
-                                data: _TEST_SVG_B64,
-                                mimeType: "image/svg+xml",
-                            },
-                        ],
-                    },
-                    isError: false,
-                },
-            });
-            _broadcastEnvelope(relayDeps, { rpc: { type: "agent_settled" } });
-            return "sent svg (envelope tool_execution_end + image)";
-        }
-        case "tool": {
-            const tc = `tc-${Date.now()}`;
-            _broadcastEnvelope(relayDeps, { rpc: { type: "turn_start" } });
-            _broadcastEnvelope(relayDeps, {
-                rpc: {
-                    type: "tool_execution_start",
-                    toolCallId: tc,
-                    toolName: "bash",
-                    args: { command: "echo hello" },
-                },
-            });
-            _broadcastEnvelope(relayDeps, {
-                rpc: {
-                    type: "tool_execution_end",
-                    toolCallId: tc,
-                    result: "hello\n",
-                    isError: false,
-                },
-            });
-            _broadcastEnvelope(relayDeps, { rpc: { type: "agent_settled" } });
-            return "sent tool pair (envelope)";
-        }
-        case "diff": {
-            // Exercise the rich diff rendering: aux `{hunks}` (input Edit diff) rides
-            // ALONGSIDE the raw edit `tool_execution_start`. OUTPUT is classified
-            // app-side from the result, so no aux.output rides the end frame.
-            const tc = `tc-diff-${Date.now()}`;
-            const hunks = [
-                {
-                    lines: [
-                        { kind: "context", oldLine: 1, newLine: 1, text: "const a = 1;" },
-                        { kind: "remove", oldLine: 2, text: "const b = 2;" },
-                        { kind: "add", newLine: 2, text: "const b = 3;" },
-                        { kind: "context", oldLine: 3, newLine: 3, text: "const c = 4;" },
-                    ],
-                },
-            ];
-            _broadcastEnvelope(relayDeps, { rpc: { type: "turn_start" } });
-            _broadcastEnvelope(relayDeps, {
-                rpc: {
-                    type: "tool_execution_start",
-                    toolCallId: tc,
-                    toolName: "edit",
-                    args: {
-                        path: "demo.ts",
-                        old_string: "const b = 2;",
-                        new_string: "const b = 3;",
-                    },
-                },
-                aux: { hunks },
-            });
-            _broadcastEnvelope(relayDeps, {
-                rpc: {
-                    type: "tool_execution_end",
-                    toolCallId: tc,
-                    result: "edited demo.ts",
-                    isError: false,
-                },
-            });
-            _broadcastEnvelope(relayDeps, { rpc: { type: "agent_settled" } });
-            return "sent diff (edit + aux hunks — shows the Diff⇄Content toggle)";
-        }
-        case "code-shell": {
-            // bash-family result → the app classifies it into a `code` block (lang
-            // shell), syntax-highlighted. OUTPUT is app-side now — no aux stamped.
-            const tc = `tc-sh-${Date.now()}`;
-            _broadcastEnvelope(relayDeps, { rpc: { type: "turn_start" } });
-            _broadcastEnvelope(relayDeps, {
-                rpc: {
-                    type: "tool_execution_start",
-                    toolCallId: tc,
-                    toolName: "bash",
-                    args: { command: "ls -la" },
-                },
-            });
-            _broadcastEnvelope(relayDeps, {
-                rpc: {
-                    type: "tool_execution_end",
-                    toolCallId: tc,
-                    result: "total 24\ndrwxr-xr-x  5 geo staff  160 Aug 29 10:00 .\n-rw-r--r--  1 geo staff 1024 index.ts\n-rw-r--r--  1 geo staff  512 README.md",
-                    isError: false,
-                },
-            });
-            _broadcastEnvelope(relayDeps, { rpc: { type: "agent_settled" } });
-            return "sent code-shell (bash output → code block, lang shell)";
-        }
-        case "code-file": {
-            // read-family with a *.swift path → `code` block, lang inferred from the
-            // extension (swift) and highlighted.
-            const tc = `tc-rd-${Date.now()}`;
-            _broadcastEnvelope(relayDeps, { rpc: { type: "turn_start" } });
-            _broadcastEnvelope(relayDeps, {
-                rpc: {
-                    type: "tool_execution_start",
-                    toolCallId: tc,
-                    toolName: "read",
-                    args: { path: "/src/Greeter.swift" },
-                },
-            });
-            _broadcastEnvelope(relayDeps, {
-                rpc: {
-                    type: "tool_execution_end",
-                    toolCallId: tc,
-                    result: 'struct Greeter {\n    let name: String\n    func greet() -> String {\n        return "Hello, \\(name)!"\n    }\n}',
-                    isError: false,
-                },
-            });
-            _broadcastEnvelope(relayDeps, { rpc: { type: "agent_settled" } });
-            return "sent code-file (read .swift → highlighted code block)";
-        }
-        case "diff-output": {
-            // A tool whose RESULT already embeds a unified diff → the app parses it
-            // into a `diff` block (re-reading persisted text; replay-safe).
-            const tc = `tc-do-${Date.now()}`;
-            _broadcastEnvelope(relayDeps, { rpc: { type: "turn_start" } });
-            _broadcastEnvelope(relayDeps, {
-                rpc: {
-                    type: "tool_execution_start",
-                    toolCallId: tc,
-                    toolName: "bash",
-                    args: { command: "git diff" },
-                },
-            });
-            _broadcastEnvelope(relayDeps, {
-                rpc: {
-                    type: "tool_execution_end",
-                    toolCallId: tc,
-                    result: 'diff --git a/app.ts b/app.ts\n--- a/app.ts\n+++ b/app.ts\n@@ -1,3 +1,3 @@\n const port = 3000;\n-const host = "127.0.0.1";\n+const host = "0.0.0.0";\n start(host, port);',
-                    isError: false,
-                },
-            });
-            _broadcastEnvelope(relayDeps, { rpc: { type: "agent_settled" } });
-            return "sent diff-output (result embeds a unified diff → diff block)";
-        }
-        case "write": {
-            // write carries the new file text in args.content; no live diff → the
-            // card shows the Content view (new text as a code block, replay-safe).
-            const tc = `tc-wr-${Date.now()}`;
-            const content = "export function add(a: number, b: number): number {\n  return a + b;\n}";
-            _broadcastEnvelope(relayDeps, { rpc: { type: "turn_start" } });
-            _broadcastEnvelope(relayDeps, {
-                rpc: {
-                    type: "tool_execution_start",
-                    toolCallId: tc,
-                    toolName: "write",
-                    args: { path: "/src/math.ts", content },
-                },
-            });
-            _broadcastEnvelope(relayDeps, {
-                rpc: {
-                    type: "tool_execution_end",
-                    toolCallId: tc,
-                    result: "wrote /src/math.ts",
-                    isError: false,
-                },
-            });
-            _broadcastEnvelope(relayDeps, { rpc: { type: "agent_settled" } });
-            return "sent write (args.content → content-as-code block)";
-        }
-        case "agent": {
-            _broadcastEnvelope(relayDeps, { rpc: { type: "turn_start" } });
-            _broadcastEnvelope(relayDeps, {
-                rpc: {
-                    type: "message_update",
-                    assistantMessageEvent: {
-                        type: "text_delta",
-                        delta: "This is a ",
-                    },
-                },
-            });
-            _broadcastEnvelope(relayDeps, {
-                rpc: {
-                    type: "message_update",
-                    assistantMessageEvent: {
-                        type: "text_delta",
-                        delta: "test agent message.",
-                    },
-                },
-            });
-            _broadcastEnvelope(relayDeps, {
-                rpc: {
-                    type: "message_end",
-                    message: {
-                        role: "assistant",
-                        content: [{ type: "text", text: "This is a test agent message." }],
-                    },
-                },
-            });
-            _broadcastEnvelope(relayDeps, { rpc: { type: "agent_settled" } });
-            return "sent agent message (envelope)";
-        }
-        case "error":
-            _broadcastEnvelope(relayDeps, {
-                rpc: {
-                    type: "message_end",
-                    message: {
-                        role: "assistant",
-                        stopReason: "error",
-                        errorMessage: "This is a test error.",
-                    },
-                },
-            });
-            _broadcastEnvelope(relayDeps, { rpc: { type: "agent_settled" } });
-            return "sent error (envelope message_end/error)";
-        case "all":
-            for (const sc of [
-                "ask-notify",
-                "plan",
-                "subagents",
-                "svg",
-                "tool",
-                "diff",
-                "code-shell",
-                "code-file",
-                "diff-output",
-                "write",
-                "agent",
-                "error",
-            ])
-                _runTestScenario(sc);
-            return "sent all (ask-notify, plan, subagents, svg, tool, diff, code-shell, code-file, diff-output, write, agent, error)";
-        default:
-            return "usage: /unbien test <ask-select|ask-confirm|ask-input|ask-editor|ask-notify|ask-rich|plan|subagents|svg|tool|diff|code-shell|code-file|diff-output|write|agent|error|all>";
-    }
-}
 /**
- * New-protocol inbound: dispatch an envelope-carried pi `RpcCommand` to the SDK
- * and answer with a `{ rpc: response }` envelope to the SENDER. Native to the
- * envelope wire — does NOT use the stock `_routeClientMessageFrom` switch. The
- * SDK primitives (`_wakeAgent`, `_abortCurrentTurn`) are pi, not old protocol.
+ * Plane routers live in ./routing.ts (carved, slice 4). These thin wrappers
+ * preserve the call sites + the CommandDeps surface; the deps accessors
+ * keep module state read LIVE at each dispatch.
  */
 function _routeRpcCommandFrom(sender, env) {
-    const frame = env.rpc;
-    if (!frame || typeof frame !== "object")
-        return; // no {evt} inbound today
-    envLog(`rpc inbound: ${String(frame.type)}`);
-    // extension_ui_response is a reply to an extension-issued dialog, not a command —
-    // route it straight to the ui bridge (same target as the stock path).
-    if (frame.type === "extension_ui_response") {
-        // SAFETY: the type-discriminator check directly above proves this frame is
-        // an extension_ui_response envelope, which is the ExtensionUiResponseWire shape.
-        _extensionUiBridge?.respond(frame);
-        return;
-    }
-    // session_sync (reconstruction) is un-bien's OWN protocol — dispatched on the
-    // un plane by _routeUnBienPlaneFrom, NOT here. Only byte-faithful pi rpc
-    // commands + extension_ui_response ride this rpc dispatch.
-    const handlers = createRpcHandlers(rpcDeps, sender);
-    void dispatchRpcCommand(frame, handlers)
-        .then((resp) => {
-        // Envelope-native ONLY: no stock fallback. An unhandled rpc type is
-        // ignored (forward-compat). un-bien's own commands (session_sync,
-        // session_launch) ride the un plane via _routeUnBienPlaneFrom.
-        if (resp)
-            sender.sendEnvelope(resp);
-    })
-        .catch((err) => {
-        console.error(`[un-bien] rpc inbound dispatch failed: ${String(err)}`);
-    });
+    routeRpcCommand(planeDeps, sender, env);
 }
-/**
- * un-bien plane inbound (`type:"ub"`): dispatch un-bien's OWN protocol frames by
- * their inner `.type`. app->ext today: `session_sync` (reconstruction request)
- * and `session_launch` (mesh remote-launch). These are NOT pi rpc — the
- * EXTENSION acts. The reconstruction REPLAY frames it emits stay byte-faithful
- * pi rpc frames on the rpc plane; only the request + `session_sync_end`
- * terminator are un-plane frames.
- */
 function _routeUnBienPlaneFrom(sender, env) {
-    const frame = env.ub;
-    if (!frame || typeof frame !== "object")
-        return;
-    const type = frame.type;
-    envLog(`ub inbound: ${String(type)}`);
-    if (type === "session_sync") {
-        const f = frame;
-        // session_sync now carries ONLY un-bien's NON-rpc display state: panels +
-        // pending extension_ui. The TRANSCRIPT is the app's OWN native get_entries
-        // rpc (reduced by SessionState.applyEntries) — NOT replayed here. Design
-        // 01M15FMQ: separate the rpc transcript (get_entries) from un-bien panel/ui
-        // state, each an independent app-driven request issued on open + reconnect.
-        for (const req of _extensionUiBridge?.pendingRequests() ?? [])
-            // ENVELOPE the replay: the app's handleRouted only dispatches
-            // {rpc|evt|ub} frames — a bare extension_ui_request fell through both
-            // branches and was silently dropped, so every session_sync replay was
-            // a no-op and the terminator then retired the still-pending prompt as
-            // "stale" (the "ask not displayed on phone" bug, 2026-09-25). The live
-            // ask path sends the same shape enveloped ({rpc}); mirror it here.
-            sender.sendEnvelope({ rpc: req });
-        const panels = _panelBridge?.pendingPanels() ?? [];
-        for (const panel of panels)
-            sender.sendEnvelope({ evt: { channel: "panel", data: panel } });
-        envLog(`session_sync(ub): panels=${panels.length} + ui (transcript is the app's get_entries rpc)`);
-        // Terminator/ack on the ub plane; carries the session clock so the app can
-        // detect a pi restart. `truncated`/`limit` are gone (a replay concern;
-        // get_entries is unbounded / since-delta). `session_name` (pre-release
-        // 2026-09-18): the NAME PULL — heals a missed session_info_changed push
-        // (an iOS backgrounded socket misses live frames; the relay's stored meta
-        // is stale until our next hello, so reconnects can't carry it either).
-        // session_sync is issued on EVERY open + reconnect, so the name heals on
-        // every natural cycle. Old apps ignore the field; old extensions omit it.
-        //
-        // SOURCE = the room's DISPLAY name (myRoomMeta.name), NOT deps.sessionName:
-        // the latter is `_sessionName`, which `_cmdJoin` sets to the mesh session
-        // id LOCAL_SESSION_NAME ("local"). Sending that here clobbered the tile
-        // label with "local" on every reconnect (the flaky-name bug) — the
-        // non-live pull disagreed with the live session_info push. myRoomMeta.name
-        // is the same value pair_ok sends (deps.displayName) and tracks live
-        // renames (session_info_changed updates it), so pull == push now.
-        const displayName = deps.myRoomMeta?.name;
-        // Fork auto-nav: a fork-born session's FIRST sync echoes the app's
-        // originating fork request id (design: fork switch). take = read+unlink,
-        // so it fires once (the app navigates on first receipt; later reconnects
-        // must not re-jump). Keyed by the session id, so it survives the extension
-        // module re-eval that ctx.fork triggers.
-        const forkSm = _rootState().sessionManager;
-        const forkedFromReq = forkSm && typeof forkSm.getSessionDir === "function"
-            ? takeForkLink(forkSm.getSessionDir(), forkSm.getSessionId())
-            : undefined;
-        sender.sendEnvelope({
-            ub: {
-                type: "session_sync_end",
-                ...(typeof f.id === "string" ? { in_reply_to: f.id } : {}),
-                session_started_at: _sessionStartedAt ?? 0,
-                ...(displayName ? { session_name: displayName } : {}),
-                ...(forkedFromReq ? { forked_from_req: forkedFromReq } : {}),
-            },
-        });
-        return;
-    }
-    if (type === "terminate") {
-        // app->ext: kill THIS session. Root room only — a child room's terminate
-        // is handled by the child-room router in subagent_rooms (never reaches
-        // here; that room's conn dispatches its own ub frames). Gate on local
-        // config; the app confirms + shows red before sending.
-        if (!effectiveAllowRemoteTerminate(loadLocalConfig(process.cwd()))) {
-            envLog("terminate(ub): remote terminate disabled on this machine");
-            return;
-        }
-        envLog(`terminate(ub): graceful host shutdown requested${typeof frame.reason === "string" ? ` (${String(frame.reason)})` : ""}`);
-        _safeNotify("Terminated from the app", "warning");
-        try {
-            // ctx.shutdown() IS the /quit equivalent — pi's own source lists
-            // "extension shutdown()" alongside Ctrl+D / /quit (interactive-mode.js
-            // 3229: same graceful this.shutdown(): drain input, ui.stop() restores
-            // cooked mode + cursor, extension disposal, resume hint, exit). It sits
-            // DIRECTLY on the event ctx (ExtensionContext.shutdown — there is no
-            // ctx.actions sub-object; the first two attempts failed exactly there).
-            //
-            // MID-TURN DEFERRAL: the interactive handler fires immediately only when
-            // idle; otherwise it sets `shutdownRequested` and waits for
-            // `agent_settled` — which never arrives when nothing is running. So
-            // abort() FIRST: aborting a running turn forces the settle that
-            // re-checks the flag; on an idle session abort is a no-op and the
-            // idle fast-path fires directly.
-            //
-            // NO process.exit fallback, ever: a raw exit leaves the TTY in raw
-            // mode (keypresses echo escape codes until `stty sane`). No live ctx =>
-            // log loudly and stay up; the user quits on the machine.
-            const ctx = _liveCtx();
-            if (ctx?.shutdown) {
-                ctx.abort?.();
-                ctx.shutdown();
-            }
-            else {
-                envLog("terminate(ub): no live ctx — refusing raw exit (would leave the terminal in raw mode); staying up");
-            }
-        }
-        catch (err) {
-            envLog(`terminate(ub) error: ${err instanceof Error ? err.message : String(err)}`);
-        }
-        return;
-    }
-    if (type === "close_child_room") {
-        // app->ext(PARENT): permanently close one of MY child rooms (done-subagent
-        // removal — the room lingers by design otherwise). Tombstone + dispose in
-        // subagent_rooms; the relay fires room_ended when the last conn drops.
-        if (!effectiveAllowRemoteTerminate(loadLocalConfig(process.cwd()))) {
-            envLog("close_child_room(ub): remote terminate disabled on this machine");
-            return;
-        }
-        const roomId = frame.room_id;
-        if (typeof roomId !== "string" || roomId.length === 0)
-            return;
-        const closed = _subagentRooms?.closeChildRoom(roomId) ?? false;
-        envLog(`close_child_room(ub): room=${roomId.slice(0, 8)} closed=${closed}`);
-        return;
-    }
-    if (type === "session_launch") {
-        const f = frame;
-        const cwd = _expandTilde(typeof f.cwd === "string" && f.cwd.length > 0 ? f.cwd : process.cwd());
-        if (!effectiveAllowRemoteLaunch(loadLocalConfig(cwd))) {
-            envLog("session_launch(ub): remote launch disabled on this machine");
-            return;
-        }
-        // Directory allow-list (design 01M211VW9), read FRESH each request.
-        if (!launchDirAllowed(cwd, loadConfig().launch?.dirs)) {
-            envLog("session_launch(ub): cwd not in launch.dirs allow-list");
-            sender.send({
-                type: "error",
-                code: "permission_denied",
-                message: "Remote launch not permitted for this directory",
-            });
-            return;
-        }
-        // Backend is a MACHINE config choice (pick-one via launch.backend), not
-        // app-chosen; rpc is a fast-follow so only tmux|herdr resolve here.
-        const backend = loadConfig().launch?.backend === "herdr" ? "herdr" : "tmux";
-        const launchError = _launchSession(backend, cwd, typeof f.name === "string" ? f.name : undefined, 
-        // Launch correlation: pi is spawned with UNBIEN_LAUNCH_REQ=<id> and
-        // echoes it in room_meta, so the launching app can match the announcing
-        // room to THIS request and auto-open the chat (resume flow).
-        typeof f.resume === "string" && f.resume.trim().length > 0
-            ? f.resume.trim()
-            : undefined, typeof f.id === "string" && f.id.trim().length > 0
-            ? f.id.trim()
-            : undefined);
-        if (launchError)
-            envLog(`session_launch(ub) error: ${launchError}`);
-        return;
-    }
-    if (type === "session_fork" || type === "session_navigate") {
-        // app->ext: fork a NEW session / branch IN PLACE from a conversation entry.
-        // ctx.fork / ctx.navigateTree live ONLY on the command ctx, so we can't act
-        // here (this is the peer-channel dispatch, not a command). Self-dispatch the
-        // registered `/unbien fork|branch` command via sendUserMessage — pi runs it
-        // with a real ExtensionCommandContext. No stashed ctx, no startup bootstrap:
-        // the command ctx lives exactly as long as the op that needs it. Not gated
-        // beyond being paired — these are no more privileged than a prompt on this
-        // same room (which the app can already send).
-        const f = frame;
-        const entryId = typeof f.entry_id === "string" ? f.entry_id : "";
-        if (!entryId) {
-            envLog(`${String(type)}(ub): missing entry_id — ignored`);
-            return;
-        }
-        if (type === "session_fork") {
-            // Thread the request id (reqId) so the new session can echo it back as
-            // forked_from_req on its first sync — the app's auto-nav correlation.
-            // Order: `<entryId> <reqId> [pos]` (see _cmdFork's parse).
-            const reqId = typeof f.id === "string" ? f.id : "";
-            const posArg = f.position === "at" || f.position === "before" ? ` ${f.position}` : "";
-            const reqArg = reqId ? ` ${reqId}` : "";
-            envLog(`session_fork(ub): entry=${entryId.slice(0, 8)}${posArg}`);
-            _pi?.sendUserMessage(`/unbien fork ${entryId}${reqArg}${posArg}`, {
-                deliverAs: "followUp",
-                expandPromptTemplates: true,
-            });
-        }
-        else {
-            envLog(`session_navigate(ub): entry=${entryId.slice(0, 8)}`);
-            _pi?.sendUserMessage(`/unbien branch ${entryId}`, {
-                deliverAs: "followUp",
-                expandPromptTemplates: true,
-            });
-        }
-        return;
-    }
+    routeUnBienPlane(planeDeps, sender, env);
 }
+// ── Plane-router deps (accessors over module state — live at dispatch) ──────
+const planeDeps = {
+    extensionUiBridge: () => _extensionUiBridge,
+    panelBridge: () => _panelBridge,
+    subagentRooms: () => _subagentRooms,
+    sessionStartedAt: () => _rootState().sessionStartedAt ?? 0,
+    myRoomMeta: () => _rootState().myRoomMeta,
+    rootState: () => _rootState(),
+    safeNotify: _safeNotify,
+    liveCtx: () => _liveCtx(),
+    pi: () => _pi,
+    // Getter: rpcDeps is declared later in the file; the dispatch reads it
+    // live at call time.
+    get rpcDeps() {
+        return rpcDeps;
+    },
+};
 // ── Display-name helpers ──────────────────────────────────────────────────────
 /**
  * Resolves the name this Pi shows to the mobile app and the relay's
@@ -1246,7 +658,6 @@ function _probeCtx(label, ctx) {
 // base-ctx methods (no newSession — that's command-ctx only); command-only ops
 // (fork/new/branch) reach a command ctx by self-dispatching a slash command
 // instead of retaining one.
-let _lastEventCtx = null;
 const _noopCtx = { ui: { notify: () => undefined }, abort: () => undefined };
 // A single Pi process can load this extension TWICE in the SAME session:
 // when it is launched as `pi -e <dist>/index.js` AND un-bien is ALSO installed
@@ -1316,7 +727,7 @@ const imageDeps = {
     },
     rootState: _rootState,
     get myRoomMeta() {
-        return _myRoomMeta;
+        return _rootState().myRoomMeta;
     },
     wakeAgent: _wakeAgent,
 };
@@ -1332,7 +743,7 @@ const rpcDeps = {
     },
     rootState: _rootState,
     get lastEventCtx() {
-        return _lastEventCtx;
+        return _rootState().baseCtx;
     },
     imageDeps,
     wakeAgent: _wakeAgent,
@@ -1414,13 +825,13 @@ const relayDeps = {
         return _cachedEd25519;
     },
     get myRoomId() {
-        return _myRoomId;
+        return _rootState().myRoomId;
     },
     get myRoomMeta() {
-        return _myRoomMeta;
+        return _rootState().myRoomMeta;
     },
     get sessionStartedAt() {
-        return _sessionStartedAt;
+        return _rootState().sessionStartedAt;
     },
     sessionCwd: () => {
         const sm = _rootState().sessionManager;
@@ -1510,30 +921,30 @@ const deps = {
         _cachedEd25519 = v;
     },
     get currentModel() {
-        return _currentModel;
+        return _rootState().currentModel ?? undefined;
     },
     set currentModel(v) {
-        _currentModel = v;
+        _rootState().currentModel = v ?? null;
     },
     get currentThinking() {
-        return _currentThinking;
+        return _rootState().thinking ?? undefined;
     },
     abortCurrentTurn: () => _abortCurrentTurn(),
     cancelPendingAsks: () => _extensionUiBridge?.cancelAllPending() ?? 0,
     set currentThinking(v) {
-        _currentThinking = v;
+        _rootState().thinking = v ?? null;
     },
     get myRoomId() {
-        return _myRoomId;
+        return _rootState().myRoomId;
     },
     set myRoomId(v) {
-        _myRoomId = v;
+        _rootState().myRoomId = v;
     },
     get myRoomMeta() {
-        return _myRoomMeta;
+        return _rootState().myRoomMeta;
     },
     set myRoomMeta(v) {
-        _myRoomMeta = v;
+        _rootState().myRoomMeta = v;
     },
     get peerShort() {
         return _peerShort;
@@ -1542,10 +953,10 @@ const deps = {
         _peerShort = v;
     },
     get sessionStartedAt() {
-        return _sessionStartedAt;
+        return _rootState().sessionStartedAt;
     },
     set sessionStartedAt(v) {
-        _sessionStartedAt = v;
+        _rootState().sessionStartedAt = v;
     },
     get cwdLock() {
         return _cwdLock;
@@ -1620,7 +1031,7 @@ const deps = {
         return _disposed;
     },
     get lastEventCtx() {
-        return _lastEventCtx;
+        return _rootState().baseCtx;
     },
     get pi() {
         return _pi;
@@ -1648,7 +1059,7 @@ const deps = {
     handleControl: _handleControl,
     relayStatus: () => _relayStatus(relayDeps),
     getState: _getState,
-    runTestScenario: _runTestScenario,
+    runTestScenario: (scenario) => runTestScenario({ broadcast: (env) => _broadcastEnvelope(relayDeps, env), emitBus: makeTestBusEmitter(() => _pi) }, scenario),
     safeNotify: _safeNotify,
     renameAgent: _renameAgent,
 };
@@ -1709,10 +1120,10 @@ const _testHooks = createTestHooks({
         _lockedName = v;
     },
     set sessionStartedAt(v) {
-        _sessionStartedAt = v;
+        _rootState().sessionStartedAt = v;
     },
     set currentModel(v) {
-        _currentModel = v;
+        _rootState().currentModel = v ?? null;
     },
     set pi(v) {
         _pi = v;
@@ -1736,6 +1147,7 @@ const _testHooks = createTestHooks({
     },
     activePeers: _activePeers,
     rootState: _rootState,
+    resetRootRecord: _resetRootRecordForTest,
     seedRootSession(sid) {
         _rootSessionId = sid;
         _stateFor(sid).sessionManager = {
@@ -1762,6 +1174,7 @@ export const _getCachedPublicKeyForTest = _testHooks.getCachedPublicKeyForTest;
 export const _setSessionStartedAtForTest = _testHooks.setSessionStartedAtForTest;
 export const _setCurrentModelForTest = _testHooks.setCurrentModelForTest;
 export const _getCurrentTurnIdForTest = _testHooks.getCurrentTurnIdForTest;
+export const _getRootProjectionForTest = _testHooks.getRootProjectionForTest;
 export const _setPiForTest = _testHooks.setPiForTest;
 export const _hasPendingReconnect = _testHooks.hasPendingReconnect;
 export const _getActivePeerCountForTest = _testHooks.getActivePeerCountForTest;
@@ -1805,7 +1218,7 @@ const extension = (pi) => {
         });
         _subagentRooms?.dispose();
         _subagentRooms = initSubagentRooms(pi, {
-            getParentRoomId: () => _myRoomId,
+            getParentRoomId: () => _rootState().myRoomId,
             getParentSessionId: () => _rootSessionId,
             broadcastPanel: (msg) => _panelBroadcast(relayDeps, msg),
         });
@@ -1888,19 +1301,19 @@ const extension = (pi) => {
         const level = event?.level;
         if (!level)
             return;
-        // Cache per-sid; only the ROOT projects to _currentThinking + room_meta.
+        // Cache per-sid; only the ROOT projects to room_meta.
         const sid = _sidOf(ctx);
-        _stateFor(sid).thinking = level;
+        const st = _stateFor(sid);
+        st.thinking = level;
         if (_isNonRootSid(sid))
             return;
-        _currentThinking = level;
-        if (_myRoomMeta)
-            _myRoomMeta = { ..._myRoomMeta, thinking: level };
-        if (!_relay || !_myRoomId)
+        if (st.myRoomMeta)
+            st.myRoomMeta = { ...st.myRoomMeta, thinking: level };
+        if (!_relay || !st.myRoomId)
             return;
         _relay.sendControl({
             type: "room_meta_update",
-            room_id: _myRoomId,
+            room_id: st.myRoomId,
             meta: { thinking: level },
         });
     });
@@ -1976,35 +1389,36 @@ const extension = (pi) => {
         }
         if (_isNonRootSid(sid))
             return; // room_meta projection is root-only
-        // Root projection: seed the global model + room_meta hello from the root's
+        // Root projection: seed the room_meta model + hello from the root's
         // cached model, once.
-        if (!_currentModel && st.model)
+        if (!st.currentModel && st.model)
             _setCurrentModel(st.model);
         // Plan/32 Part B: publish working=true as room_meta (raw, no debounce —
         // the debounce lives in the app). Same shape as the model/thinking updates.
-        // _myRoomMeta is the ROOM projection (driven only by the root session).
-        if (_myRoomMeta)
-            _myRoomMeta = { ..._myRoomMeta, working: true };
-        if (_relay && _myRoomId) {
+        // myRoomMeta is the ROOM projection (driven only by the root session).
+        if (st.myRoomMeta)
+            st.myRoomMeta = { ...st.myRoomMeta, working: true };
+        if (_relay && st.myRoomId) {
             _relay.sendControl({
                 type: "room_meta_update",
-                room_id: _myRoomId,
+                room_id: st.myRoomId,
                 meta: { working: true },
             });
         }
     });
     pi.on("turn_end", (_event, ctx) => {
         const sid = _sidOf(ctx);
-        _stateFor(sid).working = false;
+        const st = _stateFor(sid);
+        st.working = false;
         if (_isNonRootSid(sid))
             return; // room_meta is root-only
         // Plan/32 Part B: publish working=false as room_meta (raw, no debounce).
-        if (_myRoomMeta)
-            _myRoomMeta = { ..._myRoomMeta, working: false };
-        if (_relay && _myRoomId) {
+        if (st.myRoomMeta)
+            st.myRoomMeta = { ...st.myRoomMeta, working: false };
+        if (_relay && st.myRoomId) {
             _relay.sendControl({
                 type: "room_meta_update",
-                room_id: _myRoomId,
+                room_id: st.myRoomId,
                 meta: { working: false },
             });
         }
@@ -2049,8 +1463,9 @@ const extension = (pi) => {
         if (_isNonRootSid(_sidOf(ctx)))
             return;
         _sessionName = name;
-        if (_myRoomMeta)
-            _myRoomMeta = { ..._myRoomMeta, name };
+        const st = _rootState();
+        if (st.myRoomMeta)
+            st.myRoomMeta = { ...st.myRoomMeta, name };
         _broadcastEnvelope(relayDeps, {
             evt: { channel: "session_info", data: { name } },
         });
@@ -2059,10 +1474,10 @@ const extension = (pi) => {
         // reaches attached peers, so pre-attach the Home tile went stale until open
         // or reconnect. Relay >=0.6.0 merges + fans `name`; older relays drop the
         // unknown field (harmless — attached peers still get the evt). Design 01M1SPN7.
-        if (_relay && _myRoomId) {
+        if (_relay && st.myRoomId) {
             _relay.sendControl({
                 type: "room_meta_update",
-                room_id: _myRoomId,
+                room_id: st.myRoomId,
                 meta: { name },
             });
         }
@@ -2096,12 +1511,22 @@ const extension = (pi) => {
         // session_start with their own ctx). Each records its OWN sessionManager —
         // no cross-session clobber (was the unguarded `_sessionManager = ...` bug).
         const sid = _sidOf(ctx);
-        // The module BASE ctx (compact/notify fallback when no fresh ctx is passed)
-        // is the ROOT's — a subagent child's ctx must NOT clobber it, same
-        // no-cross-session-clobber rule as the per-sid sessionManager. Otherwise a
-        // subagent steals the base ctx and root-scoped notifies silently drop.
-        if (!_isNonRootSid(sid))
-            _lastEventCtx = ctx;
+        // Claim root + adopt the root sid BEFORE any _stateFor(sid) write. The root
+        // record is the stable _rootRecord, but _stateFor(sid) only routes there
+        // once sid === _rootKey() — i.e. once _rootSessionId === sid. Writing
+        // baseCtx/sessionManager before the adoption lands them in an orphaned
+        // per-sid map entry (the deferred re-arm then reads _rootState and sees
+        // null). For a subagent child _claimRootSession returns false (root owns
+        // the slot), so _rootSessionId is untouched and _stateFor(sid) correctly
+        // gives the child its own map entry.
+        const isRootClaim = _claimRootSession(pi);
+        if (isRootClaim && ctx?.sessionManager)
+            _rootSessionId = sid;
+        // Base ctx (compact/notify fallback when no fresh ctx is passed) is
+        // PER-SESSION (plan 01M18RNH) — each session_start records its OWN; the
+        // base-ctx resolution reads the ROOT's, so a child's ctx never leaks
+        // (structurally replaces the old `!_isNonRootSid` guard + global).
+        _stateFor(sid).baseCtx = ctx ?? null;
         // EVENT-CTX TARGETED PROBE (run 2026-09-18, round 3): the ctx objects
         // are guarded (throwing getters — proxies), so full reflection
         // under-reports or throws. Per-property access, each caught, is the
@@ -2119,7 +1544,7 @@ const extension = (pi) => {
         // The root claim also fixes _rootSessionId (re-captured across replacement);
         // only when a real sessionManager is present (ctx-less test events stay in
         // null-root mode where every event is treated as root).
-        if (_claimRootSession(pi)) {
+        if (isRootClaim) {
             if (ctx?.sessionManager)
                 _rootSessionId = sid;
             if (!_extensionUiBridge)
@@ -2137,7 +1562,7 @@ const extension = (pi) => {
                 });
             if (!_subagentRooms)
                 _subagentRooms = initSubagentRooms(pi, {
-                    getParentRoomId: () => _myRoomId,
+                    getParentRoomId: () => _rootState().myRoomId,
                     getParentSessionId: () => _rootSessionId,
                     broadcastPanel: (msg) => _panelBroadcast(relayDeps, msg),
                 });
@@ -2299,10 +1724,19 @@ const extension = (pi) => {
             _subagentRooms = null;
             _releaseRootSession(pi);
         }
-        // Drop the captured event ctx immediately. On module-reuse hosts the same
-        // instance survives session replacement; the next session_start re-binds
-        // `_lastEventCtx` for the new session.
-        _lastEventCtx = null;
+        // Drop the captured base ctx on the stable root record. On module-reuse
+        // hosts the same instance survives session replacement; the next
+        // session_start re-binds it for the new session. We clear ONLY baseCtx here
+        // (mirroring the pre-01M18RNH global semantics): the relay-room PROJECTION
+        // (myRoomId/myRoomMeta/sessionStartedAt) must survive the replacement by
+        // contract (_goIdle keeps it too; _cmdStart overwrites it on the new
+        // connect), and the other per-session fields (model/thinking/currentModel/
+        // sessionManager/…) are either re-populated by the new session_start + its
+        // events or intentionally fall back to the prior value when the replacement
+        // ctx carries no sessionManager (the ctx-less same-module path). Clearing
+        // sessionManager here, for instance, defers `_cmdStart` (no roomId) and
+        // breaks that path — see the same-module replacement suite.
+        _rootState().baseCtx = null;
         // No bye reason: the process keeps running and the fresh instance re-joins
         // the SAME relay room, so an explicit offline→online flap would be wrong.
         // Revoke producer/Relay/bridge authority while the global node is still
@@ -2469,7 +1903,7 @@ function _deliverMeshMessageToAgent(env) {
  * handles incoming app→pi requests.
  */
 function _abortCurrentTurn(fallbackCtx) {
-    const candidates = [_lastEventCtx, fallbackCtx];
+    const candidates = [_rootState().baseCtx, fallbackCtx];
     for (const candidate of candidates) {
         if (!candidate || candidate === _noopCtx)
             continue;