baychat 0.21.4 → 0.22.0

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,

package/dist/relay/daemon.js

@@ -34,10 +34,19 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RelayDaemon = void 0;
+exports.splitSessionCommands = splitSessionCommands;
+const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const net = __importStar(require("net"));
 const path = __importStar(require("path"));
 const config_1 = require("../config");
+const session_commands_1 = require("./session-commands");
+const terminal_pane_1 = require("./terminal-pane");
+const commands_1 = require("./acp/commands");
+const daemon_glue_1 = require("./acp/daemon-glue");
+const runner_1 = require("./acp/runner");
+const turn_queue_1 = require("./acp/turn-queue");
+const session_reply_1 = require("./session-reply");
 const runtime_binary_1 = require("../runtime-binary");
 const adapters_1 = require("./adapters");
 const parent_watch_1 = require("./parent-watch");
@@ -60,6 +69,10 @@ const watermarks_1 = require("./watermarks");
 const DISCOVERY_INTERVAL_MS = 10 * 60_000;
 class RelayDaemon {
     registry = new registry_1.SessionRegistry();
+    acpQueue = new turn_queue_1.AcpTurnQueue();
+    acp;
+    acpAlive;
+    acpKeepAlive;
     queue;
     abort = new AbortController();
     /** Live attach sockets by session name. */
@@ -83,6 +96,8 @@ class RelayDaemon {
     liveSessions = [];
     /** Why discovery last refused, per session, and when — throttles the rescan. */
     discoveryReasons = new Map();
+    /** Set at `start()`. Undefined only before the daemon is running. */
+    auth;
     discovery;
     spawnHeadless;
     isAlive;
@@ -145,6 +160,11 @@ class RelayDaemon {
         this.mailboxWatchers = (0, mailbox_1.mailboxRootCandidates)().map((root) => new mailbox_watcher_1.MailboxWatcher({
             root,
             onRegister: (reg) => {
+                // A relay-run session's program is the daemon's to choose (Ruling R32): `upsert`
+                // merges, so a mailbox file would keep `acp` and swap the binary the runner spawns.
+                const relayRun = (0, daemon_glue_1.acpAttachRefusal)(this.registry, reg.session);
+                if (relayRun)
+                    return this.log(`mailbox registration ignored: ${relayRun}`);
                 this.registry.upsert((0, mailbox_1.registrationToTarget)(reg));
                 // A session that names itself supersedes anything discovery guessed,
                 // exactly as an attach frame does.
@@ -185,6 +205,22 @@ class RelayDaemon {
             this.lastError = `delivery failed for ${session}: ${errText(err)}`;
             this.log(this.lastError);
         });
+        this.acpAlive = (0, daemon_glue_1.acpKeepAliveScheduler)(() => (0, daemon_glue_1.keepAcpSessionsAlive)({ registry: this.registry, auth: this.auth, caller: opts.acpCaller, log: this.log }));
+        this.acp = new runner_1.AcpSessionRunner({
+            registry: this.registry,
+            queue: this.acpQueue,
+            auth: () => this.auth,
+            spawn: child_process_1.spawn,
+            say: async (conversationId, session, text) => {
+                if (this.auth)
+                    await (0, session_reply_1.postSessionReply)(this.auth, conversationId, session, text);
+            },
+            log: (line) => this.log(line),
+            onDelivered: (session, batch) => this.record({ kind: "woken", via: "acp", session }, session, batch),
+            onPending: (session, batch, reason) => this.record({ kind: "pending", session, reason }, session, batch),
+            runTurn: opts.acpRunTurn,
+            caller: opts.acpCaller,
+        });
     }
     async start() {
         // The DEVICE credential, not an agent token. A laptop has one device login
@@ -199,11 +235,16 @@ class RelayDaemon {
             throw new Error(`device credential expired ${device.expiresAt} — run \`npx baychat login\``);
         }
         const auth = { baseUrl: device.baseUrl, token: device.token };
+        // Kept for session-command replies. Every other API call the daemon makes is inside
+        // the feed, which closes over `auth`; a command's reply happens in `deliver`, which
+        // does not.
+        this.auth = auth;
         this.registry.load();
         // Held messages outlive the process that held them. Loaded before the socket
         // opens, so a session that re-arms in the first moments of a new daemon is
         // handed what the previous one was holding rather than a clean slate.
         this.held.load();
+        this.acpQueue.load();
         const sockPath = (0, socket_1.socketPath)();
         if (await (0, socket_1.probeSocket)(sockPath)) {
             throw new Error(`a relay is already listening on ${sockPath} — run \`baychat relay status\``);
@@ -229,6 +270,8 @@ class RelayDaemon {
             });
         });
         writePidFile();
+        // After the socket is ours: a relay refused as a duplicate must not keep sessions alive.
+        this.acpKeepAlive = (0, daemon_glue_1.startAcpUpkeep)(this.acpAlive.run, this.log);
         this.log(`listening on ${sockPath} (pid ${process.pid}) as device "${device.user.name}"`);
         this.log(`${this.registry.all().length} known session target(s)`);
         // The event SOURCE is pluggable (socket preferred, long-poll floor); every
@@ -249,6 +292,7 @@ class RelayDaemon {
                 const dropped = this.registry.pruneToLive(names);
                 for (const name of dropped)
                     this.log(`session ended server-side, dropped: ${name}`);
+                void this.acpAlive.lapsed(this.registry, names);
             },
             onPoll: (cursor) => {
                 this.cursor = cursor;
@@ -329,6 +373,96 @@ class RelayDaemon {
             this.log(`delivered ${room.messages.length} held message(s) to ${session} in ${room.conversationId} on re-attach`);
         }
     }
+    /**
+     * Run one session command and say in the room what happened.
+     *
+     * ── EVERY PATH REPLIES, INCLUDING EVERY REFUSAL ───────────────────────────────────────
+     * A command produces no agent turn, so silence is the only thing the sender can tell
+     * apart from silence. A refusal that names its reason is the whole difference between
+     * "this feature is broken" and "start your agent inside tmux".
+     */
+    async runSessionCommand(session, message, command) {
+        const say = async (text) => {
+            if (!this.auth)
+                return;
+            try {
+                await (0, session_reply_1.postSessionReply)(this.auth, message.conversationId, session, text);
+            }
+            catch (err) {
+                // Never an empty catch: a command that ran and could not say so is exactly the
+                // state this reply exists to prevent, so it has to be visible somewhere.
+                this.log(`could not report ${command.trigger} for ${session}: ${errText(err)}`);
+            }
+        };
+        const target = this.registry.get(session);
+        if (!target) {
+            await say(`This relay does not know a session called "${session}" on this machine.`);
+            return;
+        }
+        this.log(`session command ${command.trigger} for ${session} from ${message.senderId}`);
+        if (command.id === "help") {
+            await say((0, session_commands_1.sessionCommandHelp)());
+            return;
+        }
+        // `/mode-*`, `/stop`, and what `/status` `/exit` `/clear` `/new` mean with no terminal.
+        if (await (0, commands_1.runAcpSessionCommand)(this.acp, session, target, message, command, say))
+            return;
+        if (command.id === "status") {
+            const where = target.pane
+                ? target.pane.kind === "tmux"
+                    ? `tmux pane ${target.pane.pane}`
+                    : target.pane.kind
+                : "no multiplexer — /clear and /new cannot reach it";
+            await say([
+                `Session "${session}"`,
+                `  runtime: ${target.runtime}`,
+                `  terminal: ${where}`,
+                `  attached: ${target.attached ? `yes (${target.transport ?? "socket"})` : "no"}`,
+                `  can resume: ${target.resumeId ? `yes (${target.resumeSource ?? "recorded"})` : "no"}`,
+            ].join("\n"));
+            return;
+        }
+        if (command.id === "exit") {
+            // DETACH, never kill. Ending somebody's terminal agent from a phone is not a thing
+            // the relay should be able to do by itself, and "stop being reachable" is the part it
+            // genuinely owns and can undo. The reply says which one happened, because "exit" will
+            // read to most people as the other one.
+            const sock = this.attached.get(session);
+            if (sock && !sock.destroyed)
+                sock.end();
+            this.attached.delete(session);
+            this.mailboxes.delete(session);
+            this.registry.setAttached(session, false);
+            await say(`"${session}" is no longer reachable from the Bay. Its terminal is untouched and still open — run the join command there to bring it back.`);
+            return;
+        }
+        // What is left types into the terminal.
+        if (!target.pane) {
+            await say((0, session_commands_1.noTerminalReason)());
+            return;
+        }
+        const keys = command.keys?.(target.runtime);
+        if (!keys) {
+            await say(`${command.trigger} has nothing to type for a ${target.runtime} session.`);
+            return;
+        }
+        // `ownerPid` is how a SCREEN session is verified — screen cannot be asked what is
+        // running in a window, so the question goes to the process instead. tmux ignores it and
+        // asks tmux.
+        const typed = await (0, terminal_pane_1.typeIntoPane)(target.pane, target.runtime, keys, {
+            ownerPid: target.ownerPid,
+        });
+        if (!typed.ok) {
+            await say((0, session_commands_1.noTerminalReason)(`${command.trigger} could not run: ${typed.reason}`));
+            return;
+        }
+        if (command.id === "clear" || command.id === "new") {
+            // See `SessionRegistry.clearResume`: the live session's transcript is gone, so the
+            // recorded resume id now points at something no half of this session has.
+            this.registry.clearResume(session);
+        }
+        await say(`Typed ${keys} into "${session}". Its context is cleared.`);
+    }
     /**
      * Wait for a session to re-arm its socket, up to `graceMs`.
      *
@@ -353,6 +487,20 @@ class RelayDaemon {
      * flight for the same session at once.
      */
     async deliver(session, batch) {
+        // COMMANDS FIRST, and separated from chat rather than chosen between.
+        //
+        // A batch is coalesced, so it can hold a command and a sentence at once. Dropping the
+        // sentence would lose a message; handing the command to the agent would ask a MODEL to
+        // obey something its HARNESS owns — `/clear` is read by the runtime's TUI, and no model
+        // can run it for itself. So the commands are executed here and everything else wakes
+        // the session exactly as it always did.
+        const { commands, chat } = splitSessionCommands(batch);
+        for (const { message, command } of commands) {
+            await this.runSessionCommand(session, message, command);
+        }
+        if (chat.length === 0)
+            return;
+        batch = chat;
         const target = this.registry.get(session);
         if (!target) {
             // NOT reported as pending, though an earlier version of this did.
@@ -432,6 +580,12 @@ class RelayDaemon {
                 }
             }
         }
+        if (target.acp) {
+            // The relay drives this session itself: no attach to wait for, no resume id to discover.
+            // The runner files the batch and returns at once, so this lock is free again for a `/stop`.
+            this.acp.handle(session, batch);
+            return;
+        }
         const adapter = (0, adapters_1.adapterFor)(target.runtime);
         // ORDERED ABOVE THE FIFO, deliberately.
         //
@@ -882,6 +1036,9 @@ class RelayDaemon {
         let session;
         const read = (0, socket_1.createFrameReader)((frame) => {
             if (frame.type === "attach") {
+                const relayRun = (0, daemon_glue_1.acpAttachRefusal)(this.registry, frame.session);
+                if (relayRun)
+                    return void (0, socket_1.writeFrame)(sock, { type: "error", message: relayRun });
                 if (frame.delivery === "queue" &&
                     (frame.runtime !== "codex" || !frame.resumeId || !frame.runtimeBin)) {
                     (0, socket_1.writeFrame)(sock, {
@@ -902,6 +1059,7 @@ class RelayDaemon {
                     cwd: frame.cwd,
                     runtimeBin: frame.runtimeBin,
                     ownerPid: frame.ownerPid,
+                    pane: frame.pane,
                     providerUrl: frame.providerUrl,
                     providerVar: frame.providerVar,
                 });
@@ -953,6 +1111,11 @@ class RelayDaemon {
                 (0, socket_1.writeFrame)(sock, { type: "status-result", status: this.status() });
                 return;
             }
+            if (frame.type === "acp-register") {
+                const result = (0, daemon_glue_1.registerAcpFrame)(frame, { registry: this.registry, log: this.log, resolveBinary: this.resolveBinary });
+                (0, socket_1.writeFrame)(sock, result.ok ? { type: "status-result", status: this.status() } : { type: "error", message: result.message });
+                return;
+            }
             if (frame.type === "stop") {
                 this.log("stop requested over socket");
                 (0, socket_1.writeFrame)(sock, { type: "status-result", status: this.status() });
@@ -1000,11 +1163,14 @@ class RelayDaemon {
         };
     }
     async stop() {
+        clearInterval(this.acpKeepAlive);
+        this.acp.shutdown();
         this.abort.abort();
         for (const sock of this.attached.values())
             sock.destroy();
         this.attached.clear();
         await this.queue.idle();
+        await this.acp.idle();
         for (const w of this.mailboxWatchers)
             w.stop();
         await new Promise((resolve) => this.server ? this.server.close(() => resolve()) : resolve());
@@ -1019,6 +1185,35 @@ class RelayDaemon {
     }
 }
 exports.RelayDaemon = RelayDaemon;
+/**
+ * Separate the session commands in a batch from the ordinary chat in it.
+ *
+ * THREE CONDITIONS, ALL REQUIRED, and each closes a different door:
+ *
+ *  - `shouldRespond` — the message is addressed to THIS session. Without it, a `/clear`
+ *    typed into a group chat that the session merely watches would clear it.
+ *  - `commandAuthorized` — the SERVER says this sender may command this session. The relay
+ *    never decides that itself (see `RelayMessage.commandAuthorized`), and an absent field
+ *    is a no, so an older server can only ever under-permit.
+ *  - an exact trigger match — "can you /clear please" is a sentence ABOUT a command and
+ *    must reach the agent as one.
+ *
+ * Anything failing any of them is chat, and wakes the session exactly as it does today.
+ */
+function splitSessionCommands(batch) {
+    const commands = [];
+    const chat = [];
+    for (const message of batch) {
+        const command = message.shouldRespond === true && message.commandAuthorized === true
+            ? (0, session_commands_1.parseSessionCommand)(message.content)
+            : undefined;
+        if (command)
+            commands.push({ message, command });
+        else
+            chat.push(message);
+    }
+    return { commands, chat };
+}
 function writePidFile() {
     try {
         fs.writeFileSync((0, socket_1.pidFilePath)(), String(process.pid), { mode: 0o600 });

package/dist/relay/mailbox.js

@@ -186,6 +186,7 @@ function registrationToTarget(reg) {
         cwd: reg.cwd,
         runtimeBin: reg.runtimeBin,
         ownerPid: reg.ownerPid,
+        pane: reg.pane,
         // Persisted, so a LATER headless resume still knows this session is
         // sandboxed and must be told to re-arm in the foreground. `status()`
         // recomputes the live rung for display; this is the remembered one.

package/dist/relay/profiles.js

@@ -171,6 +171,28 @@ exports.RUNTIME_PROFILES = [
         checked: "2026-08-31",
         source: "https://aider.chat/docs/config/options.html",
     },
+    {
+        id: "dsh",
+        label: "DeepSeek Harness",
+        bin: "dsh",
+        // dsh sets DSH_SESSION_ID for every command the model runs (dsh-shell-env) [source]. This
+        // table's own invariant below restricts `kind: "env"` to a row that has been RUN against a
+        // live session — only `pi` qualifies so far, and this row is `docs`, not `run` (see the
+        // header comment: "Only claude and codex are run"). So the variable is reported here as
+        // `flag-only`, not `env`: dsh's docs show the id exists, but whether a running session can
+        // read its own back and pass it to `--session-id` has not been executed here.
+        sessionId: {
+            kind: "flag-only",
+            how: "DSH_SESSION_ID is set for every command dsh's model runs (dsh-shell-env docs); whether a running session can read its own back to resume itself is unconfirmed.",
+        },
+        // No headless rung (Ruling R27): a headless `dsh --profile headless` turn would run with
+        // dsh's own permissions, outside the modes the relay enforces. dsh is driven by the relay
+        // over ACP instead (`relay/acp/`), which is where its modes live.
+        noHeadlessReason: "DeepSeek Harness is run by the relay over ACP (`baychat connect dsh`), which enforces modes; a terminal dsh session is not woken headlessly.",
+        confidence: "docs",
+        checked: "2026-09-19",
+        source: "https://www.npmjs.com/package/@deepseek-ai/dsh (0.1.5-rc.2, dsh-shell-env + dsh-acp README)",
+    },
     {
         id: "pi",
         label: "Pi",

package/dist/relay/registry.js

@@ -113,6 +113,28 @@ class SessionRegistry {
     get(name) {
         return this.sessions.get(name);
     }
+    /**
+     * Forget how to resume this session — what `/clear` means to the headless path.
+     *
+     * A separate method because `upsert` strips undefined, deliberately: every other caller
+     * is reporting what it LEARNED, and a field it did not learn must not erase one that was.
+     * This caller is the exception — it is reporting what stopped being true.
+     *
+     * Why `/clear` must do this at all: it clears the LIVE session's context by typing into
+     * its terminal, and the recorded `resumeId` still points at the conversation that just
+     * stopped existing. Left in place, a later headless wake would resume a transcript the
+     * live session no longer has — the two halves of one session disagreeing about what was
+     * said, which is worse than either being empty.
+     */
+    clearResume(name) {
+        const existing = this.sessions.get(name);
+        if (!existing)
+            return;
+        delete existing.resumeId;
+        delete existing.resumeSource;
+        delete existing.resumeEvidence;
+        this.save();
+    }
     all() {
         return [...this.sessions.values()];
     }
@@ -141,12 +163,17 @@ class SessionRegistry {
      *
      * Attached sessions are never pruned: a live socket outranks a poll, which
      * may simply have raced a join that hasn't been stamped live yet.
+     *
+     * Relay-owned ACP sessions are never pruned either: there is no terminal
+     * behind them to have ended, and the server's live list never mentions them
+     * as something a poll would confirm — the relay itself is the only thing
+     * that keeps them alive, so it must be the only thing that can drop them.
      */
     pruneToLive(liveNames) {
         const live = new Set(liveNames);
         const dropped = [];
         for (const [name, target] of this.sessions) {
-            if (!live.has(name) && !target.attached) {
+            if (!live.has(name) && !target.attached && !target.relayOwned) {
                 this.sessions.delete(name);
                 dropped.push(name);
             }
@@ -155,6 +182,24 @@ class SessionRegistry {
             this.save();
         return dropped;
     }
+    /** Record (or, with `undefined`, forget) the agent's own ACP session id. */
+    setAcpSession(name, sessionId) {
+        const t = this.sessions.get(name);
+        if (!t?.acp)
+            return;
+        if (sessionId === undefined)
+            delete t.acp.sessionId;
+        else
+            t.acp.sessionId = sessionId;
+        this.save();
+    }
+    setAcpMode(name, mode) {
+        const t = this.sessions.get(name);
+        if (!t?.acp)
+            return;
+        t.acp.mode = mode;
+        this.save();
+    }
 }
 exports.SessionRegistry = SessionRegistry;
 function stripUndefined(obj) {