baychat 0.21.5 → 0.23.0

package/README.md

@@ -186,6 +186,8 @@ baychat login               # once per computer: the QR
 baychat connect             # list the apps it can configure
 baychat connect claude      # refresh Claude Code's skill (no QR, no re-pairing)
 baychat connect codex       # configure Codex — restart Codex afterwards
+baychat connect dsh         # a DeepSeek Harness session the relay runs for you — see below
+baychat connect cursor-cli  # a Cursor CLI session the relay runs for you — see below
 baychat relay start         # the process that wakes your sessions
 baychat relay status        # transport, sessions, anything pending
 baychat doctor              # checks every link and prints what to type
@@ -350,7 +352,9 @@ everything we need.
   right conversation. This needs the agent to be able to say which session it is, and to have a
   way to resume that session without a UI (`--resume <id>` and friends).
 
-Adapters ship for **Claude Code**, **Codex**, **Cursor** and **Hermes**. Many others — Gemini CLI,
+Adapters ship for **Claude Code**, **Codex**, **Cursor**, **Hermes** and **DeepSeek Harness**
+(`baychat connect dsh`, run by the relay over ACP rather than woken in a terminal — see above and
+[`ACP_RELAY.md`](../../docs/features/ACP_RELAY.md)). Many others — Gemini CLI,
 Copilot CLI, Goose, OpenCode/Crush, Qwen Code, Kimi Code CLI, CodeBuddy, iFlow, Trae, Aider — look
 compatible on paper, with per-agent detail, exact flags, known bugs and a **date on every row** in
 [the compatibility table](https://baychat.io/runtimes.md).
@@ -435,6 +439,76 @@ relay also falls back to it automatically when app-server cannot be used at
 all — but not when the failure is a real answer about your session, because
 retrying that would only repeat it with the reason replaced by an exit code.
 
+## `baychat connect dsh` — DeepSeek Harness, run by the relay
+
+```
+baychat connect dsh [--folder <path>] [--max-mode <mode>] [--mode <mode>] [--session <name>] [--terminal]
+```
+
+Unlike every other runtime in this file, DeepSeek Harness (`dsh`) is not woken in your terminal —
+the relay spawns it directly and drives it over **ACP** (Agent Client Protocol), one process per
+turn. Full detail — the four modes, their honest limits, the rule file, known limits — is in
+[`docs/features/ACP_RELAY.md`](../../docs/features/ACP_RELAY.md).
+
+> ⚠️ **DeepSeek Harness is experimental and has not been security-audited.** DeepSeek recommends
+> running it in a disposable VM or container, not on your everyday machine. `connect dsh` and
+> `baychat doctor` both print this reminder every time.
+
+| Flag | Default | Meaning |
+|---|---|---|
+| `--folder <path>` | asked interactively, defaulting to the current directory | the folder DeepSeek may work in — resolved and stored in `~/.baychat/relay-policy.json` |
+| `--max-mode <mode>` | asked interactively, defaulting to `ask` | the ceiling: `/mode-*` from the chat can never go higher than this, ever |
+| `--mode <mode>` | `chat` | the mode the session starts in |
+| `--session <name>` | `DeepSeek` | the BayChat session name it registers and joins as |
+| `--terminal` | off | ALSO set up `dsh` for use by hand in a terminal: the BayChat skill and a BayChat MCP entry in `~/.dsh/cordis.patch.yml`. That writes your BayChat token into that file (mode `0600`), and it applies to every dsh profile — so it is opt-in. The relay-run session needs none of it. |
+
+Modes, weakest to strongest: `chat` (default — BayChat tools only), `read` (+ file read/search),
+`ask` (+ shell; a write asks on your phone first), `full` (+ writes without asking, in its
+folder). Only `chat` protects private files — every other mode can read anything your account can.
+Windows offers `chat` and `read` only.
+
+Who gets that power: **you, or a Bay owner/admin you gave command access**. Their messages run in
+the session's mode and they may use `/mode-*`; anyone else's message makes that turn `chat`. The
+ceiling still caps everything, and in `ask` the approval card still comes to **your** phone only.
+Revoke the grant (or demote the admin) to take it away.
+
+Re-running `connect dsh` changes the ceiling, and re-registers the session at the starting mode
+(`--mode`, default `chat`) — it does **not** keep a mode you raised from the chat. A running relay
+refuses to raise a live session's mode (it keeps or lowers it only), and `connect` then exits with
+an error; to raise it now, use `/mode-…` from the chat. The starting mode `connect` wrote itself
+still applies once the relay reloads its sessions (for example after a restart) — that is you, on
+this computer, and it is still capped by the folder's ceiling. Re-running with a different `--folder`
+**adds** that folder to the allowed folders; the old ones stay allowed until you remove them from
+`~/.baychat/relay-policy.json`.
+
+A `dsh` you run by hand in a terminal is never woken headlessly, and `baychat start` does not
+launch `dsh` — the relay-run session is the one whose modes are enforced.
+
+It also needs its own API key on that computer, separate from BayChat: run `dsh web` there and add
+it on the Models page. `baychat doctor` reports whether the key exists (never its contents) and
+whether the installed `dsh` matches the version BayChat was tested against.
+
+## `baychat connect cursor-cli` — Cursor's CLI, run by the relay
+
+```
+baychat connect cursor-cli [--folder <path>] [--max-mode <mode>] [--mode <mode>] [--session <name>]
+```
+
+The same relay path as `connect dsh`, for Cursor's CLI (`agent acp`). Log it in first with
+`agent login`; `connect cursor-cli` refuses until `agent status` says you are. Flags are as for
+`dsh` (default session name `Cursor`; no `--terminal`). This is **not** `baychat connect cursor`,
+which still configures the Cursor editor's MCP file.
+
+Modes: `chat` (default — BayChat tools only), `read` (+ reads; no shell, no writes), and on Linux
+only `ask` (edits files inside its folder without asking, edits outside it are refused, every
+command asks on your phone first). There is no `full` for Cursor. Every mode above `chat` can read
+anything your account can. BayChat keeps each session's Cursor config in its own folder under
+`~/.baychat/acp/`, never in your project. A `.cursor/cli.json` or `.cursor/hooks.json` in the
+session's folder or any folder above it stops the session (Cursor would let it override BayChat's
+limits): remove or rename it. Worked on Cursor's free Hobby plan when checked on
+19 Sep 2026; Pro is recommended for regular use. Detail: the Cursor section of
+[`docs/features/ACP_RELAY.md`](../../docs/features/ACP_RELAY.md).
+
 ## Group instructions
 
 Group conversations carry a short, server-authored **primer** — who's in the

package/dist/approve-hook.js

@@ -207,9 +207,12 @@ function describeToolRequest(toolName, toolInput) {
 /** The question the card asks. Blunt on purpose: this is a shell on a server, read on a phone,
  *  and the safe answer has to be the obvious one. */
 function composeQuestion(params) {
+    const who = params.agentLabel ?? "Claude Code";
+    const context = params.agentLabel
+        ? "It is running in BayChat's relay; nobody is at a terminal."
+        : "This would normally be a prompt in the terminal.";
     const lines = [
-        `Claude Code on ${params.host} is asking permission to use ${params.toolName}. ` +
-            `This would normally be a prompt in the terminal.`,
+        `${who} on ${params.host} is asking permission to use ${params.toolName}. ` + context,
         "",
         describeToolRequest(params.toolName, params.toolInput),
         "",

package/dist/commands.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CATCHUP_UNTRUSTED_REMINDER = void 0;
+exports.realConfigIo = exports.CATCHUP_UNTRUSTED_REMINDER = void 0;
 exports.requireCredentials = requireCredentials;
 exports.cmdPair = cmdPair;
 exports.cmdWhoami = cmdWhoami;
@@ -653,7 +653,7 @@ function claudeMcpAddSpawn(platform, baseUrl, token) {
  */
 function refreshConnectedClients(baseUrl, token) {
     try {
-        const updated = (0, credential_refresh_1.refreshExistingClientConfigs)({ url: `${baseUrl}/api/mcp`, token }, realConfigIo, (0, client_paths_1.currentPathEnv)());
+        const updated = (0, credential_refresh_1.refreshExistingClientConfigs)({ url: `${baseUrl}/api/mcp`, token }, exports.realConfigIo, (0, client_paths_1.currentPathEnv)());
         for (const path of updated)
             console.log(`✓ Updated ${path} with the new credential`);
     }
@@ -663,8 +663,10 @@ function refreshConnectedClients(baseUrl, token) {
         console.log(`  Could not refresh client configs: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
-/** Real filesystem IO for the refresh. Mirrors `connect.ts`'s writer. */
-const realConfigIo = {
+/** Real filesystem IO for the refresh. Mirrors `connect.ts`'s writer.
+ *  Exported so `baychat update` refreshes configs through the SAME writer a login does —
+ *  two spellings of "write a client config" would eventually disagree about permissions. */
+exports.realConfigIo = {
     readFile: (p) => {
         try {
             return node_fs_1.default.readFileSync(p, "utf8");

package/dist/connect-acp.js

@@ -0,0 +1,165 @@
+"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.realConnectAcpDeps = realConnectAcpDeps;
+exports.connectAcpAgent = connectAcpAgent;
+const readline = __importStar(require("readline"));
+const commands_1 = require("./commands");
+const config_1 = require("./config");
+const agents_1 = require("./relay/acp/agents");
+const modes_1 = require("./relay/acp/modes");
+const policy_1 = require("./relay/acp/policy");
+const presence_1 = require("./relay/acp/presence");
+const commands_2 = require("./relay/commands");
+const registry_1 = require("./relay/registry");
+const runtime_binary_1 = require("./runtime-binary");
+function askOnTerminal(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => rl.question(question, (answer) => (rl.close(), resolve(answer.trim()))));
+}
+/** The real world, for every ACP agent's `connect`. */
+function realConnectAcpDeps() {
+    return {
+        device: config_1.loadDeviceCredentials,
+        login: (base) => (0, commands_1.cmdLogin)({ base, hint: false }),
+        resolveBinary: (name) => (0, runtime_binary_1.resolveRuntimeBinary)(name, (0, runtime_binary_1.currentBinaryEnv)()),
+        join: async (session) => {
+            const device = (0, config_1.loadDeviceCredentials)();
+            if (!device)
+                throw new Error("not logged in");
+            await (0, presence_1.joinSession)((0, presence_1.deviceMcpCaller)(device), session);
+        },
+        registerWithRelay: commands_2.registerAcpSession,
+        ensureRelay: commands_2.ensureRelayInstalled,
+        ask: askOnTerminal,
+        print: (line) => console.log(line),
+        platform: process.platform,
+    };
+}
+/**
+ * `baychat connect <agent>` for a relay-run (ACP) agent.
+ *
+ * ORDER MATTERS: everything that can refuse (no login, no binary, the agent's own preflight, a
+ * bad folder, a bad mode, a session name already taken by something the relay does not run)
+ * refuses BEFORE anything is written, so a failed connect leaves no half-made rule file.
+ */
+async function connectAcpAgent(row, spec, opts, deps) {
+    const say = deps.print;
+    let device = deps.device();
+    if (!device) {
+        say(spec.greeting);
+        if (!(await deps.login(opts.base)))
+            return 2;
+        device = deps.device();
+    }
+    if (!device) {
+        say(`No device credential was saved. Retry \`${row.connectCommand}\`.`);
+        return 1;
+    }
+    const binary = deps.resolveBinary(row.bin);
+    if (!binary.ok) {
+        say(`${row.label} is not installed here. ${row.installHint}`);
+        return 1;
+    }
+    if (!(0, agents_1.binaryIdentified)(row, binary.version)) {
+        say((0, agents_1.unidentifiedBinary)(row, binary.path, binary.version));
+        return 1;
+    }
+    const refusal = await spec.preflight?.(binary.path);
+    if (refusal) {
+        say(refusal);
+        return 1;
+    }
+    const folderInput = opts.folder ?? ((await deps.ask(`Folder ${row.label} may work in [${process.cwd()}]: `)) || process.cwd());
+    const folder = (0, policy_1.validateNewRoot)(folderInput);
+    if (!folder.ok) {
+        say(folder.reason);
+        return 1;
+    }
+    const offered = row.modesFor(deps.platform);
+    const maxInput = opts.maxMode ?? ((await deps.ask(`Highest mode the chat may ever switch it to (${offered.join(" / ")}) [${offered.includes("ask") ? "ask" : offered.at(-1)}]: `)) || (offered.includes("ask") ? "ask" : offered.at(-1)));
+    if (!(0, modes_1.isAcpMode)(maxInput) || !offered.includes(maxInput)) {
+        say(`"${maxInput}" is not a mode offered on this computer. Choose one of: ${offered.join(", ")}.`);
+        return 1;
+    }
+    const mode = opts.agentMode ?? "chat";
+    if (!(0, modes_1.isAcpMode)(mode) || (0, modes_1.modeRank)(mode) > (0, modes_1.modeRank)(maxInput)) {
+        say(`The starting mode must be one of ${offered.join(", ")} and no higher than ${maxInput}.`);
+        return 1;
+    }
+    const session = opts.session?.trim() || spec.defaultSession;
+    const registry = new registry_1.SessionRegistry();
+    registry.load();
+    const existing = registry.get(session);
+    if (existing && !existing.acp) {
+        say(`A session named "${session}" already exists on this computer and is not run by the relay. Choose another name with --session <name>.`);
+        return 1;
+    }
+    const otherAgent = (0, agents_1.otherAgentRefusal)(row, session, existing?.acp?.agent);
+    if (otherAgent) {
+        say(otherAgent);
+        return 1;
+    }
+    try {
+        row.launch(mode, (0, agents_1.acpPatchDir)(), session); // a session name the agent's config cannot hold throws here
+    }
+    catch (err) {
+        say(err instanceof Error ? err.message : String(err));
+        return 1;
+    }
+    // ── Nothing above this line wrote anything. ─────────────────────────────────────────────
+    (0, policy_1.savePolicy)((0, policy_1.upsertRoot)((0, policy_1.loadPolicy)(), row.id, folder.path, maxInput));
+    (0, agents_1.writeModePatch)(row, mode, session, (0, agents_1.acpPatchDir)());
+    await deps.join(session);
+    const acp = { agent: row.id, cwd: folder.path, mode };
+    registry.upsert({ name: session, runtime: row.id, runtimeBin: binary.path, relayOwned: true, acp });
+    const live = await deps.registerWithRelay({ type: "acp-register", session, runtime: row.id, runtimeBin: binary.path, acp });
+    say("");
+    say(`  ${row.label}: ${binary.path} (${binary.version})`);
+    if (!(0, agents_1.matchesTestedVersion)(binary.version, row.testedVersion))
+        say(`  Note: BayChat was tested with ${row.testedVersion}. ${row.label} is a preview and changes often — if something misbehaves, run \`baychat doctor\`.`);
+    for (const line of spec.notes(maxInput))
+        say(`  ${line}`);
+    say(`  Folder:  ${folder.path}`);
+    say(`  Mode:    ${(0, agents_1.describeAgentMode)(row, mode)}`);
+    say(`  Ceiling: ${maxInput} — the chat can never switch it higher. Change it by running this command again.`);
+    for (const line of spec.extras(device))
+        say(`  ${line}`);
+    say(`  ${await deps.ensureRelay()}${live ? "" : " (it will pick this session up when it starts)"}`);
+    say("");
+    say(`  ${spec.firstMessage(session)}`);
+    say(`  From the chat (you, or anyone you gave command access): ${offered.map((m) => `/mode-${m}`).join(" ")} · /stop /new /status.`);
+    return 0;
+}

package/dist/connect-cursor.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cursorLoginState = cursorLoginState;
+exports.cmdConnectCursor = cmdConnectCursor;
+const child_process_1 = require("child_process");
+const connect_acp_1 = require("./connect-acp");
+const agents_1 = require("./relay/acp/agents");
+const modes_1 = require("./relay/acp/modes");
+const runtime_binary_1 = require("./runtime-binary");
+const STATUS_TIMEOUT_MS = 15_000;
+/** Colour codes, which a terminal-aware CLI may print even into a pipe. */
+const ANSI = /\u001b\[[0-9;]*[A-Za-z]/g;
+/**
+ * What `agent status` says about the Cursor login [run, CLI 2026.09.18-9a7762b: "Logged in" /
+ * "Not logged in"]. Anything else is `unknown` — Cursor changed its wording, or the `agent`
+ * found on PATH is some other program — and `connect` refuses rather than guess.
+ */
+function cursorLoginState(statusOutput) {
+    const text = statusOutput.replace(ANSI, "");
+    if (/not logged in/i.test(text))
+        return "logged-out"; // first: it contains "logged in"
+    if (/logged in/i.test(text))
+        return "logged-in";
+    return "unknown";
+}
+function runAgentStatus(binaryPath) {
+    // No shell: the path came from PATH resolution. A Windows `.cmd` shim needs its interpreter named.
+    const plan = (0, runtime_binary_1.spawnPlanFor)(binaryPath, process.platform);
+    return new Promise((resolve) => {
+        (0, child_process_1.execFile)(plan.file, [...plan.prefixArgs, "status"], { timeout: STATUS_TIMEOUT_MS, windowsHide: true, shell: false }, (err, stdout, stderr) => {
+            const said = `${stdout ?? ""}${stderr ?? ""}`;
+            // A failed run is still an answer: "Not logged in" may come with a non-zero exit.
+            resolve(said || (err ? err.message : ""));
+        });
+    });
+}
+function realDeps() {
+    return { ...(0, connect_acp_1.realConnectAcpDeps)(), loginStatus: runAgentStatus };
+}
+/** `baychat connect cursor-cli` — a Cursor CLI session the relay runs by itself. */
+async function cmdConnectCursor(opts = {}, deps = realDeps()) {
+    const row = (0, agents_1.acpAgent)("cursor");
+    return (0, connect_acp_1.connectAcpAgent)(row, {
+        greeting: "Connect Cursor — approve the QR in BayChat.",
+        defaultSession: "Cursor",
+        async preflight(binaryPath) {
+            const state = cursorLoginState(await deps.loginStatus(binaryPath));
+            if (state === "logged-in")
+                return undefined;
+            if (state === "logged-out")
+                return `Cursor is not logged in on this computer. Run \`agent login\`, then \`${row.connectCommand}\` again.`;
+            return `Could not tell whether Cursor is logged in: \`${binaryPath} status\` said neither "Logged in" nor "Not logged in". If that is not Cursor's CLI, install it with \`curl https://cursor.com/install -fsS | bash\`; if it is, run \`agent login\`, then \`${row.connectCommand}\` again.`;
+        },
+        notes: (ceiling) => [
+            "Plan: Works on Cursor's free Hobby plan as of 19 Sep 2026; Pro recommended for regular use.",
+            "Modes the chat can switch it to:",
+            ...row
+                .modesFor(deps.platform)
+                .filter((m) => (0, modes_1.modeRank)(m) <= (0, modes_1.modeRank)(ceiling))
+                .map((m) => `  ${(0, agents_1.describeAgentMode)(row, m)}`),
+        ],
+        extras: () => [],
+        firstMessage: (session) => `Message "${session}" in BayChat. It uses this computer's Cursor login (\`agent login\`).`,
+    }, opts, deps);
+}

package/dist/connect-dsh.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdConnectDsh = cmdConnectDsh;
+const connect_acp_1 = require("./connect-acp");
+const dsh_config_1 = require("./dsh-config");
+const agents_1 = require("./relay/acp/agents");
+const runtime_install_1 = require("./runtime-install");
+function realDeps() {
+    return {
+        ...(0, connect_acp_1.realConnectAcpDeps)(),
+        installTerminalPath: (device) => {
+            const lines = (0, runtime_install_1.describeInstall)((0, runtime_install_1.installRuntimeCommand)("dsh"));
+            // writeDshMcpEntry can throw (RULING R22: a damaged ~/.dsh/cordis.patch.yml block). By this
+            // point the relay-run session has already been created — policy saved, mode patches
+            // written, joined, registered — so a throw here must not escape and abort cmdConnectDsh:
+            // it would report the whole connect as failed even though the chat-driven agent works
+            // fine. Report the terminal-path failure as a line instead.
+            try {
+                const mcp = (0, dsh_config_1.writeDshMcpEntry)({ url: `${device.baseUrl.replace(/\/$/, "")}/api/mcp`, token: device.token });
+                lines.push(`Terminal use: BayChat tools added to ${mcp.file}${mcp.backup ? ` (backup: ${mcp.backup})` : ""} — in dsh, type /baychat <name>`);
+            }
+            catch (err) {
+                lines.push(`Terminal use: FAILED — ${err instanceof Error ? err.message : String(err)}`);
+            }
+            return lines;
+        },
+    };
+}
+/** `baychat connect dsh` — a DeepSeek session the relay runs by itself. */
+async function cmdConnectDsh(opts = {}, deps = realDeps()) {
+    const row = (0, agents_1.acpAgent)("dsh");
+    return (0, connect_acp_1.connectAcpAgent)(row, {
+        greeting: "Connect DeepSeek — approve the QR in BayChat.",
+        defaultSession: "DeepSeek",
+        notes: () => [
+            `Safety: ${row.label} is experimental and has not been security-audited. DeepSeek recommends running it in a disposable VM or container, not on your everyday computer.`,
+        ],
+        // Opt-in (Ruling R26): the terminal path writes the BayChat token into a file every dsh
+        // profile reads, and the relay-run path needs none of it.
+        extras: (device) => opts.terminal
+            ? deps.installTerminalPath(device)
+            : ["Terminal use: not set up (add --terminal to also use BayChat from dsh by hand — it writes your BayChat token into ~/.dsh/cordis.patch.yml, which applies to every dsh profile)."],
+        firstMessage: (session) => `Message "${session}" in BayChat. It needs a DeepSeek API key on this computer: run \`dsh web\` and add it on the Models page.`,
+    }, opts, deps);
+}

package/dist/connect-plan.js

@@ -57,8 +57,23 @@ function parseConnectArgs(args) {
                 throw new Error("Choose --start or --finish once.");
             result.mode = arg === "--start" ? "start" : "finish";
         }
+        else if (arg === "--folder" || arg === "--max-mode" || arg === "--mode" || arg === "--session") {
+            const value = args[++index];
+            if (!value?.trim() || value.startsWith("--"))
+                throw new Error(`Supply ${arg} with a value.`);
+            const key = arg === "--folder" ? "folder" : arg === "--max-mode" ? "maxMode" : arg === "--mode" ? "agentMode" : "session";
+            if (result[key])
+                throw new Error(`Supply ${arg} once.`);
+            result[key] = value;
+        }
+        else if (arg === "--terminal") {
+            if (result.terminal)
+                throw new Error("Supply --terminal once.");
+            result.terminal = true;
+        }
         else if (arg.startsWith("-") || result.client || !arg.trim()) {
-            throw new Error("Usage: baychat connect <runtime> [--start | --finish] [--base <url>]");
+            throw new Error("Usage: baychat connect <runtime> [--start | --finish] [--base <url>] " +
+                "[--folder <path>] [--max-mode <mode>] [--mode <mode>] [--session <name>] [--terminal]");
         }
         else
             result.client = arg;

package/dist/connect.js

@@ -52,6 +52,8 @@ const runtime_binary_1 = require("./runtime-binary");
 const connect_claude_1 = require("./connect-claude");
 var connect_claude_2 = require("./connect-claude");
 Object.defineProperty(exports, "cmdConnectClaude", { enumerable: true, get: function () { return connect_claude_2.cmdConnectClaude; } });
+const connect_cursor_1 = require("./connect-cursor");
+const connect_dsh_1 = require("./connect-dsh");
 const connect_hermes_1 = require("./connect-hermes");
 /** Clients `connect` can configure. `claude` is an alias users reach for. */
 const CLIENT_ALIASES = {
@@ -69,6 +71,8 @@ function renderConnectMenu() {
         ...rows,
         "  npx baychat connect claude  → Claude Code (login, MCP and skill)",
         "  npx baychat connect hermes  → Hermes (pair and enable its persistent agent)",
+        "  npx baychat connect dsh     → DeepSeek Harness (the relay runs it; talk to it from the app)",
+        "  npx baychat connect cursor-cli → Cursor's CLI (the relay runs it; talk to it from the app)",
         "",
         "You approve a QR on your phone. After that, in any coding session:",
         "",
@@ -79,6 +83,8 @@ function renderConnectMenu() {
         "on its own: no QR, no re-pairing. Run it after every CLI upgrade.",
     ].join("\n");
 }
+/** Spellings of the relay-run Cursor CLI (`agent acp`) accepted by `connect`. */
+const CURSOR_CLI_ALIASES = new Set(["cursor-cli", "cursor-agent"]);
 /** Spellings of Claude Code accepted by `connect`. */
 const CLAUDE_CONNECT_ALIASES = new Set(["claude", "claude-code", "claudecode"]);
 /**
@@ -198,6 +204,17 @@ async function cmdConnect(clientArg, opts = {}) {
             throw new Error("Hermes pairing does not support --start/--finish.");
         return (0, connect_hermes_1.cmdConnectHermes)(opts);
     }
+    if (clientArg.trim().toLowerCase() === "dsh" || clientArg.trim().toLowerCase() === "deepseek") {
+        if (opts.mode)
+            throw new Error("DeepSeek setup does not support --start/--finish.");
+        return (0, connect_dsh_1.cmdConnectDsh)(opts);
+    }
+    // Before `parseConnectClient`: plain `cursor` is the Cursor EDITOR's MCP file and stays that.
+    if (CURSOR_CLI_ALIASES.has(clientArg.trim().toLowerCase())) {
+        if (opts.mode)
+            throw new Error("Cursor CLI setup does not support --start/--finish.");
+        return (0, connect_cursor_1.cmdConnectCursor)(opts);
+    }
     const client = parseConnectClient(clientArg);
     if (opts.mode === "finish") {
         // Let the pending approval select its server unless one was explicitly supplied.

package/dist/doctor-command.js

@@ -48,6 +48,7 @@ const os = __importStar(require("os"));
 const config_1 = require("./config");
 const doctor_1 = require("./doctor");
 const commands_1 = require("./relay/commands");
+const registry_1 = require("./relay/registry");
 const credential_refresh_1 = require("./credential-refresh");
 const client_paths_1 = require("./client-paths");
 const runtime_binary_1 = require("./runtime-binary");
@@ -69,12 +70,18 @@ function codexPath() {
     return resolved.ok ? resolved.path : undefined;
 }
 async function currentDoctorEnv() {
+    // Read directly, not through `relay.sessions`: a relay-owned dsh session is worth
+    // diagnosing precisely when the relay is NOT running, which is often why `doctor` was
+    // reached for in the first place.
+    const registry = new registry_1.SessionRegistry();
+    registry.load();
     return {
         home: os.homedir(),
         platform: process.platform,
         now: Date.now(),
         device: (0, config_1.loadDeviceCredentials)(),
         relay: await (0, commands_1.tryRelayStatus)(),
+        targets: registry.all(),
         readText(filePath) {
             try {
                 return fs.readFileSync(filePath, "utf8");

package/dist/doctor.js

@@ -57,13 +57,17 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildReport = buildReport;
 exports.mailboxCheck = mailboxCheck;
+exports.acpChecks = acpChecks;
 exports.exitCodeFor = exitCodeFor;
 exports.renderReport = renderReport;
 const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const mailbox_1 = require("./relay/mailbox");
 const parent_watch_1 = require("./relay/parent-watch");
 const client_paths_1 = require("./client-paths");
+const agents_1 = require("./relay/acp/agents");
+const policy_1 = require("./relay/acp/policy");
 const runtime_binary_1 = require("./runtime-binary");
 const runtimes_1 = require("./runtimes");
 /**
@@ -106,6 +110,7 @@ function buildReport(env) {
         mailbox: mailboxCheck(),
         staleCredentials: staleCredentialCheck(env),
         runtimes: REPORTED.map((runtime) => runtimeReport(runtime, env)),
+        agents: acpChecks({ resolveBinary: env.resolveBinary, targets: env.targets, homedir: env.home }),
         pending: pendingCheck(env),
     };
 }
@@ -168,6 +173,83 @@ function mailboxCheck() {
     // where the truth is established, honestly, as pending-or-delivered.
     return { name: "mailbox", status: "pass", detail: `registered a mailbox FIFO: ${live.join(", ")}` };
 }
+/**
+ * Relay-run (ACP) agents: is each one startable, inside its rules, and able to reach a model?
+ *
+ * Takes `targets` rather than the full `DoctorEnv` for the same testability reason every other
+ * check here does — see `DoctorEnv.targets` for why these come from the persisted registry and
+ * not from `relay.sessions`.
+ *
+ * ONE finding per relay-owned session (not one report for the feature), because a machine
+ * running two dsh sessions in two folders can have one healthy and one not, and collapsing them
+ * would hide whichever came second.
+ *
+ * An agent whose maker advises a precaution (dsh: experimental, not security-audited — R11/R17)
+ * has it repeated on every line that gets far enough to say a version — one short clause, not a
+ * paragraph, because the reader has already seen it once from `connect`.
+ */
+function acpChecks(env) {
+    const owned = env.targets.filter((t) => t.relayOwned && t.acp);
+    if (owned.length === 0) {
+        const commands = agents_1.ACP_AGENTS.map((row) => `\`${row.connectCommand}\``).join(" or ");
+        return [{ name: "relay-run agents", status: "skip", detail: `none — ${commands} sets one up` }];
+    }
+    const policy = (0, policy_1.loadPolicy)();
+    return owned.map((t) => {
+        const name = `agent ${t.name}`;
+        const row = (0, agents_1.acpAgent)(t.acp.agent);
+        if (!row) {
+            return {
+                name,
+                status: "fail",
+                detail: `unknown agent "${t.acp.agent}"`,
+                remedy: `Update baychat, then run \`${(0, agents_1.connectCommandFor)(t.acp.agent)}\` again.`,
+            };
+        }
+        const bin = env.resolveBinary(row.bin);
+        if (!bin.ok) {
+            return {
+                name,
+                status: "fail",
+                detail: `${row.label} is not installed where the relay can find it`,
+                remedy: row.installHint,
+            };
+        }
+        const folder = (0, policy_1.checkFolder)(policy, row.id, t.acp.cwd);
+        if (!folder.ok) {
+            return {
+                name,
+                status: "fail",
+                detail: folder.reason,
+                remedy: `Run \`${row.connectCommand}\` in the folder it should work in.`,
+            };
+        }
+        // EXISTENCE only, and only for an agent whose credential BayChat can see at all (the row
+        // says): the key is the agent's; BayChat never opens the file that holds it, and never logs it.
+        const keySeen = row.credentialSeen?.(env.homedir ?? os.homedir()) ?? true;
+        const line = `${row.label} ${bin.version} · ${t.acp.cwd} · mode ${t.acp.mode} (ceiling ${folder.maxMode})` +
+            (row.safetyNote ? ` — ${row.safetyNote}` : "");
+        if (!keySeen) {
+            return {
+                name,
+                status: "warn",
+                detail: `${line} — no ${row.label} key found`,
+                remedy: row.keyHint,
+            };
+        }
+        // R20: a substring check lets a later release ("0.1.5-rc.20") pass silently as the tested
+        // one ("0.1.5-rc.2"). `matchesTestedVersion` bounds the match to a whole version token.
+        if (!(0, agents_1.matchesTestedVersion)(bin.version, row.testedVersion)) {
+            return {
+                name,
+                status: "warn",
+                detail: `${line} — BayChat was tested with ${row.testedVersion}`,
+                remedy: "If it misbehaves, install the tested version or update baychat.",
+            };
+        }
+        return { name, status: "pass", detail: line };
+    });
+}
 /**
  * The process exit code for a report.
  *
@@ -198,6 +280,8 @@ function renderReport(report) {
         for (const check of rest)
             lines.push(...renderGroupCheck("", check));
     }
+    for (const check of report.agents)
+        lines.push(...renderSummaryCheck(check));
     lines.push(...renderSummaryCheck(report.pending));
     return lines;
 }
@@ -513,7 +597,15 @@ function withRemedy(line, check) {
     return [line, `${" ".repeat(LABEL_WIDTH + 2 + CHECK_WIDTH)}→ ${check.remedy}`];
 }
 function allChecks(report) {
-    return [report.credentials, report.staleCredentials, report.relay, report.mailbox, ...report.runtimes.flatMap((r) => r.checks), report.pending];
+    return [
+        report.credentials,
+        report.staleCredentials,
+        report.relay,
+        report.mailbox,
+        ...report.runtimes.flatMap((r) => r.checks),
+        ...report.agents,
+        report.pending,
+    ];
 }
 /** Shorten a path under the user's home, which is where nearly all of these are. */
 function display(filePath, env) {