sign-off-axi 0.4.7 → 0.4.8

package/README.md

@@ -172,6 +172,8 @@ the new page on a phone." \
 
 *Proof of a fix, with two captures. Pass, Fail, or Needs work.*
 
+Evidence lists passed proof only: an update whose linked run passed. A plain update like this links no run, so it waits in **Waiting on you** instead, as does a failed or unchecked run, each with its honest result and its verdicts and Dismiss, so the agent still gets an answer. Passed updates are grouped by the project named in the run's proof line, `verify-<project>: ...` (trimmed, compared without case); a proof line with no such prefix goes under **Other**.
+
 ### Explainer video, with chapters
 
 ```sh
@@ -354,7 +356,8 @@ cannot block can be woken instead: an `on_answer:` line in the
 `config.yaml` beside the board names a command the board runs for every
 answer. A `notify:` block in that config can send an HTTP POST when a card
 enters Waiting on you, with its bearer token read from a named environment
-variable. The full reference, with the worked example, is in
+variable, or, with `receiver: muxr`, from the muxr host's `notify-token`
+file; `sign-off-axi notify test` sends a test notice. The full reference, with the worked example, is in
 [docs/commands.md](docs/commands.md).
 
 Every command takes `--help` and prints compact output with next-step hints.

package/dist/cli.js

@@ -28,8 +28,8 @@ const AGENTS = {
     'gemini-cli': { bin: 'gemini', dir: '.agents/skills', home: join(homedir(), '.gemini', 'skills') },
 };
 const TOP_HELP = `usage: sign-off-axi [command] [board.json] [flags]
-commands[17]:
-  (none)=list, raise, post, answers, wait, poll, open, status, stop, serve, export, init, report, signin, doctor, validate, help
+commands[18]:
+  (none)=list, raise, post, answers, wait, poll, open, status, stop, serve, export, init, report, signin, doctor, notify, validate, help
 board: the nearest .sign-off/ board (the walk's bounds and SIGN_OFF_HOME: README, "Test runs never touch your board"), else ~/.sign-off/decisions.json; a board file given always wins
 flags: --full and --json on list, answers and wait, --events on wait, --json on status, --filer on post, raise and wait, --help on every command, -v/--version
 examples:
@@ -62,7 +62,7 @@ examples:
   sign-off-axi
   sign-off-axi list ./decisions.json --full
 `,
-    raise: `usage: sign-off-axi raise [board.json] --title "<question>" [--key <key>] [--about <text>] [--detail <text>] --why <text> [--option <value>=<label>]... --outcome <value>=<text>... --recommend <value> --recommend-reason <text> --default <value> [--silent-by <ISO time>] [--merge <key>]... [--close done|release] [--filer <id>]
+    raise: `usage: sign-off-axi raise [board.json] --title "<question>" [--key <key>] [--about <text>] [--detail <text>] --why <text> [--option <value>=<label>]... --outcome <value>=<text>... --recommend <value> --recommend-reason <text> --default <value> [--silent-by <ISO time>] [--merge <key>]... [--proof <key>] [--close done|release] [--filer <id>]
        sign-off-axi raise [board.json] --from <decisions.json> [--filer <id>]
 Adds questions to the board: yes/no, or 2 to 6 choices with one --option each. --key defaults to a slug of the title.
 raise is the alias for post --type decision: same flags, same output.
@@ -76,6 +76,7 @@ Every question meets the question standard (docs/contract.md, "Asking a good que
   yes and no are labelled Yes and No; a question never takes Done, OK or Not now buttons.
 One decision is one card: look at the open cards first. --merge <key> (up to 10) names other cards on the board that ask the same thing and offer every option of this one:
 they are hidden while this one waits, and its answer closes them too, with the same value and a note naming this key. A merged card merges nothing itself, a card is named by one ask until that ask is answered, and an answered or dismissed card cannot be merged.
+--proof <key> names an evidence update already on the board that this ask rests on: Decide shows its capture and result at the top.
 The user answers with one tap and can undo it for a few seconds.
 --from adds every decision in a decisions file: ${FORMAT}
 Raising the same question again is a no-op that reports its status; a different question under a used key is refused.
@@ -286,6 +287,19 @@ It opens from disk with no server and makes no network request. --out defaults t
 examples:
   sign-off-axi export
   sign-off-axi export ./decisions.json --out ~/board-12-oct.html
+`,
+    notify: `usage: sign-off-axi notify [check|test] [dir]
+Device notifications are off until the config.yaml beside the board has a notify: block. For the muxr receiver it is:
+  notify:
+    receiver: muxr
+    link_base: https://my-machine.my-tailnet.ts.net:4410/   (https or a tailnet address, so the link opens on the iPad)
+    url: http://127.0.0.1:8793/v1/notify                    (optional: this is the default)
+The token is read at send time from the file <MUXR_HOME>/notify-token (default ~/.muxr/notify-token), never kept in the config.
+check (the default): says whether notifications are off, misconfigured, waiting on the token file, or ready. It sends nothing.
+test: sends one real "sign-off test" notice now and says plainly what happened (sent, no token file, token refused, receiver not running).
+examples:
+  sign-off-axi notify
+  sign-off-axi notify test
 `,
     doctor: `usage: sign-off-axi doctor [dir]
 Checks the repo setup init wrote: node version, config, board file, answer files, a lock a crashed command left behind, gitignore lines, folders, whether the dashboard port is free,
@@ -323,7 +337,7 @@ function fits(title, key) {
         throw fail(`${key ? `key ${key}: ` : ''}title is ${n} characters, over ${TITLE_MAX}`, 'VALIDATION_ERROR', `Shorten the title to ${TITLE_MAX} characters and put the rest in about`);
 }
 /** The question standard's flags: a decision's why, each option's outcome, the reason for the recommendation, when silence decides, the cards it merges. */
-const ASK_FLAGS = ['why', 'outcome', 'recommend-reason', 'silent-by', 'merge'];
+const ASK_FLAGS = ['why', 'outcome', 'recommend-reason', 'silent-by', 'merge', 'proof'];
 const MANY = ['option', 'outcome', 'merge'];
 /** Board types that are contract kinds: a decision (the default type) is an ask. */
 const CONTRACT_TYPES = ['decision', 'ask', 'evidence', 'report', 'plan', 'design'];
@@ -1304,7 +1318,7 @@ function buildIncoming(values, extra, filer, file) {
     try {
         const { title, key = slug(title), about, detail, why, recommend: recommend_value, default: default_if_silent, close } = values;
         const ask = !Object.hasOwn(extra, 'type'), options = ask ? outcomesOf(values) : optionsOf(values);
-        const told = ask && { why, recommend_reason: values['recommend-reason'], silent_by: values['silent-by'], merges: values.merge };
+        const told = ask && { why, recommend_reason: values['recommend-reason'], silent_by: values['silent-by'], merges: values.merge, proof: values.proof };
         writeFileSync(source, JSON.stringify({ schema: 2, items: [{ key, title, about, detail, ...told, options, recommend_value, default_if_silent, close, ...extra, filer }] }));
         const incoming = loadDecisions(source, board), raw = readItems(source).items;
         if (!ask)
@@ -1330,6 +1344,9 @@ const canon = (v) => JSON.stringify(v, (_, x) => (x && typeof x === 'object' &&
 /** A merge names cards on the board that take this card's answer: each is on the board, offers every option of this card, and merges nothing itself.
  * A card is named by one ask until that ask is answered, dismissed or not. A merge new to the board also names a card still open. */
 function checkMerges(incoming, resulting, current) {
+    for (const d of incoming)
+        if (d.proof && resulting.find((x) => x.key === d.proof)?.type !== 'evidence')
+            throw fail(`key ${d.key} rests on ${d.proof}, which is not an evidence update on the board`, 'VALIDATION_ERROR', `Post the evidence update first, or leave out --proof`);
     const byKey = new Map(resulting.map((d) => [d.key, d])), before = new Map(current.map((c) => [c.key, c]));
     const closed = (key) => !!(before.get(key)?.answer || before.get(key)?.dismissed);
     const holder = (key, self) => resulting.find((x) => x.key !== self && !before.get(x.key)?.answer && x.merges?.includes(key));
@@ -1617,11 +1634,11 @@ function readSetup(so) {
     readFileSync(join(so, 'config.yaml'), 'utf8').split(/\r?\n/).forEach((l, n) => {
         // The notify block's indented lines keep their # , and } characters: only a # after a space starts a comment.
         if (inNotify && (!l.trim() || /^\s/.test(l))) {
-            const text = l.replace(/(^|\s+)#.*$/, '').trim(), field = text.match(/^(url|token_env|link_base)\s*:\s*(.+)$/);
+            const text = l.replace(/(^|\s+)#.*$/, '').trim(), field = text.match(/^(url|token_env|link_base|receiver)\s*:\s*(.+)$/);
             if (field)
                 notify[field[1]] = field[2].replace(/^(['"])(.*)\1$/, '$2');
             else if (text)
-                problems.push(`line ${n + 1} is not one "url", "token_env" or "link_base" line under notify`);
+                problems.push(`line ${n + 1} is not one "receiver", "url", "token_env" or "link_base" line under notify`);
             return;
         }
         inNotify = false;
@@ -1661,15 +1678,36 @@ function readSetup(so) {
     catch {
         return undefined;
     } };
+    const muxr = notify.receiver?.toLowerCase() === 'muxr';
+    if (notifyBlock && notify.receiver && !muxr)
+        problems.push('notify receiver must be muxr, or leave the receiver line out');
+    if (muxr)
+        notify.url ??= MUXR_URL;
     const sendTo = parsed(notify.url), base = parsed(notify.link_base);
     const usable = !!sendTo && !!base && (sendTo.protocol === 'https:' || (sendTo.protocol === 'http:' && (loopback(sendTo.hostname.replace(/^\[|\]$/g, '')) || sendTo.hostname === 'localhost')))
         && ['http:', 'https:'].includes(base.protocol) && (notify.token_env === undefined || /^[A-Za-z_]\w*$/.test(notify.token_env));
     if (notifyBlock && !usable)
         problems.push('notify needs url (https://, or http:// on this machine) and link_base (http:// or https://) lines, and token_env must name an environment variable');
+    // A phone or iPad opens the link, so a muxr notice's link is https or a tailnet address: 127.0.0.1 or a LAN name would be dead there.
+    const reachable = !!base && (base.protocol === 'https:' || /\.ts\.net$/i.test(base.hostname) || (isIP(base.hostname) === 4 && /^100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\./.test(base.hostname)));
+    if (notifyBlock && usable && muxr && !reachable)
+        problems.push('notify link_base must be https:// or a tailnet address (a .ts.net name or 100.x address) so the link opens on the iPad');
     return { board: join(so, goodBoard ? config.board : 'decisions.json'), port: goodPort ? Number(port) : 4410, bind, hosts, onAnswer, goodBoard, problems,
-        notify: notifyBlock && usable ? { url: notify.url, token_env: notify.token_env, link_base: notify.link_base } : undefined };
+        notify: notifyBlock && usable && (!muxr || reachable) ? { url: notify.url, token_env: notify.token_env, link_base: notify.link_base, muxr } : undefined };
 }
-const NOTIFY_SENDER = `void (async()=>{const delays=[2000,10000,60000];for(let i=0;i<4;i++){try{if((await fetch(process.env.SIGN_OFF_NOTIFY_URL,{method:'POST',headers:{'content-type':'application/json',...(process.env.SIGN_OFF_NOTIFY_TOKEN&&{authorization:'Bearer '+process.env.SIGN_OFF_NOTIFY_TOKEN})},body:process.env.SIGN_OFF_NOTIFY_BODY,signal:AbortSignal.timeout(10000)})).ok)return}catch{}if(i<3)await new Promise(r=>setTimeout(r,delays[i]))}require('node:fs').appendFileSync(process.env.SIGN_OFF_NOTIFY_LOG,new Date().toISOString()+' notification send failed for card '+process.env.SIGN_OFF_NOTIFY_ID+'\\n')})();`;
+const MUXR_URL = 'http://127.0.0.1:8793/v1/notify';
+/** The muxr receiver's token file, read at send time and never stored: <MUXR_HOME>/notify-token, MUXR_HOME defaulting to ~/.muxr. */
+const muxrTokenFile = () => join(process.env.MUXR_HOME || join(homedir(), '.muxr'), 'notify-token');
+/** Why a notice cannot be sent yet, in plain words; undefined when its token is there. */
+const tokenMissing = (n) => n.muxr
+    ? (() => { try {
+        return readFileSync(muxrTokenFile(), 'utf8').trim() ? undefined : `${tilde(muxrTokenFile())} is empty`;
+    }
+    catch {
+        return `${tilde(muxrTokenFile())} is not there yet (the muxr host writes it when it updates)`;
+    } })()
+    : n.token_env && !process.env[n.token_env] ? `${n.token_env} is not set` : undefined;
+const NOTIFY_SENDER = `void (async()=>{const delays=[2000,10000,60000],f=process.env.SIGN_OFF_NOTIFY_TOKEN_FILE;for(let i=0;i<4;i++){try{const t=f?require('node:fs').readFileSync(f,'utf8').trim():process.env.SIGN_OFF_NOTIFY_TOKEN;if((await fetch(process.env.SIGN_OFF_NOTIFY_URL,{method:'POST',headers:{'content-type':'application/json',...(t&&{authorization:'Bearer '+t})},body:process.env.SIGN_OFF_NOTIFY_BODY,signal:AbortSignal.timeout(10000)})).ok)return}catch{}if(i<3)await new Promise(r=>setTimeout(r,delays[i]))}require('node:fs').appendFileSync(process.env.SIGN_OFF_NOTIFY_LOG,new Date().toISOString()+' notification send failed for card '+process.env.SIGN_OFF_NOTIFY_ID+'\\n')})();`;
 /** The cards waiting on the user before a write: a card waiting after the write but not before it has entered Waiting on you. */
 function waitingKeys(file) {
     try {
@@ -1685,7 +1723,7 @@ function waitingKeys(file) {
 function notifyEntered(file, named, before) {
     try {
         const so = dirname(named), notify = before ? readSetup(so).notify : undefined;
-        if (!before || !notify || (notify.token_env && !process.env[notify.token_env]))
+        if (!before || !notify || tokenMissing(notify))
             return;
         const { items } = readItems(file), fresh = board(file, () => { }).filter((d) => waits(d) && !before.has(d.key) && !items.some((i) => i?.key === d.key && i.announced));
         if (!fresh.length)
@@ -1700,13 +1738,18 @@ function notifyEntered(file, named, before) {
     }
     catch { }
 }
+/** The JSON one card sends: sign-off's own shape, or muxr's {title (1-80 chars), body, url, id}. */
+function noticeBody(notify, d) {
+    const kind = d.kind ?? { decision: 'ask', explainer: d.options.length ? 'ask' : 'report' }[d.type] ?? d.type;
+    const text = [...(d.about ?? d.detail ?? d.why ?? d.title).replace(/[\r\n]+/g, ' ')].slice(0, 200).join(''), url = `${notify.link_base.replace(/\/$/, '')}#waiting/${encodeURIComponent(d.key)}`;
+    if (notify.muxr)
+        return { title: [...d.title].slice(0, 80).join('') || d.key, body: text, url, id: d.key };
+    return { v: 1, source: 'sign-off', id: d.key, kind: ['ask', 'plan', 'design', 'evidence', 'report'].includes(kind) ? kind : 'ask',
+        title: [...d.title].slice(0, 120).join(''), text, url, at: d.filed ?? new Date().toISOString() };
+}
 function sendNotice(so, notify, d) {
     const token = notify.token_env ? process.env[notify.token_env] : undefined;
-    const kind = d.kind ?? { decision: 'ask', explainer: d.options.length ? 'ask' : 'report' }[d.type] ?? d.type;
-    const body = JSON.stringify({ v: 1, source: 'sign-off', id: d.key, kind: ['ask', 'plan', 'design', 'evidence', 'report'].includes(kind) ? kind : 'ask',
-        title: [...d.title].slice(0, 120).join(''), text: [...(d.about ?? d.detail ?? d.why ?? d.title).replace(/[\r\n]+/g, ' ')].slice(0, 200).join(''),
-        url: `${notify.link_base.replace(/\/$/, '')}#waiting/${encodeURIComponent(d.key)}`, at: d.filed ?? new Date().toISOString() });
-    const child = spawn(process.execPath, ['-e', NOTIFY_SENDER], { detached: true, stdio: 'ignore', env: { ...process.env, SIGN_OFF_NOTIFY_URL: notify.url, SIGN_OFF_NOTIFY_BODY: body, SIGN_OFF_NOTIFY_TOKEN: token ?? '', SIGN_OFF_NOTIFY_ID: d.key, SIGN_OFF_NOTIFY_LOG: join(so, 'notify.log') } });
+    const child = spawn(process.execPath, ['-e', NOTIFY_SENDER], { detached: true, stdio: 'ignore', env: { ...process.env, SIGN_OFF_NOTIFY_URL: notify.url, SIGN_OFF_NOTIFY_BODY: JSON.stringify(noticeBody(notify, d)), SIGN_OFF_NOTIFY_TOKEN: notify.muxr ? '' : token ?? '', SIGN_OFF_NOTIFY_TOKEN_FILE: notify.muxr ? muxrTokenFile() : '', SIGN_OFF_NOTIFY_ID: d.key, SIGN_OFF_NOTIFY_LOG: join(so, 'notify.log') } });
     child.on('error', () => warn(`notification sender could not start for card ${d.key}`));
     child.unref();
 }
@@ -1722,7 +1765,7 @@ function init(args) {
     }
     catch { }
     const files = [
-        [join(so, 'config.yaml'), `# sign-off repo setup. board: path under .sign-off/, port: dashboard port, agent: auto or the coding agents to install the skill for.\n# bind: 127.0.0.1 keeps the dashboard on this machine; a private address such as its VPN address lets a phone open it.\n# hosts: (optional) private DNS names that lead to that address, such as its mesh VPN name, commas between them.\n# on_answer: (optional) a command run for each answer, with the answer as one JSON line on its stdin; no shell, so | > && do nothing: on_answer: node hook.mjs\nboard: decisions.json\nport: 4410\nbind: 127.0.0.1\nagent: ${agent}\n`],
+        [join(so, 'config.yaml'), `# sign-off repo setup. board: path under .sign-off/, port: dashboard port, agent: auto or the coding agents to install the skill for.\n# bind: 127.0.0.1 keeps the dashboard on this machine; a private address such as its VPN address lets a phone open it.\n# hosts: (optional) private DNS names that lead to that address, such as its mesh VPN name, commas between them.\n# on_answer: (optional) a command run for each answer, with the answer as one JSON line on its stdin; no shell, so | > && do nothing: on_answer: node hook.mjs\n# name: (optional) your name, shown on the board. leash: how much agents may do without asking: ask, matters (the default) or act; the board's Leash control sets it.\nboard: decisions.json\nport: 4410\nbind: 127.0.0.1\nagent: ${agent}\n`],
         [board, `{"schema": 2, "items": []}\n`],
         [join(so, '.gitignore'), GITIGNORE],
     ];
@@ -1794,6 +1837,43 @@ function report(args) {
             : `Run \`sign-off-axi post <board.json> --type report --title "<the answer>" --about "<why it matters>" --view <path>/index.html --preview <path>/preview.svg\`, both paths from the board file's folder, which must hold this folder`,
     ]);
 }
+/** `notify check|test`: whether device notifications can work from this setup, and one real test notice. Never prints the token. */
+async function notify(args) {
+    const mode = ['check', 'test'].includes(args[0]) ? args.shift() : 'check';
+    const { dir: folder, given } = repoDir('notify', args), dir = given ? folder : setupFolderHere() ?? folder, so = join(dir, '.sign-off');
+    let setup;
+    try {
+        setup = readSetup(so);
+    }
+    catch {
+        throw fail(`no readable config.yaml in ${tilde(so)}`, 'NOT_FOUND', `Run \`sign-off-axi init ${shellPath(dir)}\``);
+    }
+    const config = shellPath(join(so, 'config.yaml'));
+    if (setup.problems.some((p) => p.startsWith('notify')))
+        throw fail(`the notify: block in ${tilde(join(so, 'config.yaml'))} cannot be used: ${setup.problems.filter((p) => p.startsWith('notify')).join('; ')}`, 'VALIDATION_ERROR', `Edit ${config}, then run \`sign-off-axi notify\` again`);
+    const n = setup.notify;
+    if (!n)
+        return toon({ notifications: 'off' }, [`Ask the user once whether they want device notifications; if yes, add \`notify:\`, \`  receiver: muxr\` and \`  link_base: <the board's https or tailnet address>\` lines to ${config}`]);
+    const why = tokenMissing(n);
+    if (why)
+        throw fail(`notifications are on but cannot send: ${why}`, 'NOT_FOUND', n.muxr ? 'Update the muxr host so it writes its notify-token file, then run `sign-off-axi notify test`' : `Export ${n.token_env} with the receiver's token`);
+    if (mode === 'check')
+        return toon({ notifications: 'on', receiver: n.muxr ? 'muxr' : 'webhook', url: n.url, link_base: n.link_base, token: n.muxr ? tilde(muxrTokenFile()) : `$${n.token_env ?? '(none)'}` }, ['Run `sign-off-axi notify test` to send one real test notice']);
+    const probe = { key: 'sign-off-test', title: 'sign-off test', about: 'Device notifications from sign-off work.', type: 'decision', options: [] };
+    let status;
+    try {
+        const token = n.muxr ? readFileSync(muxrTokenFile(), 'utf8').trim() : n.token_env ? process.env[n.token_env] : undefined;
+        status = (await fetch(n.url, { method: 'POST', headers: { 'content-type': 'application/json', ...(token && { authorization: `Bearer ${token}` }) }, body: JSON.stringify(noticeBody(n, probe)), signal: AbortSignal.timeout(10000) })).status;
+    }
+    catch {
+        throw fail(`nothing answered at ${n.url}`, 'NOT_FOUND', n.muxr ? 'Start the muxr host on this machine, then run `sign-off-axi notify test` again' : 'Check the url: line, then run `sign-off-axi notify test` again');
+    }
+    if ([401, 403].includes(status))
+        throw fail(`the receiver refused the token (HTTP ${status})`, 'VALIDATION_ERROR', n.muxr ? `Check that ${tilde(muxrTokenFile())} holds the token the muxr host expects` : `Check ${n.token_env}`);
+    if (status >= 300)
+        throw fail(`the receiver answered HTTP ${status}, so the test notice was not accepted`, 'VALIDATION_ERROR', 'Check the receiver is the notification endpoint');
+    return toon({ notifications: 'on', test: 'sent', http: status }, ['Check the device for the "sign-off test" notice']);
+}
 async function doctor(args) {
     const { dir: folder, given } = repoDir('doctor', args), dir = given ? folder : setupFolderHere() ?? folder, so = join(dir, '.sign-off'), rerun = `sign-off-axi init ${shellPath(dir)}`;
     const checks = [];
@@ -1861,8 +1941,9 @@ async function doctor(args) {
                     check('config', `board ${basename(board)}, port ${port}`);
                 else
                     check('config', `${basename(config)}: ${setup.problems.join('; ')}`, `Edit ${shellPath(config)} to hold "board: <name>.json", "port: <0-65535>" and "bind: <127.0.0.1 or a private address>" lines, such as board: decisions.json, port: 4410 and bind: 127.0.0.1, and hosts: only DNS names${setup.goodBoard ? '' : `, or delete it and run \`${rerun}\``}`);
-                if (setup.notify?.token_env && !process.env[setup.notify.token_env])
-                    check('notify', `${setup.notify.token_env} is not set, so no notice is sent`, `Export ${setup.notify.token_env} with the receiver's token`);
+                const why = setup.notify && tokenMissing(setup.notify);
+                if (setup.notify && why)
+                    check('notify', `${why}, so no notice is sent`, setup.notify.muxr ? 'Update the muxr host so it writes its notify-token file, then run `sign-off-axi notify test`' : `Export ${setup.notify.token_env} with the receiver's token`);
                 // A hosts: name is only of use when it leads to the bind address.
                 const astray = [];
                 for (const h of setup.hosts) {
@@ -1987,11 +2068,12 @@ async function doctor(args) {
         throw fail(`${bad.length} of ${checks.length} checks need a fix in ${tilde(dir)}`, 'NOT_FOUND', ...bad.map((c) => `${c.name}: ${c.ok}. ${c.fix}`));
     return toon({ dir: tilde(dir), checks: checks.map(({ name, ok }) => ({ name, ok })) }, [`Run \`sign-off-axi open ${shellPath(board)}\` to show the board to the user`]);
 }
-let file = '', evidenceRoot = '', bind = '127.0.0.1', hosts = [], onAnswer = [];
+let file = '', config = '', evidenceRoot = '', bind = '127.0.0.1', hosts = [], onAnswer = [];
 async function serve(args) {
     const parsed = parse('serve', args, BOARD_FLAGS), port = boardPort(parsed.named, parsed.values.port);
     ready(parsed.file, parsed.on, parsed.values['evidence-root']);
     bind = bindOf(parsed.named, parsed.values.bind);
+    config = join(dirname(parsed.named), 'config.yaml');
     ({ hosts = [], onAnswer = [] } = setupOf(parsed.named) ?? {});
     let warned = false;
     const sweep = async (phase) => {
@@ -2064,6 +2146,7 @@ async function exportBoard(args) {
     const parsed = parse('export', args, { out: { type: 'string' }, 'evidence-root': { type: 'string' } });
     ready(parsed.file, parsed.on, parsed.values['evidence-root']);
     [file, evidenceRoot] = [parsed.file, parsed.values['evidence-root'] ? resolve(parsed.values['evidence-root']) : ''];
+    config = join(dirname(parsed.named), 'config.yaml');
     guardReady = warmGuard();
     await guardReady;
     const { file: _, messages: _messages, annotations: _annotations, ...frozen } = state(), files = {}, q = encodeURIComponent;
@@ -2182,6 +2265,22 @@ const warmGuard = () => new Promise((done) => {
     };
     pass(true);
 });
+/** How much agents may do without asking, from the leash: line of config.yaml: ask (wait on every ask), matters (take the default at the
+ * silent-by time, the default) or act (take the recommended pick now and report it). With the name: line it is the page's only setting. */
+const LEASHES = ['ask', 'matters', 'act'];
+const configLine = (text, key) => new RegExp(`^[ \\t]*${key}[ \\t]*:([^#\\n]*)`, 'm').exec(text)?.[1].trim() || undefined;
+/** The user's name and leash; none for a board with no config.yaml beside it. */
+function profile() {
+    let text;
+    try {
+        text = readFileSync(config, 'utf8');
+    }
+    catch {
+        return {};
+    }
+    const leash = configLine(text, 'leash') ?? '';
+    return { name: configLine(text, 'name')?.slice(0, 40), leash: LEASHES.includes(leash) ? leash : 'matters' };
+}
 const state = () => {
     reap();
     // The page marks sent comments in annotations, so answers and rounds go without theirs: a read-only board or an export carries none.
@@ -2196,6 +2295,7 @@ const state = () => {
             ...(d.mocks && { mocks: d.mocks.map((m) => ({ ...m, hash: mockHash(m.path) })) }) })),
         readonly: readOnly(),
         answers_only: answersOnly(),
+        ...profile(),
         answers,
         seen: Object.values(answers).filter(taken).map((a) => a.key),
         rounds,
@@ -2372,7 +2472,7 @@ async function route(req) {
         clearTimeout(timer);
         return [200, state()];
     }
-    if (req.method !== 'POST' || !['/api/answers', '/api/rounds', '/api/messages', '/api/annotations', '/api/dismiss', '/api/signin'].includes(req.url ?? ''))
+    if (req.method !== 'POST' || !['/api/answers', '/api/rounds', '/api/messages', '/api/annotations', '/api/dismiss', '/api/signin', '/api/leash'].includes(req.url ?? ''))
         return [404, { error: 'Not found' }];
     if (readOnly())
         return [403, { error: 'This board is read-only' }];
@@ -2440,6 +2540,21 @@ async function route(req) {
             return board(file).find((x) => x.key === key)?.answer ? [200, { state: state() }] : [502, { error: e.message, state: state() }];
         }
     }
+    if (req.url === '/api/leash') {
+        const { leash } = JSON.parse(body) ?? {};
+        if (!LEASHES.includes(leash))
+            return [400, { error: `Send a leash of ${LEASHES.join(', ')}` }];
+        let text;
+        try {
+            text = readFileSync(config, 'utf8');
+        }
+        catch {
+            return [409, { error: 'This board has no config.yaml to keep the leash in; run sign-off-axi init' }];
+        }
+        const line = /^[ \t]*leash[ \t]*:.*$/m;
+        writeFileSync(config, line.test(text) ? text.replace(line, `leash: ${leash}`) : `${text.replace(/\n?$/, '\n')}leash: ${leash}\n`);
+        return [200, state()];
+    }
     if (req.url === '/api/dismiss') {
         const { keys, dismissed } = JSON.parse(body) ?? {};
         if (!Array.isArray(keys) || !keys.length || keys.length > 200 || typeof dismissed !== 'boolean')
@@ -2447,8 +2562,6 @@ async function route(req) {
         const have = new Map(board(file).map((x) => [x.key, x]));
         if (!keys.every((k) => isKey(k) && have.has(k)))
             return [404, { error: 'This item is no longer in the file' }];
-        if (dismissed && keys.some((k) => have.get(k)?.type === 'plan' && !have.get(k)?.answer))
-            return [400, { error: 'A plan waits until it is sent back, so it cannot be dismissed' }];
         appendDismissed(file, [...new Set(keys)], dismissed);
         return [200, state()];
     }
@@ -2675,7 +2788,7 @@ await runAxiCli({
     topLevelHelp: TOP_HELP,
     getCommandHelp: (cmd) => HELP[cmd],
     home: axi('list', list),
-    commands: { list: axi('list', list), raise: axi('raise', (args) => post(args, 'raise')), post: axi('post', post), answers: axi('answers', answers), wait: axi('wait', wait), poll: axi('poll', poll), open: axi('open', open), status: axi('status', status), stop: axi('stop', stop), serve: axi('serve', serve), export: axi('export', exportBoard), init: axi('init', init), report: axi('report', report), signin: axi('signin', signin), doctor: axi('doctor', doctor), validate, help: ([name, ...rest]) => {
+    commands: { list: axi('list', list), raise: axi('raise', (args) => post(args, 'raise')), post: axi('post', post), answers: axi('answers', answers), wait: axi('wait', wait), poll: axi('poll', poll), open: axi('open', open), status: axi('status', status), stop: axi('stop', stop), serve: axi('serve', serve), export: axi('export', exportBoard), init: axi('init', init), report: axi('report', report), signin: axi('signin', signin), doctor: axi('doctor', doctor), notify: axi('notify', notify), validate, help: ([name, ...rest]) => {
             if (rest.length || (name && !HELP[name]))
                 throw fail(`unknown command or argument: ${[name, ...rest].join(' ')}`, 'VALIDATION_ERROR', 'Run `sign-off-axi --help` to see the commands');
             return name ? HELP[name] : TOP_HELP;

package/dist/contract.js

@@ -1,7 +1,7 @@
 // The v1 communication contract (docs/contract.md): one strict, versioned shape per kind of message.
 import { accessSync, constants, readFileSync, realpathSync, statSync } from 'node:fs';
 import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
-import { isKey, MEDIA_MAX } from './store.js';
+import { isKey, MEDIA_MAX, REPORT_FORMS } from './store.js';
 /** A message that does not match: what is wrong, and the one line that says how to fix it. */
 export class ContractError extends Error {
     help;
@@ -15,12 +15,12 @@ export const SCHEMAS = { ask: 1, report: 2, evidence: 1, gate: 1, finding: 1, pl
 export const KINDS = Object.keys(SCHEMAS);
 const COMMON = ['contract', 'kind', 'schema', 'key', 'title', 'filer', 'link', 'about'];
 const FIELDS = {
-    ask: [...COMMON, 'detail', 'why', 'options', 'recommend_value', 'recommend_reason', 'default_if_silent', 'silent_by', 'close', 'merges'],
-    report: [...COMMON, 'filed', 'group', 'decided', 'view', 'preview'],
+    ask: [...COMMON, 'detail', 'why', 'options', 'recommend_value', 'recommend_reason', 'default_if_silent', 'silent_by', 'close', 'merges', 'proof'],
+    report: [...COMMON, 'filed', 'group', 'decided', 'form', 'video', 'asked_by', 'view', 'preview'],
     evidence: [...COMMON, 'media', 'run'],
     gate: [...COMMON, 'run', 'options', 'recommend_value', 'close'],
     finding: [...COMMON, 'cause', 'incidents', 'days', 'evidence_ids', 'change_kind', 'proposal', 'options', 'recommend_value'],
-    plan: [...COMMON, 'sections', 'decisions', 'steps', 'view'],
+    plan: [...COMMON, 'project', 'sections', 'decisions', 'steps', 'view'],
     design: [...COMMON, 'group', 'filed', 'status', 'preview', 'journeys', 'options', 'recommend'],
 };
 /** A done-done run: its id, full commit and the four Checks lines. */
@@ -82,7 +82,7 @@ const show = (v) => JSON.stringify(v);
 /** A field name as it reads inside a sentence: escaped, so a newline or control character shows as \n or \u001b. */
 const escaped = (v) => show(v).slice(1, -1);
 /** The raise flag each question field fills: a refusal of a flag post names that flag, not the field. */
-const FLAG_OF = { why: 'why', about: 'about', detail: 'detail', title: 'title', default_if_silent: 'default', recommend_reason: 'recommend-reason', recommend_value: 'recommend', silent_by: 'silent-by', merges: 'merge', options: 'option', label: 'option', value: 'option', outcome: 'outcome' };
+const FLAG_OF = { why: 'why', about: 'about', detail: 'detail', title: 'title', default_if_silent: 'default', recommend_reason: 'recommend-reason', recommend_value: 'recommend', silent_by: 'silent-by', merges: 'merge', proof: 'proof', options: 'option', label: 'option', value: 'option', outcome: 'outcome' };
 /** The flag a field fills: options[1].outcome is --outcome, merges[0] is --merge. */
 const flagOf = (field) => { const f = field.replace(/^options\[\d+\]\./, '').replace(/\[\d+\]$/, ''); return `--${FLAG_OF[f] ?? f}`; };
 /** A field as a refusal names it: the JSON field, or the raise flag that fills it. */
@@ -249,6 +249,12 @@ export function checkMessage(m, want, flags = false) {
             text('group', m.group, 40, 'the section it belongs to, in 40 characters or fewer, or leave it out');
         if (Object.hasOwn(m, 'decided'))
             text('decided', m.decided, 200, 'what was decided, in 200 characters or fewer, or leave it out');
+        if (Object.hasOwn(m, 'form') && !REPORT_FORMS.includes(m.form))
+            throw bad('form', `${show(m.form)} is not one of ${REPORT_FORMS.join(', ')}`, `Set "form" to ${REPORT_FORMS.join(', ')}, or leave it out`);
+        if (Object.hasOwn(m, 'video'))
+            text('video', m.video, 10, 'the video length such as "0:28", in 10 characters or fewer, or leave it out');
+        if (Object.hasOwn(m, 'asked_by'))
+            text('asked_by', m.asked_by, 40, 'who asked for it, such as "You asked" or "Docs agent", in 40 characters or fewer, or leave it out');
         // A report is a page to tap through and a picture of it for the card: text alone is a status note, not a report.
         const need = 'a report is a page to tap through, not text';
         page('view', /\.html$/i, '.html', '"mocks/<key>/index.html"', need);
@@ -309,6 +315,8 @@ export function checkMessage(m, want, flags = false) {
     }
     // A plan is sections to approve or change, decisions with a recommended pick, steps to tap through, and where it goes as a diagram.
     if (m.kind === 'plan') {
+        if (Object.hasOwn(m, 'project'))
+            text('project', m.project, 40, 'the project name, in 40 characters or fewer, or leave it out');
         const ids = list('sections', 1, 8, ['id', 'heading', 'body'], '{"id":"goals","heading":"Goals and non-goals","body":"<what it does and does not do>"}').map((o, n) => {
             if (!(typeof o.id === 'string' && /^[a-z0-9-]{1,40}$/.test(o.id)))
                 throw bad(`sections[${n}].id`, 'must be 1-40 of a-z 0-9 -', 'Set "id" to a short slug such as "goals"');
@@ -319,7 +327,7 @@ export function checkMessage(m, want, flags = false) {
         const twice = ids.findIndex((id, n) => ids.indexOf(id) < n);
         if (twice >= 0)
             throw bad(`sections[${twice}].id`, `repeats ${ids[twice]}`, 'Give every section its own id');
-        list('decisions', 0, 5, ['key', 'question', 'why', 'options', 'recommend'], '{"key":"store","question":"Keep plans in the board file?","why":"...","options":[...],"recommend":"yes"}').forEach((o, n, all) => {
+        list('decisions', 0, 5, ['key', 'question', 'why', 'reason', 'after', 'options', 'recommend'], '{"key":"store","question":"Keep plans in the board file?","why":"...","options":[...],"recommend":"yes"}').forEach((o, n, all) => {
             const at = `decisions[${n}]`;
             if (!isKey(o.key))
                 throw bad(`${at}.key`, 'must be 1-128 of A-Z a-z 0-9 . _ -', 'Set "key" to a short id such as "store"');
@@ -333,13 +341,21 @@ export function checkMessage(m, want, flags = false) {
             if (!/[\p{L}\p{N}]/u.test(q) || q.split(/\s+/).length > 12)
                 throw bad(`${at}.question`, 'must be one question of 12 words or fewer, ending in a question mark', 'Ask it in 12 words or fewer, ending in a question mark; put the rest in "why"');
             text(`${at}.why`, o.why, 500, 'why it matters, in 500 characters or fewer');
+            if (Object.hasOwn(o, 'reason'))
+                text(`${at}.reason`, o.reason, 300, 'why the recommended option, in 300 characters or fewer, or leave it out');
+            if (Object.hasOwn(o, 'after') && !ids.includes(o.after))
+                throw bad(`${at}.after`, `must be the id of one of the plan's sections`, `Set "after" to one of: ${ids.join(', ')}`);
             if (!Array.isArray(o.options) || o.options.length < 2 || o.options.length > 6)
                 throw bad(`${at}.options`, Object.hasOwn(o, 'options') ? 'must list 2 to 6 options' : 'is required', 'Set "options" to 2-6 objects such as {"value":"yes","label":"Yes","outcome":"Plans live in the board file"}');
             checkOptions(`${at}.options`, o.options, 'plan');
             recommend(`${at}.recommend`, o, o.options);
         });
         if (Object.hasOwn(m, 'steps'))
-            list('steps', 2, 12, ['title'], '{"title":"The agent posts the plan"}').forEach((o, n) => text(`steps[${n}].title`, o.title, 80, 'the step, in 80 characters or fewer'));
+            list('steps', 2, 12, ['title', 'text'], '{"title":"The agent posts the plan"}').forEach((o, n) => {
+                text(`steps[${n}].title`, o.title, 80, 'the step, in 80 characters or fewer');
+                if (Object.hasOwn(o, 'text'))
+                    text(`steps[${n}].text`, o.text, 300, 'what happens in this step, in 300 characters or fewer, or leave it out');
+            });
         page('view', /\.html$/i, '.html', '"mocks/<key>/index.html"', 'a plan shows where it goes as a diagram on a page', 'Set "view" to "mocks/<key>/index.html", a path from the board file\'s folder');
         return { kind: m.kind, schema: m.schema };
     }
@@ -393,6 +409,12 @@ export function checkMessage(m, want, flags = false) {
                 throw bad(`merges[${n}]`, `repeats ${k}`, 'List each key once');
         });
     }
+    if (Object.hasOwn(m, 'proof')) {
+        if (!isKey(m.proof))
+            throw bad('proof', 'must be 1-128 of A-Z a-z 0-9 . _ -', `Set ${named('proof', flags)} to the key of an evidence update on the board that this ask rests on, such as ${flags ? '--proof update-3' : '"update-3"'}`);
+        if (m.proof === m.key)
+            throw bad('proof', 'is this ask\'s own key', 'Name the evidence update the ask rests on, not the ask');
+    }
     if (ask && flags)
         question(m, bad, flags);
     // A gate's run is its own rule (section 5), so it comes after the field rules of section 4.
@@ -554,9 +576,10 @@ export function reportPage(m, base) {
         throw bad(`${page} has no dark mode`, 'Add a @media (prefers-color-scheme: dark) block, or start again from report init');
     if (!/<(svg|img|canvas|video)\b/i.test(html))
         throw bad(`${page} has no picture or diagram`, 'Draw the idea: add an <svg> or <img> under the answer and a diagram under it');
-    if (!/<(button|input|select)\b/i.test(html))
+    // A plan's page is its diagram: the steps and the details are on the board, so it needs nothing to tap and no fold.
+    if (m.kind !== 'plan' && !/<(button|input|select)\b/i.test(html))
         throw bad(`${page} has nothing to tap or slide, so it is text, not a report`, 'Add a demo the reader can tap through, such as the scaffold\'s steps with Back and Next');
-    if (!/<details\b/i.test(html))
+    if (m.kind !== 'plan' && !/<details\b/i.test(html))
         throw bad(`${page} has no folded detail`, 'Fold the detail into <details><summary>Details</summary>...</details> at the end');
     if (/<(script|img|iframe|link|video|audio|source)\b[^>]*\b(src|href)\s*=\s*["']?\s*(https?:)?\/\//i.test(html))
         throw bad(`${page} loads something from the web, which the board blocks`, 'Put scripts, styles and pictures in the page or beside it');

package/dist/store.js

@@ -29,6 +29,8 @@ const isText = (v) => typeof v === 'string';
 export const isKey = (v) => isText(v) && /^[A-Za-z0-9._-]{1,128}$/.test(v);
 const ONE_OF = { close: ['done', 'release'], area: ['waiting', 'evidence', 'reports', 'answered'] };
 /** What a step uses or can stop on: an AI model, a store, a gate, a hard fail. */
+/** What a report explains with: the board draws one line icon per form. */
+export const REPORT_FORMS = ['diagram', 'chart', 'before-after'];
 const MARKS = ['ai', 'store', 'gate', 'fail'];
 export const NOTE_MAX = 500;
 const TRADEOFF_MAX = 1000;
@@ -87,6 +89,8 @@ export function loadDecisions(path, board) {
                 throw bad(f, 'must be text');
         if (d.merges !== undefined && !(Array.isArray(d.merges) && d.merges.every(isKey)))
             throw bad('merges', 'must list keys of 1-128 of A-Z a-z 0-9 . _ -');
+        if (d.proof !== undefined && !isKey(d.proof))
+            throw bad('proof', 'must be a key of 1-128 of A-Z a-z 0-9 . _ -');
         if (d.evidence !== undefined && (!d.evidence || !/^[A-Za-z0-9._-]{1,128}$/.test(d.evidence.run_id ?? '')
             || !/^[a-f0-9]{40}$/.test(d.evidence.commit ?? '')
             || ['outcome', 'repro', 'proof', 'evidence'].some((f) => !isText(d.evidence[f]) || !d.evidence[f].trim() || [...d.evidence[f]].length > 1000))) {
@@ -120,6 +124,12 @@ export function loadDecisions(path, board) {
             throw bad('group', 'must be text of 40 characters or fewer');
         if (d.filed !== undefined && !(isText(d.filed) && /^\d{4}-\d{2}-\d{2}T/.test(d.filed) && !Number.isNaN(Date.parse(d.filed))))
             throw bad('filed', 'must be an ISO 8601 date-time such as 2026-10-13T07:19:00Z');
+        if (d.form !== undefined && !REPORT_FORMS.includes(d.form))
+            throw bad('form', `must be one of ${REPORT_FORMS.join(', ')}`);
+        if (d.video !== undefined && !(isText(d.video) && d.video.trim() && [...d.video].length <= 10))
+            throw bad('video', 'must be text of 10 characters or fewer');
+        if (d.asked_by !== undefined && !(isText(d.asked_by) && d.asked_by.trim() && [...d.asked_by].length <= 40))
+            throw bad('asked_by', 'must be text of 40 characters or fewer');
         if (d.decided !== undefined && !(isText(d.decided) && d.decided.trim() && [...d.decided].length <= 200))
             throw bad('decided', 'must be text of 200 characters or fewer');
         if (d.type === 'evidence' && !(Number.isInteger(d.number) && d.number >= 1))
@@ -204,20 +214,21 @@ export function loadDecisions(path, board) {
         }
         return {
             key: d.key, title: d.title, about: d.about, detail: d.detail, options: options.map((o) => ({ value: o.value, label: o.label, ...(o.outcome && { outcome: o.outcome }) })),
-            ...(d.why && { why: d.why }), ...(d.recommend_reason && { recommend_reason: d.recommend_reason }), ...(d.silent_by && { silent_by: d.silent_by }), ...(d.merges && { merges: [...d.merges] }),
+            ...(d.why && { why: d.why }), ...(d.recommend_reason && { recommend_reason: d.recommend_reason }), ...(d.silent_by && { silent_by: d.silent_by }), ...(d.merges && { merges: [...d.merges] }), ...(d.proof && { proof: d.proof }),
             recommend_value: d.recommend_value, default_if_silent: d.default_if_silent, close: d.close ?? 'done', evidence: d.evidence,
             type: plan ? 'plan' : d.type ?? 'decision', tradeoff: d.tradeoff, link: d.link, mocks: d.mocks?.map((m) => ({ value: m.value, path: m.path })),
             ...(views && { view: d.view }), ...(report && views && { preview: d.preview }), ...(d.reply && { reply: true }), ...(d.filer && { filer: d.filer }), ...(d.area && { area: d.area }),
             ...(signin && { unlocks: d.unlocks, waits: d.waits, ...(d.expires && { expires: d.expires }), ...(d.start && { start: [...d.start] }) }),
             ...(d.group && { group: d.group }), ...(d.filed && { filed: d.filed }), ...(d.decided && { decided: d.decided }),
-            ...(d.steps && { steps: d.steps.map(({ title, marks }) => ({ title, ...(marks?.length && { marks }) })) }),
+            ...(d.form && { form: d.form }), ...(d.video && { video: d.video }), ...(d.asked_by && { asked_by: d.asked_by }),
+            ...(d.steps && { steps: d.steps.map(({ title, marks, text }) => ({ title, ...(text && { text }), ...(marks?.length && { marks }) })) }),
             ...(stored && d.media && { media: d.media.map(({ path, sha256, bytes }) => ({ path, sha256, bytes })) }),
             ...(d.type === 'evidence' && { number: d.number }),
             // A gate's run is part of its question: the same key with another run is a different question.
             ...(d.kind === 'gate' && d.run && { run: { run_id: d.run.run_id, commit: d.run.commit } }),
             // So is a finding's proposal, with the counts and records behind it.
             ...(d.kind === 'finding' && { finding: { cause: d.cause, incidents: d.incidents, days: d.days, evidence_ids: d.evidence_ids, change_kind: d.change_kind, proposal: d.proposal } }),
-            ...(plan && { sections: d.sections, decisions: d.decisions }),
+            ...(plan && { sections: d.sections, decisions: d.decisions, ...(d.project && { project: d.project }) }),
             ...(design && { kind: 'design', type: 'design', group: d.group, filed: d.filed, status: d.status, preview: d.preview, journeys: d.journeys, ...(d.options && { options: d.options, recommend_value: d.recommend }) }),
             ...(d.type === 'explainer' && d.chapters && { chapters: d.chapters.map(({ at, title }) => ({ at, title })) }),
         };

package/fixtures/contract/plan.v1/page/index.html

@@ -5,17 +5,14 @@
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>Plan: show plans on the board</title>
 <style>
-body { font: 16px/1.5 system-ui, sans-serif; margin: 1rem; color: #111; background: #fff; }
-@media (prefers-color-scheme: dark) { body { color: #eee; background: #111; } }
-svg { display: block; width: 100%; max-width: 34rem; height: auto; margin: 1rem 0; }
+:root { color-scheme: light dark; }
+body { font: 16px/1.5 system-ui, sans-serif; margin: 0; color: #111; background: transparent; }
+@media (prefers-color-scheme: dark) { body { color: #eee; } }
+svg { display: block; width: 100%; height: auto; }
 svg text { font: 13px system-ui, sans-serif; fill: currentColor; }
-.step { min-height: 3rem; }
-button { font: inherit; min-height: 2.75rem; padding: 0 1rem; }
 </style>
 </head>
 <body>
-<h1>Show plans on the board</h1>
-<p>Umer reviews an agent's plan on a phone: approve or change each section, answer each decision, then send it all back at once.</p>
 <svg viewBox="0 0 340 110" role="img" aria-label="The agent posts a plan, the board shows it, Umer answers, and one send-back returns to the agent">
   <rect x="2" y="25" width="70" height="40" rx="6" fill="none" stroke="currentColor"/><text x="37" y="50" text-anchor="middle">Agent</text>
   <rect x="134" y="25" width="70" height="40" rx="6" fill="none" stroke="currentColor"/><text x="169" y="50" text-anchor="middle">Board</text>
@@ -23,20 +20,5 @@ button { font: inherit; min-height: 2.75rem; padding: 0 1rem; }
   <path d="M74 40 H130 M206 40 H262" stroke="currentColor" stroke-width="2"/>
   <path d="M301 67 V100 H37 V67" fill="none" stroke="currentColor" stroke-dasharray="4 3"/><text x="169" y="90" text-anchor="middle">one send-back</text>
 </svg>
-<h2>How it works</h2>
-<p class="step" id="step" aria-live="polite"></p>
-<p><button type="button" id="back">Back</button> <button type="button" id="next">Next</button></p>
-<details><summary>Details</summary>
-<p>Sections: goals and non-goals, architecture, slices and order, coding standards, risks. Each takes Approve or Change with a note.</p>
-<p>Decisions: send every answer back as one event, and show plans under Waiting on you.</p>
-</details>
-<script>
-const steps = ['1 of 4. The agent posts the plan.', '2 of 4. The board stores it under Waiting on you.', '3 of 4. Umer answers each section and decision.', '4 of 4. Send back returns every answer to the agent.'];
-let i = 0;
-const show = () => { document.getElementById('step').textContent = steps[i]; };
-document.getElementById('back').onclick = () => { i = Math.max(0, i - 1); show(); };
-document.getElementById('next').onclick = () => { i = Math.min(steps.length - 1, i + 1); show(); };
-show();
-</script>
 </body>
 </html>