baychat 0.21.5 → 0.22.0

package/dist/relay/acp/runner.js

@@ -0,0 +1,311 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AcpSessionRunner = void 0;
+exports.effectiveMode = effectiveMode;
+const os = __importStar(require("os"));
+const spawn_env_1 = require("../spawn-env");
+const agents_1 = require("./agents");
+const approval_1 = require("./approval");
+const client_1 = require("./client");
+const modes_1 = require("./modes");
+const permissions_1 = require("./permissions");
+const policy_1 = require("./policy");
+const presence_1 = require("./presence");
+const prompt_1 = require("./prompt");
+/**
+ * How much power ONE turn gets.
+ *
+ * The session's mode is a maximum, not a grant. It applies only when EVERY addressed message in
+ * the batch is from someone with command access to this session — the owner, or a Bay owner/admin
+ * the owner granted (the server's `commandAuthorized`, re-checked on every message; `senderIsOwner`
+ * also counts; absent = no). One message from anyone else makes the whole turn `chat`, because a
+ * coalesced prompt cannot give half of itself tools. (Owner-only until 19 Sep 2026 — Karmen's call.)
+ * Then the rule file's ceiling, then what this platform can actually enforce.
+ */
+function effectiveMode(sessionMode, ceiling, allAuthorized, allowedHere) {
+    if (!allAuthorized)
+        return "chat";
+    const wanted = (0, modes_1.clampMode)(sessionMode, ceiling);
+    const usable = modes_1.ACP_MODES.filter((m) => allowedHere.includes(m) && (0, modes_1.modeRank)(m) <= (0, modes_1.modeRank)(wanted));
+    return usable.at(-1) ?? "chat";
+}
+const RETRY_MAX_MS = 60_000;
+const errText = (err) => (err instanceof Error ? err.message : String(err));
+/**
+ * Runs an ACP session's turns ONE AT A TIME, in arrival order.
+ *
+ * `handle` never blocks: it files the batch and makes sure a drain loop is running. That is what
+ * lets a `/stop` typed during a long turn be processed at all — the daemon's per-session delivery
+ * lock is already free again.
+ */
+class AcpSessionRunner {
+    deps;
+    running = new Map();
+    loops = new Map();
+    said = new Map();
+    backoff = new Map();
+    retryTimers = new Set();
+    closed = false;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    handle(session, batch) {
+        const { dropped } = this.deps.queue.add(session, batch);
+        if (dropped > 0)
+            this.deps.log(`acp: ${session} has too many messages waiting — ${dropped} not queued`);
+        this.kick(session);
+    }
+    stop(session) {
+        const turn = this.running.get(session);
+        if (!turn)
+            return false;
+        turn.abort();
+        return true;
+    }
+    reset(session) {
+        this.deps.registry.setAcpSession(session, undefined);
+    }
+    setMode(session, wanted) {
+        const target = this.deps.registry.get(session);
+        if (!target?.acp)
+            return { ok: false, reason: `"${session}" is not run by the relay, so it has no mode.` };
+        const row = (0, agents_1.acpAgent)(target.acp.agent);
+        if (!row)
+            return { ok: false, reason: `This relay does not know the agent "${target.acp.agent}".` };
+        const folder = (0, policy_1.checkFolder)((this.deps.loadPolicy ?? policy_1.loadPolicy)(), row.id, target.acp.cwd);
+        if (!folder.ok)
+            return { ok: false, reason: folder.reason };
+        const allowed = (0, agents_1.modeAllowedHere)(row, wanted, folder.maxMode, this.deps.platform ?? process.platform);
+        if (!allowed.ok)
+            return allowed;
+        this.deps.registry.setAcpMode(session, wanted);
+        return { ok: true, mode: wanted };
+    }
+    status(session) {
+        return { running: this.running.has(session), queued: this.deps.queue.depth(session) };
+    }
+    async idle() {
+        while (this.loops.size > 0)
+            await Promise.all([...this.loops.values()]);
+    }
+    shutdown() {
+        this.closed = true;
+        for (const t of this.retryTimers)
+            clearTimeout(t);
+        this.retryTimers.clear();
+        for (const turn of this.running.values())
+            turn.abort();
+    }
+    kick(session) {
+        if (this.closed || this.loops.has(session))
+            return;
+        const loop = this.drain(session)
+            .catch((err) => {
+            this.deps.log(`acp: ${session} drain failed — ${errText(err)}`);
+            return "failed";
+        })
+            .then((end) => {
+            this.loops.delete(session);
+            // A `handle` that landed after the drain saw an empty queue found this loop still
+            // registered and did not start one; pick its batch up now rather than at the next message.
+            if (end === "empty" && !this.closed && this.deps.queue.depth(session) > 0)
+                this.kick(session);
+        });
+        this.loops.set(session, loop);
+    }
+    async drain(session) {
+        for (;;) {
+            if (this.closed)
+                return "closed";
+            const turn = this.deps.queue.take(session);
+            if (!turn)
+                return "empty";
+            let next;
+            try {
+                next = await this.runOne(session, turn);
+            }
+            catch (err) {
+                // A bug or a disk error, not an outcome. The turn was taken off the queue, so it is
+                // recorded pending (never silently lost) and the loop moves on to the next one.
+                this.deps.log(`acp: ${session} turn failed unexpectedly — ${errText(err)}`);
+                this.deps.onPending(session, turn.addressed, "the relay failed while running this turn");
+                next = "next";
+            }
+            if (next === "retry-later")
+                return next;
+        }
+    }
+    async sayOnce(session, key, conversationId, text) {
+        const seen = this.said.get(session) ?? new Set();
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        this.said.set(session, seen);
+        try {
+            await this.deps.say(conversationId, session, text);
+        }
+        catch (err) {
+            this.deps.log(`acp: could not tell the room about ${session} (${key}) — ${errText(err)}`);
+        }
+    }
+    async runOne(session, turn) {
+        const { deps } = this;
+        const room = turn.addressed.at(-1).conversationId;
+        const drop = async (key, reason) => {
+            deps.onPending(session, turn.addressed, reason);
+            await this.sayOnce(session, key, room, reason);
+            return "next";
+        };
+        const target = deps.registry.get(session);
+        const acp = target?.acp;
+        const row = acp ? (0, agents_1.acpAgent)(acp.agent) : undefined;
+        if (!target || !acp || !row)
+            return drop("setup", `"${session}" is not set up on that computer any more. Run \`baychat connect dsh\` there.`);
+        const auth = deps.auth();
+        if (!auth)
+            return drop("setup", `The relay on that computer is not logged in to BayChat. Run \`baychat connect ${row.id}\` there.`);
+        if (!target.runtimeBin)
+            return drop("spawn", `${row.label} is not installed where the relay can find it. ${row.installHint}`);
+        const folder = (0, policy_1.checkFolder)((deps.loadPolicy ?? policy_1.loadPolicy)(), row.id, acp.cwd);
+        if (!folder.ok)
+            return drop("policy", folder.reason);
+        const platform = deps.platform ?? process.platform;
+        const allAuthorized = turn.addressed.every((m) => m.senderIsOwner === true || m.commandAuthorized === true);
+        const mode = effectiveMode(acp.mode, folder.maxMode, allAuthorized, row.modesFor(platform));
+        const patchDir = deps.patchDir ?? (0, agents_1.acpPatchDir)();
+        (0, agents_1.writeModePatches)(row, patchDir); // cheap, and an upgrade that changes a patch takes effect at once
+        const launch = row.launch(mode, patchDir);
+        const onPermission = async (call) => {
+            const host = (deps.hostname ?? os.hostname)();
+            const decision = (0, permissions_1.decidePermission)(mode, call, { cwd: acp.cwd, host, agentLabel: row.label });
+            if (decision.kind === "refuse") {
+                deps.log(`acp: ${session} permission REFUSED — ${decision.reason}`);
+                return "reject";
+            }
+            typing?.pause(); // the card is the signal while a person decides
+            const answer = await (deps.askPhone ?? approval_1.askPhone)({ auth, session, conversationId: room, question: decision.question });
+            typing?.resume(); // a no-op once the turn has stopped typing — `stop()` is final
+            deps.log(`acp: ${session} permission ${answer.allowed ? "ALLOWED" : "REFUSED"} — ${answer.reason}`);
+            return answer.allowed ? "allow" : "reject";
+        };
+        const caller = (deps.caller ?? presence_1.deviceMcpCaller)(auth);
+        const abort = new AbortController();
+        let typing;
+        let outcome;
+        try {
+            this.running.set(session, abort);
+            typing = (0, presence_1.startTyping)(caller, session, room, { log: deps.log });
+            deps.log(`acp: ${session} turn — ${turn.addressed.length} addressed, ${turn.digest.messages.length} context, mode ${mode}${allAuthorized ? "" : " (not all from someone with command access)"}`);
+            outcome = await (deps.runTurn ?? client_1.runAcpTurn)({
+                binaryPath: target.runtimeBin,
+                args: launch.args,
+                env: { ...(deps.env ?? spawn_env_1.headlessSpawnEnv)(), ...launch.env },
+                cwd: acp.cwd,
+                sessionId: acp.sessionId,
+                mcpServers: [{ type: "http", name: "baychat", url: `${auth.baseUrl.replace(/\/$/, "")}/api/mcp`, headers: [{ name: "Authorization", value: `Bearer ${auth.token}` }] }],
+                prompt: `Mode for this turn: ${mode}.\n\n${(0, prompt_1.turnPrompt)(turn)}`,
+                freshPreamble: (0, prompt_1.setupPreamble)(session, mode),
+                onPermission,
+                // Its message is in the room; a refreshed indicator after that would be a ghost.
+                onToolCall: (call) => {
+                    if (call.title === "mcp__baychat__send_message")
+                        typing?.stop();
+                },
+                classifyError: (m) => row.classifyError(m),
+                signal: abort.signal,
+            }, { spawn: deps.spawn, log: deps.log, platform });
+        }
+        finally {
+            // Every exit — outcome or throw — ends typing and frees `/stop`, or `/stop` would lie.
+            typing?.stop();
+            this.running.delete(session);
+        }
+        if (outcome.kind === "completed") {
+            deps.registry.setAcpSession(session, outcome.sessionId);
+            deps.onDelivered(session, turn.addressed);
+            this.said.delete(session);
+            this.backoff.delete(session);
+            if (outcome.memoryLost) {
+                await this.sayOnce(session, "session", room, `${row.label}'s earlier memory could not be reopened on that computer, so this conversation started fresh.`);
+                this.said.delete(session);
+            }
+            return "next";
+        }
+        if (outcome.cause === "baychat-unreachable")
+            return this.retryLater(session, turn);
+        if (outcome.cause === "cancelled") {
+            // Aborted by `shutdown`, not by a person: the batch is still owed an answer after restart.
+            if (this.closed) {
+                deps.queue.putBack(session, turn);
+                return "next";
+            }
+            deps.onPending(session, turn.addressed, "stopped from the chat");
+            return "next";
+        }
+        const reasons = {
+            "missing-key": row.keyHint,
+            busy: `${row.label} has this conversation open in a terminal on that computer. Close it there, or use a different session name for the terminal.`,
+            spawn: `${row.label} could not be started on that computer: ${outcome.reason}. ${row.installHint}`,
+        };
+        const named = reasons[outcome.cause];
+        if (named)
+            return drop(outcome.cause, named);
+        // Unclassified: the raw reason can name paths on that computer, so the room gets a generic
+        // line and the full (already redacted) reason goes to the log only (Ruling R29).
+        deps.log(`acp: ${session} could not answer (${outcome.cause}) — ${outcome.reason}`);
+        return drop(outcome.cause, `${row.label} could not answer this time. The details are in the relay's log on that computer.`);
+    }
+    /**
+     * The one retryable cause: nothing is wrong with the session, and the room cannot be told
+     * anyway. Put the turn back and try again, slower each time.
+     */
+    retryLater(session, turn) {
+        this.deps.queue.putBack(session, turn);
+        if (this.closed)
+            return "retry-later"; // kept for the restart; no timer outlives shutdown
+        const wait = Math.min((this.backoff.get(session) ?? (this.deps.retryBaseMs ?? 5_000) / 2) * 2, RETRY_MAX_MS);
+        this.backoff.set(session, wait);
+        this.deps.log(`acp: ${session} could not reach BayChat — retrying in ${Math.round(wait / 1000)}s`);
+        const timer = setTimeout(() => {
+            this.retryTimers.delete(timer);
+            this.kick(session);
+        }, wait);
+        timer.unref?.();
+        this.retryTimers.add(timer);
+        return "retry-later";
+    }
+}
+exports.AcpSessionRunner = AcpSessionRunner;

package/dist/relay/acp/sdk.js

@@ -0,0 +1,19 @@
+"use strict";
+// The one door to `@agentclientprotocol/sdk`.
+//
+// WHY A DOOR. The SDK is published ESM-only (`"type": "module"`, no `require` export) and this
+// package compiles to CommonJS (`module: node16`). A static `import` of it is a compile error
+// (TS1479) and a `require` is a runtime error on Node 20. A dynamic `import()` is the one form
+// that TypeScript preserves under node16 and that Node resolves from CJS — so every use of the
+// SDK goes through here, and a second entry point cannot quietly reintroduce the problem.
+//
+// Types are imported where needed with:
+//   import type { X } from "@agentclientprotocol/sdk" with { "resolution-mode": "import" };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAcpSdk = loadAcpSdk;
+let cached;
+/** Load the SDK once per process. Rejects only if the package is missing from the install. */
+function loadAcpSdk() {
+    cached ??= import("@agentclientprotocol/sdk");
+    return cached;
+}

package/dist/relay/acp/turn-queue.js

@@ -0,0 +1,163 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AcpTurnQueue = void 0;
+exports.acpQueuePath = acpQueuePath;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("../../config");
+const DEFAULT_CAPS = { digestMessages: 20, digestChars: 4_000, maxAddressed: 50 };
+function acpQueuePath() {
+    return path.join((0, config_1.configDir)(), "acp-queue.json");
+}
+/**
+ * The minimum shape `trimDigest`/`take`/`putBack` rely on: an `id`/`conversationId` to
+ * de-duplicate and route by, and `content` because `trimDigest` measures `m.content.length`.
+ * A parseable-but-wrong entry (e.g. `{}`) is not a RelayMessage and must be dropped on load,
+ * not trusted — otherwise the first digest trim after a restart throws.
+ */
+function isRelayMessage(value) {
+    const m = value;
+    return (!!m &&
+        typeof m === "object" &&
+        typeof m.id === "string" &&
+        typeof m.conversationId === "string" &&
+        typeof m.content === "string");
+}
+class AcpTurnQueue {
+    file;
+    caps;
+    sessions = new Map();
+    constructor(file = acpQueuePath(), caps = DEFAULT_CAPS) {
+        this.file = file;
+        this.caps = caps;
+    }
+    load() {
+        let raw;
+        try {
+            raw = JSON.parse(fs.readFileSync(this.file, "utf8"));
+        }
+        catch {
+            return; // absent or corrupt: an empty queue. There is nothing to recover from either.
+        }
+        if (!raw || typeof raw !== "object")
+            return;
+        for (const [name, value] of Object.entries(raw)) {
+            if (!value || !Array.isArray(value.addressed) || !Array.isArray(value.digest))
+                continue;
+            const addressed = value.addressed.filter(isRelayMessage);
+            const digest = value.digest.filter(isRelayMessage);
+            const malformed = value.addressed.length - addressed.length + (value.digest.length - digest.length);
+            if (malformed > 0) {
+                // Same convention as save()'s failure line: say it once, to stderr, and keep going —
+                // a queue that quietly ate messages is worse than one that says so and moves on.
+                process.stderr.write(`baychat relay: dropped ${malformed} malformed message(s) from the ACP queue for session "${name}"\n`);
+            }
+            const rawOmitted = Number(value.omitted);
+            const omitted = Number.isFinite(rawOmitted) && rawOmitted > 0 ? Math.floor(rawOmitted) : 0;
+            this.sessions.set(name, { addressed, digest, omitted });
+        }
+    }
+    add(session, batch) {
+        const state = this.state(session);
+        let addressed = 0;
+        let dropped = 0;
+        for (const message of batch) {
+            if (message.shouldRespond === true) {
+                if (state.addressed.length >= this.caps.maxAddressed)
+                    dropped += 1;
+                else {
+                    state.addressed.push(message);
+                    addressed += 1;
+                }
+            }
+            else
+                state.digest.push(message);
+        }
+        this.trimDigest(state);
+        this.save();
+        return { addressed, dropped };
+    }
+    take(session) {
+        const state = this.sessions.get(session);
+        if (!state || state.addressed.length === 0)
+            return undefined;
+        const turn = { addressed: state.addressed, digest: { messages: state.digest, omitted: state.omitted } };
+        this.sessions.set(session, { addressed: [], digest: [], omitted: 0 });
+        this.save();
+        return turn;
+    }
+    putBack(session, turn) {
+        const state = this.state(session);
+        state.addressed = [...turn.addressed, ...state.addressed];
+        state.digest = [...turn.digest.messages, ...state.digest];
+        state.omitted += turn.digest.omitted;
+        this.trimDigest(state);
+        this.save();
+    }
+    depth(session) {
+        return this.sessions.get(session)?.addressed.length ?? 0;
+    }
+    clear(session) {
+        this.sessions.delete(session);
+        this.save();
+    }
+    state(session) {
+        let s = this.sessions.get(session);
+        if (!s)
+            this.sessions.set(session, (s = { addressed: [], digest: [], omitted: 0 }));
+        return s;
+    }
+    trimDigest(state) {
+        const size = () => state.digest.reduce((n, m) => n + m.content.length, 0);
+        while (state.digest.length > this.caps.digestMessages || (state.digest.length > 1 && size() > this.caps.digestChars)) {
+            state.digest.shift();
+            state.omitted += 1;
+        }
+    }
+    save() {
+        try {
+            fs.mkdirSync(path.dirname(this.file), { recursive: true });
+            fs.writeFileSync(this.file, JSON.stringify(Object.fromEntries(this.sessions)), { mode: 0o600 });
+            fs.chmodSync(this.file, 0o600);
+        }
+        catch (err) {
+            // The queue still works in memory; what is lost is surviving a restart. Say so once per
+            // failure rather than hide it — a silently unpersisted queue is a message lost later.
+            process.stderr.write(`baychat relay: could not persist the ACP queue — ${err instanceof Error ? err.message : String(err)}\n`);
+        }
+    }
+}
+exports.AcpTurnQueue = AcpTurnQueue;

package/dist/relay/acp/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/relay/commands.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.cmdRelayStart = cmdRelayStart;
 exports.ensureRelayInstalled = ensureRelayInstalled;
 exports.tryRelayStatus = tryRelayStatus;
+exports.registerAcpSession = registerAcpSession;
 exports.cmdRelayStatus = cmdRelayStatus;
 exports.cmdRelayStop = cmdRelayStop;
 exports.shouldFallBackToMailbox = shouldFallBackToMailbox;
@@ -56,6 +57,7 @@ const profiles_1 = require("./profiles");
 const provider_env_1 = require("./provider-env");
 const autostart_1 = require("./autostart");
 const runtime_binary_1 = require("../runtime-binary");
+const terminal_pane_1 = require("./terminal-pane");
 const owner_pid_1 = require("./owner-pid");
 const parent_watch_1 = require("./parent-watch");
 const daemon_1 = require("./daemon");
@@ -203,6 +205,24 @@ async function tryRelayStatus() {
         return null;
     }
 }
+/** Tell a RUNNING relay about a relay-owned ACP session. Returns false when no relay answers. */
+async function registerAcpSession(frame) {
+    try {
+        await request(await connectOrFail(), frame);
+        return true;
+    }
+    catch (err) {
+        // No relay yet is ordinary during a first `connect` — the registry file written beside this
+        // call is what a relay started afterwards reads. A refusal, though, must be seen, and so
+        // must a denied or wedged relay: only the exact "absent" wording `connectOrFail` produces
+        // (or the socket vanishing between its probe and the connect) counts as no relay.
+        const absent = (0, socket_1.describeProbeFailure)((0, socket_1.socketPath)(), { alive: false, reason: "absent" });
+        const code = err.code;
+        if (err instanceof Error && (err.message === absent || code === "ENOENT" || code === "ECONNREFUSED"))
+            return false;
+        throw err;
+    }
+}
 async function cmdRelayStatus() {
     let status;
     try {
@@ -446,6 +466,9 @@ async function attachViaMailbox(opts) {
         // seconds — recording either told the daemon a live session had gone, and it
         // spawned a headless duplicate. See `currentOwnerPid`.
         ownerPid: opts.ownerPid ?? (0, owner_pid_1.currentOwnerPid)(opts.runtime),
+        // Recorded on BOTH transports: a sandboxed session on the fifo rung is still running
+        // in somebody's terminal, and typing into it does not go through the sandbox at all.
+        pane: (0, terminal_pane_1.detectPane)(),
         registeredAt: new Date().toISOString(),
     });
     const timeoutMs = opts.timeoutMs;
@@ -766,6 +789,11 @@ async function cmdRelayAttach(opts) {
             // found by walking past the launching shell, which does not outlive the
             // wake and so cannot witness anything.
             ownerPid: opts.ownerPid ?? (0, owner_pid_1.currentOwnerPid)(runtime),
+            // WHERE TO TYPE. Read from this process's environment because this process is
+            // inside the session's terminal and the daemon is not — the same rule `runtimeBin`
+            // above follows. Undefined for a session in a bare terminal, which is not a failure:
+            // it is the one honest answer, and the commands that need a pane refuse by name.
+            pane: (0, terminal_pane_1.detectPane)(),
             // The URL only. `provider-env.ts` is the module that guarantees no
             // credential travels with it.
             providerUrl: provider?.url,