@geohar/un-bien 0.7.0 → 0.9.0

package/dist/index.js

@@ -29,17 +29,17 @@
  *   AgentBridge (src/session/agent_bridge.ts) remains the tested, mockable unit
  *   for integration tests.
  */
-import { createHash, randomUUID } from "node:crypto";
-import { SettingsManager, convertToPng } from "@earendil-works/pi-coding-agent";
+import { randomUUID } from "node:crypto";
+import { SettingsManager } from "@earendil-works/pi-coding-agent";
 import { buildQRUri, qrSession, renderQRAscii, clampPairTtlMs, TOKEN_TTL_MS, } from "./pairing/qr.js";
-import { addPeer, getOrCreateEd25519Keypair, KeyringUnavailableError, PairedIdentityMissingError, listPeers, removePeer, snapshotOwnerPubkeys, conditionalRemovePeer, } from "./pairing/storage.js";
+import { addPeer, getOrCreateEd25519Keypair, describeIdentity, KeyringUnavailableError, PairedIdentityMissingError, listPeers, removePeer, snapshotOwnerPubkeys, conditionalRemovePeer, } from "./pairing/storage.js";
 import { MeshClient } from "./mesh/client.js";
-import { canonicalizeEd25519PublicKey, decodeEd25519PublicKey, publicKeyFingerprint, } from "./mesh/encoding.js";
 import { SelfRevoke } from "./mesh/self_revoke.js";
 import { RelayClient, RoomAlreadyOpenError } from "./transport/relay_client.js";
 import { PlainPeerChannel } from "./transport/peer_channel.js";
 import { createExtensionUiBridge, } from "./extension_ui_bridge.js";
 import { createPanelBridge } from "./panel_bridge.js";
+import { initSubagentRooms, subagentRoomsEnabled, } from "./subagent_rooms.js";
 import { createRpcEnvelope, isEnvelopeFrame, helloEnvelope, } from "./session/rpc_envelope.js";
 import { dispatchRpcCommand, } from "./session/rpc_inbound.js";
 import { envLog } from "./session/debug_log.js";
@@ -51,20 +51,21 @@ import { wireFromModel, } from "./actions/handlers.js";
 import { ensureModelRegistry } from "./actions/registry.js";
 import { ensureGlobalDirs, LOCAL_SESSION_NAME, sessionAuditPath, sessionSockPath, skillsDir, } from "./session/global_config.js";
 import { acquireCwdLock } from "./session/cwd_lock.js";
-import { addDaemon, listDaemons, removeDaemon } from "./daemon/registry.js";
-import { EXIT_DAEMON_FRESH_SESSION } from "./daemon/rpc_child.js";
-import { callSupervisor, supervisorOnline, SupervisorOfflineError, } from "./daemon/client.js";
-import { installService, uninstallService, linkCliBinaries, unlinkCliBinaries, LAUNCHD_LABEL, SYSTEMD_UNIT, WINDOWS_TASK_NAME, } from "./daemon/install.js";
+import { installService, uninstallService, linkCliBinaries, unlinkCliBinaries, } from "./daemon/install.js";
 import { defaultAgentName, effectiveAutoStartRelay, effectiveAllowRemoteLaunch, loadLocalConfig, localConfigExists, saveLocalConfig, } from "./session/local_config.js";
 import { runSetupWizard } from "./session/setup_wizard.js";
 import { updateFooter } from "./ui/footer.js";
-import { join, dirname, resolve, basename } from "node:path";
+import { join, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { chmodSync, mkdtempSync, mkdirSync, copyFileSync, existsSync, statSync, unlinkSync, readFileSync, writeFileSync, realpathSync, } from "node:fs";
+import { chmodSync, mkdirSync, copyFileSync, existsSync, unlinkSync, readFileSync, writeFileSync, realpathSync, } from "node:fs";
 import { createInterface } from "node:readline";
-import { spawn, spawnSync } from "node:child_process";
+import { spawnSync } from "node:child_process";
 import { hostname, tmpdir } from "node:os";
-import { resolveRelayUrl, saveConfig, isValidRelayUrl, isWebSocketScheme, toWebSocketUrl, } from "./config.js";
+import { resolveRelayUrl, loadConfig, saveConfig, isValidRelayUrl, isWebSocketScheme, toWebSocketUrl, } from "./config.js";
+import { _expandTilde, _launchSession } from "./launch.js";
+import { _enrichToolArgs } from "./enrich_tool_args.js";
+import { IMAGE_PREVIEW_MIME, _imageCacheRootDir, _imageExtension, _safeFilenameToken, _safePreviewPath, _renderablePngPathFromImage, _decodeImagePayload, } from "./image_codec.js";
+import { _findKnownPeer, _inspectPeerRecord, _runtimeOwnerFingerprint, } from "./pairing/peer_trust.js";
 import { Box, Container, Image, Text } from "@earendil-works/pi-tui";
 let _state = "idle";
 let _relay = null;
@@ -93,36 +94,7 @@ 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)
 const UNBIEN_RECEIVED_IMAGE_TYPE = "un-bien:received-image";
-const RECEIVED_IMAGE_MAX_BYTES = 10 * 1024 * 1024;
-const IMAGE_PREVIEW_MIME = "image/png";
-const IMAGE_CACHE_PREFIX = "pi-app-";
-let _imageCacheDir;
 const _pendingReceivedImagePreviews = [];
-function _isBase64Char(code) {
-    return ((code >= 48 && code <= 57) || // 0-9
-        (code >= 65 && code <= 90) || // A-Z
-        (code >= 97 && code <= 122) || // a-z
-        code === 43 || // +
-        code === 47); // /
-}
-function _isStrictBase64(data) {
-    if (data.length === 0 || data.length % 4 !== 0)
-        return false;
-    if (data.startsWith("="))
-        return false;
-    const padding = data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0;
-    for (let i = 0; i < data.length; i += 1) {
-        const code = data.charCodeAt(i);
-        if (i >= data.length - padding) {
-            if (code !== 61)
-                return false;
-            continue;
-        }
-        if (!_isBase64Char(code))
-            return false;
-    }
-    return true;
-}
 let _myRoomId = null; // this Pi's room id (derived from the session id)
 /** THE App<->Pi room id for the current chat session. Prefers the STABLE pi
  *  session id (durable across resume) so the room can't drift when the assigned
@@ -239,115 +211,6 @@ function _publishWorking(working) {
         });
     }
 }
-function _imageCacheRootDir() {
-    if (_imageCacheDir) {
-        try {
-            mkdirSync(_imageCacheDir, { recursive: true, mode: 0o700 });
-        }
-        catch { }
-        try {
-            chmodSync(_imageCacheDir, 0o700);
-        }
-        catch {
-            /* best-effort permission hardening */
-        }
-        return _imageCacheDir;
-    }
-    const dir = mkdtempSync(join(tmpdir(), IMAGE_CACHE_PREFIX));
-    try {
-        chmodSync(dir, 0o700);
-    }
-    catch {
-        /* best-effort permission hardening */
-    }
-    _imageCacheDir = dir;
-    return dir;
-}
-function _imageExtension(mime) {
-    if (mime === "image/jpeg")
-        return "jpg";
-    if (mime === "image/png")
-        return "png";
-    if (mime === "image/webp")
-        return "webp";
-    if (mime === "image/gif")
-        return "gif";
-    return undefined;
-}
-function _safeFilenameToken(value) {
-    return (value
-        .trim()
-        .replace(/[^A-Za-z0-9._-]+/g, "-")
-        .replace(/-+/g, "-")
-        .replace(/^-+|-+$/g, "") || "message");
-}
-function _safePreviewPath(dir, messageId, index) {
-    return join(dir, `${_safeFilenameToken(messageId)}-${index}.preview.png`);
-}
-function _cleanupPreviewFile(previewPath) {
-    try {
-        if (existsSync(previewPath))
-            unlinkSync(previewPath);
-    }
-    catch {
-        // best effort
-    }
-}
-async function _renderablePngPathFromImage(imageData, mime, previewPath) {
-    if (mime === IMAGE_PREVIEW_MIME)
-        return undefined;
-    try {
-        const converted = await convertToPng(imageData, mime);
-        if (!converted ||
-            converted.mimeType !== IMAGE_PREVIEW_MIME ||
-            !converted.data) {
-            return undefined;
-        }
-        const previewBytes = Buffer.from(converted.data, "base64");
-        if (previewBytes.length === 0 ||
-            previewBytes.length > RECEIVED_IMAGE_MAX_BYTES) {
-            return undefined;
-        }
-        try {
-            writeFileSync(previewPath, previewBytes, { mode: 0o600 });
-            try {
-                chmodSync(previewPath, 0o600);
-            }
-            catch {
-                /* best-effort permission hardening */
-            }
-            return previewPath;
-        }
-        catch {
-            _cleanupPreviewFile(previewPath);
-        }
-    }
-    catch {
-        _cleanupPreviewFile(previewPath);
-    }
-    return undefined;
-}
-function _decodeImagePayload(data, mime) {
-    if (!_imageExtension(mime))
-        return { ok: false, reason: `unsupported mime: ${mime}` };
-    if (data.startsWith("data:"))
-        return { ok: false, reason: "data URI payloads are not supported" };
-    if (!_isStrictBase64(data))
-        return { ok: false, reason: "invalid base64 payload" };
-    const padding = data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0;
-    const estimate = (data.length / 4) * 3 - padding;
-    if (estimate > RECEIVED_IMAGE_MAX_BYTES) {
-        return { ok: false, reason: `image too large (${estimate} bytes)` };
-    }
-    const decoded = Buffer.from(data, "base64");
-    if (decoded.length === 0 || decoded.length > RECEIVED_IMAGE_MAX_BYTES) {
-        return {
-            ok: false,
-            reason: `invalid decoded image size (${decoded.length} bytes)`,
-        };
-    }
-    return { ok: true, decoded, size: decoded.length };
-}
 function _sendReceivedImagePreviewNow(details) {
     if (!_pi)
         return;
@@ -675,9 +538,12 @@ function _ctxUi(preferred) {
     }
 }
 /** Best-effort TUI notify; never throws (relay reconnect must not crash pi). */
-function _safeNotify(message, level = "info") {
+function _safeNotify(message, level = "info", preferred) {
     try {
-        const ui = _ctxUi();
+        // Prefer the caller's fresh ctx (e.g. a command ctx) over the module's
+        // last-event ctx — a session_start ctx can be ui-less/stale and would
+        // otherwise shadow it, silently dropping the notify.
+        const ui = _ctxUi(preferred);
         if (ui && typeof ui.notify === "function")
             ui.notify(message, level);
     }
@@ -772,6 +638,8 @@ export function _resetBridgeOwnersForTest() {
     _panelBridge = null;
     _rpcEnvelope?.dispose();
     _rpcEnvelope = null;
+    _subagentRooms?.dispose();
+    _subagentRooms = null;
     _extensionUiBridge?.dispose();
     _extensionUiBridge = null;
 }
@@ -894,6 +762,7 @@ function _stateFor(sid) {
             agentRun: { active: false, generation: 0 },
             sessionManager: null,
             model: null,
+            thinking: null,
         };
         _sessions.set(sid, st);
     }
@@ -925,6 +794,11 @@ let _panelBridge = null;
 // (always on, advertised as the `rpc_envelope` capability); runs alongside the
 // stock ServerMessage path only until M4 parity retirement.
 let _rpcEnvelope = null;
+// Per-child subagent relay rooms — each subagent surfaced to the app as its own
+// session, opt-in via the `subagents.rooms` un-bien setting (a no-op controller
+// otherwise). Owned by the ROOT session; a child session_start calls
+// onChildSession on this same instance.
+let _subagentRooms = null;
 let _stopAutoListener = null;
 // Cached keypair (loaded once, reused across start/pair cycles)
 let _cachedEd25519 = null;
@@ -1411,9 +1285,11 @@ function _routeRpcCommandFrom(sender, env) {
     if (!frame || typeof frame !== "object")
         return; // no {evt} inbound today
     envLog(`rpc inbound: ${String(frame.type)}`);
-    // extension_ui_response is a reply to a fork-issued dialog, not a command —
+    // 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;
     }
@@ -1431,15 +1307,14 @@ function _routeRpcCommandFrom(sender, env) {
             //  - seed `_rootState().turnId` for a fresh (non-steer) turn so the agent's
             //    reply chunks/done have a target; restore it if the handoff fails.
             // The APP owns the steer-vs-followUp semantic switch (design 01M14T6J5W):
-            // pass its chosen streamingBehavior straight through to pi. The fork does
+            // pass its chosen streamingBehavior straight through to pi. The extension does
             // NOT force steer over a followUp anymore. `shouldSteer` below is now only
             // BOOKKEEPING (turn-seeding + image-preview defer), not the delivery verb.
             const requestedSteer = opts.streamingBehavior === "steer";
             // Authoritative busy signal from pi's OWN state (AgentSession.isStreaming),
             // correct across subagent lifecycles (turnId/working stick busy after a
             // subagent run).
-            const streaming = _pi?.isStreaming ===
-                true;
+            const streaming = _pi?.isStreaming === true;
             const shouldSteer = requestedSteer || streaming;
             const msg = {
                 type: "user_message",
@@ -1499,6 +1374,9 @@ function _routeRpcCommandFrom(sender, env) {
             // Route via the minimal ActionPi view (matches handleModelSet): the
             // registry's `find` returns the minimal SdkModelLike, structurally fine
             // for setModel at runtime.
+            // SAFETY: _pi (checked non-null above) is the concrete AgentSession; its
+            // setModel accepts the minimal SdkModelLike the registry's find() returns,
+            // matching handleModelSet's ActionPi view.
             const ok = await _pi.setModel(model);
             if (!ok)
                 throw new Error("no auth configured for this model");
@@ -1527,33 +1405,10 @@ function _routeRpcCommandFrom(sender, env) {
         },
         newSession: async () => {
             const actionCtx = (_lastEventCtx ?? _lastCtx);
-            const daemonMode = process.env["UNBIEN_DAEMON"] === "1";
-            // Daemon fresh-restart (ported from the retired stock session_new): with no
-            // command ctx — or when the drive below fails on a STALE ctx — the supervisor
-            // relaunches with a genuinely fresh session via process.exit. Ack first (the
-            // response goes out before the 100ms-deferred exit); interactive mode has no
-            // supervisor so it still surfaces the error.
-            const restartFresh = () => {
-                _resetSessionForNew();
-                setTimeout(() => process.exit(EXIT_DAEMON_FRESH_SESSION), 100);
-            };
             if (!actionCtx?.newSession) {
-                if (daemonMode) {
-                    restartFresh();
-                    return { cancelled: false };
-                }
                 throw new Error("new_session unavailable (no command ctx)");
             }
-            try {
-                await actionCtx.newSession({ withSession: async () => { } });
-            }
-            catch (err) {
-                if (daemonMode) {
-                    restartFresh();
-                    return { cancelled: false };
-                }
-                throw err;
-            }
+            await actionCtx.newSession({ withSession: async () => { } });
             // Restamp the session clock (parity with the retired stock session_new):
             // session_sync_end carries it so the app can detect the pi restart.
             _resetSessionForNew();
@@ -1562,13 +1417,15 @@ function _routeRpcCommandFrom(sender, env) {
         clearQueue: async () => {
             if (!_pi)
                 throw new Error("agent session not bound");
+            // SAFETY: _pi (checked non-null above) is the concrete AgentSession,
+            // which implements clearQueue(); the public ExtensionAPI type omits it.
             return _pi.clearQueue();
         },
         getEntries: async (since) => {
             // Native pi get_entries: the app reconstructs the transcript itself from
             // the raw entry log (each message entry carries an AgentMessage). `since`
             // slices to entries AFTER that id (delta cursor); leafId is the cursor to
-            // resume from next time. The fork does NOT replay these — see the app's
+            // resume from next time. The extension does NOT replay these — see the app's
             // SessionState.applyEntries (design 01M15FMQ).
             const sm = _rootState().sessionManager;
             if (!sm)
@@ -1636,12 +1493,15 @@ function _routeUnBienPlaneFrom(sender, env) {
     }
     if (type === "session_launch") {
         const f = frame;
-        const cwd = typeof f.cwd === "string" && f.cwd.length > 0 ? f.cwd : process.cwd();
+        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;
         }
-        const launchError = _launchSession(f.mode === "rpc" ? "rpc" : "tmux", cwd, typeof f.name === "string" ? f.name : undefined);
+        // 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);
         if (launchError)
             envLog(`session_launch(ub) error: ${launchError}`);
         return;
@@ -1735,64 +1595,6 @@ function _displayName(cwd) {
     const local = loadLocalConfig(cwd);
     return local.agent_name || defaultAgentName(cwd);
 }
-function _rawOwnerFingerprint(rawValue) {
-    let fingerprintInput;
-    if (typeof rawValue === "string") {
-        fingerprintInput = rawValue;
-    }
-    else {
-        try {
-            const serialized = JSON.stringify(rawValue);
-            const type = rawValue === null ? "null" : typeof rawValue;
-            fingerprintInput = `${type}:${serialized ?? ""}`;
-        }
-        catch {
-            fingerprintInput = `${typeof rawValue}:unserializable`;
-        }
-    }
-    return createHash("sha256")
-        .update(fingerprintInput, "utf8")
-        .digest("hex")
-        .slice(0, 8);
-}
-function _runtimeOwnerFingerprint(runtimeKey) {
-    try {
-        return publicKeyFingerprint(decodeEd25519PublicKey(runtimeKey, "Owner runtime key"));
-    }
-    catch {
-        // Relay authentication guarantees canonical keys in production. This
-        // fallback keeps diagnostics metadata-only at defensive/test boundaries.
-        return _rawOwnerFingerprint(runtimeKey);
-    }
-}
-function _inspectPeerRecord(record) {
-    if (!record || typeof record !== "object") {
-        const fingerprint = _rawOwnerFingerprint(record);
-        console.warn(`[un-bien] event=invalid_owner_record owner_fp=${fingerprint}`);
-        return null;
-    }
-    const candidate = record;
-    const rawHandle = candidate.remote_epk;
-    if (typeof rawHandle !== "string") {
-        const fingerprint = _rawOwnerFingerprint(rawHandle);
-        console.warn(`[un-bien] event=invalid_owner_record owner_fp=${fingerprint}`);
-        return null;
-    }
-    const safeRecord = {
-        name: typeof candidate.name === "string" ? candidate.name : "Unknown Owner",
-        remote_epk: rawHandle,
-        paired_at: typeof candidate.paired_at === "string" ? candidate.paired_at : "",
-    };
-    try {
-        const runtimeKey = canonicalizeEd25519PublicKey(rawHandle, "stored Owner public key");
-        return { record: safeRecord, rawHandle, runtimeKey };
-    }
-    catch {
-        const fingerprint = _rawOwnerFingerprint(rawHandle);
-        console.warn(`[un-bien] event=invalid_owner_record owner_fp=${fingerprint}`);
-        return { record: safeRecord, rawHandle, runtimeKey: null };
-    }
-}
 function _reportRevocationByFingerprint(canonicalOwnerPubkey) {
     const fingerprint = _runtimeOwnerFingerprint(canonicalOwnerPubkey);
     _pi?.sendMessage({
@@ -1811,21 +1613,6 @@ function _revokeActiveOwnerRuntime(canonicalOwnerPubkey) {
     _refreshFooter();
     _reportRevocationByFingerprint(canonicalOwnerPubkey);
 }
-async function _findKnownPeer(appPeerIdStd) {
-    let runtimeKey;
-    try {
-        runtimeKey = canonicalizeEd25519PublicKey(appPeerIdStd, "Relay Owner key");
-    }
-    catch {
-        return null;
-    }
-    for (const record of await listPeers()) {
-        const inspected = _inspectPeerRecord(record);
-        if (inspected?.runtimeKey === runtimeKey)
-            return inspected.record;
-    }
-    return null;
-}
 // ── Transition helpers ────────────────────────────────────────────────────────
 /**
  * Full teardown: stop listener, detach channel, close relay → idle.
@@ -2044,6 +1831,9 @@ function _emitRelayState(force = false) {
  *  ctx is available in the `input` hook). cwd matches the daemon's launch dir,
  *  so the derived relay room is identical to the one `_cmdStart` first used. */
 function _controlCtx() {
+    // SAFETY: _headlessUi() implements every ui method the relay start/stop path
+    // actually calls; the notify-forwarding shim is structurally narrower than the
+    // full ExtensionContext["ui"] but complete for this headless control path.
     return {
         ui: _headlessUi(),
         cwd: process.cwd(),
@@ -2212,7 +2002,9 @@ function _attachOwner(relay, appPeerId, peerName, firstInner) {
     // is a captured command ctx that goes stale after session replacement (#55).
     const channel = new PlainPeerChannel(relay, appPeerId, _myRoomId ?? undefined, (msg) => _routeClientMessageFrom(channel, msg, _liveCtx() ?? _noopCtx), () => _onPeerDisconnect(appPeerId), (env) => env.ub === undefined
         ? _routeRpcCommandFrom(channel, env)
-        : _routeUnBienPlaneFrom(channel, env));
+        : _routeUnBienPlaneFrom(channel, env), () => _rootState().sessionManager?.getSessionId() ??
+        _rootSessionId ??
+        undefined);
     _attachPeerChannel(appPeerId, channel);
     // Envelope-native capability handshake: advertise caps up front so the app can
     // enable the {rpc|evt} route + suppress stock before any session content
@@ -2307,6 +2099,8 @@ function _installAutoListener(relay) {
             const innerObj = inner;
             if (isEnvelopeFrame(innerObj)) {
                 {
+                    // SAFETY: isEnvelopeFrame confirmed rpc/evt/ub envelope keys are
+                    // present, so this ClientMessage is byte-compatible with EnvelopeMessage.
                     const innerEnv = inner;
                     if (innerEnv.ub === undefined)
                         _routeRpcCommandFrom(channel, innerEnv);
@@ -2361,7 +2155,7 @@ const _HOSTNAME = hostname();
 // un-bien capability handshake. PROTOCOL_VERSION bumps on a HARD (breaking)
 // wire change; the app gates UI on capability PRESENCE, not this number.
 const PROTOCOL_VERSION = 1;
-// Features this fork supports, advertised on attach (session_history) + pair_ok.
+// Features this extension supports, advertised on attach (session_history) + pair_ok.
 // `remote_launch` is conditional (added only when local config opts in) — see
 // `_capabilities()`. Passive server->app extras (images/panels) are listed so
 // the app can also gate any future *controls* it grows for them.
@@ -2386,48 +2180,6 @@ function _capabilities() {
     }
     return caps;
 }
-/** Sanitize a tmux session name: keep it shell-safe and tmux-legal. */
-function _safeTmuxName(name, fallback) {
-    const base = (name ?? "").trim() || fallback;
-    // tmux disallows `.` and `:` in session names; strip anything risky.
-    const clean = base
-        .replace(/[^A-Za-z0-9_-]+/g, "-")
-        .replace(/-{2,}/g, "-")
-        .replace(/^-+|-+$/g, "");
-    return clean.slice(0, 40) || "pi";
-}
-/** Build the argv for a detached tmux launch of `pi` in `cwd`. Args are an
- *  ARRAY (never a shell string) so cwd/name can't inject. Exported for tests. */
-export function _buildTmuxLaunchArgs(name, cwd) {
-    return ["new-session", "-d", "-s", name, "-c", cwd, "pi"];
-}
-/**
- * Honor a `session_launch` request. Gated by the caller: config opt-in already
- * checked. `tmux` mode spawns a detached tmux running `pi` in `cwd` (which
- * joins the relay if that cwd has un-bien auto-start); `rpc` is not wired yet.
- * Returns null on success or an error string.
- */
-function _launchSession(mode, cwd, name) {
-    if (mode === "rpc")
-        return "launch mode 'rpc' is not supported yet";
-    if (mode !== "tmux")
-        return `unknown launch mode '${mode}'`;
-    if (!existsSync(cwd) || !statSync(cwd).isDirectory()) {
-        return `cwd does not exist or is not a directory: ${cwd}`;
-    }
-    const sessionName = _safeTmuxName(name, `pi-${basename(cwd) || "session"}`);
-    try {
-        const child = spawn("tmux", _buildTmuxLaunchArgs(sessionName, cwd), {
-            detached: true,
-            stdio: "ignore",
-        });
-        child.unref();
-        return null;
-    }
-    catch (error) {
-        return `tmux launch failed: ${error instanceof Error ? error.message : String(error)}`;
-    }
-}
 async function _handlePairRequest(relay, appPeerId, inner, hasListenerAuthority) {
     const sendInner = (msg) => {
         const ct = Buffer.from(JSON.stringify(msg)).toString("base64");
@@ -2533,13 +2285,13 @@ let _lastCtx = null;
 let _lastEventCtx = null;
 const _noopCtx = { ui: { notify: () => undefined }, abort: () => undefined };
 // A single Pi process can load this extension TWICE in the SAME session:
-// pi-supervisord launches each daemon child as `pi -e <dist>/index.js`, but if
-// un-bien is ALSO installed as a pi-package (auto-discovered from
-// ~/.pi/agent/extensions or <cwd>/.pi/extensions), Pi loads it a second time
-// for that same session. Both loads receive the same session-scoped `pi` and
-// would re-run registerTool/registerCommand for identical names — a hard
-// duplicate-registration conflict that crashes the daemon child on boot (see
-// daemon/rpc_child.ts). Idempotent, first-load-wins: whichever load runs first
+// when it is launched as `pi -e <dist>/index.js` AND un-bien is ALSO installed
+// as a pi-package (auto-discovered from ~/.pi/agent/extensions or
+// <cwd>/.pi/extensions), Pi loads it a second time for that same session. Both
+// loads receive the same session-scoped `pi` and would re-run
+// registerTool/registerCommand for identical names — a hard
+// duplicate-registration conflict that crashes the process on boot.
+// Idempotent, first-load-wins: whichever load runs first
 // does all the wiring; the duplicate is an inert no-op. A genuine session
 // REPLACEMENT gets a FRESH `pi`, so re-registration for the new session still
 // happens.
@@ -2615,14 +2367,22 @@ const extension = (pi) => {
         _extensionUiBridge?.dispose();
         _extensionUiBridge = createExtensionUiBridge(pi, _uiBroadcast);
         _panelBridge?.dispose();
-        _panelBridge = createPanelBridge(pi, _panelBroadcast);
+        _panelBridge = createPanelBridge(pi, _panelBroadcast, {
+            suppressAgents: subagentRoomsEnabled(),
+        });
         _rpcEnvelope?.dispose();
         _rpcEnvelope = createRpcEnvelope(pi, _broadcastEnvelope, {
             enrichArgs: (tool, args) => {
-                const e = _enrichToolArgs(tool, args);
+                const e = _enrichToolArgs(tool, args, _resolveToolCwd());
                 return Array.isArray(e.hunks) ? { hunks: e.hunks } : null;
             },
         });
+        _subagentRooms?.dispose();
+        _subagentRooms = initSubagentRooms(pi, {
+            getParentRoomId: () => _myRoomId,
+            getParentSessionId: () => _rootSessionId,
+            broadcastPanel: _panelBroadcast,
+        });
     }
     // Plano 19: ensure ~/.pi/un-bien/{sessions,skills}/ exist and deploy the
     // agent-network skill on first load. resources_discover lets Pi find it.
@@ -2680,25 +2440,33 @@ const extension = (pi) => {
     // SDK fires model_select on settings load + every user switch. We cache the
     // friendly name and broadcast a room_meta_update so the relay can fan it
     // out to subscribed apps without needing a new pair.
-    pi.on("model_select", (event) => {
+    pi.on("model_select", (event, ctx) => {
         const m = event?.model;
         const modelName = m?.name ?? m?.id;
         if (!modelName)
             return;
-        // Cache + fan out. Keeps the cached room_meta fresh so a future reconnect
-        // carries the current model in its hello, and pushes a room_meta_update to
-        // apps already subscribed.
-        _setCurrentModel(modelName);
+        // Cache per-sid for THIS session (root + subagent) so a subagent's model is
+        // queryable and never clobbers the root's. Only the ROOT projects to
+        // _currentModel + room_meta (the app-room's model hello/update).
+        const sid = _sidOf(ctx);
+        _stateFor(sid).model = modelName;
+        if (!_isNonRootSid(sid))
+            _setCurrentModel(modelName);
     });
     // Plan/28 Wave D.1: mirror model's room_meta_update path for thinking
     // level so the app hydrates the segmented control on first open instead
     // of starting null. SDK fires `thinking_level_select` on settings load
     // AND on every user toggle (matching `model_select`'s behavior), so
     // late-pairing apps see the current level via `room_meta_updated`.
-    pi.on("thinking_level_select", (event) => {
+    pi.on("thinking_level_select", (event, ctx) => {
         const level = event?.level;
         if (!level)
             return;
+        // Cache per-sid; only the ROOT projects to _currentThinking + room_meta.
+        const sid = _sidOf(ctx);
+        _stateFor(sid).thinking = level;
+        if (_isNonRootSid(sid))
+            return;
         _currentThinking = level;
         if (_myRoomMeta)
             _myRoomMeta = { ..._myRoomMeta, thinking: level };
@@ -2754,22 +2522,27 @@ const extension = (pi) => {
         if (ctx?.sessionManager)
             st.sessionManager = ctx.sessionManager;
         st.working = true;
-        if (_isNonRootSid(sid))
-            return; // model hydration + room_meta are root-only
-        // Late model hydration: if the model was still unknown at connect (resolved
-        // lazily by the SDK), grab it on the first turn and fan it out — so a daemon
-        // whose model only materialises at turn 1 still reports it to the app.
-        if (!_currentModel) {
+        // Late model hydration for THIS session: if the model was unknown at
+        // connect (SDK resolves it lazily), grab it on the first turn and cache
+        // per-sid — root AND subagent, so a subagent's model is queryable and the
+        // root's is never clobbered by a child.
+        if (!st.model) {
             try {
                 const m = ctx.getModel?.();
                 const name = m?.name ?? m?.id;
                 if (name)
-                    _setCurrentModel(name);
+                    st.model = name;
             }
             catch {
                 /* defensive — never block a turn on a model lookup */
             }
         }
+        if (_isNonRootSid(sid))
+            return; // room_meta projection is root-only
+        // Root projection: seed the global model + room_meta hello from the root's
+        // cached model, once.
+        if (!_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).
@@ -2802,19 +2575,24 @@ const extension = (pi) => {
     // Plan/32: compaction feedback. compact() doesn't run a turn, so bracket it
     // with working=true/false here. Returning void = no veto → default
     // compaction proceeds.
-    pi.on("session_before_compact", (event) => {
+    pi.on("session_before_compact", (event, ctx) => {
         if (event.preparation) {
             event.preparation.messagesToSummarize =
                 _filterInternalMessagesFromContext(event.preparation.messagesToSummarize);
             event.preparation.turnPrefixMessages = _filterInternalMessagesFromContext(event.preparation.turnPrefixMessages);
         }
-        _publishWorking(true);
+        // working=true brackets the ROOT room's compaction; the per-session message
+        // filtering above always runs, but a subagent that compacts must not
+        // flicker the root's working indicator.
+        if (!_isNonRootSid(_sidOf(ctx)))
+            _publishWorking(true);
     });
-    pi.on("session_compact", () => {
+    pi.on("session_compact", (_event, ctx) => {
         // Live compaction result rides the rpc-envelope compaction_end (app applyRPC),
         // and the persisted CompactionEntry surfaces natively via get_entries. Only
-        // the working=false bracket remains here.
-        _publishWorking(false);
+        // the working=false bracket remains here — the ROOT room's, so guard it.
+        if (!_isNonRootSid(_sidOf(ctx)))
+            _publishWorking(false);
     });
     // Re-capture the freshest base ctx on every session replacement so compact
     // never operates on a stale captured ctx — this is the fix for the
@@ -2822,11 +2600,16 @@ const extension = (pi) => {
     // New session. Fires on startup/new/fork/reload/resume; the ctx is always
     // bound to the current session.
     pi.on("session_start", (_event, ctx) => {
-        _lastEventCtx = ctx;
         // Register THIS session's record (root + every subagent get their own
         // 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;
         if (ctx?.sessionManager)
             _stateFor(sid).sessionManager = ctx.sessionManager;
         // session_shutdown disposes per-session pi-ask subscriptions. A host that
@@ -2843,14 +2626,27 @@ const extension = (pi) => {
             if (!_extensionUiBridge)
                 _extensionUiBridge = createExtensionUiBridge(pi, _uiBroadcast);
             if (!_panelBridge)
-                _panelBridge = createPanelBridge(pi, _panelBroadcast);
+                _panelBridge = createPanelBridge(pi, _panelBroadcast, {
+                    suppressAgents: subagentRoomsEnabled(),
+                });
             if (!_rpcEnvelope)
                 _rpcEnvelope = createRpcEnvelope(pi, _broadcastEnvelope, {
                     enrichArgs: (tool, args) => {
-                        const e = _enrichToolArgs(tool, args);
+                        const e = _enrichToolArgs(tool, args, _resolveToolCwd());
                         return Array.isArray(e.hunks) ? { hunks: e.hunks } : null;
                     },
                 });
+            if (!_subagentRooms)
+                _subagentRooms = initSubagentRooms(pi, {
+                    getParentRoomId: () => _myRoomId,
+                    getParentSessionId: () => _rootSessionId,
+                    broadcastPanel: _panelBroadcast,
+                });
+        }
+        else if (_isNonRootSid(sid)) {
+            // A subagent child session (non-root) — surface it as its own relay room.
+            // `pi` here is the CHILD's ExtensionAPI (per-activation).
+            _subagentRooms?.onChildSession(pi, ctx);
         }
         // Rearm a reused-but-disposed instance. The session_shutdown teardown (below)
         // sets _disposed=true assuming the host re-evaluates THIS module fresh for the
@@ -2936,6 +2732,18 @@ const extension = (pi) => {
     // best-effort: every step is guarded so a partially-initialised instance
     // (e.g. shutdown lands mid-`_cmdRoot`) tears down without throwing.
     pi.on("session_shutdown", async () => {
+        // A subagent child's session_shutdown owns NOTHING at the module level: the
+        // connection, mesh node, cwd lock, lifecycle generations, and base ctx are
+        // the ROOT's, and its child room outlives the turn (reaped by the root's
+        // _subagentRooms.dispose(), not here). So a non-root shutdown is a no-op.
+        // Without this, a subagent ENDING poisoned _disposed + the generations AND
+        // tore down the root's mesh node / cwd lock; the next root session_start's
+        // `if (_disposed)` rearm then re-ran _cmdRoot, dropping and re-announcing
+        // the root room — the "parent disappears while still running" flap. This is
+        // root-lifecycle authority (Tier 2), NOT the per-sid data path, so an
+        // early return is correct here — there is no session-local state to cache.
+        if (!_isRootSession(pi))
+            return;
         // Revoke async authority synchronously, before any teardown await. `_disposed`
         // blocks the outgoing continuation immediately; the root and candidate
         // generations keep queued work stale even if a same-module session_start
@@ -2966,6 +2774,8 @@ const extension = (pi) => {
             _panelBridge = null;
             _rpcEnvelope?.dispose();
             _rpcEnvelope = null;
+            _subagentRooms?.dispose();
+            _subagentRooms = null;
             _releaseRootSession(pi);
         }
         // Drop captured ctxs immediately. On module-reuse hosts the same instance
@@ -3042,6 +2852,8 @@ const extension = (pi) => {
                 "relay status",
                 "relay url",
                 "config",
+                "identity",
+                "identity show",
                 "test", // hidden e2e UI harness (dev-only)
                 "peers", // plan/25 Wave D — local + cross-PC inventory
                 "create",
@@ -3101,9 +2913,12 @@ const extension = (pi) => {
             else if (sub === "config") {
                 _cmdConfig(ctx);
             }
+            else if (sub === "identity" || sub.startsWith("identity ")) {
+                await _cmdIdentity(ctx);
+            }
             else if (sub === "test" || sub.startsWith("test ")) {
                 // Hidden dev-only e2e UI harness: broadcast canned frames to paired apps.
-                _safeNotify(`[un-bien test] ${_runTestScenario(sub.slice("test".length).trim())}`, "info");
+                _safeNotify(`[un-bien test] ${_runTestScenario(sub.slice("test".length).trim())}`, "info", ctx);
             }
             else if (sub === "rename" || sub.startsWith("rename ")) {
                 await _renameAgent(sub.slice("rename".length).trim());
@@ -3111,34 +2926,6 @@ const extension = (pi) => {
             else if (sub === "peers") {
                 await _cmdPeers(ctx);
             }
-            else if (sub.startsWith("create")) {
-                await _cmdCreate(sub.slice("create".length).trim(), ctx);
-            }
-            else if (sub.startsWith("remove")) {
-                await _cmdRemove(sub.slice("remove".length).trim(), ctx);
-            }
-            else if (sub === "daemons") {
-                await _cmdDaemonsList(ctx);
-            }
-            else if (sub === "daemon start" || sub.startsWith("daemon start ")) {
-                await _cmdDaemonStart(ctx, sub.slice("daemon start".length).trim() || undefined);
-            }
-            else if (sub === "daemon stop" || sub.startsWith("daemon stop ")) {
-                await _cmdDaemonStop(ctx, sub.slice("daemon stop".length).trim() || undefined);
-            }
-            else if (sub === "daemon restart" ||
-                sub.startsWith("daemon restart ")) {
-                await _cmdDaemonRestart(ctx, sub.slice("daemon restart".length).trim() || undefined);
-            }
-            else if (sub === "daemon status") {
-                await _cmdDaemonStatus(ctx);
-            }
-            else if (sub.startsWith("daemon send")) {
-                await _cmdDaemonSend(sub.slice("daemon send".length).trim(), ctx);
-            }
-            else if (sub === "cron" || sub.startsWith("cron ")) {
-                await _cmdCron(sub.slice("cron".length).trim(), ctx);
-            }
             else if (sub === "install") {
                 _cmdInstall(ctx, { linkCli: true });
             }
@@ -3217,98 +3004,45 @@ const extension = (pi) => {
             _cmdConfig(ctx);
         },
     });
-    pi.registerCommand("unbien relay", {
-        description: "Relay control: start | stop | status | url <http(s) url> (no arg toggles)",
-        handler: async (args, ctx) => {
-            _lastCtx = ctx;
-            await _cmdRelay(args.trim(), ctx);
-        },
-    });
-    // Plan/25 Wave D
-    pi.registerCommand("unbien peers", {
-        description: "List local + cross-PC mesh peers, grouped by PC label",
+    pi.registerCommand("unbien identity", {
+        description: "Show this machine's identity: active EPK (public), backend, and source",
         handler: async (_, ctx) => {
             _lastCtx = ctx;
-            await _cmdPeers(ctx);
-        },
-    });
-    // Daemon registry (plan/26 Wave 1) — create + remove. start/stop/send/
-    // status/install/uninstall come in later waves with the supervisor.
-    pi.registerCommand("unbien create", {
-        description: "Register a folder as a daemon and start it (when the supervisor is running)",
-        handler: async (args, ctx) => {
-            _lastCtx = ctx;
-            await _cmdCreate(args.trim(), ctx);
-        },
-    });
-    pi.registerCommand("unbien remove", {
-        description: "Stop + unregister a daemon by id (local config is preserved)",
-        handler: async (args, ctx) => {
-            _lastCtx = ctx;
-            await _cmdRemove(args.trim(), ctx);
+            await _cmdIdentity(ctx);
         },
     });
-    // Fleet ops via the supervisor (plan/26 W2). `/unbien stop` stays as
-    // local stop — fleet stop is `/unbien daemon stop`.
-    pi.registerCommand("unbien daemons", {
-        description: "List registered daemons + state",
+    pi.registerCommand("unbien identity show", {
+        description: "Show this machine's identity (EPK/backend/source) — alias of `identity`",
         handler: async (_, ctx) => {
             _lastCtx = ctx;
-            await _cmdDaemonsList(ctx);
-        },
-    });
-    pi.registerCommand("unbien daemon start", {
-        description: "Start daemons: all, or one by id (`daemon start <id>`)",
-        handler: async (args, ctx) => {
-            _lastCtx = ctx;
-            await _cmdDaemonStart(ctx, args.trim() || undefined);
+            await _cmdIdentity(ctx);
         },
     });
-    pi.registerCommand("unbien daemon stop", {
-        description: "Stop daemons: all, or one by id (`daemon stop <id>`)",
-        handler: async (args, ctx) => {
-            _lastCtx = ctx;
-            await _cmdDaemonStop(ctx, args.trim() || undefined);
-        },
-    });
-    pi.registerCommand("unbien daemon restart", {
-        description: "Restart daemons: all, or one by id (`daemon restart <id>`)",
+    pi.registerCommand("unbien relay", {
+        description: "Relay control: start | stop | status | url <http(s) url> (no arg toggles)",
         handler: async (args, ctx) => {
             _lastCtx = ctx;
-            await _cmdDaemonRestart(ctx, args.trim() || undefined);
+            await _cmdRelay(args.trim(), ctx);
         },
     });
-    pi.registerCommand("unbien daemon status", {
-        description: "Show fleet runtime status (pid, uptime, restarts)",
+    // Plan/25 Wave D
+    pi.registerCommand("unbien peers", {
+        description: "List local + cross-PC mesh peers, grouped by PC label",
         handler: async (_, ctx) => {
             _lastCtx = ctx;
-            await _cmdDaemonStatus(ctx);
-        },
-    });
-    pi.registerCommand("unbien daemon send", {
-        description: 'Send a prompt to a daemon: `daemon send <id> "<text>"`',
-        handler: async (args, ctx) => {
-            _lastCtx = ctx;
-            await _cmdDaemonSend(args.trim(), ctx);
-        },
-    });
-    pi.registerCommand("unbien cron", {
-        description: "Schedule recurring prompts to daemons: `cron <add|list|remove|enable|disable|run|log>`",
-        handler: async (args, ctx) => {
-            _lastCtx = ctx;
-            await _cmdCron(args.trim(), ctx);
+            await _cmdPeers(ctx);
         },
     });
-    // Service install / uninstall (plan/26 W3)
+    // Service install / uninstall — the launcher daemon as a system service.
     pi.registerCommand("unbien install", {
-        description: "Install pi-supervisord as a system service + link the un-bien CLI (systemd/launchd/Task Scheduler; Windows prompts for admin)",
+        description: "Install the un-bien launcher daemon as a system service + link the un-bien CLI (systemd/launchd/Task Scheduler; Windows prompts for admin)",
         handler: async (_, ctx) => {
             _lastCtx = ctx;
             _cmdInstall(ctx, { linkCli: true });
         },
     });
     pi.registerCommand("unbien uninstall", {
-        description: "Remove the pi-supervisord system service + the CLI shims (daemons registry preserved; Windows prompts for admin)",
+        description: "Remove the un-bien launcher daemon system service + the CLI shims (Windows prompts for admin)",
         handler: async (_, ctx) => {
             _lastCtx = ctx;
             _cmdUninstall(ctx, { linkCli: true });
@@ -3479,6 +3213,9 @@ async function _cmdRootInner(ctx, rootLifecycleGeneration) {
     }
     // First-time wizard: no local config in this cwd → run interactive setup.
     if (!localConfigExists(cwd)) {
+        // SAFETY: ctx.ui MIGHT carry the wizard's select/input methods (interactive
+        // Pi) or not (headless); the `typeof ui.select !== "function"` guard on the
+        // next line validates the structural assumption before any method call.
         const ui = ctx.ui;
         if (typeof ui.select !== "function") {
             _cmdStatus(ctx);
@@ -3535,6 +3272,9 @@ async function _cmdRootInner(ctx, rootLifecycleGeneration) {
  */
 async function _cmdSetup(ctx) {
     const cwd = "cwd" in ctx ? ctx.cwd : process.cwd();
+    // SAFETY: ctx.ui MIGHT carry the wizard's select/input methods (interactive
+    // Pi) or not (headless); the `typeof ui.select !== "function"` guard on the
+    // next line validates the structural assumption before any method call.
     const ui = ctx.ui;
     if (typeof ui.select !== "function") {
         ctx.ui.notify("[un-bien] Setup requires an interactive UI.", "warning");
@@ -3582,7 +3322,7 @@ async function _cmdStart(ctx) {
             ctx.ui.notify("[un-bien] Could not read this machine's identity: the system " +
                 "keychain is locked or access was denied. Unlock it (open the app / " +
                 "log in) and run /unbien again. Your pairing is NOT lost. " +
-                "(Set UNBIEN_ALLOW_FILE_IDENTITY=1 only for headless hosts.)", "error");
+                '(For a headless host, set "identity": { "storage": "file" } in un-bien.json.)', "error");
             return;
         }
         if (err instanceof PairedIdentityMissingError) {
@@ -3652,8 +3392,14 @@ async function _cmdStart(ctx) {
                 const provider = sm.getDefaultProvider();
                 const modelId = sm.getDefaultModel();
                 if (modelId) {
+                    // SAFETY: ensureModelRegistry only reads modelRegistry/getModel off
+                    // the ctx; c (and the _lastEventCtx/_lastCtx fallbacks) carry those
+                    // when present, and it tolerates null.
+                    const regCtx = (c ??
+                        _lastEventCtx ??
+                        _lastCtx);
                     const found = provider
-                        ? ensureModelRegistry((c ?? _lastEventCtx ?? _lastCtx)).find(provider, modelId)
+                        ? ensureModelRegistry(regCtx).find(provider, modelId)
                         : undefined;
                     _currentModel = found?.name ?? modelId;
                 }
@@ -3680,6 +3426,12 @@ async function _cmdStart(ctx) {
         roomMeta.model = modelName;
     if (_currentThinking)
         roomMeta.thinking = _currentThinking;
+    // The room's OWN pi sessionId on the announce — so the app keys per-session
+    // state by the pi id (wire identity), not the routing roomId. roomId stays
+    // relay-routing only.
+    const rootSid = _rootState().sessionManager?.getSessionId() ?? _rootSessionId ?? undefined;
+    if (rootSid)
+        roomMeta.sessionId = rootSid;
     // Persist so _attemptReconnect can replay the same hello payload — without
     // this, reconnect issues a bare hello and the relay creates a "default room"
     // entry that surfaces in the app as a phantom legacy session.
@@ -4067,6 +3819,21 @@ function _cmdConfig(ctx) {
         : "";
     ctx.ui.notify(`[un-bien]\n  Relay URL: ${url ?? "(none)"}\n  Source: ${source} — ${origin}${live}`, "info");
 }
+/**
+ * `/unbien identity` — report NON-SECRET identity state (active EPK, backend,
+ * resolved source). The private seed is NEVER shown: command output is
+ * LLM-visible, so extraction stays a manual `cat`/keychain op. Read-only
+ * (never mints).
+ */
+async function _cmdIdentity(ctx) {
+    const info = await describeIdentity();
+    const backendLine = info.backend === "file" ? `file (${info.filePath})` : "keychain";
+    const epkLine = info.epk ?? "(none yet — minted on first use)";
+    const sourceLine = info.detail
+        ? `${info.source} — ${info.detail}`
+        : info.source;
+    ctx.ui.notify(`[un-bien] identity\n  Backend: ${backendLine}\n  EPK (public): ${epkLine}\n  Source: ${sourceLine}`, info.source === "error" ? "error" : "info");
+}
 /**
  * `/unbien relay [start|stop|status|url <url>]` — issue #119.
  *
@@ -4127,465 +3894,19 @@ async function _cmdRelay(arg, ctx) {
             return;
     }
 }
-// ── Daemon registry commands (plan/26 Wave 1) ─────────────────────────────────
-/**
- * `/unbien create [<cwd>] [--name <name>]`
- *
- * Promotes a folder to a daemon entry in `~/.pi/un-bien/daemons.json`. The
- * cwd is **always normalized to an absolute realpath** before storage —
- * `~/Movies`, `./Movies`, `../foo/Movies` all collapse to a single
- * canonical entry. Relative paths resolve against the Pi process's
- * current working directory, not the slash-command's `ctx.cwd`.
- *
- * Side effects on the cwd's local config (`<cwd>/.pi/un-bien/config.json`):
- *   - If the config doesn't exist: created with `auto_start_relay=true`
- *     (mandatory for daemons) and `agent_name` from `--name` if provided.
- *   - If the config already exists: left untouched. Re-running `create`
- *     on an existing daemon is idempotent at this layer; the registry
- *     itself rejects duplicate cwds.
- */
-async function _cmdCreate(arg, ctx) {
-    // Parse `[cwd] [--name "value with spaces" | --name word]` in any order.
-    // The first non-flag token is the cwd; the rest of the line after
-    // `--name` (quoted or unquoted) is the display name.
-    const nameMatch = arg.match(/--name\s+"([^"]+)"|--name\s+(\S+)/);
-    const name = nameMatch ? (nameMatch[1] ?? nameMatch[2]) : undefined;
-    const cwdRaw = arg.replace(/--name\s+"[^"]+"|--name\s+\S+/, "").trim();
-    if (!cwdRaw) {
-        ctx.ui.notify('[un-bien] Usage: /unbien create <absolute-or-relative-cwd> [--name "Display name"]', "warning");
-        return;
-    }
-    let result;
-    try {
-        result = addDaemon(cwdRaw, name);
-    }
-    catch (err) {
-        ctx.ui.notify(`[un-bien] create failed: ${String(err)}`, "error");
-        return;
-    }
-    // No local `.pi/un-bien/config.json` is written anymore — the name lives
-    // in the registry and the supervisor injects the full config (agent_name,
-    // auto_start_relay true) via UNBIEN_DIRECT_CONFIG when it spawns the
-    // daemon. The cwd needs no init folder.
-    ctx.ui.notify(`[un-bien] Daemon registered: id=${result.id} name="${result.name}" cwd=${result.cwd}`, "info");
-    // Auto-start: register alone used to leave the daemon idle until the next
-    // supervisor restart (the reported bug — `create` didn't run anything). Ask
-    // the supervisor to spawn THIS daemon now; it reads the name from the
-    // registry and injects the config via env. When the supervisor is offline we
-    // keep the
-    // registration and tell the user it'll boot on the next supervisor start.
-    try {
-        await callSupervisor({ op: "start", id: result.id });
-        ctx.ui.notify(`[un-bien] Daemon started: id=${result.id}`, "info");
-    }
-    catch (err) {
-        if (err instanceof SupervisorOfflineError) {
-            ctx.ui.notify(`[un-bien] Registered, but the supervisor is offline — not running yet. ` +
-                `Run \`unbien install\` (or start \`pi-supervisord\`); it auto-starts on the next supervisor boot.`, "warning");
-            return;
-        }
-        ctx.ui.notify(`[un-bien] Registered, but auto-start failed: ${String(err)}`, "error");
-    }
-}
-/**
- * `/unbien remove <id>`
- *
- * Unregisters a daemon by its 8-hex-char id (the same id printed by
- * `/unbien create` and `/unbien daemons`). The cwd's local config
- * stays on disk — re-creating later with the same cwd is a no-op
- * because the existing config wins.
- */
-async function _cmdRemove(arg, ctx) {
-    const id = arg.trim();
-    if (!id) {
-        ctx.ui.notify("[un-bien] Usage: /unbien remove <id>. Run /unbien daemons to see ids.", "warning");
-        return;
-    }
-    // Prefer the supervisor's `unregister`: it STOPS the running child (SIGTERM →
-    // SIGKILL) BEFORE deleting the registry entry. Removing only the registry
-    // (the old behaviour) left an orphaned `pi --mode rpc` process running with
-    // nothing left to manage it — the reported bug. Fall back to a registry-only
-    // removal when the supervisor is offline (no managed process to stop anyway).
-    try {
-        const data = await callSupervisor({ op: "unregister", id });
-        if (!data.removed) {
-            const known = listDaemons()
-                .map((d) => d.id)
-                .join(", ") || "(none)";
-            ctx.ui.notify(`[un-bien] No daemon with id "${id}". Known ids: ${known}`, "warning");
-            return;
-        }
-        ctx.ui.notify(`[un-bien] Daemon removed + process stopped: id=${id} cwd=${data.cwd}. ` +
-            `Local config at ${data.cwd}/.pi/un-bien/config.json was kept.`, "info");
-        return;
-    }
-    catch (err) {
-        if (!(err instanceof SupervisorOfflineError)) {
-            ctx.ui.notify(`[un-bien] remove failed: ${String(err)}`, "error");
-            return;
-        }
-        // Supervisor offline — fall through to registry-only removal below.
-    }
-    let result;
-    try {
-        result = removeDaemon(id);
-    }
-    catch (err) {
-        ctx.ui.notify(`[un-bien] remove failed: ${String(err)}`, "error");
-        return;
-    }
-    if (!result.removed) {
-        const known = listDaemons()
-            .map((d) => d.id)
-            .join(", ") || "(none)";
-        ctx.ui.notify(`[un-bien] No daemon with id "${id}". Known ids: ${known}`, "warning");
-        return;
-    }
-    ctx.ui.notify(`[un-bien] Daemon removed from registry: id=${id} cwd=${result.cwd}. ` +
-        `Supervisor was offline, so any running process was NOT stopped. Local config kept.`, "warning");
-}
-// ── Fleet-ops commands (plan/26 W2) — talk to the supervisor over UDS ─────────
+// ── Install/uninstall the launcher-daemon service ────────────────────────────
 //
-// Every command here is a thin wrapper around `callSupervisor(...)`. When
-// the supervisor isn't running we fall back to a friendly hint instead of
-// the raw error, so the user can't get stuck on "what's wrong?".
-function _notifyOffline(ctx, err) {
-    ctx.ui.notify(`[un-bien] ${err.message}`, "warning");
-}
-function _formatDaemonTable(daemons) {
-    if (daemons.length === 0)
-        return "(no daemons registered)";
-    const rows = daemons.map((d) => {
-        const uptime = d.uptime_s === undefined ? "—" : `${d.uptime_s}s`;
-        const pid = d.pid === undefined ? "—" : String(d.pid);
-        const restarts = d.restart_count ?? 0;
-        return `  ${d.id}  ${d.state.padEnd(8)}  pid=${pid}  up=${uptime}  restarts=${restarts}  ${d.name}  ${d.cwd}`;
-    });
-    return rows.join("\n");
-}
-/**
- * `/unbien daemons` — registry + runtime state in one view. When the
- * supervisor is offline we still show registry-only output (state =
- * "stopped" everywhere), so the user can see what's configured even
- * before `install`.
- */
-async function _cmdDaemonsList(ctx) {
-    if (!(await supervisorOnline())) {
-        const registry = listDaemons();
-        if (registry.length === 0) {
-            ctx.ui.notify("[un-bien] No daemons registered. Run /unbien create <cwd>.", "info");
-            return;
-        }
-        const rows = registry
-            .map((d) => {
-            const cfg = loadLocalConfig(d.cwd);
-            const name = cfg.agent_name ?? defaultAgentName(d.cwd);
-            return `  ${d.id}  ${name}  ${d.cwd}  (supervisor offline)`;
-        })
-            .join("\n");
-        ctx.ui.notify(`[un-bien] Daemons (registry only — run install to bring supervisor up):\n${rows}`, "info");
-        return;
-    }
-    try {
-        const data = await callSupervisor({ op: "list" });
-        ctx.ui.notify(`[un-bien] Daemons:\n${_formatDaemonTable(data.daemons)}`, "info");
-    }
-    catch (err) {
-        if (err instanceof SupervisorOfflineError) {
-            _notifyOffline(ctx, err);
-            return;
-        }
-        ctx.ui.notify(`[un-bien] daemons failed: ${String(err)}`, "error");
-    }
-}
-async function _cmdDaemonStatus(ctx) {
-    try {
-        const data = await callSupervisor({ op: "status" });
-        ctx.ui.notify(`[un-bien] Fleet status:\n${_formatDaemonTable(data.daemons)}`, "info");
-    }
-    catch (err) {
-        if (err instanceof SupervisorOfflineError) {
-            _notifyOffline(ctx, err);
-            return;
-        }
-        ctx.ui.notify(`[un-bien] status failed: ${String(err)}`, "error");
-    }
-}
-async function _cmdDaemonStart(ctx, id) {
-    try {
-        if (id) {
-            const data = await callSupervisor({ op: "start", id });
-            ctx.ui.notify(data.started
-                ? `[un-bien] Started daemon ${id} (${data.state}).`
-                : `[un-bien] Daemon ${id} already ${data.state}.`, "info");
-            return;
-        }
-        const data = await callSupervisor({ op: "start_all" });
-        ctx.ui.notify(`[un-bien] Started ${data.started.length} daemon(s), ` +
-            `${data.already_running.length} already running.`, "info");
-    }
-    catch (err) {
-        if (err instanceof SupervisorOfflineError) {
-            _notifyOffline(ctx, err);
-            return;
-        }
-        ctx.ui.notify(`[un-bien] start failed: ${String(err)}`, "error");
-    }
-}
-async function _cmdDaemonStop(ctx, id) {
-    try {
-        if (id) {
-            const data = await callSupervisor({ op: "stop", id });
-            ctx.ui.notify(data.stopped
-                ? `[un-bien] Stopped daemon ${id}.`
-                : `[un-bien] Daemon ${id} already ${data.state}.`, "info");
-            return;
-        }
-        const data = await callSupervisor({ op: "stop_all" });
-        ctx.ui.notify(`[un-bien] Stopped ${data.stopped.length} daemon(s), ` +
-            `${data.already_stopped.length} already stopped.`, "info");
-    }
-    catch (err) {
-        if (err instanceof SupervisorOfflineError) {
-            _notifyOffline(ctx, err);
-            return;
-        }
-        ctx.ui.notify(`[un-bien] stop failed: ${String(err)}`, "error");
-    }
-}
-async function _cmdDaemonRestart(ctx, id) {
-    try {
-        if (id) {
-            const data = await callSupervisor({ op: "restart", id });
-            ctx.ui.notify(`[un-bien] Restarted daemon ${id} (${data.state}).`, "info");
-            return;
-        }
-        const data = await callSupervisor({ op: "restart_all" });
-        ctx.ui.notify(`[un-bien] Restarted ${data.restarted.length} daemon(s).`, "info");
-    }
-    catch (err) {
-        if (err instanceof SupervisorOfflineError) {
-            _notifyOffline(ctx, err);
-            return;
-        }
-        ctx.ui.notify(`[un-bien] restart failed: ${String(err)}`, "error");
-    }
-}
+// Installs the un-bien launcher daemon as a user-level system service (systemd
+// `--user` unit on Linux, launchd LaunchAgent on macOS, Task Scheduler on
+// Windows). Once installed the launcher daemon starts at login + survives
+// reboots. Uninstall is the inverse.
 /**
- * `/unbien daemon send <id> "<text>"` — injects a prompt into a
- * running daemon via its RPC stdin. The agent processes the prompt as
- * if a user typed it; output flows back via the relay/mesh, not here.
- *
- * Fire-and-forget at this layer — the CLI just confirms delivery.
- */
-async function _cmdDaemonSend(arg, ctx) {
-    // Parse `<id> <text...>` — id is the first token, rest is the prompt.
-    // The text may be quoted; if so, strip the outer quotes. Otherwise
-    // take the entire remainder verbatim.
-    const m = arg.match(/^(\S+)\s+(?:"([^"]*)"|(.*))$/);
-    if (!m) {
-        ctx.ui.notify('[un-bien] Usage: /unbien daemon send <id> "<prompt text>"', "warning");
-        return;
-    }
-    const id = m[1];
-    const text = (m[2] ?? m[3] ?? "").trim();
-    if (!text) {
-        ctx.ui.notify("[un-bien] daemon send: prompt text is empty.", "warning");
-        return;
-    }
-    try {
-        const data = await callSupervisor({ op: "send", id, text });
-        if (data.delivered) {
-            ctx.ui.notify(`[un-bien] Sent to ${id}: ${text.slice(0, 60)}${text.length > 60 ? "…" : ""}`, "info");
-        }
-        else {
-            ctx.ui.notify(`[un-bien] daemon ${id} did not accept the prompt (not running?)`, "warning");
-        }
-    }
-    catch (err) {
-        if (err instanceof SupervisorOfflineError) {
-            _notifyOffline(ctx, err);
-            return;
-        }
-        ctx.ui.notify(`[un-bien] daemon send failed: ${String(err)}`, "error");
-    }
-}
-// ── Cron — scheduled prompts for daemons (plan/39) ──────────────────────────
-/** Splits an arg string into tokens, honoring double-quoted groups. */
-function _tokenizeArgs(s) {
-    const out = [];
-    const re = /"([^"]*)"|(\S+)/g;
-    let m;
-    while ((m = re.exec(s)) !== null)
-        out.push(m[1] === undefined ? m[2] : m[1]);
-    return out;
-}
-/**
- * `/unbien cron <add|list|remove|enable|disable|run|log>` — schedules
- * recurring prompts to daemons via the supervisor. All subcommands require the
- * supervisor running (offline → friendly notice, not a crash).
- */
-async function _cmdCron(arg, ctx) {
-    const trimmed = arg.trim();
-    const sp = trimmed.indexOf(" ");
-    const sub = (sp === -1 ? trimmed : trimmed.slice(0, sp)).toLowerCase();
-    const rest = sp === -1 ? "" : trimmed.slice(sp + 1).trim();
-    try {
-        switch (sub) {
-            case "":
-            case "list":
-                return await _cronList(ctx);
-            case "add":
-                return await _cronAdd(rest, ctx);
-            case "remove":
-            case "rm":
-                return await _cronMutate({ op: "cron_remove", job_id: rest.trim() }, rest.trim(), ctx);
-            case "enable":
-                return await _cronMutate({ op: "cron_enable", job_id: rest.trim(), enabled: true }, rest.trim(), ctx);
-            case "disable":
-                return await _cronMutate({ op: "cron_enable", job_id: rest.trim(), enabled: false }, rest.trim(), ctx);
-            case "run":
-                return await _cronRun(rest.trim(), ctx);
-            case "log":
-                return await _cronLog(rest, ctx);
-            default:
-                ctx.ui.notify("[un-bien] Usage: /unbien cron <add|list|remove|enable|disable|run|log>", "warning");
-        }
-    }
-    catch (err) {
-        if (err instanceof SupervisorOfflineError) {
-            ctx.ui.notify("[un-bien] Cron needs the supervisor running. Run `unbien install` " +
-                "(or start `pi-supervisord`).", "warning");
-            return;
-        }
-        ctx.ui.notify(`[un-bien] cron ${sub || "list"} failed: ${String(err)}`, "error");
-    }
-}
-async function _cronAdd(rest, ctx) {
-    const toks = _tokenizeArgs(rest);
-    let tz;
-    let wake = false;
-    let skipBusy = true;
-    let catchup = false;
-    const pos = [];
-    for (let i = 0; i < toks.length; i++) {
-        const t = toks[i];
-        if (t === "--wake")
-            wake = true;
-        else if (t === "--no-skip-busy")
-            skipBusy = false;
-        else if (t === "--catchup")
-            catchup = true;
-        else if (t === "--tz")
-            tz = toks[++i];
-        else
-            pos.push(t);
-    }
-    const [daemonId, schedule, prompt] = pos;
-    if (!daemonId || !schedule || !prompt) {
-        ctx.ui.notify('[un-bien] Usage: /unbien cron add <daemonId> "<cron-expr>" "<prompt>" ' +
-            "[--tz Area/City] [--wake] [--no-skip-busy] [--catchup]", "warning");
-        return;
-    }
-    const req = {
-        op: "cron_add",
-        daemon_id: daemonId,
-        schedule,
-        prompt,
-    };
-    if (tz)
-        req.tz = tz;
-    if (wake)
-        req.wake = true;
-    if (!skipBusy)
-        req.skip_if_busy = false;
-    if (catchup)
-        req.catchup = true;
-    const data = await callSupervisor(req);
-    ctx.ui.notify(`[un-bien] Cron ${data.job.id} added → daemon ${daemonId}: "${schedule}"` +
-        `${tz ? ` (${tz})` : ""}. Next run: ${data.job.next_run ?? "?"}`, "info");
-}
-async function _cronList(ctx) {
-    const data = await callSupervisor({ op: "cron_list" });
-    if (data.jobs.length === 0) {
-        ctx.ui.notify("[un-bien] No cron jobs.", "info");
-        return;
-    }
-    const lines = data.jobs.map((j) => `${j.enabled ? "✓" : "✗"} ${j.id}  "${j.schedule}"${j.tz ? ` (${j.tz})` : ""}  → ${j.daemon_id}  ` +
-        `next:${j.next_run ?? "?"}  last:${j.last_status ?? "—"}${j.last_run ? `@${j.last_run}` : ""}`);
-    ctx.ui.notify(`[un-bien] Cron jobs (${data.jobs.length}):\n${lines.join("\n")}`, "info");
-}
-async function _cronMutate(req, jobId, ctx) {
-    if (!jobId) {
-        ctx.ui.notify(`[un-bien] Usage: /unbien cron ${req.op === "cron_remove" ? "remove" : "enable|disable"} <jobId>`, "warning");
-        return;
-    }
-    if (req.op === "cron_remove") {
-        const data = await callSupervisor(req);
-        ctx.ui.notify(data.removed
-            ? `[un-bien] Cron ${jobId} removed.`
-            : `[un-bien] No cron job ${jobId}.`, data.removed ? "info" : "warning");
-    }
-    else {
-        const data = await callSupervisor(req);
-        ctx.ui.notify(data.updated
-            ? `[un-bien] Cron ${jobId} ${data.enabled ? "enabled" : "disabled"}.`
-            : `[un-bien] No cron job ${jobId}.`, data.updated ? "info" : "warning");
-    }
-}
-async function _cronRun(jobId, ctx) {
-    if (!jobId) {
-        ctx.ui.notify("[un-bien] Usage: /unbien cron run <jobId>", "warning");
-        return;
-    }
-    const data = await callSupervisor({ op: "cron_run", job_id: jobId });
-    ctx.ui.notify(`[un-bien] Cron ${jobId} fired now → ${data.result}`, "info");
-}
-async function _cronLog(rest, ctx) {
-    const toks = _tokenizeArgs(rest);
-    let jobId;
-    let tail = 20;
-    for (let i = 0; i < toks.length; i++) {
-        const t = toks[i];
-        if (t === "--tail") {
-            const n = Number(toks[++i]);
-            if (Number.isFinite(n))
-                tail = n;
-        }
-        else if (!t.startsWith("--"))
-            jobId = t;
-    }
-    const req = {
-        op: "cron_log",
-        tail,
-    };
-    if (jobId)
-        req.job_id = jobId;
-    const data = await callSupervisor(req);
-    if (data.entries.length === 0) {
-        ctx.ui.notify("[un-bien] No cron log entries.", "info");
-        return;
-    }
-    const lines = data.entries.map((e) => `${new Date(e.ts).toISOString()}  ${e.fired ? "▶" : "∅"} ${e.result}  ${e.job_id} → ${e.daemon_id}  ${e.prompt_preview}`);
-    ctx.ui.notify(`[un-bien] Cron log (last ${data.entries.length}):\n${lines.join("\n")}`, "info");
-}
-// ── Install/uninstall the supervisor service (plan/26 W3) ────────────────────
-//
-// Installs `pi-supervisord` as a user-level system service (systemd
-// `--user` unit on Linux, launchd LaunchAgent on macOS). Once installed:
-//   - Supervisor starts at login + survives reboots.
-//   - `unbien daemon start/stop/send/...` work without manually
-//     spawning the supervisor.
-// Uninstall is the inverse — leaves the registry (`daemons.json`) intact,
-// so re-installing later picks up where you left off.
-/**
- * `linkCli` controls whether we symlink `un-bien` + `pi-supervisord`
- * into `~/.local/bin/`. The slash-command path passes `true` (user is
- * inside Pi's TUI — they installed via `pi install npm:un-bien` and
- * need us to expose the CLI for them). The standalone-CLI path passes
- * `false` because the user is already running our binary from PATH (they
- * did `npm install -g un-bien`), so re-linking would point their
- * `un-bien` at the Pi-extension copy and diverge on upgrades.
+ * `linkCli` controls whether we symlink `un-bien` into `~/.local/bin/`. The
+ * slash-command path passes `true` (user is inside Pi's TUI — they installed
+ * via `pi install npm:un-bien` and need us to expose the CLI for them). The
+ * standalone-CLI path passes `false` because the user is already running our
+ * binary from PATH (they did `npm install -g un-bien`), so re-linking would
+ * point their `un-bien` at the Pi-extension copy and diverge on upgrades.
  */
 /** Returns true on success, false when install failed (so the standalone CLI
  *  can exit non-zero — e.g. the Cockpit / CI detect failure by exit code).
@@ -4596,7 +3917,7 @@ function _cmdInstall(ctx, opts = {}) {
     try {
         const result = installService();
         const sections = [
-            `[un-bien] Supervisor service installed (${result.platform}).`,
+            `[un-bien] Launcher daemon service installed (${result.platform}).`,
             `  Unit: ${result.unitPath}`,
             `  Steps:\n${result.log.map((l) => "    " + l).join("\n")}`,
         ];
@@ -4605,10 +3926,10 @@ function _cmdInstall(ctx, opts = {}) {
             sections.push(`  CLI bins linked into ${link.binDir}:`, link.links.map((l) => `    ${l.name} → ${l.target}`).join("\n"), `  Steps:\n${link.log.map((l) => "    " + l).join("\n")}`);
             if (!link.onPath) {
                 if (process.platform === "win32") {
-                    sections.push(`  ⚠ ${link.binDir} was just added to your user PATH (it wasn't there yet).`, `    Open a NEW terminal and run \`unbien daemons\` to verify.`);
+                    sections.push(`  ⚠ ${link.binDir} was just added to your user PATH (it wasn't there yet).`, `    Open a NEW terminal and run \`unbien status\` to verify.`);
                 }
                 else {
-                    sections.push(`  ⚠ ${link.binDir} is not on $PATH yet. Add this line to ~/.zshrc / ~/.bashrc:`, `      export PATH="$HOME/.local/bin:$PATH"`, `    Then open a new terminal and run \`unbien daemons\` to verify.`);
+                    sections.push(`  ⚠ ${link.binDir} is not on $PATH yet. Add this line to ~/.zshrc / ~/.bashrc:`, `      export PATH="$HOME/.local/bin:$PATH"`, `    Then open a new terminal and run \`unbien status\` to verify.`);
                 }
             }
         }
@@ -4625,10 +3946,9 @@ function _cmdUninstall(ctx, opts = {}) {
     try {
         const result = uninstallService();
         const sections = [
-            `[un-bien] Supervisor service uninstalled (${result.platform}).`,
+            `[un-bien] Launcher daemon service uninstalled (${result.platform}).`,
             `  Unit: ${result.unitPath} (${result.removed ? "removed" : "not present"})`,
             `  Steps:\n${result.log.map((l) => "    " + l).join("\n")}`,
-            `  Note: daemons registry (~/.pi/un-bien/daemons.json) kept — re-install restores everything.`,
         ];
         if (linkCli) {
             const unlink = unlinkCliBinaries();
@@ -5075,240 +4395,11 @@ function _resetSessionForNew() {
     // get_entries against the fresh session and drops the old one on the new hello.
     _sessionStartedAt = Date.now();
 }
-export function _enrichToolArgs(tool, args) {
-    if (!args || typeof args !== "object")
-        return {};
-    const base = args;
-    switch (tool.toLowerCase()) {
-        case "edit":
-            return _enrichEditToolArgs(base);
-        default:
-            return base;
-    }
-}
-function _enrichEditToolArgs(base) {
-    const filePath = _stringArg(base, ["path", "file_path"]);
-    const rawEdits = base["edits"];
-    const edits = Array.isArray(rawEdits) ? rawEdits : [base];
-    const text = _readToolFile(filePath);
-    const hunks = [];
-    let searchFrom = 0;
-    for (const rawEdit of edits) {
-        if (!rawEdit || typeof rawEdit !== "object")
-            continue;
-        const edit = rawEdit;
-        const oldText = _stringArg(edit, [
-            "oldText",
-            "old_text",
-            "old_string",
-            "oldString",
-        ]);
-        const newText = _stringArg(edit, [
-            "newText",
-            "new_text",
-            "new_string",
-            "newString",
-        ]);
-        if (!oldText && !newText)
-            continue;
-        const matchAt = oldText && text !== null ? text.indexOf(oldText, searchFrom) : -1;
-        const fallbackAt = oldText && matchAt < 0 && text !== null ? text.indexOf(oldText) : matchAt;
-        const startOffset = fallbackAt >= 0 ? fallbackAt : searchFrom;
-        if (text === null)
-            continue;
-        const hunk = _buildEditHunk(text, startOffset, oldText, newText);
-        if (hunk.length > 0)
-            hunks.push({ lines: hunk });
-        searchFrom = startOffset + Math.max(oldText.length, 1);
-    }
-    return hunks.length === 0 ? base : { ...base, hunks };
-}
-function _readToolFile(filePath) {
-    if (!filePath)
-        return null;
-    const cwd = _lastCtx && "cwd" in _lastCtx ? _lastCtx.cwd : process.cwd();
-    const homePath = filePath.startsWith("~/") && process.env.HOME
-        ? resolve(process.env.HOME, filePath.slice(2))
-        : null;
-    const candidates = [
-        filePath,
-        resolve(cwd, filePath),
-        resolve(process.cwd(), filePath),
-        homePath,
-    ].filter((p) => typeof p === "string");
-    for (const candidate of candidates) {
-        try {
-            return readFileSync(candidate, "utf8");
-        }
-        catch {
-            // try next candidate
-        }
-    }
-    return null;
-}
-function _buildEditHunk(fileText, startOffset, oldText, newText) {
-    const context = 4;
-    const fileLines = fileText.split("\n");
-    const oldLines = _splitPreviewLines(oldText);
-    const newLines = _splitPreviewLines(newText);
-    const oldStart = _lineNumberAt(fileText, startOffset);
-    const newStart = oldStart;
-    const startIndex = oldStart - 1;
-    const beforeStart = Math.max(0, startIndex - context);
-    const afterStart = startIndex + oldLines.length;
-    const afterEnd = Math.min(fileLines.length, afterStart + context);
-    const out = [];
-    if (beforeStart > 0)
-        out.push({ kind: "ellipsis" });
-    for (let i = beforeStart; i < startIndex; i++) {
-        out.push({
-            kind: "context",
-            oldLine: i + 1,
-            newLine: i + 1,
-            text: fileLines[i] ?? "",
-        });
-    }
-    let commonPrefix = 0;
-    while (commonPrefix < oldLines.length &&
-        commonPrefix < newLines.length &&
-        oldLines[commonPrefix] === newLines[commonPrefix]) {
-        commonPrefix++;
-    }
-    let commonSuffix = 0;
-    while (commonSuffix < oldLines.length - commonPrefix &&
-        commonSuffix < newLines.length - commonPrefix &&
-        oldLines[oldLines.length - 1 - commonSuffix] ===
-            newLines[newLines.length - 1 - commonSuffix]) {
-        commonSuffix++;
-    }
-    for (let i = 0; i < commonPrefix; i++) {
-        out.push({
-            kind: "context",
-            oldLine: oldStart + i,
-            newLine: newStart + i,
-            text: oldLines[i] ?? "",
-        });
-    }
-    for (let i = commonPrefix; i < oldLines.length - commonSuffix; i++) {
-        out.push({
-            kind: "remove",
-            oldLine: oldStart + i,
-            text: oldLines[i] ?? "",
-        });
-    }
-    for (let i = commonPrefix; i < newLines.length - commonSuffix; i++) {
-        out.push({ kind: "add", newLine: newStart + i, text: newLines[i] ?? "" });
-    }
-    for (let i = oldLines.length - commonSuffix; i < oldLines.length; i++) {
-        const newLine = newStart + newLines.length - (oldLines.length - i);
-        out.push({
-            kind: "context",
-            oldLine: oldStart + i,
-            newLine,
-            text: oldLines[i] ?? "",
-        });
-    }
-    for (let i = afterStart; i < afterEnd; i++) {
-        const newLine = newStart + newLines.length + (i - afterStart);
-        out.push({
-            kind: "context",
-            oldLine: i + 1,
-            newLine,
-            text: fileLines[i] ?? "",
-        });
-    }
-    if (afterEnd < fileLines.length)
-        out.push({ kind: "ellipsis" });
-    return out;
-}
-function _lineNumberAt(text, offset) {
-    let line = 1;
-    for (let i = 0; i < Math.max(0, offset); i++)
-        if (text[i] === "\n")
-            line++;
-    return line;
-}
-function _splitPreviewLines(text) {
-    if (!text)
-        return [];
-    const lines = text.split("\n");
-    if (lines.length > 0 && lines[lines.length - 1] === "")
-        lines.pop();
-    return lines;
-}
-function _stringArg(args, keys) {
-    for (const key of keys) {
-        const value = args[key];
-        if (typeof value === "string")
-            return value;
-    }
-    return "";
-}
-function _stringifyContent(content) {
-    if (typeof content === "string")
-        return content;
-    if (!Array.isArray(content))
-        return "";
-    return content
-        .map((c) => {
-        if (!c || typeof c !== "object")
-            return "";
-        const block = c;
-        return block.type === "text" ? String(block.text ?? "") : "";
-    })
-        .join("");
-}
-/** Pure: the OS command sequence that restarts the supervisor service, or null
- *  when the platform isn't supported. Most platforms are 1 step; Windows is 2
- *  (`schtasks /End` then `/Run`). Exported for tests. */
-export function _restartSupervisorCommand(platform, uid) {
-    if (platform === "darwin")
-        return [
-            {
-                cmd: "launchctl",
-                args: ["kickstart", "-k", `gui/${uid}/${LAUNCHD_LABEL}`],
-            },
-        ];
-    if (platform === "linux")
-        return [{ cmd: "systemctl", args: ["--user", "restart", SYSTEMD_UNIT] }];
-    if (platform === "win32")
-        return [
-            {
-                cmd: "schtasks",
-                args: ["/End", "/TN", WINDOWS_TASK_NAME],
-                ignoreFailure: true,
-            },
-            { cmd: "schtasks", args: ["/Run", "/TN", WINDOWS_TASK_NAME] },
-        ];
-    return null;
-}
-function _restartSupervisor() {
-    const uid = process.getuid?.() ?? 0;
-    const steps = _restartSupervisorCommand(process.platform, uid);
-    if (!steps) {
-        console.error(`[un-bien] restart-supervisor is not supported on '${process.platform}' yet. ` +
-            "Restart pi-supervisord manually.");
-        process.exit(1);
-    }
-    for (const step of steps) {
-        const r = spawnSync(step.cmd, step.args, {
-            stdio: ["ignore", "pipe", "pipe"],
-            encoding: "utf8",
-        });
-        if (r.error) {
-            if (step.ignoreFailure)
-                continue;
-            console.error(`[un-bien] restart-supervisor failed: ${step.cmd} not runnable (${r.error.message}). Is the service installed? Run \`unbien install\`.`);
-            process.exit(1);
-        }
-        if (r.status !== 0 && !step.ignoreFailure) {
-            const detail = (r.stderr || r.stdout || "").trim();
-            console.error(`[un-bien] restart-supervisor failed (${step.cmd} exited ${r.status})${detail ? `: ${detail}` : ""}.`);
-            process.exit(r.status === null ? 1 : r.status);
-        }
-    }
-    console.log("[un-bien] Supervisor restarted.");
+/** Resolve the base dir for tool-arg file lookups from the last command ctx. */
+function _resolveToolCwd() {
+    return _lastCtx && "cwd" in _lastCtx ? _lastCtx.cwd : process.cwd();
 }
+// ── Standalone CLI ────────────────────────────────────────────────────────────
 function _isDirectRun() {
     try {
         return (fileURLToPath(import.meta.url) === realpathSync(process.argv[1] ?? ""));
@@ -5387,6 +4478,14 @@ export async function probeListPeers(sockPath, timeoutMs = 2000) {
         sock.on("close", () => done(null));
     });
 }
+function _cliStubUi() {
+    // SAFETY: the CLI fleet/daemon/setup handlers only ever call ui.notify; the
+    // other ExtensionContext["ui"] methods (select/input/editor/…) are never
+    // reached on the direct-run path, so a notify-only console shim is safe.
+    return {
+        notify: (msg) => console.log(msg),
+    };
+}
 if (_isDirectRun()) {
     const [, , subcmd, ...cliArgs] = process.argv;
     if (subcmd === "devices" || subcmd === "list") {
@@ -5440,81 +4539,6 @@ if (_isDirectRun()) {
             console.log(`Invalid URL: ${raw}. Must start with http:// or https://`);
         }
     }
-    else if (subcmd === "create") {
-        // Standalone: `unbien create <cwd> [--name "X"]`. The shell already
-        // split the args and stripped the outer quotes, so an arg like
-        // `Tmp Agent` arrives as a single element with embedded space. Re-add
-        // quotes around any arg containing whitespace so the regex-based
-        // parser (shared with the slash-command path) sees the same shape
-        // as it would from a Pi interactive prompt.
-        const joined = cliArgs.map((a) => (/\s/.test(a) ? `"${a}"` : a)).join(" ");
-        await _cmdCreate(joined, {
-            ui: {
-                notify: (msg) => console.log(msg),
-            },
-        });
-    }
-    else if (subcmd === "remove") {
-        const id = (cliArgs[0] ?? "").trim();
-        await _cmdRemove(id, {
-            ui: {
-                notify: (msg) => console.log(msg),
-            },
-        });
-    }
-    else if (subcmd === "daemons") {
-        // Mirror the slash handler: ask the supervisor when reachable,
-        // fall back to registry-only when not.
-        const stubCtx = {
-            ui: {
-                notify: (msg) => console.log(msg),
-            },
-        };
-        await _cmdDaemonsList(stubCtx);
-    }
-    else if (subcmd === "daemon") {
-        // `unbien daemon <op> [args]`. Reuse the fleet-ops handlers — they
-        // already accept a minimal ctx with `notify`.
-        const op = cliArgs[0] ?? "";
-        const rest = cliArgs
-            .slice(1)
-            .map((a) => (/\s/.test(a) ? `"${a}"` : a))
-            .join(" ");
-        const stubCtx = {
-            ui: {
-                notify: (msg) => console.log(msg),
-            },
-        };
-        if (op === "start") {
-            await _cmdDaemonStart(stubCtx, cliArgs[1]);
-        }
-        else if (op === "stop") {
-            await _cmdDaemonStop(stubCtx, cliArgs[1]);
-        }
-        else if (op === "restart") {
-            await _cmdDaemonRestart(stubCtx, cliArgs[1]);
-        }
-        else if (op === "status") {
-            await _cmdDaemonStatus(stubCtx);
-        }
-        else if (op === "send") {
-            await _cmdDaemonSend(rest, stubCtx);
-        }
-        else {
-            console.log('Usage: unbien daemon <start|stop|restart [<id>]|status|send <id> "<text>">');
-        }
-    }
-    else if (subcmd === "cron") {
-        // `unbien cron <op> [args]`. Re-quote args with spaces so the shared
-        // parser sees the same shape as a Pi slash prompt.
-        const joined = cliArgs.map((a) => (/\s/.test(a) ? `"${a}"` : a)).join(" ");
-        const stubCtx = {
-            ui: {
-                notify: (msg) => console.log(msg),
-            },
-        };
-        await _cmdCron(joined, stubCtx);
-    }
     else if (subcmd === "peers") {
         // Read-only roster of the local + cross-PC mesh. Unlike `devices` (which
         // reads paired phones from peers.json), the mesh roster lives only in the
@@ -5534,59 +4558,33 @@ if (_isDirectRun()) {
     }
     else if (subcmd === "install") {
         // CLI mode = user installed via `npm install -g un-bien`, so the
-        // `un-bien` / `pi-supervisord` bins are already on $PATH via npm's
-        // global prefix. Explicit `linkCli: false` so we never stomp those
-        // with symlinks pointing at a parallel Pi-extension install.
-        const stubCtx = {
-            ui: {
-                notify: (msg) => console.log(msg),
-            },
-        };
+        // `un-bien` bin is already on $PATH via npm's global prefix. Explicit
+        // `linkCli: false` so we never stomp those with symlinks pointing at a
+        // parallel Pi-extension install.
+        const stubCtx = { ui: _cliStubUi() };
         // Propagate failure as a non-zero exit so callers (Cockpit / CI) detect it
         // — installService throws on a failed schtasks/launchctl/systemctl step.
         if (!_cmdInstall(stubCtx, { linkCli: false }))
             process.exit(1);
     }
     else if (subcmd === "uninstall") {
-        const stubCtx = {
-            ui: {
-                notify: (msg) => console.log(msg),
-            },
-        };
+        const stubCtx = { ui: _cliStubUi() };
         // `linkCli: true` even from the CLI: unlinking is ALWAYS safe and must run
         // regardless of how install ran. `unlinkCliBinaries` only removes OUR
-        // reserved symlinks (`un-bien` / `pi-supervisord`) under `~/.local/bin`;
-        // npm-global bins live in a different prefix and are never touched. So a
-        // user who installed via the TUI (`/unbien install`, which links) and
-        // uninstalls from a shell still gets the links cleaned up — the asymmetry
-        // that left an orphaned `~/.local/bin/unbien` behind.
+        // reserved `un-bien` symlink under `~/.local/bin`; npm-global bins live in
+        // a different prefix and are never touched. So a user who installed via the
+        // TUI (`/unbien install`, which links) and uninstalls from a shell still
+        // gets the link cleaned up — the asymmetry that left an orphaned
+        // `~/.local/bin/unbien` behind.
         _cmdUninstall(stubCtx, { linkCli: true });
     }
-    else if (subcmd === "restart-supervisor") {
-        _restartSupervisor();
-    }
     else {
         console.log([
             "Usage: un-bien <command>",
             "",
-            "Daemon registry:",
-            '  create <cwd> [--name "Name"]   Register a folder as a daemon',
-            "  remove <id>                     Unregister a daemon",
-            "  daemons                         List registered daemons",
-            "",
-            "Fleet control:",
-            "  daemon start [<id>]             Start all daemons, or one by id",
-            "  daemon stop [<id>]              Stop all daemons, or one by id",
-            "  daemon restart [<id>]           Restart all daemons, or one by id",
-            "  daemon status                   Show pid / uptime / restarts",
-            '  daemon send <id> "<text>"       Send a prompt to a daemon',
-            '  cron add <id> "<expr>" "<txt>"  Schedule a recurring prompt (≥60s; --tz, --wake)',
-            "  cron list|run|remove|log        Manage scheduled prompts (needs the supervisor)",
-            "",
             "Service:",
-            "  install                         Install pi-supervisord as a system service",
+            "  install                         Install the un-bien launcher daemon as a system service",
             "  uninstall                       Remove the system service",
-            "  restart-supervisor              Restart the pi-supervisord process",
             "",
             "Devices:",
             "  devices                         List paired phones (peers.json)",