baychat 0.40.0 → 0.41.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "baychat",
-  "version": "0.40.0",
+  "version": "0.41.0",
   "displayName": "BayChat",
   "description": "Wakes this Claude Code session the moment a BayChat message arrives: no Monitor, no 30-minute deadline. Uses the baychat CLI already on this computer (npm install -g baychat, then baychat login).",
   "author": {

package/README.md

@@ -918,6 +918,10 @@ instruction):
 | `get_note` | Read one note in full (and the version to edit from) |
 | `create_note` | Write a note for the project or the chat; it lands on the shelf (people pin) |
 | `update_note` | Edit a note from the version you read; if someone saved since, nothing is overwritten and you get theirs to merge |
+| `list_board_cards` | The to-dos on the boards of the chat's project, by column, with the board's table fields and each to-do's values; `mine` marks the ones you may move or edit |
+| `add_board_card` | Add a to-do: yours by default (claim the work you are doing); one for a person or nobody is only a suggestion until a person accepts it |
+| `move_board_card` | Move one of your to-dos to another column (Doing, Done, Blocked) |
+| `update_board_card` | Edit the title, notes, dates or table values of one of your to-dos (money in integer cents) |
 | `get_conversation_summary` | The rolling catch-up summary (decisions, tasks, questions, facts + source ids) |
 | `get_messages` | Recent messages enriched with sender, mentions, and `shouldRespond` |
 | `send_message` | Send a message into a conversation |

package/dist/launch/claude-trust.js

@@ -176,7 +176,9 @@ function trustProblemText(reason, file) {
 }
 /**
  * Set `projects[folder].hasTrustDialogAccepted = true` and nothing else. `folder` should be the
- * realpath (the spot's stored path). Called ONLY from `baychat launch add` after a person said y.
+ * realpath (the spot's stored path). Called from `baychat launch add` after a person said y, and from
+ * the relay for the owner's "Allow… in this folder" on their phone — only for a folder that person
+ * opened to it (`phoneMayAllow`, relay/launcher/spot-request.ts).
  */
 function trustFolder(folder, file = claudeConfigPath()) {
     // Write through a symlinked ~/.claude.json (dotfile managers) instead of replacing the link.

package/dist/launch/codex-trust.js

@@ -0,0 +1,177 @@
+"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.codexConfigPath = void 0;
+exports.isCodexFolderTrusted = isCodexFolderTrusted;
+exports.codexTrustProblemText = codexTrustProblemText;
+exports.trustCodexFolder = trustCodexFolder;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const codex_launch_1 = require("../relay/launcher/codex-launch");
+Object.defineProperty(exports, "codexConfigPath", { enumerable: true, get: function () { return codex_launch_1.codexConfigPath; } });
+function read(file) {
+    try {
+        return { ok: true, raw: fs.readFileSync(file, "utf8") };
+    }
+    catch (err) {
+        return { ok: false, reason: err.code === "ENOENT" ? "CONFIG_MISSING" : "CONFIG_UNREADABLE" };
+    }
+}
+/** Read-only, by the relay's own rule: the folder's own table says trusted. */
+function isCodexFolderTrusted(folder, file = (0, codex_launch_1.codexConfigPath)()) {
+    const r = read(file);
+    if (!r.ok)
+        return false;
+    // codexLaunchProblem also wants the MCP entry; ask it only about trust by handing it a config that has one.
+    const withEntry = `[mcp_servers.baychat]\n${r.raw}`;
+    return (0, codex_launch_1.codexLaunchProblem)(folder, () => withEntry) === undefined;
+}
+/** A sentence for each problem, for the person at the terminal. */
+function codexTrustProblemText(reason, file) {
+    switch (reason) {
+        case "CONFIG_MISSING":
+            return `${file} does not exist yet (Codex has not run on this computer).`;
+        case "CONFIG_UNREADABLE":
+            return `${file} could not be read.`;
+        case "PATH_UNSAFE":
+            return "the folder's name has a line break, or both a quote and a backslash, which BayChat will not write into Codex's config.";
+        case "CONFIG_UNKNOWN_FORM":
+            return `${file} already names this folder in a form BayChat does not edit, so it was left alone. Set the trust in Codex itself.`;
+        case "CONFIG_CHANGING":
+            return `${file} kept changing while BayChat tried to write it (is Codex busy?).`;
+        case "WRITE_FAILED":
+            return `${file} could not be written.`;
+    }
+}
+/** The folder as a TOML key: a basic string, else a literal string, else null (neither can hold it). */
+function tomlKey(folder) {
+    if (/[\n\r]/.test(folder))
+        return null;
+    if (!/["\\]/.test(folder))
+        return `"${folder}"`;
+    if (!folder.includes("'"))
+        return `'${folder}'`;
+    return null;
+}
+/**
+ * The config with `folder` trusted: its table's level set in place, or one table appended — or null when the
+ * folder is already a key in some other form, where an appended table would be a duplicate key.
+ */
+function withTrust(raw, folder) {
+    const header = new RegExp(`^[ \\t]*\\[projects\\.${(0, codex_launch_1.codexProjectKeyRe)(folder)}\\][ \\t]*$`, "m");
+    const found = header.exec(raw);
+    if (found) {
+        const start = found.index + found[0].length;
+        const next = raw.slice(start).search(/^[ \t]*\[/m);
+        const end = next === -1 ? raw.length : start + next;
+        const body = raw.slice(start, end);
+        const level = /^([ \t]*trust_level[ \t]*=[ \t]*)("[^"\n]*"|'[^'\n]*')/m;
+        const nextBody = level.test(body) ? body.replace(level, '$1"trusted"') : `\ntrust_level = "trusted"${body}`;
+        return raw.slice(0, start) + nextBody + raw.slice(end);
+    }
+    const otherForm = new RegExp(`${(0, codex_launch_1.codexProjectKeyRe)(folder)}\\s*(?:=|\\.)`);
+    if (otherForm.test(raw))
+        return null;
+    const sep = raw === "" || raw.endsWith("\n") ? "" : "\n";
+    return `${raw}${sep}\n[projects.${tomlKey(folder)}]\ntrust_level = "trusted"\n`;
+}
+/**
+ * Trust `folder` (the spot's stored realpath) for Codex. Called from `baychat launch add` after a person at this
+ * computer said y, and from the relay for the owner's "Allow… in this folder" on their phone — only for a folder
+ * that person opened to it (`phoneMayAllow`, relay/launcher/spot-request.ts).
+ */
+function trustCodexFolder(folder, file = (0, codex_launch_1.codexConfigPath)()) {
+    if (tomlKey(folder) === null)
+        return { ok: false, reason: "PATH_UNSAFE" };
+    // Write through a symlinked config (dotfile managers) instead of replacing the link.
+    let target = file;
+    try {
+        target = fs.realpathSync(file);
+    }
+    catch {
+        // Missing: read() reports it below.
+    }
+    for (let attempt = 0; attempt < 3; attempt++) {
+        const r = read(target);
+        // A fresh Codex install has its folder but no config.toml yet (vps, 4 Nov): create it holding only this
+        // table, 0600, and only if nothing appeared there meanwhile (`wx`). No folder: Codex has not run here.
+        if (!r.ok && r.reason === "CONFIG_MISSING" && fs.existsSync(path.dirname(target))) {
+            try {
+                fs.writeFileSync(target, (withTrust("", folder) ?? "").replace(/^\n/, ""), { mode: 0o600, flag: "wx" });
+                fs.chmodSync(target, 0o600); // writeFile's mode is masked by the umask
+                return { ok: true, changed: true };
+            }
+            catch (err) {
+                if (err.code === "EEXIST")
+                    continue; // Codex wrote it first: start over.
+                return { ok: false, reason: "WRITE_FAILED" };
+            }
+        }
+        if (!r.ok)
+            return r;
+        if (isCodexFolderTrusted(folder, target))
+            return { ok: true, changed: false };
+        const text = withTrust(r.raw, folder);
+        if (text === null)
+            return { ok: false, reason: "CONFIG_UNKNOWN_FORM" };
+        let mode;
+        try {
+            mode = fs.statSync(target).mode & 0o777;
+            const bak = `${target}.bak`;
+            fs.copyFileSync(target, bak);
+            fs.chmodSync(bak, mode);
+        }
+        catch {
+            return { ok: false, reason: "WRITE_FAILED" };
+        }
+        const tmp = path.join(path.dirname(target), `.${path.basename(target)}.baychat-${process.pid}-${Date.now()}.tmp`);
+        try {
+            fs.writeFileSync(tmp, text, { mode });
+            fs.chmodSync(tmp, mode); // writeFile's mode is masked by the umask
+            // If Codex rewrote it since we read it, start over rather than rename our older copy over its newer one.
+            if (fs.readFileSync(target, "utf8") !== r.raw) {
+                fs.rmSync(tmp, { force: true });
+                continue;
+            }
+            fs.renameSync(tmp, target);
+            return { ok: true, changed: true };
+        }
+        catch {
+            fs.rmSync(tmp, { force: true });
+            return { ok: false, reason: "WRITE_FAILED" };
+        }
+    }
+    return { ok: false, reason: "CONFIG_CHANGING" };
+}

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/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

@@ -42,6 +42,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";
@@ -499,6 +500,8 @@ const CONVERSATION_HANDLERS = {
     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