baychat 0.40.0 → 0.41.1

package/dist/launch/command.js

@@ -33,18 +33,22 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.trustByHand = exports.CODEX_UNATTENDED_NOTICE = exports.AGENT_STARTS_NOTICE = exports.APPROVALS_NOTICE = exports.LAUNCH_USAGE = void 0;
+exports.trustByHand = exports.codexTrustByHand = exports.CODEX_UNATTENDED_NOTICE = exports.PHONE_ALLOW_NOTICE = exports.AGENT_STARTS_NOTICE = exports.APPROVALS_NOTICE = exports.LAUNCH_USAGE = void 0;
 exports.cmdLaunch = cmdLaunch;
 const path = __importStar(require("path"));
 const args_1 = require("../args");
 const multiplexer_launch_1 = require("../multiplexer-launch");
 const policy_1 = require("../relay/acp/policy");
 const claude_trust_1 = require("./claude-trust");
+const codex_trust_1 = require("./codex-trust");
+const capabilities_1 = require("../relay/launcher/capabilities");
+const runtime_binary_1 = require("../runtime-binary");
 const policy_2 = require("./policy");
-exports.LAUNCH_USAGE = `Usage: baychat launch add <folder> [--label <label>] [--runtime claude,codex] [--max <n>] [--unattended] [--agent-starts]
+exports.LAUNCH_USAGE = `Usage: baychat launch add <folder> [--label <label>] [--runtime claude,codex] [--max <n>] [--unattended] [--agent-starts] [--phone-may-allow | --no-phone-allow]
                                   Let BayChat start sessions in <folder> from the app
                                   (--unattended: also let it start Codex there, which then never asks)
                                   (--agent-starts: agents you allowed "Always" may start sessions there without asking you each time)
+                                  (--phone-may-allow: you may allow Claude Code or Codex there later from your phone)
        baychat launch list         The folders BayChat may start sessions in
        baychat launch remove <id>  Stop offering one of them`;
 /** Printed by every `add`: the one thing a person must know before saying yes. */
@@ -53,6 +57,9 @@ exports.APPROVALS_NOTICE = "Claude Code sessions started here from BayChat ask f
 exports.AGENT_STARTS_NOTICE = "Agents you allowed with \"Always for this agent here\" on their card may start sessions here without asking you each time — " +
     "only for this folder, computer and runtime, for 30 days, and only with no task or one of your own messages as the task: a task an agent or anyone else writes still asks. " +
     "Those sessions ask for approvals in BayChat like any other; they never start Codex unattended. Revoke an agent in Settings → Devices.";
+/** Printed when a folder is opened to the phone: what the owner may then do from it, and what never. */
+exports.PHONE_ALLOW_NOTICE = "From your phone you can then allow Claude Code or Codex in this folder (and trust it for them), one at a time — after your code or passkey if your account has one. " +
+    "It never adds a folder or changes anything else here. `baychat launch add <folder> --no-phone-allow` turns it off.";
 /** Printed when Codex is offered: what it may do without asking, and what it asks on the phone. */
 exports.CODEX_UNATTENDED_NOTICE = "Codex started here from BayChat is run by the relay (Codex 0.160 or newer): it can change files in this folder without asking, with no network, " +
     "and asks for approval in BayChat — on the session owner's phone — before anything more (a command outside its sandbox, network access, files elsewhere). " +
@@ -61,10 +68,13 @@ exports.CODEX_UNATTENDED_NOTICE = "Codex started here from BayChat is run by the
     "MCP servers in its own config run as usual.";
 const realDeps = () => {
     const file = (0, claude_trust_1.claudeConfigPath)();
+    const codexFile = (0, codex_trust_1.codexConfigPath)();
     return {
         print: (line) => console.log(line),
         policyFile: (0, policy_2.launchPolicyPath)(),
         trust: { isTrusted: (folder) => (0, claude_trust_1.isFolderTrusted)(folder, file), trust: (folder) => (0, claude_trust_1.trustFolder)(folder, file), file },
+        codexTrust: { isTrusted: (folder) => (0, codex_trust_1.isCodexFolderTrusted)(folder, codexFile), trust: (folder) => (0, codex_trust_1.trustCodexFolder)(folder, codexFile), file: codexFile },
+        foundRuntimes: () => policy_2.LAUNCH_RUNTIMES.filter((r) => (0, runtime_binary_1.resolveRuntimeBinary)(capabilities_1.RUNTIME_BINARY[r], (0, runtime_binary_1.currentBinaryEnv)()).ok),
         interactive: !!process.stdin.isTTY && !!process.stdout.isTTY,
         ask: multiplexer_launch_1.askLine,
     };
@@ -93,8 +103,9 @@ async function addSpot(args, deps) {
     const label = (0, args_1.flag)(args, "--label");
     const runtimeList = (0, args_1.flag)(args, "--runtime");
     const maxRaw = (0, args_1.flag)(args, "--max");
-    const unattended = args.includes("--unattended");
+    let unattended = args.includes("--unattended");
     const agentStarts = args.includes("--agent-starts");
+    const phoneFlag = args.includes("--phone-may-allow") ? true : args.includes("--no-phone-allow") ? false : undefined;
     const valued = new Set([label, runtimeList, maxRaw].filter((v) => v !== undefined));
     const folderArg = args.find((a) => !a.startsWith("--") && !valued.has(a));
     if (unattended && !(runtimeList ?? "").split(",").map((r) => r.trim()).includes("codex")) {
@@ -113,7 +124,13 @@ async function addSpot(args, deps) {
         deps.print(`A label is 1-${policy_2.SPOT_LABEL_MAX} characters.`);
         return 1;
     }
-    const requested = (runtimeList ?? "claude").split(",").map((r) => r.trim()).filter(Boolean);
+    const requested = runtimeList !== undefined ? runtimeList.split(",").map((r) => r.trim()).filter(Boolean) : await defaultRuntimes(deps);
+    if (runtimeList === undefined && requested.includes("codex") && !unattended) {
+        if (await allowCodexUnattended(deps))
+            unattended = true;
+        else
+            requested.splice(requested.indexOf("codex"), 1);
+    }
     const unknown = requested.filter((r) => !(0, policy_2.isLaunchRuntime)(r));
     if (requested.length === 0 || unknown.length > 0) {
         deps.print(`Unknown runtime ${unknown.join(", ") || "(none given)"}. Choose from: ${policy_2.LAUNCH_RUNTIMES.join(", ")}.`);
@@ -126,6 +143,8 @@ async function addSpot(args, deps) {
     }
     const policy = (0, policy_2.loadLaunchPolicy)(deps.policyFile);
     const existing = policy?.spots.find((s) => s.path === folder.path);
+    // Without a flag or a terminal, a folder added again keeps what it said; a new one stays closed.
+    const keptPhone = phoneFlag ?? (deps.interactive ? undefined : existing?.phoneMayAllow === true);
     const spot = {
         id: existing?.id ?? (0, policy_2.suggestSpotId)(policy, folder.path),
         label: spotLabel,
@@ -134,6 +153,8 @@ async function addSpot(args, deps) {
         maxSessions,
         ...(unattended ? { unattendedCodex: true } : {}),
         ...(agentStarts ? { agentStarts: true } : {}),
+        ...(keptPhone ? { phoneMayAllow: true } : {}),
+        ...(keptPhone && existing?.phoneAllowedAt ? { phoneAllowedAt: existing.phoneAllowedAt } : {}),
     };
     (0, policy_2.saveLaunchPolicy)((0, policy_2.upsertSpot)(policy, spot), deps.policyFile);
     deps.print(`${existing ? "Updated" : "Added"} "${spot.label}" (${spot.id}): ${spot.path}`);
@@ -148,8 +169,82 @@ async function addSpot(args, deps) {
     }
     if (spot.runtimes.includes("claude"))
         await offerClaudeTrust(spot.path, deps);
+    if (spot.runtimes.includes("codex") && spot.unattendedCodex)
+        await offerCodexTrust(spot.path, deps);
+    if (keptPhone === undefined) {
+        // Asked last, once, at a terminal only — Enter is yes (Karmen, 4 Nov: (a), asked once at setup).
+        const answer = await deps.ask("Let you allow more agents in this folder from your phone later? (Y/n) ");
+        if (!/^\s*n(o)?\s*$/i.test(answer)) {
+            const opened = { ...spot, phoneMayAllow: true, ...(existing?.phoneAllowedAt ? { phoneAllowedAt: existing.phoneAllowedAt } : {}) };
+            (0, policy_2.saveLaunchPolicy)((0, policy_2.upsertSpot)((0, policy_2.loadLaunchPolicy)(deps.policyFile), opened), deps.policyFile);
+            deps.print(`  ${exports.PHONE_ALLOW_NOTICE}`);
+        }
+    }
+    else if (keptPhone) {
+        deps.print(`  ${exports.PHONE_ALLOW_NOTICE}`);
+    }
+    else if (phoneFlag === undefined) {
+        deps.print("  To allow more agents here later from your phone, add --phone-may-allow.");
+    }
     return 0;
 }
+/** The runtimes' names a person reads, for the questions below. */
+const RUNTIME_NAMES = { claude: "Claude Code", codex: "Codex", dsh: "DeepSeek Harness", "cursor-cli": "Cursor CLI" };
+/**
+ * `add` without --runtime (Karmen, 4 Nov: "when we launch baychat every agent works"): every runtime found here,
+ * asked once at a terminal — Enter for all, or a list. Nothing found: Claude Code, as before.
+ */
+async function defaultRuntimes(deps) {
+    const found = deps.foundRuntimes();
+    if (found.length === 0)
+        return ["claude"];
+    if (!deps.interactive || found.length === 1)
+        return [...found];
+    const answer = await deps.ask(`Found here: ${found.map((r) => RUNTIME_NAMES[r]).join(", ")}. Allow these in this folder? [Enter = all, or a list like ${found.join(",")}] `);
+    const picked = answer.split(",").map((r) => r.trim()).filter(Boolean);
+    return picked.length > 0 ? picked : [...found];
+}
+/**
+ * Codex runs here unattended (it never stops to ask), so it is never part of a default without its own y.
+ * Without a terminal it is left out, and the person is told the one line that adds it.
+ */
+async function allowCodexUnattended(deps) {
+    if (!deps.interactive) {
+        const all = deps.foundRuntimes().join(",");
+        deps.print(`Codex is installed here but was left out: it runs without asking. To allow it, run baychat launch add <folder> --runtime ${all} --unattended`);
+        return false;
+    }
+    deps.print(`  ${exports.CODEX_UNATTENDED_NOTICE}`);
+    const answer = await deps.ask("Allow Codex in this folder too, on those terms? (y/N) ");
+    return /^\s*y(es)?\s*$/i.test(answer);
+}
+/** How to trust a folder for Codex by hand: what Codex itself asks on its first start there. */
+const codexTrustByHand = (folder) => `run \`codex\` in ${folder} once and answer that you trust it.`;
+exports.codexTrustByHand = codexTrustByHand;
+/**
+ * Codex's twin of `offerClaudeTrust`: a Codex started from the phone in a folder it has not trusted is refused
+ * (FOLDER_NOT_TRUSTED), so `add` offers it here, to the person at this computer, after they typed y.
+ */
+async function offerCodexTrust(folder, deps) {
+    if (deps.codexTrust.isTrusted(folder))
+        return;
+    deps.print("Codex hasn't trusted this folder yet, so it can't be started here from BayChat.");
+    if (!deps.interactive) {
+        deps.print(`To fix that, ${(0, exports.codexTrustByHand)(folder)}`);
+        return;
+    }
+    const answer = await deps.ask("Trust this folder for Codex now? (y/N) ");
+    if (!/^\s*y(es)?\s*$/i.test(answer)) {
+        deps.print(`Not trusted. Codex can't start here from BayChat until you ${(0, exports.codexTrustByHand)(folder)}`);
+        return;
+    }
+    const result = deps.codexTrust.trust(folder);
+    if (result.ok) {
+        deps.print(`Trusted. Codex will start in ${folder} (a copy of its old config, if it had one, is in ${deps.codexTrust.file}.bak).`);
+        return;
+    }
+    deps.print(`Couldn't record it: ${(0, codex_trust_1.codexTrustProblemText)(result.reason, deps.codexTrust.file)} Instead, ${(0, exports.codexTrustByHand)(folder)}`);
+}
 /** How to trust a folder by hand: the one answer Claude Code itself accepts. */
 const trustByHand = (folder) => `run \`claude\` in ${folder} once and choose "Yes, I trust this folder".`;
 exports.trustByHand = trustByHand;
@@ -186,7 +281,12 @@ function listSpots(deps) {
         return 0;
     }
     for (const s of policy.spots) {
-        const flags = [s.unattendedCodex ? "unattended Codex" : "", s.agentStarts ? "agent starts" : ""].filter(Boolean);
+        const flags = [
+            s.unattendedCodex ? "unattended Codex" : "",
+            s.agentStarts ? "agent starts" : "",
+            s.phoneMayAllow ? "phone may allow" : "",
+            s.phoneAllowedAt ? `allowed from phone ${new Date(s.phoneAllowedAt).toLocaleDateString("en-GB", { day: "numeric", month: "short", timeZone: "UTC" })}` : "",
+        ].filter(Boolean);
         deps.print(`${s.id}  "${s.label}"  ${s.path}  [${s.runtimes.join(", ")}] max ${s.maxSessions}${flags.length ? `  (${flags.join(", ")})` : ""}`);
     }
     return 0;

package/dist/launch/policy.js

@@ -50,8 +50,10 @@ const policy_1 = require("../relay/acp/policy");
  * Where BayChat may START sessions on this computer: `~/.baychat/launch-policy.json` (0600).
  *
  * ── WHAT MAKES THIS A BOUNDARY ────────────────────────────────────────────────────────
- * Nothing that arrives over the network writes this file. Only `baychat launch add|remove`, run
- * by a person at this machine, changes it. The relay advertises its spots by LABEL only and
+ * Only `baychat launch add|remove`, run by a person at this machine, changes it — with ONE narrow
+ * exception that person switches on per folder: `phoneMayAllow` lets the computer's owner add one
+ * runtime to that existing folder from their phone (relay/launcher/spot-request.ts, which re-checks
+ * everything here first). Nothing over the network ever adds a folder. The relay advertises its spots by LABEL only and
  * re-reads this file for every launch, so a deleted spot stops launches at once. Invalid is
  * treated as absent: a file we cannot read offers nothing — it never means "allow everything".
  *
@@ -136,7 +138,7 @@ function resolveSpotFolder(spot) {
 function parseSpot(entry) {
     if (!entry || typeof entry !== "object")
         return null;
-    const { id, label, path: p, runtimes, maxSessions, unattendedCodex, agentStarts } = entry;
+    const { id, label, path: p, runtimes, maxSessions, unattendedCodex, agentStarts, phoneMayAllow, phoneAllowedAt } = entry;
     if (typeof id !== "string" || !exports.SPOT_ID_RE.test(id))
         return null;
     if (typeof label !== "string" || label.trim().length === 0 || label.length > exports.SPOT_LABEL_MAX)
@@ -152,6 +154,10 @@ function parseSpot(entry) {
         return null;
     if (agentStarts !== undefined && agentStarts !== true)
         return null;
+    if (phoneMayAllow !== undefined && phoneMayAllow !== true)
+        return null;
+    if (phoneAllowedAt !== undefined && (typeof phoneAllowedAt !== "string" || Number.isNaN(Date.parse(phoneAllowedAt))))
+        return null;
     return {
         id,
         label,
@@ -160,5 +166,7 @@ function parseSpot(entry) {
         maxSessions,
         ...(unattendedCodex ? { unattendedCodex } : {}),
         ...(agentStarts ? { agentStarts } : {}),
+        ...(phoneMayAllow ? { phoneMayAllow } : {}),
+        ...(typeof phoneAllowedAt === "string" ? { phoneAllowedAt } : {}),
     };
 }

package/dist/main.js

@@ -11,6 +11,7 @@ const notify_hook_1 = require("./notify-hook");
 const notify_answer_1 = require("./notify-answer");
 const session_name_1 = require("./session-name");
 const start_command_1 = require("./start-command");
+const attach_command_1 = require("./attach-command");
 const setup_command_1 = require("./setup-command");
 const update_command_1 = require("./update-command");
 const notice_1 = require("./auto-update/notice");
@@ -87,6 +88,9 @@ async function main() {
             return (0, session_command_1.cmdJoinSession)(args);
         case "start":
             return (0, start_command_1.cmdStart)(args);
+        case "attach":
+            (0, args_1.rejectUnknownFlags)(args, [], "baychat attach [name]");
+            return (0, attach_command_1.cmdAttach)(args);
         case "setup":
             // Look again and set up what is new (an app installed since); starts nothing.
             (0, args_1.rejectUnknownFlags)(args, [], "baychat setup");

package/dist/mcp-board-cards.js

@@ -0,0 +1,115 @@
+"use strict";
+// The board to-do tools of the local stdio MCP server (protocol v2.17): `list_board_cards`,
+// `add_board_card`, `move_board_card`, `update_board_card`. Defined in `tool-defs.ts` (shared with
+// the remote endpoint); each handler here is one agent-API call, rendered for a model to read.
+//
+// A to-do's title and notes are text people and other agents wrote: shown on one line and
+// cleaned like message content, never as structure.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BOARD_CARD_HANDLERS = void 0;
+exports.renderValue = renderValue;
+exports.renderCard = renderCard;
+exports.renderBoards = renderBoards;
+exports.handleListBoardCards = handleListBoardCards;
+exports.handleAddBoardCard = handleAddBoardCard;
+exports.handleMoveBoardCard = handleMoveBoardCard;
+exports.handleUpdateBoardCard = handleUpdateBoardCard;
+const api_1 = require("./api");
+const mcp_result_1 = require("./mcp-result");
+const terminal_text_1 = require("./relay/terminal-text");
+function oneLine(text) {
+    return (0, terminal_text_1.cleanTerminalText)(text).replace(/\s+/g, " ").trim();
+}
+/** A cell as a model reads it: money from cents with its currency, a choice by its label. */
+function renderValue(field, value) {
+    if (field.type === "money" && typeof value === "number")
+        return `${(value / 100).toFixed(2)} ${field.options?.currency ?? "EUR"}`;
+    if (field.type === "select")
+        return oneLine(field.options?.choices?.find((c) => c.id === value)?.label ?? String(value));
+    return oneLine(String(value));
+}
+/** `- "Title" [id] — Ada, due 2026-11-09, suggestion, yours; Amount 12.50 EUR` */
+function renderCard(card, fields = []) {
+    const parts = [
+        card.assignee ? oneLine(card.assignee.name) || card.assignee.kind : "nobody",
+        ...(card.dueAt ? [`due ${card.dueAt.slice(0, 10)}`] : []),
+        ...(card.suggestion ? ["suggestion"] : []),
+        ...(card.mine ? ["yours"] : []),
+    ];
+    const cells = fields.flatMap((f) => (card.values && f.id in card.values ? [`${oneLine(f.name)} ${renderValue(f, card.values[f.id])}`] : []));
+    return `- "${oneLine(card.title)}" [${card.id}] — ${parts.join(", ")}${cells.length ? `; ${cells.join(", ")}` : ""}`;
+}
+/** Each board, each column with its to-dos under it. */
+function renderBoards(boards) {
+    if (boards.length === 0)
+        return "This project has no boards yet.";
+    return boards
+        .map((board) => {
+        const columns = board.columns.map((column) => {
+            const cards = board.cards.filter((c) => c.columnId === column.id);
+            const head = `  ${oneLine(column.name)} (${column.role}) [${column.id}]`;
+            return cards.length === 0 ? `${head}: empty` : `${head}:\n${cards.map((c) => `    ${renderCard(c, board.fields)}`).join("\n")}`;
+        });
+        const more = board.truncated ? "\n  (more to-dos than shown)" : "";
+        const fields = board.fields?.length
+            ? `\n  Fields: ${board.fields.map((f) => `${oneLine(f.name)} (${f.type}${f.type === "money" ? `, ${f.options?.currency ?? "EUR"}, cents` : ""}) [${f.id}]`).join(", ")}`
+            : "";
+        return `Board "${oneLine(board.name)}" [${board.id}]${fields}\n${columns.join("\n")}${more}`;
+    })
+        .join("\n\n");
+}
+/** A refusal the model can act on: the code and the reason. */
+function cardError(err) {
+    if (err instanceof api_1.ApiError && err.code && /^(CARD_|INVALID_CARD|ASSIGNEE_|BOARD_|COLUMN_|PROJECT_NOT_FOUND)/.test(err.code)) {
+        return (0, mcp_result_1.fail)(`${err.code}: ${err.message}`);
+    }
+    return (0, mcp_result_1.toToolError)(err);
+}
+const base = (conversationId) => `/api/agent-api/conversations/${encodeURIComponent(conversationId)}/board-cards`;
+async function handleListBoardCards(args) {
+    try {
+        const qs = args.boardId ? `?boardId=${encodeURIComponent(args.boardId)}` : "";
+        const res = await (0, api_1.apiRequest)((0, mcp_result_1.requireCredentials)(), "GET", `${base(args.conversationId)}${qs}`);
+        return (0, mcp_result_1.ok)(renderBoards(res.boards ?? []), res);
+    }
+    catch (err) {
+        return cardError(err);
+    }
+}
+async function handleAddBoardCard(args) {
+    try {
+        const { conversationId, ...body } = args;
+        const res = await (0, api_1.apiRequest)((0, mcp_result_1.requireCredentials)(), "POST", base(conversationId), body);
+        const what = res.card.suggestion ? "Suggested" : "Added";
+        return (0, mcp_result_1.ok)(`${what} "${oneLine(res.card.title)}" [${res.card.id}].`, res);
+    }
+    catch (err) {
+        return cardError(err);
+    }
+}
+async function handleMoveBoardCard(args) {
+    try {
+        const res = await (0, api_1.apiRequest)((0, mcp_result_1.requireCredentials)(), "POST", `${base(args.conversationId)}/${encodeURIComponent(args.cardId)}/move`, { ...(args.column ? { column: args.column } : {}), ...(args.columnId ? { columnId: args.columnId } : {}) });
+        return (0, mcp_result_1.ok)(`Moved "${oneLine(res.card.title)}" [${res.card.id}].`, res);
+    }
+    catch (err) {
+        return cardError(err);
+    }
+}
+async function handleUpdateBoardCard(args) {
+    try {
+        const { conversationId, cardId, ...body } = args;
+        const res = await (0, api_1.apiRequest)((0, mcp_result_1.requireCredentials)(), "PATCH", `${base(conversationId)}/${encodeURIComponent(cardId)}`, body);
+        return (0, mcp_result_1.ok)(`Saved "${oneLine(res.card.title)}" [${res.card.id}].`, res);
+    }
+    catch (err) {
+        return cardError(err);
+    }
+}
+/** Handler per board to-do tool name, registered with the conversation tools (mcp.ts). */
+exports.BOARD_CARD_HANDLERS = {
+    list_board_cards: (args) => handleListBoardCards(args),
+    add_board_card: (args) => handleAddBoardCard(args),
+    move_board_card: (args) => handleMoveBoardCard(args),
+    update_board_card: (args) => handleUpdateBoardCard(args),
+};

package/dist/mcp.js

@@ -22,6 +22,7 @@ exports.handleGetMessages = handleGetMessages;
 exports.handleSendMessage = handleSendMessage;
 exports.handleSetTyping = handleSetTyping;
 exports.handleCreatePoll = handleCreatePoll;
+exports.handleClosePoll = handleClosePoll;
 exports.handleVoteInPoll = handleVoteInPoll;
 exports.handleReactToMessage = handleReactToMessage;
 exports.fileSourceSuffix = fileSourceSuffix;
@@ -42,6 +43,7 @@ const project_brief_1 = require("./relay/project-brief");
 const project_notes_1 = require("./relay/project-notes");
 const context_notice_1 = require("./relay/context-notice");
 const mcp_notes_1 = require("./mcp-notes");
+const mcp_board_cards_1 = require("./mcp-board-cards");
 /** The features this server asks the context reads for: it shows the project brief, the notes
  * delta and BayChat's 90% memory notice (protocol v1.17), so it may be handed them. */
 const BRIEF_FEATURE = "brief,notes,notice";
@@ -302,6 +304,25 @@ async function handleCreatePoll(args) {
         return (0, mcp_result_1.toToolError)(err);
     }
 }
+/**
+ * POST /polls/:id/close — close a poll this session asked (or, seated ADMIN in its own Bay's room,
+ * any poll there; never through a visit). It keeps its result and takes no more votes. The answer
+ * names the final tally in words, as `vote_in_poll` does.
+ */
+async function handleClosePoll(args) {
+    try {
+        const creds = (0, mcp_result_1.requireCredentials)();
+        await (0, api_1.apiRequest)(creds, "POST", `/api/agent-api/polls/${args.pollId}/close`);
+        const view = await (0, api_1.apiRequest)(creds, "GET", `/api/agent-api/polls/${args.pollId}`);
+        const tally = view.options
+            .map((label, i) => `${label}: ${view.poll.options.find((o) => o.index === i)?.count ?? 0}`)
+            .join(", ");
+        return (0, mcp_result_1.ok)(`Poll closed. Final tally — ${tally}.`, { pollId: args.pollId, poll: view.poll });
+    }
+    catch (err) {
+        return (0, mcp_result_1.toToolError)(err);
+    }
+}
 /**
  * POST /polls/:id/vote — this session's own vote.
  *
@@ -493,12 +514,15 @@ const CONVERSATION_HANDLERS = {
     send_message: (args) => handleSendMessage(args),
     create_poll: (args) => handleCreatePoll(args),
     vote_in_poll: (args) => handleVoteInPoll(args),
+    close_poll: (args) => handleClosePoll(args),
     set_typing: (args) => handleSetTyping(args),
     react_to_message: (args) => handleReactToMessage(args),
     list_files: (args) => handleListFiles(args),
     get_file: (args) => handleGetFile(args),
     // Notes (protocol v1.17, mcp-notes.ts).
     ...mcp_notes_1.NOTE_HANDLERS,
+    // Board to-dos (protocol v2.17, mcp-board-cards.ts).
+    ...mcp_board_cards_1.BOARD_CARD_HANDLERS,
 };
 /**
  * The conversation definitions as the LOCAL server registers them: the shared

package/dist/multiplexer-launch.js

@@ -134,23 +134,19 @@ deps) {
         return multiplexer === "tmux" ? ["new", "-d", "-s", naming.name, "-c", naming.cwd, ...tmuxCommand(naming.name)] : ["-dmS", naming.name, ...commandWith({})];
     }
     if (!deps)
-        throw new Error("multiplexerArgv: a fresh or reattached session needs the launch deps");
+        throw new Error("multiplexerArgv: a fresh or named session needs the launch deps");
+    // Never `-A` (tmux) or `-R` (screen): both would resume an existing session instead of starting
+    // the agent that was asked for.
+    const base = naming.kind === "named" ? naming.name : `${naming.prefix}-${deps.pid}`;
     if (multiplexer === "tmux") {
-        if (naming.kind === "reattach") {
-            // `-A` attaches to an existing session of that name instead of failing, so running this
-            // twice returns you to your agent rather than erroring at you.
-            return ["new", "-A", "-s", naming.name, ...tmuxCommand(naming.name)];
-        }
-        const name = uniqueTmuxName(naming.prefix, deps);
+        const name = uniqueTmuxName(base, deps);
         return ["new", "-s", name, ...tmuxCommand(name)];
     }
-    const command = commandWith({});
-    // screen tells same-named sessions apart by pid, so a fresh one needs no uniqueness check.
-    return naming.kind === "reattach" ? ["-S", naming.name, "-R", ...command] : ["-S", `${naming.prefix}-${deps.pid}`, ...command];
+    // screen tells same-named sessions apart by pid, so a new one needs no uniqueness check.
+    return ["-S", base, ...commandWith({})];
 }
-/** `claude-<pid>`, or with a suffix when a tmux session of that name already exists. */
-function uniqueTmuxName(prefix, deps) {
-    const base = `${prefix}-${deps.pid}`;
+/** `base`, or `base-2`, `base-3`… when a tmux session of that name already exists. */
+function uniqueTmuxName(base, deps) {
     for (let n = 1; n < 100; n++) {
         const name = n === 1 ? base : `${base}-${n}`;
         if (!deps.tmuxHasSession(name))