dsh-composer-plus 1.17.0 → 1.18.0

package/index.js

@@ -65,14 +65,16 @@ export const SEND_FIRST_PATH = '/api/composer-plus.send-first';
 export const MEMORY_PATH = '/api/composer-plus.memory';
 export const MEMORY_EDIT_PATH = '/api/composer-plus.memory-edit';
 export const PROTECTED_PATH = '/api/composer-plus.protected-files';
+export const BLOCKED_PATH = '/api/composer-plus.blocked-commands';
 export const HANDOFF_PATH = '/api/composer-plus.handoff';
 export const CONTEXT_PATH = '/api/composer-plus.context';
+export const PLANNED_PATH = '/api/composer-plus.planned-steps';
 /** Tether's green dots: at most this many unread chat ids are kept (the oldest goes first). */
 export const UNREAD_MAX = 1000;
 /** Feature screenshots shipped in assets/features/<id>.webp; only these ids are served (no path input). */
 export const SHOTS = ['changesPanel', 'featureIdeas', 'projectStatus', 'recentProjects', 'collapseProjects', 'statusOrder', 'notifications', 'idleSwitch', 'allowForChat', 'continueButton', 'resumeAfterRestart', 'inputHistory', 'planToggle', 'keepFocus', 'questionFit', 'headerFit',
   'queueReorder', 'mobileConnect', 'copyDeeplink', 'copyProjectPath', 'projectPicker', 'nextPrediction', 'typingCompletion', 'promptImprove', 'exportMarkdown', 'language', 'autoUpdate', 'contentSearch', 'turnRollback', 'deleteChat', 'projectName', 'markProjectRead', 'queueEdit', 'copyMessageLink', 'findInChat', 'sessionBranch', 'worktreeChats', 'branchTree', 'defaultWorkspace', 'goalCheck', 'projectMemory',
-  'backup', 'autoBackup', 'sessionDoctor', 'rescueConsole', 'stopSendFirst', 'protectedFiles', 'handoffChat', 'contextBreakdown'];
+  'backup', 'autoBackup', 'sessionDoctor', 'rescueConsole', 'stopSendFirst', 'protectedFiles', 'blockedCommands', 'handoffChat', 'contextBreakdown', 'taskBoard', 'plannedSteps'];
 const PACKAGE = JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf8'));
 const NPM_NAME = 'dsh-composer-plus';
 const RELEASES_URL = 'https://api.github.com/repos/furkancak1r/dsh-composer-plus/releases/latest';
@@ -2009,8 +2011,11 @@ export function apply(ctx) {
   installDefaultWorkspace(ctx, home);
   installMemory(ctx, home);
   installProtectedFiles(ctx, home);
+  installBlockedCommands(ctx, home);
   installHandoff(ctx, home);
   installContext(ctx);
+  installBoard(ctx, home);
+  installPlannedSteps(ctx, home);
   installBackup(ctx, home);
 }
 
@@ -4168,6 +4173,291 @@ export function installProtectedFiles(ctx, home, file = join(home, 'storages', '
   });
 }
 
+/* Blocked commands (after dsh-superagent's `blockedCommands`): the agent's shell tools (`bash`, `pwsh`) do not run a command
+ * that matches one of the user's rules ("block"), or they ask the user first with dsh's own approval card ("ask first").
+ * A `tools/pre-execute` gate, after every other gate. It reads the command text only: a variable (`$CMD`), an alias, a
+ * function, a script file, another interpreter (`python -c`) or an MCP tool can still run the command, which the README
+ * says. On by default with an empty list: it starts no work and opens no port; the Host keeps the switch and the list. */
+export const BLOCK_MAX = 50; // rules
+export const BLOCK_RULE_MAX = 200; // characters of one rule
+const BLOCK_DEPTH = 3; // `bash -c`, `eval` and here-document texts are read again, at most this deep
+const SHELL_NAMES = new Set(['sh', 'bash', 'zsh', 'dash', 'ksh', 'fish', 'su', 'pwsh', 'powershell']);
+const EVAL_NAMES = new Set(['eval', 'iex', 'invoke-expression']);
+/** `[{rule, mode: 'block'|'ask'}]` with single spaces; of two rules with the same words (any case) the first stays. Strict (a
+ * save): undefined when the list is not valid. Not strict (the saved file): the valid rules, at most BLOCK_MAX. */
+export function parseRules(list, strict = true) {
+  if (!Array.isArray(list) || (strict && list.length > BLOCK_MAX)) return undefined;
+  const out = [];
+  for (const r of list) {
+    const raw = r?.rule;
+    const ok = plainObject(r) && Object.keys(r).every((k) => k === 'rule' || k === 'mode') && (r.mode === 'block' || r.mode === 'ask')
+      && typeof raw === 'string' && raw.length <= BLOCK_RULE_MAX && !/[\0\r\n]/.test(raw) && raw.trim() !== '';
+    if (!ok) { if (strict) return undefined; continue; }
+    const rule = raw.trim().split(/\s+/).join(' ');
+    if (!out.some((o) => o.rule.toLowerCase() === rule.toLowerCase())) out.push({ rule, mode: r.mode });
+    if (out.length === BLOCK_MAX) break;
+  }
+  return out;
+}
+/** Saved settings `{on, rules}`: on with no rules when there is no file. */
+export const blockedStore = (file) => settingsStore(file, (v) => ({ on: v?.on !== false, rules: parseRules(v?.rules, false) ?? [] }));
+/** A command word as a name: its last path part, lower case, without `.exe`, `.cmd`, `.bat` or `.com`. */
+const commandName = (word) => word.slice(Math.max(word.lastIndexOf('/'), word.lastIndexOf('\\')) + 1).toLowerCase().replace(/\.(exe|cmd|bat|com)$/, '');
+/** `*` any characters (also `/`), `?` one; both texts in lower case. A `*` of the rule is checked first, so it also matches
+ * a `*` in the text (`rm *` matches `rm *.log`). The last-star method: at most |p|·|s| steps, never exponential (the gate
+ * runs in the Host's event loop). ponytail: a rule like `*a*a*a…` (200 characters) against a very long word costs |p|·|s|;
+ * the user writes the rules, and a rule without `*` stops at the first different character. */
+export function wildMatch(p, s) {
+  let i = 0; let j = 0; let star = -1; let mark = 0;
+  while (j < s.length) {
+    if (i < p.length && p[i] === '*') { star = i; i += 1; mark = j; }
+    else if (i < p.length && (p[i] === '?' || p[i] === s[j])) { i += 1; j += 1; }
+    else if (star !== -1) { i = star + 1; mark += 1; j = mark; }
+    else return false;
+  }
+  while (p[i] === '*') i += 1;
+  return i === p.length;
+}
+/** The texts that a simple command runs again, found where the shell takes them (AGENTS.md rule 13), and the words after
+ * `eval` (`iex` for pwsh). sh (case-sensitive): after a `-…c…` or `+…c…` group, the first word that is not an option (`--`
+ * or `-` end the options; each `o`/`O` of a group takes a value, as in `-o pipefail`); a here-string (`bash <<< 'npm
+ * publish'`). pwsh (any case, PowerShell's `MatchSwitch`): `-`, `--` or `/` and a prefix of `command` (`-c`, `-co`, …): the
+ * rest of the words; `-cwa`/`-CommandWithArgs`: the next word. One pass, so a long command stays linear.
+ * ponytail: a word that is not an option before `-c` (a script file, su's user) does not end the search, so `bash x.sh -c
+ * 'y'` also reads `y`; that can only make a rule match more often. */
+function rereads(words) {
+  const out = [];
+  let shell = null; // 'sh' or 'ps' after a shell name, until its script
+  let c = false; let skip = 0; // sh: a `-…c…` group was read; option values still to pass
+  const take = (script, ps) => { if (script !== undefined && script !== '') out.push([script, ps]); shell = null; };
+  for (let k = 0; k < words.length; k++) {
+    const word = words[k];
+    const w = word.toLowerCase();
+    if (shell === 'sh') {
+      if (skip > 0) { skip -= 1; continue; }
+      if (w === '--' || w === '-') { if (c) { take(words[k + 1], false); k += 1; } continue; }
+      if (/^[-+][A-Za-z]+$/.test(word)) { c ||= word.includes('c'); skip = word.replace(/[^oO]/g, '').length; continue; }
+      if (w.startsWith('--')) continue;
+      if (w.startsWith('<<<')) { take(w === '<<<' ? words[k + 1] : word.slice(3), false); k += 1; continue; }
+      if (c) { take(word, false); continue; }
+    } else if (shell === 'ps') {
+      const key = w.replace(/^(--?|\/)/, '');
+      if (key !== w && key !== '' && 'command'.startsWith(key)) { take(words.slice(k + 1).join(' '), true); break; }
+      if (key === 'cwa' || key === 'commandwithargs') { take(words[k + 1], true); k += 1; continue; }
+    }
+    const name = commandName(w);
+    if (EVAL_NAMES.has(name)) { if (k + 1 < words.length) out.push([words.slice(k + 1).join(' '), name !== 'eval']); break; }
+    if (SHELL_NAMES.has(name)) { shell = name === 'pwsh' || name === 'powershell' ? 'ps' : 'sh'; c = false; skip = 0; }
+  }
+  return out;
+}
+/** The simple commands of a shell text, each as its words (quotes removed). bash: `; & | ( )`, a newline and `{ }` at a word
+ * start end a command; `'…'`, `"…"` and `\`; `$(…)` and backticks (also inside "…") are commands of their own; `#` at a
+ * word start is a comment; a here-document body is skipped, unless its delimiter is unquoted (then only its `$(…)` and
+ * backticks count). pwsh (`pwsh`): the same separators, the backtick escape, `''` and `""` inside quotes, `$(…)`. The
+ * texts of `bash -c`/`eval` (see rereads) and of here-documents are read again, at most BLOCK_DEPTH deep. Never throws;
+ * linear in the text length (each level reads at most the text once).
+ * ponytail: not a shell parser: `case x in a)`, nested backticks and aliases are not understood; a cut command can only
+ * make a rule match more often (or, past BLOCK_DEPTH, not at all; the README says). */
+export function shellCommands(text, pwsh = false, depth = 0, hereText = false) {
+  const commands = [];
+  if (typeof text !== 'string' || depth > BLOCK_DEPTH) return commands;
+  const esc = pwsh ? '`' : '\\';
+  let words = []; let word = ''; let has = false;
+  let quote = hereText ? 'h' : null; // null, "'", '"' or 'h' (the text of a here-document: only substitutions are commands)
+  let close = null; let parens = 0; let top = hereText; // `top`: this level is text, not commands
+  const stack = []; // the outer command while a $( … ) or ` … ` is read
+  const pending = []; // here-documents whose body starts at the next newline
+  let lineShell = false; // a command of this line names a shell: its here-document bodies are commands (`bash <<'EOF'`)
+  const endWord = () => { if (has) { words.push(word); word = ''; has = false; } };
+  const endCommand = () => {
+    endWord();
+    if (words.length > 0 && !top) {
+      if (words.some((w) => SHELL_NAMES.has(commandName(w)))) lineShell = true;
+      commands.push(words);
+      for (const [script, ps] of rereads(words)) for (const c of shellCommands(script, ps, depth + 1)) commands.push(c);
+    }
+    words = [];
+  };
+  const open = (c) => { stack.push({ words, word, quote, close, parens, top }); words = []; word = ''; has = false; quote = null; close = c; parens = 0; top = false; };
+  const shut = () => { endCommand(); ({ words, word, quote, close, parens, top } = stack.pop()); has = true; };
+  const hereStart = (j) => {
+    let dash = false;
+    if (text[j] === '-') { dash = true; j += 1; }
+    while (text[j] === ' ' || text[j] === '\t') j += 1;
+    let delim = ''; let quoted = false; let q = null;
+    for (; j < text.length; j++) {
+      const d = text[j];
+      if (q !== null) { if (d === q) q = null; else delim += d; continue; }
+      if (d === "'" || d === '"') { q = d; quoted = true; continue; }
+      if (d === '\\') { quoted = true; if (j + 1 < text.length) { j += 1; delim += text[j]; } continue; }
+      if (' \t\n;&|()<>'.includes(d)) break;
+      delim += d;
+    }
+    if (delim !== '' || quoted) pending.push({ delim, dash, quoted });
+    return j;
+  };
+  // The start of each line by its text (and by its text without leading tabs, for `<<-`), made once: finding an end line
+  // is a binary search, so many here-documents without an end line stay linear.
+  let lineIndex;
+  const endLine = (delim, dash, pos) => {
+    if (lineIndex === undefined) {
+      lineIndex = [new Map(), new Map()];
+      for (let s = 0; s <= text.length;) {
+        const nl = text.indexOf('\n', s); const e = nl === -1 ? text.length : nl;
+        const line = text.slice(s, e);
+        for (const [k, key] of [[0, line], [1, line.replace(/^\t+/, '')]]) { const at = lineIndex[k].get(key); if (at === undefined) lineIndex[k].set(key, [s]); else at.push(s); }
+        if (nl === -1) break;
+        s = nl + 1;
+      }
+    }
+    const at = lineIndex[dash ? 1 : 0].get(delim);
+    if (at === undefined) return -1;
+    let lo = 0; let hi = at.length;
+    while (lo < hi) { const mid = (lo + hi) >> 1; if (at[mid] < pos) lo = mid + 1; else hi = mid; }
+    return lo < at.length ? at[lo] : -1;
+  };
+  // The bodies of the pending here-documents, from `pos` (the line after `<<`); answers the index after the last one. A
+  // body with no end line is read as commands (fail safe: `$((1<<2))` is no here-document).
+  const hereBodies = (pos) => {
+    for (const { delim, dash, quoted } of pending.splice(0)) {
+      const begin = pos;
+      const end = endLine(delim, dash, pos);
+      if (end === -1) break;
+      const nl = text.indexOf('\n', end);
+      pos = nl === -1 ? text.length : nl + 1;
+      if (lineShell || !quoted) for (const c of shellCommands(text.slice(begin, end), false, depth + 1, !lineShell)) commands.push(c);
+    }
+    lineShell = false;
+    return pos;
+  };
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (quote === "'") {
+      if (c !== "'") word += c;
+      else if (pwsh && text[i + 1] === "'") { word += "'"; i += 1; } else quote = null;
+      continue;
+    }
+    if (quote === '"' || quote === 'h') {
+      if (c === esc && i + 1 < text.length) {
+        i += 1;
+        const n = text[i];
+        if (n === '\n') continue; // a line goes on
+        if (pwsh || n === '$' || n === '`' || n === '\\' || (quote === '"' && n === '"')) word += n; else word += c + n;
+        continue;
+      }
+      if (c === '"' && quote === '"') { if (pwsh && text[i + 1] === '"') { word += '"'; i += 1; } else quote = null; continue; }
+      if (c === '$' && text[i + 1] === '(') { open(')'); i += 1; continue; }
+      if (c === '`' && !pwsh) { open('`'); continue; }
+      word += c;
+      continue;
+    }
+    if (c === esc && i + 1 < text.length) { i += 1; if (text[i] !== '\n') { word += text[i]; has = true; } continue; }
+    if (c === "'" || c === '"') { quote = c; has = true; continue; }
+    if (c === '$' && text[i + 1] === '(') { open(')'); i += 1; continue; }
+    if (c === '`' && !pwsh) { if (close === '`') shut(); else open('`'); continue; }
+    if (c === ' ' || c === '\t' || c === '\r') { endWord(); continue; }
+    if (c === '\n' || c === ';' || c === '&' || c === '|') {
+      endCommand();
+      if (c === '\n') { if (pending.length > 0) i = hereBodies(i + 1) - 1; lineShell = false; }
+      continue;
+    }
+    if (c === '(') { endCommand(); parens += 1; continue; }
+    if (c === ')') { if (parens > 0) { parens -= 1; endCommand(); } else if (close === ')') shut(); else endCommand(); continue; }
+    if (!has && (c === '{' || c === '}') && (i + 1 === text.length || ' \t\r\n;&|)'.includes(text[i + 1]))) { endCommand(); continue; }
+    if (!has && c === '#') { const n = text.indexOf('\n', i); i = (n === -1 ? text.length : n) - 1; continue; }
+    if (!pwsh && c === '<' && text[i + 1] === '<') {
+      if (text[i + 2] === '<') { word += '<<<'; has = true; i += 2; continue; } // a here-string: its word is text
+      endWord(); i = hereStart(i + 2) - 1; continue;
+    }
+    word += c; has = true;
+  }
+  for (;;) {
+    endCommand();
+    if (stack.length === 0) break;
+    ({ words, word, quote, close, parens, top } = stack.pop());
+    has = true;
+  }
+  return commands;
+}
+/** The rule that a shell command breaks: `{rule, mode, command}` (`command`: the simple command, its words joined), else
+ * undefined. A rule's first word is a command name: any word of a simple command (so `sudo npm publish`, `env A=1 npm
+ * publish` and `/usr/bin/npm publish` match `npm publish`); its other words must follow in the same order, with other
+ * words between them allowed. A block rule wins over an ask rule; else the first rule in the list. */
+export function blockedHit(rules, command, pwsh = false) {
+  if (!Array.isArray(rules) || rules.length === 0 || typeof command !== 'string') return undefined;
+  const commands = shellCommands(command, pwsh).map((words) => ({ words, lower: words.map((w) => w.toLowerCase()), names: words.map(commandName) }));
+  let ask;
+  for (const r of rules) {
+    const want = r.rule.toLowerCase().split(' ');
+    const first = commandName(want[0]);
+    for (const { words, lower, names } of commands) {
+      const start = names.findIndex((n) => wildMatch(first, n));
+      if (start === -1) continue;
+      let x = 1;
+      for (let k = start + 1; k < lower.length && x < want.length; k++) if (wildMatch(want[x], lower[k])) x += 1;
+      if (x < want.length) continue;
+      const hit = { rule: r.rule, mode: r.mode, command: words.join(' ') };
+      if (r.mode === 'block') return hit;
+      ask ??= hit;
+      break;
+    }
+  }
+  return ask;
+}
+const shownCommand = (text) => {
+  const s = text.slice(0, 400).replace(/[\u0000-\u001f\u007f]+/g, ' ');
+  return s.length > 160 ? `${s.slice(0, 159)}…` : s;
+};
+export function installBlockedCommands(ctx, home, file = join(home, 'storages', 'dsh-composer-plus', 'blocked-commands.json')) {
+  const get = (name) => { try { return ctx.get?.(name); } catch { return undefined; } };
+  const store = blockedStore(file);
+  let settings;
+  const read = store.read().then((s) => { settings = s; });
+  ctx.on('tools/pre-execute', async (exec, next) => {
+    const decision = await next();
+    // A denied or cancelled call stays so; only an allowed call and one that would ask are checked.
+    if ((decision?.kind !== 'allow' && decision?.kind !== 'ask') || (exec.name !== 'bash' && exec.name !== 'pwsh')) return decision;
+    await read;
+    if (!settings.on || settings.rules.length === 0) return decision;
+    const hit = blockedHit(settings.rules, argsOf(exec.arguments)?.command, exec.name === 'pwsh');
+    if (hit === undefined) return decision;
+    const shown = shownCommand(hit.command);
+    // A chat whose approval policy is `never` (Full access, a delegated child) cannot ask: dsh would reject the ask with no
+    // reason, so the agent reads this one instead. The effective policy is the chat's own `approval/policy` event, else the
+    // configured default (dsh-user-approval `effectivePolicy`; `never` when dsh starts with DSH_PERMISSION_MODE=danger-full-access).
+    let never = false;
+    try {
+      const approval = get('approval'); const session = exec.agent?.session;
+      const policy = typeof approval?.effectivePolicy === 'function' ? approval.effectivePolicy(session) : approval?.overrideOf?.(session) ?? approval?.config?.policy;
+      never = policy === 'never';
+    } catch { never = false; }
+    if (hit.mode === 'block' || never) {
+      const why = hit.mode === 'ask' ? ' (ask first, and this chat cannot ask: its approval policy is never)' : '';
+      return { kind: 'deny', reason: `Blocked command: ${shown} matches "${hit.rule}"${why} in Composer Plus → Blocked commands. Do not run it in another way (a script, another shell, a variable). If the task needs it, ask the user.` };
+    }
+    // dsh's approval card shows this reason. It must not start like an Auto review ask: Allow for this chat answers those.
+    const own = `Composer Plus → Blocked commands: ${shown} matches "${hit.rule}" (ask first).`;
+    return { kind: 'ask', reason: decision.kind === 'ask' && typeof decision.reason === 'string' && decision.reason !== '' ? `${own} ${decision.reason}` : own };
+  });
+  ctx.connection.fetch.register({
+    path: BLOCKED_PATH, methods: ['GET', 'POST'], requestBody: 'buffered',
+    fetch: async (request) => {
+      await read;
+      if (request.method === 'POST') {
+        let body;
+        try { body = await request.json(); } catch { return json({ error: 'bad request' }, 400); }
+        if (!plainObject(body)) return json({ error: 'bad request' }, 400);
+        const keys = Object.keys(body).sort().join(',');
+        const rules = keys === 'rules' ? parseRules(body.rules) : undefined;
+        if (!(keys === 'on' && typeof body.on === 'boolean') && rules === undefined) return json({ error: 'bad request' }, 400);
+        try { settings = await store.change((s) => (rules === undefined ? { ...s, on: body.on } : { ...s, rules })); } catch (error) { return json({ error: String(error?.message ?? error) }, 500); }
+      }
+      return json(settings);
+    },
+  });
+}
+
 /** Worktree chats: a `.worktreeinclude` larger than this is refused (a cut pattern could name more than the user wrote). */
 export const INCLUDE_MAX = 64 * 1024;
 const WORKTREES_MAX = 20;
@@ -6125,3 +6415,748 @@ export function installBackup(ctx, home, { graceMs = AUTO_BACKUP_GRACE_MS, retry
   });
   return { settled: () => new Promise((resolve) => { const wait = () => (busy === null ? resolve() : setTimeout(wait, 10)); wait(); }), tick };
 }
+
+/** Task board (Host half): a kanban board of the dsh projects for the user and the agents, after Kanzo's idea
+ * (github.com/emanuele-em/kanzo, AGPL-3.0; no code of it is used here). One owner-only JSON file
+ * `storages/dsh-composer-plus/board.json`: `{ v, next, nextComment, backlog, projects: [{path, slug}], tasks: [...] }`.
+ * A task belongs to a project folder (a dsh project; a Branch per chat folder `<repo>/.worktrees/<name>` counts as its
+ * repository). Task ids are one sequence for all projects; the key is `<slug>#<id>`. Each column has one order (a float
+ * position) over all projects: a new task and a status change go to the bottom, a drop before a card goes between it and
+ * the card above it. */
+export const BOARD_PATH = '/api/composer-plus.board';
+export const BOARD_TASKS_PATH = '/api/composer-plus.board-tasks';
+export const BOARD_STATUSES = ['backlog', 'todo', 'doing', 'review', 'done'];
+/** The board shows the newest this many done tasks of a view ("Show N older" loads the rest). */
+export const BOARD_DONE_SHOWN = 50;
+export const BOARD_LIMITS = { title: 300, description: 20000, tags: 20, tag: 40, comment: 10000, comments: 500, tasks: 10000, search: 30 };
+const BOARD_AGENT_DONE = 20; // board_list_tasks with a status shows at most this many done tasks (the newest)
+const BOARD_SHOWN_MAX = 2000;
+export const BOARD_SECTION = `# Task board
+This project has open tasks on the user's task board (Composer Plus → Task board). Tasks look like api#12. Keep the board current without being asked:
+- When you start a task from the board, move it to doing (board_next_task takes the top todo task and moves it).
+- Comment on what you did with board_add_comment: the result, the files, the checks and their outcome.
+- Move the task to review when you finish it or when you are blocked. Never move a task to done: the user does that.
+- Leave human tasks and backlog tasks to the user.`;
+
+const boardStatuses = (data) => (data.backlog ? BOARD_STATUSES : BOARD_STATUSES.slice(1));
+/** One line: runs of white space become one space, the ends are trimmed. */
+const boardLine = (raw) => String(raw ?? '').replace(/\s+/g, ' ').trim();
+/** Comma-separated tags: each one trimmed, lower case, one space between words; no empty or repeated tag; first seen first. */
+export const boardTags = (raw) => {
+  const list = Array.isArray(raw) ? raw : String(raw ?? '').split(',');
+  const out = [];
+  for (const part of list) { const tag = boardLine(part).toLowerCase(); if (tag !== '' && !out.includes(tag)) out.push(tag); }
+  if (out.length > BOARD_LIMITS.tags) throw refused(`a task has at most ${BOARD_LIMITS.tags} tags`, 400);
+  if (out.some((tag) => tag.length > BOARD_LIMITS.tag)) throw refused(`a tag has at most ${BOARD_LIMITS.tag} characters`, 400);
+  return out;
+};
+/** A short id for a project name: lower case a–z, 0–9 and "-", at most 24 characters; a taken one gets -2, -3, … */
+export const boardSlug = (name, taken) => {
+  const base = String(name ?? '').normalize('NFKD').replace(/[\u0300-\u036f]/g, '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 24).replace(/-+$/, '') || 'project';
+  if (!taken.has(base)) return base;
+  for (let n = 2; ; n++) if (!taken.has(`${base}-${n}`)) return `${base}-${n}`;
+};
+const BRANCH_DIR = /^(.+?)[\\/]\.worktrees[\\/][^\\/]+(?:[\\/].*)?$/;
+const trimSlash = (p) => (p.length > 1 ? p.replace(/[\\/]+$/, '') : p);
+/** The board project of a chat folder: a Branch per chat folder counts as its repository, then the nearest dsh project at or
+ * above the folder; else the folder itself. */
+export function boardProjectOf(cwd, paths) {
+  let root = trimSlash(String(cwd));
+  const branch = BRANCH_DIR.exec(root);
+  if (branch !== null) root = branch[1];
+  let best;
+  for (const p of paths) {
+    const q = trimSlash(p);
+    if ((root === q || root.startsWith(q.endsWith(sep) ? q : q + sep)) && (best === undefined || q.length > best.length)) best = q;
+  }
+  return best ?? root;
+}
+const emptyBoard = () => ({ v: 1, next: 1, nextComment: 1, backlog: false, projects: [], tasks: [] });
+const isTime = (v) => typeof v === 'string' && v.length <= 40 && !Number.isNaN(Date.parse(v));
+/** A saved board with every malformed entry left out. */
+function cleanBoard(raw) {
+  if (!plainObject(raw)) throw new Error('the board file is not a JSON object');
+  const data = emptyBoard();
+  data.backlog = raw.backlog === true;
+  const slugs = new Set();
+  for (const p of Array.isArray(raw.projects) ? raw.projects : []) {
+    if (!isText(p?.path, 4096) || !isAbsolute(p.path) || !/^[a-z0-9-]{1,32}$/.test(p?.slug ?? '') || slugs.has(p.slug) || data.projects.some((x) => x.path === p.path)) continue;
+    slugs.add(p.slug); data.projects.push({ path: p.path, slug: p.slug });
+  }
+  const ids = new Set();
+  for (const t of Array.isArray(raw.tasks) ? raw.tasks : []) {
+    if (!Number.isSafeInteger(t?.id) || t.id < 1 || ids.has(t.id) || !data.projects.some((p) => p.path === t.path) || !isText(t.title, BOARD_LIMITS.title)
+      || !BOARD_STATUSES.includes(t.status) || !Number.isFinite(t.position) || !isTime(t.created) || !isTime(t.updated)) continue;
+    ids.add(t.id);
+    const comments = (Array.isArray(t.comments) ? t.comments : []).filter((c) => Number.isSafeInteger(c?.id) && (c.by === 'user' || c.by === 'agent')
+      && isText(c.body, BOARD_LIMITS.comment) && isTime(c.at) && (c.sessionId === undefined || isText(c.sessionId, 128)))
+      .map((c) => ({ id: c.id, by: c.by, ...(c.sessionId === undefined ? {} : { sessionId: c.sessionId }), body: c.body, at: c.at }));
+    data.tasks.push({ id: t.id, path: t.path, title: t.title, description: typeof t.description === 'string' ? t.description.slice(0, BOARD_LIMITS.description) : '',
+      tags: Array.isArray(t.tags) ? t.tags.filter((x) => isText(x, BOARD_LIMITS.tag)).slice(0, BOARD_LIMITS.tags) : [], human: t.human === true,
+      status: t.status, position: t.position, created: t.created, updated: t.updated, comments });
+  }
+  if (data.tasks.some((t) => t.status === 'backlog')) data.backlog = true;
+  // A loop, not Math.max(...list): a spread of about 125k values throws RangeError (the board allows 10k tasks × 500 comments).
+  data.next = data.tasks.reduce((n, t) => Math.max(n, t.id + 1), Math.max(1, Number.isSafeInteger(raw.next) ? raw.next : 1));
+  data.nextComment = data.tasks.reduce((n, t) => t.comments.reduce((m, c) => Math.max(m, c.id + 1), n), Math.max(1, Number.isSafeInteger(raw.nextComment) ? raw.nextComment : 1));
+  return data;
+}
+
+/** The board file: every change runs alone on a copy and replaces the file atomically; the copy becomes the board only
+ * after the write (all or none). A broken file is kept as `board.json.broken-<time>` and the board starts empty; a file
+ * that cannot be read (other than missing) stops every change, so nothing overwrites it. */
+export function boardStore(file, { now = () => new Date() } = {}) {
+  let data = emptyBoard();
+  let rev = Date.now();
+  const ready = (async () => {
+    let text;
+    try { text = await readFile(file, 'utf8'); } catch (error) { if (error?.code === 'ENOENT') return; throw error; }
+    try { data = cleanBoard(JSON.parse(text)); } catch { await rename(file, `${file}.broken-${Date.now()}`); }
+  })();
+  let queue = ready.catch(() => {});
+  const write = async (next) => {
+    await mkdir(dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.tmp`;
+    await writeFile(tmp, JSON.stringify(next), { mode: 0o600 });
+    await rename(tmp, file);
+  };
+  return {
+    ready,
+    /** The board now (do not change it). Empty until the file is read. */
+    peek: () => data,
+    rev: () => rev,
+    /** `fn(draft, now)` changes a copy; it throws to change nothing. Answers what `fn` answers. */
+    change(fn) {
+      const done = queue.then(async () => {
+        await ready;
+        const draft = structuredClone(data);
+        const result = fn(draft, now().toISOString());
+        await write(draft);
+        data = draft; rev += 1;
+        return result;
+      });
+      queue = done.catch(() => {});
+      return done;
+    },
+  };
+}
+
+/** The projects of the board: dsh's projects (not Branch per chat folders) and every project that has tasks, A–Z, each
+ * with its slug (saved, or the one it gets with its first task) and its counts. */
+export function boardProjects(data, registry = []) {
+  const list = new Map();
+  for (const w of registry) {
+    if (!isText(w?.path, 4096) || !isAbsolute(w.path) || BRANCH_DIR.test(trimSlash(w.path))) continue;
+    const path = trimSlash(w.path);
+    if (!list.has(path)) list.set(path, { path, name: (typeof w.title === 'string' && w.title.trim()) || basename(path) || path });
+  }
+  for (const p of data.projects) if (!list.has(p.path)) list.set(p.path, { path: p.path, name: basename(p.path) || p.path });
+  const taken = new Set(data.projects.map((p) => p.slug));
+  const out = [...list.values()].sort((a, b) => a.name.localeCompare(b.name) || a.path.localeCompare(b.path));
+  for (const p of out) {
+    const saved = data.projects.find((x) => x.path === p.path)?.slug;
+    p.slug = saved ?? boardSlug(p.name, taken);
+    taken.add(p.slug);
+    const own = data.tasks.filter((t) => t.path === p.path);
+    p.open = own.filter((t) => t.status !== 'done').length;
+    p.total = own.length;
+  }
+  return out;
+}
+const byPosition = (a, b) => a.position - b.position || a.id - b.id;
+const slugMap = (projects) => new Map(projects.map((p) => [p.path, p.slug]));
+const keyOf = (t, slugs) => `${slugs.get(t.path) ?? 'task'}#${t.id}`;
+/** A card: the task without its comments (their count instead) and its description cut to a preview. */
+const boardCard = (t, slugs) => ({ id: t.id, key: keyOf(t, slugs), path: t.path, title: t.title, preview: t.description.slice(0, 240), tags: t.tags, human: t.human,
+  status: t.status, position: t.position, created: t.created, updated: t.updated, comments: t.comments.length });
+/** One view of the board: `project` is a project path or 'all'. Done shows its newest BOARD_DONE_SHOWN unless `done`. */
+export function boardView(data, registry, { project = 'all', done = false } = {}) {
+  const projects = boardProjects(data, registry);
+  const slugs = slugMap(projects);
+  const own = data.tasks.filter((t) => project === 'all' || t.path === project).sort(byPosition);
+  const finished = own.filter((t) => t.status === 'done');
+  const hiddenDone = done ? 0 : Math.max(0, finished.length - BOARD_DONE_SHOWN);
+  const hidden = new Set(finished.slice(0, hiddenDone).map((t) => t.id));
+  return { backlog: data.backlog, statuses: boardStatuses(data), projects, project, hiddenDone, tasks: own.filter((t) => !hidden.has(t.id)).map((t) => boardCard(t, slugs)) };
+}
+/** A task with its comments, for the detail panel. */
+export function boardTask(data, registry, id) {
+  const t = data.tasks.find((x) => x.id === id);
+  if (t === undefined) return undefined;
+  const projects = boardProjects(data, registry);
+  return { ...boardCard(t, slugMap(projects)), description: t.description, comments: t.comments, project: projects.find((p) => p.path === t.path)?.name ?? basename(t.path) };
+}
+/** Search every project: each word must be in the key, title, description or tags. Open tasks first, then the newest change. */
+export function boardSearch(data, registry, query) {
+  const slugs = slugMap(boardProjects(data, registry));
+  const words = boardLine(query).toLowerCase().split(' ').filter(Boolean).slice(0, 10);
+  const hits = data.tasks.filter((t) => { const text = `${keyOf(t, slugs)} ${t.title} ${t.description} ${t.tags.join(' ')}`.toLowerCase(); return words.every((w) => text.includes(w)); });
+  hits.sort((a, b) => (a.status === 'done') - (b.status === 'done') || Date.parse(b.updated) - Date.parse(a.updated) || b.id - a.id);
+  return hits.slice(0, BOARD_LIMITS.search).map((t) => boardCard(t, slugs));
+}
+const utcTime = (iso) => `${iso.slice(0, 10)} ${iso.slice(11, 16)} UTC`;
+/** The board (one project or all) as Markdown or JSON, with every done task and every comment. */
+export function boardExport(data, registry, project, format, at = new Date().toISOString()) {
+  const projects = boardProjects(data, registry).filter((p) => (project === 'all' ? p.total > 0 : p.path === project));
+  const statuses = boardStatuses(data);
+  const tasksOf = (p) => data.tasks.filter((t) => t.path === p.path).sort((a, b) => statuses.indexOf(a.status) - statuses.indexOf(b.status) || byPosition(a, b));
+  if (format === 'json') {
+    return JSON.stringify({ exported: at, statuses, projects: projects.map((p) => ({ name: p.name, slug: p.slug, path: p.path, open: p.open, total: p.total,
+      tasks: tasksOf(p).map((t) => ({ key: `${p.slug}#${t.id}`, id: t.id, title: t.title, description: t.description, tags: t.tags, human: t.human, status: t.status,
+        created: t.created, updated: t.updated, comments: t.comments })) })) }, null, 2);
+  }
+  const lines = ['# Task board', '', `Exported ${utcTime(at)}.`];
+  for (const p of projects) {
+    lines.push('', `## ${p.name} \`${p.slug}\``, '', `${p.open} open of ${p.total} task(s).`);
+    for (const status of statuses) {
+      const list = tasksOf(p).filter((t) => t.status === status);
+      if (list.length === 0) continue;
+      lines.push('', `### ${status}`);
+      for (const t of list) {
+        lines.push('', `#### ${p.slug}#${t.id} ${t.title}`, '', `Created ${utcTime(t.created)}, updated ${utcTime(t.updated)}.`);
+        if (t.human) lines.push('Human task.');
+        if (t.tags.length > 0) lines.push(`Tags: ${t.tags.join(', ')}.`);
+        if (t.description !== '') lines.push('', t.description);
+        if (t.comments.length > 0) {
+          lines.push('', 'Comments:', '');
+          for (const c of t.comments) lines.push(`- **${c.by === 'agent' ? 'agent' : 'you'}**, ${utcTime(c.at)}: ${c.body.replace(/\n/g, '\n  ')}`);
+        }
+      }
+    }
+  }
+  return `${lines.join('\n')}\n`;
+}
+
+/** The changes of the board, on a draft (`boardStore.change`). Each throws `refused` to change nothing. */
+const bottomOf = (d, status) => Math.floor(Math.max(0, ...d.tasks.filter((t) => t.status === status).map((t) => t.position))) + 1;
+const findTask = (d, id) => { const t = d.tasks.find((x) => x.id === id); if (t === undefined) throw refused(`no task #${id}`, 404); return t; };
+const checkStatus = (d, status) => { if (!boardStatuses(d).includes(status)) throw refused(`unknown status "${String(status).slice(0, 40)}"; use one of: ${boardStatuses(d).join(', ')}`, 400); return status; };
+const checkTitle = (raw) => { const title = boardLine(raw); if (title === '') throw refused('a task needs a title', 400); if (title.length > BOARD_LIMITS.title) throw refused(`a title has at most ${BOARD_LIMITS.title} characters`, 400); return title; };
+const checkText = (raw) => { const text = String(raw ?? '').trim(); if (text.length > BOARD_LIMITS.description) throw refused(`a description has at most ${BOARD_LIMITS.description} characters`, 400); return text; };
+/** The project's saved slug; a project gets one with its first task. */
+function ensureProject(d, path, registry) {
+  const saved = d.projects.find((p) => p.path === path);
+  if (saved !== undefined) return saved.slug;
+  const listed = boardProjects(d, registry).find((p) => p.path === path);
+  const slug = listed?.slug ?? boardSlug(basename(path), new Set(d.projects.map((p) => p.slug)));
+  d.projects.push({ path, slug });
+  return slug;
+}
+export const boardOps = {
+  create(d, now, { path, title, description = '', tags = [], human = false, status = 'todo' }, registry) {
+    if (d.tasks.length >= BOARD_LIMITS.tasks) throw refused(`the board keeps at most ${BOARD_LIMITS.tasks} tasks; delete old done tasks first`);
+    const task = { id: d.next, path, title: checkTitle(title), description: checkText(description), tags: boardTags(tags), human: human === true,
+      status: checkStatus(d, status), position: 0, created: now, updated: now, comments: [] };
+    task.position = bottomOf(d, task.status);
+    ensureProject(d, path, registry);
+    d.next += 1; d.tasks.push(task);
+    return task.id;
+  },
+  /** `was`: the values that the editor started from; a field that changed meanwhile (an agent, another window) refuses the
+   * whole change with 409. */
+  update(d, now, id, patch, was = {}, registry = []) {
+    const t = findTask(d, id);
+    const same = { title: (v) => t.title === boardLine(v), description: (v) => t.description === String(v ?? '').trim(), tags: (v) => t.tags.join(',') === boardTags(v).join(',') };
+    for (const [field, value] of Object.entries(was)) if (same[field] !== undefined && !same[field](value)) throw refused(`the ${field} changed meanwhile`, 409);
+    let changed = false;
+    if (patch.title !== undefined) { const v = checkTitle(patch.title); changed ||= v !== t.title; t.title = v; }
+    if (patch.description !== undefined) { const v = checkText(patch.description); changed ||= v !== t.description; t.description = v; }
+    if (patch.tags !== undefined) { const v = boardTags(patch.tags); changed ||= v.join(',') !== t.tags.join(','); t.tags = v; }
+    if (patch.human !== undefined) { changed ||= t.human !== (patch.human === true); t.human = patch.human === true; }
+    if (patch.path !== undefined && patch.path !== t.path) { ensureProject(d, patch.path, registry); t.path = patch.path; changed = true; }
+    if (patch.status !== undefined && checkStatus(d, patch.status) !== t.status) { t.position = bottomOf(d, patch.status); t.status = patch.status; changed = true; }
+    if (changed) t.updated = now;
+    return t.id;
+  },
+  /** A drag: to the bottom of `status`, or just above the task `before` in that column. */
+  move(d, now, id, status, before) {
+    const t = findTask(d, id);
+    checkStatus(d, status);
+    const column = () => d.tasks.filter((x) => x.status === status && x.id !== id).sort(byPosition);
+    const target = before === undefined ? undefined : column().find((x) => x.id === before);
+    if (t.status !== status) t.updated = now;
+    t.status = status;
+    if (target === undefined) { t.position = bottomOf({ tasks: column() }, status); return t.id; }
+    const place = () => { const list = column(); const i = list.indexOf(target); return i <= 0 ? [undefined, target] : [list[i - 1], target]; };
+    let [above] = place();
+    if (above !== undefined && target.position - above.position < 1e-9) { column().forEach((x, i) => { x.position = i + 1; }); [above] = place(); }
+    t.position = above === undefined ? target.position - 1 : (above.position + target.position) / 2;
+    return t.id;
+  },
+  comment(d, now, id, { body, by, sessionId }) {
+    const t = findTask(d, id);
+    const text = String(body ?? '').trim();
+    if (text === '') throw refused('a comment needs text', 400);
+    if (text.length > BOARD_LIMITS.comment) throw refused(`a comment has at most ${BOARD_LIMITS.comment} characters`, 400);
+    if (t.comments.length >= BOARD_LIMITS.comments) throw refused(`a task keeps at most ${BOARD_LIMITS.comments} comments`);
+    t.comments.push({ id: d.nextComment, by, ...(isText(sessionId, 128) ? { sessionId } : {}), body: text, at: now });
+    d.nextComment += 1;
+    return t.id;
+  },
+  uncomment(d, id, commentId) {
+    const t = findTask(d, id);
+    const at = t.comments.findIndex((c) => c.id === commentId);
+    if (at < 0) throw refused('no such comment', 404);
+    t.comments.splice(at, 1);
+    return t.id;
+  },
+  remove(d, id) { const t = findTask(d, id); d.tasks.splice(d.tasks.indexOf(t), 1); return t; },
+  /** The top todo task that is not for a person, moved to the bottom of doing; undefined when there is none. */
+  next(d, now, path) {
+    const t = d.tasks.filter((x) => x.status === 'todo' && !x.human && (path === 'all' || x.path === path)).sort(byPosition)[0];
+    if (t === undefined) return undefined;
+    t.position = bottomOf(d, 'doing'); t.status = 'doing'; t.updated = now;
+    return t.id;
+  },
+};
+
+/** Agents' text: `api#12 [todo] Title {tag, tag} (2 comments)` and a task in full. */
+const plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+const boardTaskLine = (t, slugs) => `${keyOf(t, slugs)} [${t.status}] ${t.title}${t.human ? ' (human)' : ''}${t.tags.length > 0 ? ` {${t.tags.join(', ')}}` : ''}${t.comments.length > 0 ? ` (${plural(t.comments.length, 'comment')})` : ''}`;
+function boardTaskText(t, slugs) {
+  const lines = [`${keyOf(t, slugs)} ${t.title}${t.tags.length > 0 ? ` {${t.tags.join(', ')}}` : ''}`,
+    `status: ${t.status}${t.human ? ', human: for the user, not for agents' : ''}, created ${utcTime(t.created)}${t.updated !== t.created ? `, updated ${utcTime(t.updated)}` : ''}`];
+  if (t.description !== '') lines.push('', t.description);
+  if (t.comments.length > 0) lines.push('', `Comments (${t.comments.length}):`, ...t.comments.map((c) => `- ${c.by === 'agent' ? 'agent' : 'user'}, ${utcTime(c.at)}: ${c.body}`));
+  return lines.join('\n');
+}
+/** `api#12`, `#12`, `12` or 12; a slug that is not the task's project finds nothing. */
+export function boardKey(raw, data, slugs) {
+  const m = /^\s*(?:([a-z0-9-]{1,32})?#)?(\d{1,15})\s*$/i.exec(String(raw ?? ''));
+  if (m === null) throw refused(`"${String(raw).slice(0, 40)}" is not a task: use a key like api#12`, 400);
+  const t = findTask(data, Number(m[2]));
+  if (m[1] !== undefined && slugs.get(t.path) !== m[1].toLowerCase()) throw refused(`no task ${raw}`, 404);
+  return t.id;
+}
+
+/** Task board (Host half): the switch route, the board route, and while the switch is on the tools and the prompt section. */
+export function installBoard(ctx, home, dir = join(home, 'storages', 'dsh-composer-plus')) {
+  const get = (name) => { try { return ctx.get?.(name); } catch { return undefined; } };
+  const store = boardStore(join(dir, 'board.json'));
+  const sw = mobileSwitch(join(dir, 'board-switch.json'), true);
+  const registry = () => { try { return get('workspaceRegistry')?.list?.() ?? []; } catch { return []; } };
+  const listing = () => boardProjects(store.peek(), registry());
+  let on = true;
+  let fiber;
+  const shown = new Set(); // chats whose prompt has the section: it stays (the prompt prefix stays the same)
+  const folderOf = (agent) => {
+    let cwd;
+    try { cwd = get('workingDirectory')?.get?.(agent?.session); } catch { cwd = undefined; }
+    cwd ??= agent?.session?.header?.cwd;
+    return isText(cwd, 4096) && isAbsolute(cwd) ? cwd : undefined;
+  };
+  const sectionFor = (agent) => {
+    if (!on || !isText(agent?.id)) return '';
+    if (shown.has(agent.id)) return BOARD_SECTION;
+    const cwd = folderOf(agent);
+    if (cwd === undefined) return '';
+    const path = boardProjectOf(cwd, listing().map((p) => p.path));
+    if (!store.peek().tasks.some((t) => t.path === path && ['todo', 'doing', 'review'].includes(t.status))) return '';
+    shown.add(agent.id);
+    if (shown.size > BOARD_SHOWN_MAX) shown.delete(shown.values().next().value);
+    return BOARD_SECTION;
+  };
+  /** The project that a tool names (`project`: a slug, a name or "all"), else the calling chat's project. */
+  const projectArg = (exec, raw, allowAll) => {
+    const projects = listing();
+    const name = boardLine(raw).toLowerCase();
+    if (name === 'all') { if (allowAll) return 'all'; throw refused('name one project, not "all"', 400); }
+    if (name !== '') {
+      const hit = projects.find((p) => p.slug === name) ?? projects.find((p) => p.name.toLowerCase() === name);
+      if (hit === undefined) throw refused(`no project "${String(raw).slice(0, 60)}"; projects: ${projects.map((p) => p.slug).join(', ') || 'none'}`, 404);
+      return hit.path;
+    }
+    const cwd = folderOf(exec?.agent);
+    if (cwd === undefined) throw refused('this chat has no project folder: pass `project` (see board_list_projects)', 400);
+    return boardProjectOf(cwd, projects.map((p) => p.path));
+  };
+  const slugs = () => slugMap(listing());
+  const keyParam = { type: 'string', description: 'The task, like api#12' };
+  const projectParam = { type: 'string', description: 'A project slug or name, or "all". Default: the project of this chat' };
+  const tools = [
+    { name: 'board_list_projects', description: 'List the projects of the task board with their slugs and open task counts.',
+      parameters: { type: 'object', properties: {} }, output: textOutput,
+      async execute(_args, exec) {
+        await store.ready;
+        const projects = listing();
+        let here; try { here = projectArg(exec, '', false); } catch { here = undefined; }
+        return projects.length === 0 ? 'No projects.' : projects.map((p) => `${p.slug}${p.slug !== p.name ? ` "${p.name}"` : ''}: ${p.open} open of ${p.total}${p.path === here ? ' <- this chat' : ''}`).join('\n');
+      } },
+    { name: 'board_list_tasks', description: 'List the tasks of the task board in board order. Without status, done and human tasks are left out.',
+      parameters: { type: 'object', properties: { project: projectParam, status: { type: 'string', description: 'One column (backlog, todo, doing, review, done), or "all"' } } }, output: textOutput,
+      async execute(args, exec) {
+        await store.ready;
+        const d = store.peek(); const path = projectArg(exec, args?.project, true); const s = slugs();
+        const status = boardLine(args?.status).toLowerCase();
+        if (status !== '' && status !== 'all') checkStatus(d, status);
+        const statuses = boardStatuses(d);
+        const own = d.tasks.filter((t) => (path === 'all' || t.path === path) && (status === '' || status === 'all' || t.status === status))
+          .sort((a, b) => statuses.indexOf(a.status) - statuses.indexOf(b.status) || byPosition(a, b));
+        const human = own.filter((t) => t.human).length;
+        const done = own.filter((t) => t.status === 'done');
+        const shownDone = status === '' ? [] : done.slice(-BOARD_AGENT_DONE);
+        const list = own.filter((t) => !t.human && (t.status !== 'done' || shownDone.includes(t)));
+        const lines = list.map((t) => boardTaskLine(t, s));
+        if (lines.length === 0) lines.push(`No tasks in ${path === 'all' ? 'any project' : s.get(path) ?? basename(path)}.`);
+        if (human > 0) lines.push(`(${plural(human, 'human task')} not shown: for the user, not for agents)`);
+        const left = done.filter((t) => !t.human).length - shownDone.filter((t) => !t.human).length;
+        if (left > 0) lines.push(status === '' ? `(${left} done not shown; pass status "done" or "all")` : `(${left} older done not shown)`);
+        return lines.join('\n');
+      } },
+    { name: 'board_get_task', description: 'Show one task of the task board with its description and comments.',
+      parameters: { type: 'object', properties: { id: keyParam }, required: ['id'] }, output: textOutput,
+      async execute(args) { await store.ready; const d = store.peek(); const s = slugs(); return boardTaskText(findTask(d, boardKey(args?.id, d, s)), s); } },
+    { name: 'board_create_task', description: 'Add a task to the task board, at the bottom of todo unless you pass status.',
+      parameters: { type: 'object', properties: { title: { type: 'string' }, description: { type: 'string', description: 'Markdown' }, project: { type: 'string', description: 'A project slug or name. Default: the project of this chat' },
+        tags: { type: 'string', description: 'Comma-separated' }, status: { type: 'string', description: 'A column; default todo' }, human: { type: 'boolean', description: 'For the user, not for agents' } }, required: ['title'] }, output: textOutput,
+      async execute(args, exec) {
+        await store.ready;
+        const path = projectArg(exec, args?.project, false);
+        const id = await store.change((d, now) => boardOps.create(d, now, { path, title: args?.title, description: args?.description, tags: args?.tags, human: args?.human, status: boardLine(args?.status ?? 'todo').toLowerCase() || 'todo' }, registry()));
+        const t = store.peek().tasks.find((x) => x.id === id);
+        return `Created ${keyOf(t, slugs())} in ${t.status}: ${t.title}`;
+      } },
+    { name: 'board_update_task', description: 'Change the fields that you pass of one task of the task board. A new status puts it at the bottom of that column.',
+      parameters: { type: 'object', properties: { id: keyParam, title: { type: 'string' }, description: { type: 'string', description: 'Markdown' }, status: { type: 'string', description: 'A column, like review' },
+        tags: { type: 'string', description: 'Comma-separated; "" removes all' }, human: { type: 'boolean' } }, required: ['id'] }, output: textOutput,
+      async execute(args) {
+        await store.ready;
+        let before;
+        const id = await store.change((d, now) => {
+          const tid = boardKey(args?.id, d, slugMap(boardProjects(d, registry())));
+          before = d.tasks.find((x) => x.id === tid).status;
+          return boardOps.update(d, now, tid, { title: args?.title, description: args?.description, tags: args?.tags, human: typeof args?.human === 'boolean' ? args.human : undefined,
+            status: args?.status === undefined ? undefined : boardLine(args.status).toLowerCase() });
+        });
+        const t = store.peek().tasks.find((x) => x.id === id);
+        return `Updated ${keyOf(t, slugs())}${before !== t.status ? `, ${before} -> ${t.status}` : ''}: ${t.title}`;
+      } },
+    { name: 'board_add_comment', description: 'Comment on a task of the task board, for example to report what you did.',
+      parameters: { type: 'object', properties: { id: keyParam, body: { type: 'string', description: 'Markdown' } }, required: ['id', 'body'] }, output: textOutput,
+      async execute(args, exec) {
+        await store.ready;
+        const id = await store.change((d, now) => boardOps.comment(d, now, boardKey(args?.id, d, slugMap(boardProjects(d, registry()))), { body: args?.body, by: 'agent', sessionId: exec?.agent?.id }));
+        return `Comment added to ${keyOf(store.peek().tasks.find((x) => x.id === id), slugs())}.`;
+      } },
+    { name: 'board_next_task', description: 'Take the top todo task of the task board that is not for a person, move it to doing and show it.',
+      parameters: { type: 'object', properties: { project: projectParam } }, output: textOutput,
+      async execute(args, exec) {
+        await store.ready;
+        const path = projectArg(exec, args?.project, true);
+        const id = await store.change((d, now) => { const tid = boardOps.next(d, now, path); if (tid === undefined) throw Object.assign(new Error('none'), { none: true }); return tid; })
+          .catch((error) => { if (error?.none) return undefined; throw error; });
+        const s = slugs();
+        if (id === undefined) return `Nothing in todo for ${path === 'all' ? 'any project' : s.get(path) ?? basename(path)}.`;
+        return `Moved to doing:\n${boardTaskText(store.peek().tasks.find((x) => x.id === id), s)}`;
+      } },
+    { name: 'board_delete_task', description: 'Delete a task of the task board with its comments. This cannot be undone.',
+      parameters: { type: 'object', properties: { id: keyParam }, required: ['id'] }, output: textOutput,
+      async execute(args) {
+        await store.ready;
+        const s = slugs();
+        const t = await store.change((d) => boardOps.remove(d, boardKey(args?.id, d, s)));
+        return `Deleted ${keyOf(t, s)}${t.comments.length > 0 ? ` and its ${plural(t.comments.length, 'comment')}` : ''}: ${t.title}`;
+      } },
+  ];
+  const apply = (next) => {
+    on = next;
+    if (on && fiber === undefined && typeof ctx.inject === 'function') {
+      fiber = ctx.inject(['tools', 'systemPrompt'], (sub) => {
+        for (const tool of tools) sub.tools.register(tool);
+        sub.systemPrompt.section({ name: 'composer-plus:board', order: 655, interpolate: false, text: (context) => sectionFor(context?.agent) });
+      });
+    } else if (!on) { fiber?.dispose?.(); fiber = undefined; shown.clear(); }
+  };
+  const ready = sw.read().then(apply, () => apply(true));
+  ctx.effect?.(() => () => { on = false; fiber?.dispose?.(); fiber = undefined; }, 'dsh-composer-plus: task board');
+  let switching = ready;
+  ctx.connection.fetch.register({
+    path: BOARD_PATH, methods: ['GET', 'POST'], requestBody: 'buffered',
+    fetch: async (request) => {
+      await ready;
+      try {
+        if (request.method === 'POST') {
+          let body;
+          try { body = await request.json(); } catch { return json({ error: 'bad request' }, 400); }
+          const key = plainObject(body) ? Object.keys(body).join() : '';
+          if ((key !== 'on' && key !== 'backlog') || typeof body[key] !== 'boolean') return json({ error: 'bad request' }, 400);
+          if (key === 'on') {
+            const change = switching.then(async () => { await sw.write(body.on); apply(body.on); });
+            switching = change.catch(() => {});
+            await change;
+          } else {
+            await store.change((d) => {
+              if (!body.backlog && d.tasks.some((t) => t.status === 'backlog')) throw refused(`move the ${plural(d.tasks.filter((t) => t.status === 'backlog').length, 'task')} out of Backlog first`);
+              d.backlog = body.backlog;
+            });
+          }
+        }
+        await store.ready.catch(() => {});
+        return json({ on, backlog: store.peek().backlog });
+      } catch (error) { return json({ error: String(error?.message ?? error) }, Number.isInteger(error?.status) ? error.status : 500); }
+    },
+  });
+  /** The board. GET: `?project=<path>|all[&done=all][&rev=N]` (a view; `{rev, same}` when nothing changed since rev),
+   * `?sessionId=` (the view of that chat's project), `?task=<id>`, `?q=<words>`, `?export=markdown|json&project=`. POST
+   * `{op, …}`: create, update, move, comment, uncomment, delete. While the switch is off: 409. */
+  ctx.connection.fetch.register({
+    path: BOARD_TASKS_PATH, methods: ['GET', 'POST'], requestBody: 'buffered',
+    fetch: async (request) => {
+      await ready;
+      if (!on) return json({ error: 'Task board is off' }, 409);
+      try {
+        await store.ready;
+        const known = (path) => isText(path, 4096) && listing().some((p) => p.path === path);
+        if (request.method === 'GET') {
+          const q = new URL(request.url).searchParams;
+          const rev = store.rev();
+          if (q.has('task')) {
+            const task = boardTask(store.peek(), registry(), Number(q.get('task')));
+            return task === undefined ? json({ error: 'this task was deleted', rev }, 404) : json({ rev, task });
+          }
+          if (q.has('q')) return json({ rev, results: boardSearch(store.peek(), registry(), String(q.get('q')).slice(0, 200)) });
+          let project = q.get('project') ?? 'all';
+          if (q.has('sessionId')) {
+            // The open chat's project; a chat without a folder, or a folder that is no board project, shows every project.
+            const cwd = await chatFolder(ctx.sessionQuery, q.get('sessionId'), request.signal).catch(() => undefined);
+            project = cwd === undefined ? 'all' : boardProjectOf(cwd, listing().map((p) => p.path));
+            if (!known(project)) project = 'all';
+          } else if (project !== 'all' && !known(project)) return json({ error: 'unknown project' }, 404);
+          if (q.has('export')) {
+            const format = q.get('export') === 'json' ? 'json' : 'markdown';
+            const name = project === 'all' ? 'task-board' : `task-board-${listing().find((p) => p.path === project)?.slug ?? 'project'}`;
+            return json({ name: `${name}.${format === 'json' ? 'json' : 'md'}`, text: boardExport(store.peek(), registry(), project, format) });
+          }
+          if (q.get('rev') === String(rev)) return json({ rev, same: true });
+          return json({ rev, ...boardView(store.peek(), registry(), { project, done: q.get('done') === 'all' }) });
+        }
+        let body;
+        try { body = await request.json(); } catch { return json({ error: 'bad request' }, 400); }
+        if (!plainObject(body)) return json({ error: 'bad request' }, 400);
+        const id = Number.isSafeInteger(body.id) && body.id > 0 ? body.id : undefined;
+        const text = (v, max) => v === undefined || (typeof v === 'string' && v.length <= max);
+        const fieldsOk = text(body.title, 1000) && text(body.description, BOARD_LIMITS.description + 1000) && (body.tags === undefined || typeof body.tags === 'string' || (Array.isArray(body.tags) && body.tags.every((x) => typeof x === 'string')))
+          && (body.human === undefined || typeof body.human === 'boolean') && text(body.status, 20);
+        let result;
+        switch (body.op) {
+          case 'create':
+            if (!fieldsOk || !known(body.project) || typeof body.title !== 'string') return json({ error: 'bad request' }, 400);
+            result = await store.change((d, now) => boardOps.create(d, now, { path: body.project, title: body.title, description: body.description, tags: body.tags, human: body.human, status: body.status ?? 'todo' }, registry()));
+            break;
+          case 'update': {
+            const was = body.was ?? {};
+            if (id === undefined || !fieldsOk || !plainObject(was) || !Object.entries(was).every(([k, v]) => ['title', 'description', 'tags'].includes(k) && typeof v === 'string')
+              || (body.project !== undefined && !known(body.project))) return json({ error: 'bad request' }, 400);
+            result = await store.change((d, now) => boardOps.update(d, now, id, { title: body.title, description: body.description, tags: body.tags, human: body.human, status: body.status, path: body.project }, was, registry()));
+            break;
+          }
+          case 'move':
+            if (id === undefined || typeof body.status !== 'string' || (body.before !== undefined && !Number.isSafeInteger(body.before))) return json({ error: 'bad request' }, 400);
+            result = await store.change((d, now) => boardOps.move(d, now, id, body.status, body.before));
+            break;
+          case 'comment':
+            if (id === undefined || typeof body.body !== 'string' || body.body.length > BOARD_LIMITS.comment + 1000) return json({ error: 'bad request' }, 400);
+            result = await store.change((d, now) => boardOps.comment(d, now, id, { body: body.body, by: 'user' }));
+            break;
+          case 'uncomment':
+            if (id === undefined || !Number.isSafeInteger(body.comment)) return json({ error: 'bad request' }, 400);
+            result = await store.change((d) => boardOps.uncomment(d, id, body.comment));
+            break;
+          case 'delete':
+            if (id === undefined) return json({ error: 'bad request' }, 400);
+            await store.change((d) => boardOps.remove(d, id));
+            return json({ rev: store.rev(), deleted: id });
+          default: return json({ error: 'bad request' }, 400);
+        }
+        return json({ rev: store.rev(), task: boardTask(store.peek(), registry(), result) });
+      } catch (error) { return json({ error: String(error?.message ?? error) }, Number.isInteger(error?.status) ? error.status : 500); }
+    },
+  });
+  return { store, ready, tools, sectionFor };
+}
+
+/* Planned steps, after HarnessMM (arXiv 2610.32813, "guarded decision reuse"): the model plans its next commands with the
+ * exact arguments and a guard (`plan_next_steps`). When the newest tool results meet the guard of exactly one step, Composer
+ * Plus answers the agent's next model request itself (dsh's `llm/stream` waterfall) with one assistant message: a short
+ * reasoning block (only when the model's own planning message has one: DeepSeek's thinking mode refuses a history message
+ * without it), a text line and the step's tool call. dsh then runs the call on its normal path (tools/pre-execute: approval,
+ * sandbox, Protected files). Stateless: the plan is the tool call's arguments in the request history, so a restart, a fork,
+ * a rollback or /compact needs no code of its own. No step, two ready steps, a failed guard or any user message → the model. */
+export const PLANNED_TOOL = 'plan_next_steps';
+export const PLANNED_LIMITS = { steps: 8, args: 8 * 1024 };
+export const PLANNED_STEP_TOOLS = ['bash', 'read', 'grep', 'glob'];
+const PLANNED_GUARDS = ['ok', 'always'];
+const PLANNED_ID = /^[a-z0-9-]{1,32}$/;
+/** Composer Plus's own tool-call ids: `cpgs-<8 hex of the plan call's id>-<step number>`. */
+const PLANNED_CALL = /^cpgs-([0-9a-f]{8})-([1-9]\d?)$/;
+const PLANNED_SECTION = `# Planned steps (Composer Plus)
+When you already know the exact next commands and only a tool result decides whether they run (for example: build, then test when the build passes), call \`${PLANNED_TOOL}\` in the same message as the first command. Composer Plus runs each planned step without asking you again when its predecessor finished and its guard holds.
+- \`after\`: "root" (the other tool calls of that message) or the id of an earlier step.
+- \`when\`: "ok" (the predecessor succeeded; for bash: no \`[exit code: N]\` or other fail mark) or "always".
+- Tools: ${PLANNED_STEP_TOOLS.join(', ')}. Write the complete, literal arguments. Do not plan a step whose arguments depend on output that you did not see.
+You see every result. When a guard fails, when two steps are ready at the same time, or after the last step, you answer again. A new user message ends the plan.`;
+
+/** The steps of one `plan_next_steps` call, checked; throws a plain reason (the tool's error text) for a bad plan. */
+export function parsePlan(args) {
+  const fail = (message) => { throw new Error(message); };
+  if (!plainObject(args) || !Array.isArray(args.steps)) fail('"steps" must be a list of steps');
+  if (args.steps.length < 1 || args.steps.length > PLANNED_LIMITS.steps) fail(`a plan has 1 to ${PLANNED_LIMITS.steps} steps`);
+  const ids = new Set();
+  return args.steps.map((s, i) => {
+    const at = `step ${i + 1}`;
+    if (!plainObject(s)) fail(`${at} must be an object`);
+    if (typeof s.id !== 'string' || !PLANNED_ID.test(s.id) || s.id === 'root') fail(`${at}: "id" must be 1 to 32 of a-z, 0-9 and "-" (not "root")`);
+    if (ids.has(s.id)) fail(`${at}: the id "${s.id}" is used twice`);
+    const after = s.after ?? 'root';
+    if (after !== 'root' && !ids.has(after)) fail(`${at}: "after" must be "root" or the id of an earlier step`);
+    const when = s.when ?? 'ok';
+    if (!PLANNED_GUARDS.includes(when)) fail(`${at}: "when" must be "ok" or "always"`);
+    if (!PLANNED_STEP_TOOLS.includes(s.tool)) fail(`${at}: "tool" must be one of ${PLANNED_STEP_TOOLS.join(', ')}`);
+    if (!plainObject(s.arguments)) fail(`${at}: "arguments" must be an object`);
+    if (s.tool === 'bash' && s.arguments.run_in_background === true) fail(`${at}: a planned bash step runs in the foreground (its result is the guard)`);
+    // dsh's bash tool needs a description; it is only the label in the chat.
+    const args2 = s.tool === 'bash' && typeof s.arguments.description !== 'string' ? { description: `Planned step ${s.id}`, ...s.arguments } : s.arguments;
+    if (JSON.stringify(args2).length > PLANNED_LIMITS.args) fail(`${at}: "arguments" are longer than ${PLANNED_LIMITS.args} characters`);
+    ids.add(s.id);
+    return { id: s.id, after, when, tool: s.tool, args: args2 };
+  });
+}
+
+/** One finished call passed: not an error, and for bash no fail mark of dsh in the last 8 lines (the Goal check rule). */
+const plannedOk = (tool, result) => result !== undefined && result.isError !== true
+  && (tool !== 'bash' || !BASH_FAIL.test(textBlocks(result.content).split('\n').slice(-8).join('\n')));
+const planTag = (callId) => createHash('sha256').update(String(callId)).digest('hex').slice(0, 8);
+
+/** The step to run now for a model request's `messages`, or undefined (then the model answers). `tools`: the names that the
+ * request offers. Reads back from the end: tool results, dsh's runtime context, developer and system messages are neutral;
+ * Composer Plus's own step messages are counted; the newest model message before them must hold an accepted plan. Any other
+ * user message (the user, steer, Continue, /compact, a rollback marker) ends the plan. */
+export function nextPlannedStep(messages, tools) {
+  if (!Array.isArray(messages)) return undefined;
+  const results = new Map();
+  const ran = [];
+  let i = messages.length - 1;
+  for (; i >= 0; i--) {
+    const m = messages[i];
+    if (m?.role === 'tool') { results.set(m.toolCallId ?? m.source?.callId, m); continue; }
+    if (m?.role === 'developer' || m?.role === 'system') continue;
+    if (m?.role === 'user') { if (m.source?.kind === 'runtime-context') continue; return undefined; }
+    if (m?.role !== 'assistant') return undefined;
+    const calls = (Array.isArray(m.content) ? m.content : []).filter((b) => b?.type === 'tool-call');
+    if (calls.length === 1 && PLANNED_CALL.test(calls[0].id)) { ran.push(calls[0]); continue; }
+    break;
+  }
+  if (i < 0 || !Array.isArray(messages[i].content)) return undefined;
+  const planned = messages[i];
+  const calls = planned.content.filter((b) => b?.type === 'tool-call');
+  const planCall = calls.find((c) => c.name === PLANNED_TOOL);
+  if (planCall === undefined || !plannedOk(PLANNED_TOOL, results.get(planCall.id))) return undefined;
+  let steps;
+  try { steps = parsePlan(argsOf(planCall.arguments)); } catch { return undefined; }
+  const tag = planTag(planCall.id);
+  // `root`: the other calls of the planning message (the plan call alone when there are none); all of them have results.
+  const rootCalls = calls.length > 1 ? calls.filter((c) => c !== planCall) : [planCall];
+  if (!rootCalls.every((c) => results.has(c.id))) return undefined;
+  const done = new Map([['root', rootCalls.every((c) => plannedOk(c.name, results.get(c.id)))]]);
+  for (const call of ran) {
+    const [, t, n] = call.id.match(PLANNED_CALL);
+    const step = steps[Number(n) - 1];
+    if (t !== tag || step === undefined || done.has(step.id) || !results.has(call.id)) return undefined;
+    done.set(step.id, plannedOk(step.tool, results.get(call.id)));
+  }
+  const ready = steps.map((step, k) => ({ step, n: k + 1 })).filter(({ step }) => !done.has(step.id) && done.has(step.after)
+    && (step.when === 'always' || done.get(step.after) === true) && (tools === undefined || tools.has(step.tool)));
+  if (ready.length !== 1) return undefined;
+  return { ...ready[0], tag, reasoning: planned.content.some((b) => b?.type === 'reasoning') };
+}
+
+/** The chunks of the assistant message that runs `found` (the answer of nextPlannedStep). */
+export function plannedStepChunks(found) {
+  const { step, n, tag, reasoning } = found;
+  const id = `cpgs-${tag}-${n}`;
+  const args = JSON.stringify(step.args);
+  const blocks = [];
+  if (reasoning) blocks.push({ type: 'reasoning', text: `Composer Plus ran step "${step.id}" of an earlier ${PLANNED_TOOL} plan because its guard "${step.when}" held after "${step.after}". The model did not reason for this step.` });
+  blocks.push({ type: 'text', text: `Composer Plus · Planned steps: ran \`${step.id}\` (after \`${step.after}\`, guard ${step.when}) without a model call.` });
+  const chunks = [];
+  blocks.forEach((b, index) => {
+    chunks.push({ type: 'block-start', index, blockType: b.type });
+    chunks.push({ type: b.type === 'text' ? 'text-delta' : 'reasoning-delta', index, text: b.text });
+    chunks.push({ type: 'block-end', index, block: b });
+  });
+  const index = blocks.length;
+  chunks.push({ type: 'block-start', index, blockType: 'tool-call' });
+  chunks.push({ type: 'tool-call-delta', index, id, name: step.tool, argumentsDelta: args });
+  chunks.push({ type: 'block-end', index, block: { type: 'tool-call', id, name: step.tool, arguments: args } });
+  chunks.push({ type: 'finish', reason: { kind: 'tool-calls' } });
+  return chunks;
+}
+
+/** The `llm/stream` listener: an agent request of a chat (it has a session, no purpose such as compaction, and offers the
+ * plan tool) with one ready step gets the step's message; every other request goes on to the model. */
+export function plannedStream(options, next) {
+  let found;
+  try {
+    const tools = Array.isArray(options?.tools) ? new Set(options.tools.map((t) => t?.name)) : undefined;
+    if (options?.sessionId !== undefined && options.purpose === undefined && tools?.has(PLANNED_TOOL)) found = nextPlannedStep(options.messages, tools);
+  } catch { found = undefined; }
+  if (found === undefined) return next();
+  const chunks = plannedStepChunks(found);
+  return (async function* () { yield* chunks; })();
+}
+
+/** Planned steps (Host half): the switch route (off by default), and while it is on: the tool, the prompt section and the
+ * `llm/stream` listener, all in one fiber that switching off disposes. */
+export function installPlannedSteps(ctx, home, file = join(home, 'storages', 'dsh-composer-plus', 'planned-steps.json')) {
+  const sw = mobileSwitch(file);
+  let on = false;
+  let fiber;
+  const tool = {
+    name: PLANNED_TOOL,
+    description: `Plan your next tool calls when you already know their exact arguments and only a tool result decides whether they run. Composer Plus runs each step without a new model call when its predecessor finished and its guard holds; you see every result. Call it in the same message as the first command. Steps: ${PLANNED_STEP_TOOLS.join(', ')} only.`,
+    parameters: { type: 'object', properties: {
+      steps: { type: 'array', description: `1 to ${PLANNED_LIMITS.steps} steps, in order`, items: { type: 'object', properties: {
+        id: { type: 'string', description: 'A short name: a-z, 0-9 and "-", such as "test"' },
+        after: { type: 'string', description: '"root" (the default: the other tool calls of this message) or the id of an earlier step' },
+        when: { type: 'string', enum: PLANNED_GUARDS, description: '"ok" (the default): only when the predecessor succeeded; "always": when it finished' },
+        tool: { type: 'string', enum: PLANNED_STEP_TOOLS },
+        arguments: { type: 'object', description: 'The complete, literal arguments of the tool call' },
+      }, required: ['id', 'tool', 'arguments'] } },
+    }, required: ['steps'] },
+    output: textOutput,
+    async execute(args) {
+      const steps = parsePlan(args);
+      return `Plan accepted: ${steps.map((s) => `${s.id} (${s.tool}, after ${s.after}, when ${s.when})`).join('; ')}. Composer Plus runs a step without a model call when its predecessor finished and its guard holds. A failed guard, two ready steps, the last step or a new user message gives the turn back to you.`;
+    },
+  };
+  const apply = (next) => {
+    on = next;
+    if (on && fiber === undefined && typeof ctx.inject === 'function') {
+      fiber = ctx.inject(['tools', 'systemPrompt'], (sub) => {
+        sub.tools.register(tool);
+        sub.systemPrompt.section({ name: 'composer-plus:planned-steps', order: 660, interpolate: false, text: () => PLANNED_SECTION });
+        sub.on('llm/stream', plannedStream);
+      });
+    } else if (!on) { fiber?.dispose?.(); fiber = undefined; }
+  };
+  const ready = sw.read().then(apply, () => apply(false));
+  ctx.effect?.(() => () => { on = false; fiber?.dispose?.(); fiber = undefined; }, 'dsh-composer-plus: planned steps');
+  // One switch change at a time, in order: the saved file and the live state always end on the newest click.
+  let switching = ready;
+  ctx.connection.fetch.register({
+    path: PLANNED_PATH, methods: ['GET', 'POST'], requestBody: 'buffered',
+    fetch: async (request) => {
+      await ready;
+      if (request.method === 'POST') {
+        let body;
+        try { body = await request.json(); } catch { return json({ error: 'bad request' }, 400); }
+        if (!plainObject(body) || Object.keys(body).join() !== 'on' || typeof body.on !== 'boolean') return json({ error: 'bad request' }, 400);
+        const change = switching.then(async () => { await sw.write(body.on); apply(body.on); });
+        switching = change.catch(() => {});
+        try { await change; } catch (error) { return json({ error: String(error?.message ?? error) }, 500); }
+      }
+      return json({ on });
+    },
+  });
+  return { ready, tool };
+}