sign-off-axi 0.5.0 → 0.5.1

package/README.md

@@ -75,7 +75,7 @@ A board that fills up with noise stops being read, so the rules sit at the door.
 - A question must say why it is asked, what each answer does, which one the agent recommends and what happens if you stay quiet; one that does not is refused with the fix ([the question standard](docs/contract.md#ask-schema-1)).
 - One decision is one card: raising the same question again changes nothing, and `--merge <key>` folds an older card into the better-asked one.
 - Proof posted as a Pass/Fail question is refused, and proof that is mostly text, a placeholder or a test card is refused too: proof goes to Evidence, as a capture of the real product; a report must be a page to tap, not a wall of words.
-- **Dismiss** hides a card from the board, **Undo** brings it back (`sign-off-axi dismiss <key>` and `restore <key>` do the same from a shell).
+- **Dismiss** hides a card from the board, **Undo** brings it back (`sign-off-axi dismiss <key>` and `restore <key>` do the same from a shell). `sign-off-axi dismiss --filer <id>` closes a finished task: every card that id still waits on leaves the board. Evidence and reports leave the main view a day after they were filed and wait under **Archived**; nothing is deleted, and Restore brings one back. A new ask that repeats an open ask on the same decision is refused, and answering one closes its twins.
 
 ## What you can ask
 
@@ -86,6 +86,7 @@ One line on what the agent runs per kind; the full reference is [docs/question-k
 | Yes or no, pick one | `raise --title ... --recommend ...` | buttons, the recommended one first |
 | Design pick (mocks A/B/C) | `post --type design --mock a=... --mock b=... --link a=<url>` | mocks side by side, an Open live link under each option that has a `--link`, a note on any part |
 | Proof update | `post --type evidence --media shot.png` | the capture, its result, Pass / Fail / Needs work |
+| Proof with a file to install | `post --type evidence --media shot.png --attach app.apk` | the capture, and the file with its size and a Download button (any type, up to 1 GB, `SIGN_OFF_ATTACH_MAX_MB` to change) |
 | Explainer video | `post --type explainer --media clip.mp4 --chapter 0:00=Start` | a player with chapter buttons, then Yes or No |
 | Report page | `report init <folder>`, then `post --type report --view ...` | a page to tap through |
 | Diagram, interactive page | `post --type diagram --view flow.svg` | the picture on the card; interactive pages run sandboxed |

package/dist/cli.js

@@ -3,16 +3,17 @@ import { createServer } from 'node:http';
 import { isIP } from 'node:net';
 import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
 import { spawn, spawnSync } from 'node:child_process';
-import { accessSync, closeSync, constants, existsSync, lstatSync, mkdirSync, mkdtempSync, openSync, readdirSync, readFileSync, realpathSync, rmSync, statSync, watch, writeFileSync } from 'node:fs';
+import { accessSync, chmodSync, closeSync, constants, copyFileSync, createReadStream, existsSync, lstatSync, mkdirSync, mkdtempSync, openSync, readdirSync, readFileSync, readSync, realpathSync, rmSync, statSync, watch, writeFileSync } from 'node:fs';
 import { lookup } from 'node:dns/promises';
 import { availableParallelism, homedir, tmpdir, userInfo } from 'node:os';
 import { Worker } from 'node:worker_threads';
+import { pipeline } from 'node:stream';
 import { basename, delimiter, dirname, extname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { parseArgs } from 'node:util';
 import { encode } from '@toon-format/toon';
 import { AxiError, runAxiCli } from 'axi-sdk-js';
-import { CHAPTERS_MAX, SIGNED_IN, CLEARED, InputError, MEDIA_MAX, NOTE_MAX, REPLY, answersPath, appendAnnotation, appendAnswer, appendDismissed, appendSendBack, appendDesignAnswer, appendMessage, appendRound, awaitsVerdict, isKey, loadDecisions, markDelivered, markSeen, messagesPath, readAnnotations, readAnswers, readDismissed, readItems, readMessages, readRounds, roundsPath, seenBy, seenPath, sentIds, unreadable as reasonOf, writeItems } from './store.js';
-import { ContractError, KINDS, MEDIA_BYTES, REPORT_INIT, checkMessage, mediaFiles, parseMessage, reportPage } from './contract.js';
+import { ATTACH_DEFAULT_MB, ATTACH_MAX, ATTACH_NAME, CHAPTERS_MAX, SIGNED_IN, CLEARED, InputError, MEDIA_MAX, NOTE_MAX, REPLY, answersPath, appendAnnotation, asks, appendAnswer, appendDismissed, appendSendBack, appendDesignAnswer, appendMessage, appendRound, awaitsVerdict, appendRead, answerDeeper, askDeeper, deeperPath, guidePart, markDeeperRead, readDeeper, readReads, seenAt, isKey, loadDecisions, markDelivered, markSeen, messagesPath, readAnnotations, readAnswers, readDismissed, readItems, sameDecision, readMessages, readRounds, roundsPath, seenBy, seenPath, sentIds, unreadable as reasonOf, writeItems } from './store.js';
+import { ContractError, KINDS, MEDIA_BYTES, REPORT_INIT, checkMessage, guided, mediaFiles, parseMessage, reportPage } from './contract.js';
 import { faults, isStill } from './evidence-text.js';
 import { deliverVault, errors, readVaultExpiry, sweepVault, takeVaultExpiries, VaultError } from './vault.js';
 const FORMAT = 'https://github.com/umeranjum17/sign-off/blob/main/docs/file-formats.md';
@@ -28,8 +29,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[21]:
-  (none)=list, raise, post, answers, wait, poll, open, status, stop, serve, export, init, report, signin, dismiss, restore, refile, doctor, notify, validate, help
+commands[22]:
+  (none)=list, raise, post, answers, wait, poll, deeper, open, status, stop, serve, export, init, report, signin, dismiss, restore, refile, 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:
@@ -40,6 +41,7 @@ examples:
   sign-off-axi post .sign-off/decisions.json --type diagram --title "Is this the sign-in flow?" --view mocks/sign-in/flow.svg
   sign-off-axi post --type explainer --title "Is the new sign-in clear?" --about "The new sign-in has 2 steps." --media explainer.mp4 --chapter 0:00=Start
   sign-off-axi report init .sign-off/mocks/sign-in-flow
+  sign-off-axi deeper
   sign-off-axi post .sign-off/decisions.json --type report --title "Sign-in now takes 2 steps" --about "Why the code step moved first." --view mocks/sign-in-flow/index.html --preview mocks/sign-in-flow/preview.svg
   sign-off-axi post --type signin --key npm-login --service npm --link https://example.com/login --unlocks "Publish the release" --waits "Main" --expires 15m
   sign-off-axi signin done --key npm-login
@@ -77,6 +79,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.
+A new ask that repeats an open ask on the same decision (the same answers, titles that share at least 80% of their words), from anyone, is not posted: the refusal names the card to wait on. When one is answered, every open ask on the same decision takes the answer and leaves Decide.
 --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}
@@ -90,7 +93,8 @@ examples:
 `,
     validate: `usage: sign-off-axi validate <message.json>... [--kind <kind>] [--expect-invalid]
 Checks message files against the communication contract without posting them: ${CONTRACT}
-A message is one JSON object with "contract": 1, its "kind" and its "schema". This build checks kinds ask, evidence, gate, finding, plan and design at schema 1, and report at schema 2.
+A message is one JSON object with "contract": 1, its "kind" and its "schema". This build checks kinds ask, evidence, gate, finding and design at schema 1, report at schema 3 (schema 2 still passes) and plan at schema 2 (schema 1 still passes).
+A report 3 and a plan 2 are guided pages: fields the board draws as one scroll, no page of your own.
 An evidence message's media paths read from the message file's folder: each file must be there, inside it, and 50 MB or less.
 A report is a page to tap through: its "view" (.html) and "preview" (its picture, beside it) are checked for their shape here; the files themselves are checked at post, from the board file's folder, filled with no FILL: lines left (see report init).
 A plan's "view" (.html) is checked for its shape here; the file itself is checked at post, from the board file's folder.
@@ -177,7 +181,7 @@ examples:
   sign-off-axi serve --port 0
 `,
     post: `usage: sign-off-axi post [board.json] [--type decision|design|diagram|interactive] --title "<question>" [--key <key>] [--about <text>] [--option <value>=<label>]... [--mock <value>=<path>]... [--link <value>=<url>]... [--view <path>] [--tradeoff <text>] [--recommend <value>] [--default <value>] [--close done|release] [--filer <id>]
-       sign-off-axi post [board.json] --type evidence --title "<what this shows>" --about "<short note>" --media <file>... [--link <commit or URL>] [--detail <text>] [--filer <id>]
+       sign-off-axi post [board.json] --type evidence --title "<what this shows>" --about "<short note>" --media <file>... [--attach <file>]... [--link <commit or URL>] [--detail <text>] [--filer <id>]
        sign-off-axi post [board.json] --from <board file> --replace [--filer <id>]
        sign-off-axi post [board.json] --kind <kind> --from <message.json|-> [--filer <id>]
        sign-off-axi post [board.json] --type explainer --title "<question>" --media <video> [--about <summary>] [--chapter <m:ss>=<title>]... [--key <key>] [--option <value>=<label>]... [--recommend <value>]
@@ -212,6 +216,7 @@ An empty items list removes that filer's items.
 an image (.svg, .png, .jpg, .jpeg, .webp, 5 MB or less) shown at card width for a diagram, or one self-contained .html page for interactive.
 The page runs in a sandboxed frame: no fetch, no remote files, no access to the dashboard or its tab. Answers work as for a decision.
 --type evidence posts the next numbered update (key update-<number>): 1 to ${MEDIA_MAX} screenshots or recordings (.png, .jpg, .jpeg, .webp, .mp4, .webm, 50 MB each), copied into evidence/<number>/ next to the board, with a short note and an optional commit or PR link. A still that is not a picture of the product is refused: mostly text (a log, receipt or summary), a colour-bar test card or a placeholder card. Post a real capture of the running product; a colour-bar or placeholder card already posted is not shown on the board.
+--attach <file> (up to ${ATTACH_MAX}, any file type, such as an Android .apk) adds a file the user downloads from the card, over the board link, on a phone or tablet. It is copied (never read into memory) into evidence/<number>/ and streamed on download. A file over ${ATTACH_DEFAULT_MB} MB is refused; raise the limit with SIGN_OFF_ATTACH_MAX_MB=<megabytes>. An update may have only --attach files and no --media.
 The user gives a verdict, pass, fail or needs-work, with an optional note; read it with answers or wait --key update-<number>.
 --type explainer is a decision shown with a narrated video you made: one --media .mp4 or .webm (50 MB or less), copied into evidence/<number>/ like evidence
 and played on the card. --about is its short summary; up to ${CHAPTERS_MAX} --chapter m:ss=<title> (in order) are buttons that jump the video there. Answers work as for a decision.
@@ -241,6 +246,7 @@ examples:
 A design message lists project journeys, per-screen image or HTML view variants, and a card preview; post checks every asset stays under the board folder.
   sign-off-axi post .sign-off/decisions.json --type interactive --title "Does the sign-in flow feel right?" --view mocks/sign-in/demo.html --option yes=Yes --option no="Needs work" --recommend yes
   sign-off-axi post --type evidence --title "Sign-in screen on a phone" --about "The new screen loads in 1 second." --media phone.png --media flow.mp4 --link https://github.com/acme/app/pull/12
+  sign-off-axi post --type evidence --title "Debug build for the phone" --about "The app installs and signs in." --media phone.png --attach app-debug.apk
   sign-off-axi post --type explainer --title "Is the new sign-in clear?" --about "The new sign-in has 2 steps." --media explainer.mp4 --chapter 0:00=Start --chapter 0:12="Step 2"
   sign-off-axi post .sign-off/decisions.json --type report --title "Sign-in now takes 2 steps" --about "Why the code step moved first." --view mocks/sign-in-flow/index.html --preview mocks/sign-in-flow/preview.svg
   sign-off-axi post --type signin --key npm-login --service npm --link https://example.com/login --unlocks "Publish the release" --waits "Main" --expires 15m
@@ -253,10 +259,14 @@ examples:
   sign-off-axi signin done --key npm-login
 `,
     dismiss: `usage: sign-off-axi dismiss <key> [board.json]
+       sign-off-axi dismiss --filer <id> [board.json]
 Hides a card from the board, like its Dismiss button. The agent is not told, and an ask it waits on keeps waiting.
+--filer <id> closes a finished task: every card that id still has waiting leaves the board. Run it when your work ends, so nothing of yours is left on Decide.
+Evidence and reports leave the main view by themselves a day after they were filed; they stay under Archived on their screen, and restore brings one back for good.
 restore <key> [board.json] brings it back. Find the key with \`sign-off-axi list --full\`.
 examples:
   sign-off-axi dismiss ship-the-new-sign-in-screen-this-week
+  sign-off-axi dismiss --filer agent-41
   sign-off-axi restore ship-the-new-sign-in-screen-this-week
 `,
     refile: `usage: sign-off-axi refile <key> [board.json] --media <file>... [--link <commit or URL>]
@@ -288,6 +298,17 @@ examples:
   sign-off-axi init
   sign-off-axi init ./my-project --agent opencode
   sign-off-axi init --agent codex,gemini-cli
+`,
+    deeper: `usage: sign-off-axi deeper [board.json] [--filer <id>] [--all] [--json]
+       sign-off-axi deeper [board.json] --id <id> --text "<answer>" [--more]
+Go deeper is the button on every part of a plan 2 or report 3. The person taps it; wait --filer wakes with the ask, or this command lists the ones nobody finished.
+Answer in plain words about the part they tapped, a few lines at a time: each --more piece streams into that spot on the board while they watch, and a last call without --more ends it.
+  --id     the ask to answer   --text  the answer, or - to read stdin (2000 characters or fewer per piece)
+  --more   more pieces follow   --all  also the finished asks
+examples:
+  sign-off-axi deeper
+  sign-off-axi deeper --id 3fa9c1 --text "I timed all three paths on 12 Oct." --more
+  sign-off-axi deeper --id 3fa9c1 --text "The After bars are goals, not measurements."
 `,
     poll: `usage: sign-off-axi poll [board.json] [--timeout 600] [--json]
 Blocks until the user comments on an item or queues a prompt for the agent on the page, then prints every new one once and marks it read.
@@ -403,7 +424,7 @@ function contractItems(items, from, file, replace = false) {
         }
         try {
             checkMessage(check);
-            if (check.kind === 'report' || check.kind === 'plan')
+            if ((check.kind === 'report' || check.kind === 'plan') && !guided(check))
                 reportPage(check, dirname(file));
             if (check.kind === 'design')
                 designFiles(check, dirname(file));
@@ -520,14 +541,16 @@ function filerOf(values, session = false) {
 const waitFor = (on, filer, key) => (filer ? `Run \`sign-off-axi wait${on} --filer ${filer}\` to block until the user answers`
     : `Run \`sign-off-axi wait${on}${key ? ` --key ${key}` : ''}\` to block until the user answers`);
 /** Still waiting on the user: not answered, not dismissed, and something to answer (an item with no options and no reply is only shown). */
-const waits = (d) => d.type !== 'evidence' && !d.dismissed && awaitsVerdict(d.type, d.answer) && (d.options.length > 0 || !!d.reply || d.type === 'signin' || d.type === 'plan' || d.type === 'design');
+const waits = (d) => asks(d) && !d.dismissed && awaitsVerdict(d.type, d.answer);
+/** The items that archive after a day: all of them, except on a board another program feeds, which owns what it shows. */
+const archivable = (file, decisions) => ((x) => (x.readonly === true || x.answers_only === true ? [] : decisions))(readItems(file).extra);
 /** The board's decisions with their latest answer; a missing board file is an empty board.
  *  A dismissal hides an item from the board and is not waiting here either, checked against the same dismissed log the board reads. */
 function board(file, say = warn) {
     if (!existsSync(file))
         return [];
     const decisions = loadDecisions(file), answers = readAnswers(file, say);
-    const hidden = new Set(readDismissed(file, answers, readRounds(file), say));
+    const hidden = new Set(readDismissed(file, answers, readRounds(file), say, archivable(file, decisions)));
     for (const key of Object.keys(answers))
         if (!decisions.some((d) => d.key === key))
             say(`left out the answer for ${key}: that question is no longer in ${basename(file)}`);
@@ -623,6 +646,45 @@ function eventLines(file, rows, answers, rounds) {
         ...rounds.map(({ key, note, at, comments }) => ({ at, line: { ...head('round', key), note, at, ...tail(key, comments) } }))]
         .sort((a, b) => (a.at < b.at ? -1 : a.at > b.at ? 1 : 0)).map(({ line }) => JSON.stringify(line)).join('\n');
 }
+/** Go deeper asks as the agent reads them: what part, what it is about, the question if the person typed one, and how to answer. */
+function deeperOut(file, asks, on, events) {
+    if (events) {
+        const kind = kindOf(file), titles = new Map(board(file).map((d) => [d.key, d.title]));
+        return asks.map(({ id, key, part, about, q, at }) => JSON.stringify({ event: 'deeper', ...kind(key), key, title: titles.get(key), id, part, about, ...(q && { q }), at })).join('\n');
+    }
+    return toon({ board: tilde(file), deeper: asks.map(({ id, key, part, about, q = '', at }) => ({ id, key, part, about, q, at })) }, ['The person tapped Go deeper: answer in plain words, a few lines at a time, as the part they tapped',
+        `Run \`sign-off-axi deeper${on} --id <id> --text "<what you found>" --more\` for each piece, then once more without --more to finish`]);
+}
+/** `deeper`: the Go deeper asks nobody has finished, or with --id and --text one piece of the answer the board streams under the part the person tapped. */
+async function deeper(args) {
+    const { file, values, on } = parse('deeper', args, { filer: { type: 'string' }, id: { type: 'string' }, text: { type: 'string' }, more: { type: 'boolean' }, all: { type: 'boolean' }, json: { type: 'boolean' } });
+    ready(file, on);
+    const filer = filerOf(values);
+    if (values.id === undefined) {
+        if (values.text !== undefined || values.more)
+            throw fail('--text and --more answer one ask, so they need --id', 'VALIDATION_ERROR', 'Run `sign-off-axi deeper` to see the ids');
+        const mine = new Set(board(file).filter((d) => filer === undefined || d.filer === filer).map((d) => d.key));
+        const open = readDeeper(file).filter((x) => mine.has(x.key) && (values.all || !x.done));
+        if (values.json)
+            return JSON.stringify({ deeper: open });
+        if (!open.length)
+            return toon({ board: tilde(file), deeper: '0 open' }, [`Run \`sign-off-axi wait${on}\` to be woken when the person taps Go deeper`]);
+        markDeeperRead(file, open.filter((x) => !x.read).map((x) => x.id));
+        return toon({ board: tilde(file), deeper: open.map(({ id, key, part, about, q = '', at, done }) => ({ id, key, part, about, q, at, done: !!done })) }, [`Run \`sign-off-axi deeper${on} --id <id> --text "<answer>"\` to answer one`]);
+    }
+    const ask = readDeeper(file).find((x) => x.id === values.id);
+    if (!ask)
+        throw fail(`no Go deeper ask with id ${values.id}`, 'NOT_FOUND', `Run \`sign-off-axi deeper${on}\` to see the open ones`);
+    if (ask.done)
+        throw fail(`ask ${values.id} is already answered`, 'CONFLICT', 'The person can tap Go deeper again for a follow-up');
+    let text = values.text;
+    if (text === '-')
+        text = readFileSync(0, 'utf8');
+    if (typeof text !== 'string' || !text.trim() || [...text.trim()].length > 2000)
+        throw fail('--text must be the answer, 2000 characters or fewer', 'VALIDATION_ERROR', 'Run `sign-off-axi deeper --help`');
+    answerDeeper(file, ask.id, text.trim(), !!values.more);
+    return toon({ id: ask.id, key: ask.key, part: ask.part, answered: values.more ? 'piece sent, more to come' : 'done' }, values.more ? [`Run \`sign-off-axi deeper${on} --id ${ask.id} --text "<next piece>" [--more]\``] : [`Run \`sign-off-axi wait${on}\` for the next answer or ask`]);
+}
 async function wait(args) {
     const { file, values, on: onBoard } = parse('wait', args, { ...TIERS, events: { type: 'boolean' }, filer: { type: 'string' }, key: { type: 'string' }, timeout: { type: 'string', default: '600' }, into: { type: 'string' } });
     if (!/^\d{1,7}$/.test(values.timeout))
@@ -649,10 +711,10 @@ async function wait(args) {
         seenRounds.set(r.key, (seenRounds.get(r.key) ?? 0) + 1);
     // A save wakes the loop at once; the 1 second timer is the fallback where file events are unavailable.
     let wake = () => { }, watcher, vaultWarned = false;
-    const name = basename(answersPath(file));
+    const name = basename(answersPath(file)), asking = basename(deeperPath(file));
     try {
         try {
-            watcher = watch(dirname(file), (_, changed) => changed === name && wake()).on('error', () => { });
+            watcher = watch(dirname(file), (_, changed) => (changed === name || changed === asking) && wake()).on('error', () => { });
         }
         catch { }
         for (let first = true;; first = false) {
@@ -687,6 +749,16 @@ async function wait(args) {
             if (found.length) {
                 return printAnswers(file, found, waiting, values, [waiting ? `Run \`sign-off-axi wait${on}\` for the next of the ${waiting} waiting` : `Run \`sign-off-axi stop${onBoard}\` to close the board`]);
             }
+            // A Go deeper ask on this filer's guided page wakes the wait once, and is marked read when it is handed over.
+            if (values.key === undefined) {
+                const asks = await locked(`${deeperPath(file)}.lock`, () => {
+                    const got = readDeeper(file).filter((x) => !x.read && rows.some((d) => d.key === x.key));
+                    markDeeperRead(file, got.map((x) => x.id));
+                    return got;
+                }, 'another wait is still taking Go deeper asks');
+                if (asks.length)
+                    return deeperOut(file, asks, onBoard + (filer ? ` --filer ${filer}` : ''), values.events);
+            }
             // Private vault expiries and refusals reach a filer wait only once its ordinary answers are out; each is taken once.
             let live = 0, unknown = false;
             if (filer !== undefined && values.key === undefined) {
@@ -815,11 +887,11 @@ const mockFile = (path) => path.split('?')[0];
 /** Posts an item. `raise` is the alias for `post --type decision`: same flags as before, same output. */
 function post(args, cmd = 'post') {
     const typed = cmd === 'post' ? { replace: { type: 'boolean' }, kind: { type: 'string' }, type: { type: 'string' }, tradeoff: { type: 'string' }, mock: { type: 'string', multiple: true },
-        media: { type: 'string', multiple: true }, link: { type: 'string', multiple: true }, view: { type: 'string' }, preview: { type: 'string' }, chapter: { type: 'string', multiple: true },
+        media: { type: 'string', multiple: true }, attach: { type: 'string', multiple: true }, link: { type: 'string', multiple: true }, view: { type: 'string' }, preview: { type: 'string' }, chapter: { type: 'string', multiple: true },
         ...Object.fromEntries(SIGNIN_FIELDS.map((f) => [f, { type: 'string' }])) } : {};
     const { file, named, values, on } = parse(cmd, args, { from: { type: 'string' }, filer: { type: 'string' }, ...typed,
         ...Object.fromEntries(RAISE_FIELDS.map((f) => [f, { type: 'string', multiple: MANY.includes(f) }])) });
-    const given = [...RAISE_FIELDS, 'type', 'tradeoff', 'mock', 'media', 'link', 'view', 'preview', 'chapter', ...SIGNIN_FIELDS].filter((f) => values[f] !== undefined);
+    const given = [...RAISE_FIELDS, 'type', 'tradeoff', 'mock', 'media', 'attach', 'link', 'view', 'preview', 'chapter', ...SIGNIN_FIELDS].filter((f) => values[f] !== undefined);
     // Only a design takes --link more than once (one per option); any other type keeps its one item link, the last given.
     const optionLinks = values.link ?? [];
     if (values.type !== 'design' && optionLinks.length)
@@ -855,8 +927,8 @@ function post(args, cmd = 'post') {
         throw fail(`--type must be decision, design, evidence, diagram, interactive, explainer, report or signin`, 'VALIDATION_ERROR', 'Run `sign-off-axi post --help`');
     if (type === 'evidence' || type === 'explainer')
         return postMedia(file, named, on, values, type, filer);
-    if (values.media !== undefined || (type !== 'design' && values.link !== undefined) || values.chapter !== undefined)
-        throw fail('--media, --link and --chapter need --type evidence or explainer (--link also goes on --type design, one per option)', 'VALIDATION_ERROR', 'Run `sign-off-axi post --help`');
+    if (values.media !== undefined || values.attach !== undefined || (type !== 'design' && values.link !== undefined) || values.chapter !== undefined)
+        throw fail('--media, --attach, --link and --chapter need --type evidence or explainer (--link also goes on --type design, one per option)', 'VALIDATION_ERROR', 'Run `sign-off-axi post --help`');
     if (type !== 'design' && (values.tradeoff !== undefined || values.mock !== undefined))
         throw fail('--tradeoff and --mock need --type design', 'VALIDATION_ERROR', 'Run `sign-off-axi post --help`');
     const view = type === 'diagram' || type === 'interactive';
@@ -1002,11 +1074,21 @@ function signin(args) {
 function dismiss(restoring) {
     const cmd = restoring ? 'restore' : 'dismiss';
     return (args) => {
-        const at = args.findIndex((a) => !a.startsWith('-') && !existsSync(a) && !a.endsWith('.json')), key = args[at];
-        if (at < 0)
+        // dismiss --filer <id> closes a finished task: every card that filer still has waiting leaves the board.
+        const f = restoring ? -1 : args.findIndex((a) => a === '--filer'), filer = f < 0 ? undefined : args[f + 1], rest = f < 0 ? args : args.filter((_, i) => i !== f && i !== f + 1);
+        if (f >= 0 && !isKey(filer))
+            throw fail('--filer needs an id of 1-128 of A-Z a-z 0-9 . _ -', 'VALIDATION_ERROR', 'Pass the id you posted with');
+        const at = rest.findIndex((a) => !a.startsWith('-') && !existsSync(a) && !a.endsWith('.json')), key = rest[at];
+        if (at < 0 && f < 0)
             throw fail(`${cmd} needs a card key`, 'VALIDATION_ERROR', `sign-off-axi ${cmd} <key> [board.json]`);
-        const { file, on } = parse(cmd, args.filter((_, i) => i !== at), {});
+        const { file, on } = parse(cmd, rest.filter((_, i) => i !== at), {});
         return locked(`${file}.lock`, () => {
+            if (filer) {
+                const keys = board(file).filter((d) => d.filer === filer && waits(d)).map((d) => d.key);
+                if (keys.length)
+                    appendDismissed(file, keys, true);
+                return toon({ board: tilde(file), dismissed: keys.length ? keys : `0 cards of ${filer} were waiting` }, keys.length ? [`Run \`sign-off-axi restore${on} <key>\` to bring one back`] : []);
+            }
             if (!isKey(key) || !board(file).some((x) => x.key === key))
                 throw fail(`no card with key ${key} on ${tilde(file)}`, 'NOT_FOUND', `Run \`sign-off-axi list${on} --full\` to see the keys`);
             appendDismissed(file, [key], !restoring);
@@ -1103,10 +1185,47 @@ const UNFIT = {
     'colour bars': (path) => `--media ${path} is a colour-bar test card, not evidence`,
     placeholder: (path) => `--media ${path} is a placeholder card, not evidence`,
 };
+/** The attachment size limit in bytes: SIGN_OFF_ATTACH_MAX_MB, else 1 GB. */
+function attachLimit() {
+    const raw = process.env.SIGN_OFF_ATTACH_MAX_MB, mb = raw === undefined || raw === '' ? ATTACH_DEFAULT_MB : Number(raw);
+    if (!(mb > 0))
+        throw fail(`SIGN_OFF_ATTACH_MAX_MB=${raw} must be a number of megabytes above 0`, 'VALIDATION_ERROR', 'Unset it, or set it to a size such as 1024');
+    return mb * 1024 * 1024;
+}
+/** One --attach file: it must be a real file within the limit. Its download name is made safe here (letters, digits and . _ ( ) + - only), and never names a place on disk. */
+function attachment(given) {
+    const path = resolve(given);
+    let info;
+    try {
+        info = statSync(path, { throwIfNoEntry: false });
+    }
+    catch (e) {
+        throw fail(`--attach ${given} ${reasonOf(e.code)}`, 'NOT_FOUND', 'Name a file that is there');
+    }
+    if (!info?.isFile())
+        throw fail(`--attach ${given} ${info || existsSync(path) ? 'is not a file' : 'is not there'}`, 'NOT_FOUND', 'Name a file that is there');
+    const limit = attachLimit();
+    if (info.size > limit)
+        throw fail(`--attach ${tilde(path)} is ${Math.ceil(info.size / 1048576)} MB, over the ${Math.floor(limit / 1048576)} MB limit`, 'VALIDATION_ERROR', 'Raise the limit with SIGN_OFF_ATTACH_MAX_MB=<megabytes>, or attach a smaller file');
+    const ext = extname(path).toLowerCase(), name = basename(path).replace(/[^\w.()+ -]/g, '_').replace(/^\.+/, '_').slice(-120);
+    return { src: path, ext: /^\.[a-z0-9]{1,10}$/.test(ext) ? ext : '.bin', name: ATTACH_NAME.test(name) ? name : 'file' };
+}
+/** The SHA-256 of a file, read in 1 MB chunks. */
+function hashFile(path) {
+    const hash = createHash('sha256'), buf = Buffer.allocUnsafe(1 << 20), fd = openSync(path, 'r');
+    try {
+        for (let n; (n = readSync(fd, buf, 0, buf.length, null)) > 0;)
+            hash.update(buf.subarray(0, n));
+    }
+    finally {
+        closeSync(fd);
+    }
+    return hash.digest('hex');
+}
 function postMedia(file, named, on, values, type, filer, message) {
     fits(values.title);
     const explainer = type === 'explainer';
-    const extra = (explainer ? ['mock', 'tradeoff', 'view', 'link'] : ['key', 'option', 'recommend', 'default', 'mock', 'tradeoff', 'view', 'chapter']).find((f) => values[f] !== undefined);
+    const extra = (explainer ? ['mock', 'tradeoff', 'view', 'link', 'attach'] : ['key', 'option', 'recommend', 'default', 'mock', 'tradeoff', 'view', 'chapter']).find((f) => values[f] !== undefined);
     if (extra)
         throw fail(`--${extra} does not apply to --type ${type}`, 'VALIDATION_ERROR', 'Run `sign-off-axi post --help`');
     const example = explainer ? 'sign-off-axi post --type explainer --title "<question>" --about "<short summary>" --media explainer.mp4'
@@ -1115,8 +1234,10 @@ function postMedia(file, named, on, values, type, filer, message) {
         throw fail('--about is required for --type evidence: the short note', 'VALIDATION_ERROR', example);
     if (explainer && values.media?.length !== 1)
         throw fail('--type explainer needs one --media video (.mp4 or .webm)', 'VALIDATION_ERROR', example);
-    if ((!message && !values.media?.length) || values.media.length > MEDIA_MAX)
-        throw fail(`--type evidence needs 1 to ${MEDIA_MAX} --media files`, 'VALIDATION_ERROR', example);
+    if ((!message && !values.media?.length && !values.attach?.length) || (values.media?.length ?? 0) > MEDIA_MAX)
+        throw fail(`--type evidence needs 1 to ${MEDIA_MAX} --media files, or an --attach file`, 'VALIDATION_ERROR', example);
+    if ((values.attach?.length ?? 0) > ATTACH_MAX)
+        throw fail(`--attach takes up to ${ATTACH_MAX} files`, 'VALIDATION_ERROR', 'Zip the files together, or post a second update');
     const kinds = explainer ? ['.mp4', '.webm'] : Object.keys(mediaTypes), options = optionsOf(values);
     recommended([{ options, recommend_value: values.recommend }], true);
     const chapters = values.chapter?.map((c) => {
@@ -1125,7 +1246,7 @@ function postMedia(file, named, on, values, type, filer, message) {
             throw fail(`--chapter ${c} must be <m:ss>=<title>`, 'VALIDATION_ERROR', 'sign-off-axi post --type explainer ... --chapter 0:00=Start --chapter 0:12="Step 2"');
         return { at: Number(m[1]) * 60 + Number(m[2]), title: m[3] };
     });
-    const sources = values.media.map((m) => {
+    const sources = (values.media ?? []).map((m) => {
         const path = resolve(m);
         let info;
         try {
@@ -1142,6 +1263,7 @@ function postMedia(file, named, on, values, type, filer, message) {
             throw fail(`--media ${tilde(path)} is over 50 MB`, 'VALIDATION_ERROR', 'Trim or compress the recording');
         return path;
     });
+    const attached = (values.attach ?? []).map((a) => attachment(a));
     // A still that is not a picture of the product (text, colour bars or a placeholder) is measured before anything is copied.
     const [unfit] = explainer ? [] : sources.flatMap((src) => isStill(src) ? faults(src).map((f) => ({ src, f })) : []);
     if (unfit)
@@ -1178,13 +1300,20 @@ function postMedia(file, named, on, values, type, filer, message) {
             }
         }
         const key = own || `update-${number}`, dir = join(store, String(number));
-        let media;
+        let media, attachments = [];
         try {
             media = sources.map((src, i) => {
                 const bytes = readFileSync(src), path = `evidence/${number}/${i + 1}${extname(src).toLowerCase()}`;
                 writeFileSync(join(dir, `${i + 1}${extname(src).toLowerCase()}`), bytes, { mode: 0o600 });
                 return { path, sha256: sha256(bytes), bytes: bytes.length };
             });
+            // An attachment is copied by the kernel and hashed in chunks: the file is never held in memory.
+            attachments = attached.map(({ src, ext, name }, i) => {
+                const stored = `attach-${i + 1}${ext}`, dest = join(dir, stored);
+                copyFileSync(src, dest, constants.COPYFILE_EXCL);
+                chmodSync(dest, 0o600);
+                return { path: `evidence/${number}/${stored}`, name, sha256: hashFile(dest), bytes: statSync(dest).size };
+            });
         }
         catch (e) {
             // A file that cannot be read after all leaves no copies behind.
@@ -1195,7 +1324,7 @@ function postMedia(file, named, on, values, type, filer, message) {
         const { run, media: _paths, ...fields } = message ?? {};
         items.push(explainer ? { key, type, title, about, detail, options, recommend_value, default_if_silent, close, chapters, media, filer, filed }
             : message ? { ...fields, key, type, number, ...(media.length ? { media } : {}), ...(run && { evidence: run }), filed }
-                : { key, type, number, title, about, detail, close, link, media, filer, filed });
+                : { key, type, number, title, about, detail, close, link, ...(media.length && { media }), ...(attachments.length && { attachments }), filer, filed });
         // The whole board is checked before it is written, so a bad post leaves the board and evidence/ as they were.
         const check = `${file}.${process.pid}.check`;
         writeFileSync(check, JSON.stringify({ ...extra, schema: 2, items }), { mode: 0o600 });
@@ -1214,7 +1343,7 @@ function postMedia(file, named, on, values, type, filer, message) {
         notifyEntered(file, named, before);
         if (explainer)
             return toon({ board: tilde(file), raised: [{ key, status: 'raised', title }] }, [`Run \`sign-off-axi open${on}\` so the user can watch and answer`, waitFor(on, filer, key)]);
-        return toon({ board: tilde(file), posted: [{ key, number, media: media.length, title, ...(message && { status: 'posted' }) }] });
+        return toon({ board: tilde(file), posted: [{ key, number, media: media.length, ...(attachments.length && { attached: attachments.length }), title, ...(message && { status: 'posted' }) }] });
     });
 }
 /** post --type report: the flags as one report message, posted as post --kind report posts it. A report with no page is refused before anything is read. */
@@ -1259,7 +1388,7 @@ async function postKind(file, named, on, values, built) {
         if (m.kind === 'evidence')
             sources = mediaFiles(m, from === '-' ? process.cwd() : dirname(resolve(from)));
         // A report's or plan's page is served from the board file's folder, as --view is.
-        if (m.kind === 'report' || m.kind === 'plan')
+        if ((m.kind === 'report' || m.kind === 'plan') && !guided(m))
             reportPage(m, dirname(file));
         if (m.kind === 'design')
             designFiles(m, dirname(file));
@@ -1440,6 +1569,12 @@ function storeIncoming(file, named, on, { incoming, raw }, filer, exact = false)
         const proof = incoming.find((d) => d.type === 'decision' && !d.kind && !current.some((c) => c.key === d.key) && ['pass', 'fail'].every((v) => d.options.some((o) => o.value === v)));
         if (proof)
             throw fail(`key ${proof.key} offers Pass and Fail: a proof is not an ask and would wait on you`, 'VALIDATION_ERROR', 'Post it with sign-off-axi post --type evidence --title "<what this shows>" --about "<short note>" --media <file>');
+        // One decision is one card: a new ask that repeats an open one, whoever filed it, is not posted. Merging it into that card is the way to ask it better.
+        for (const d of incoming) {
+            const open = current.some((c) => c.key === d.key) ? undefined : current.find((c) => waits(c) && !d.merges?.includes(c.key) && sameDecision(c, d));
+            if (open)
+                throw fail(`key ${d.key} asks what ${open.key} already asks, and ${open.key} still waits`, 'CONFLICT', `Wait on it: \`sign-off-axi wait${on} --key ${open.key}\`; or post this ask with --merge ${open.key} to ask it better`);
+        }
         const raised = incoming.map((d, i) => {
             const had = current.find((c) => c.key === d.key);
             // A contract message refused for its key exits 2 like any other refusal (contract section 4); raise --title keeps exit 1.
@@ -1686,7 +1821,7 @@ const skillInstalled = (dir, agent) => [join(dir, AGENTS[agent].dir), AGENTS[age
     .some((skills) => existsSync(join(skills, 'sign-off-axi', 'SKILL.md')));
 const SKILL_ADD = ['-y', 'skills', 'add', 'umeranjum17/sign-off', '--skill', 'sign-off-axi', '-y', '-a'];
 const skillAdd = (agents) => `npx ${[...SKILL_ADD, ...agents].join(' ')}`;
-const GITIGNORE = 'mocks/\nevidence/\n*.answers.jsonl\n*.rounds.jsonl\n*.messages.jsonl\n*.annotations.jsonl\n*.seen.jsonl\n*.dismissed.jsonl\n*.board.pid\n*.board.log\nnotify.log\n*.token\n*.export.html\n';
+const GITIGNORE = 'mocks/\nevidence/\n*.answers.jsonl\n*.rounds.jsonl\n*.messages.jsonl\n*.annotations.jsonl\n*.seen.jsonl\n*.dismissed.jsonl\n*.reads.jsonl\n*.deeper.jsonl\n*.board.pid\n*.board.log\nnotify.log\n*.token\n*.export.html\n';
 /** The board, port, bind and hosts in <so>/config.yaml (the `key: value` lines init writes). A bad line falls back on its own default
  * (decisions.json, 4410) and `problems` says what is wrong; a file that cannot be read throws. */
 function readSetup(so) {
@@ -2364,10 +2499,13 @@ const state = () => {
         ...profile(),
         answers,
         seen: Object.values(answers).filter(taken).map((a) => a.key),
+        seen_at: Object.fromEntries(Object.values(answers).flatMap((a) => { const t = seenAt(file)(a); return t ? [[a.key, t]] : []; })),
+        reads: readReads(file),
+        deeper: readDeeper(file),
         rounds,
         messages: readMessages(file, warn),
         annotations: readOnly() || answersOnly() ? [] : ((sent) => readAnnotations(file, warn).map((a) => (sent.has(a.id) ? { ...a, sent: true } : a)))(sentIds(file)),
-        dismissed: readDismissed(file, answers, rounds, warn),
+        dismissed: readDismissed(file, answers, rounds, warn, archivable(file, loadDecisions(file))),
     };
 };
 /** A mock file's sha256 now, or null when it is gone: a comment shows only on the exact file it was made on.
@@ -2391,6 +2529,8 @@ const answersOnly = () => readItems(file).extra.answers_only === true;
 const mediaTypes = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.webp': 'image/webp', '.mp4': 'video/mp4', '.webm': 'video/webm' };
 const mockTypes = { '.html': 'text/html', '.svg': 'image/svg+xml', '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.webp': 'image/webp' };
 /** What a mock's folder may serve beside it: pages, styles, scripts, images, fonts and clips; never the board, answers, token or config. */
+/** Download types for --attach files; any other extension downloads as application/octet-stream. */
+const attachTypes = { '.apk': 'application/vnd.android.package-archive', '.zip': 'application/zip', '.pdf': 'application/pdf', '.txt': 'text/plain; charset=utf-8', '.json': 'application/json', '.csv': 'text/csv', '.gz': 'application/gzip' };
 const assetTypes = { ...mediaTypes, ...mockTypes, '.css': 'text/css', '.js': 'text/javascript', '.mjs': 'text/javascript', '.gif': 'image/gif', '.woff2': 'font/woff2' };
 const MOCK_BYTES = 5_000_000;
 /** A sandboxed mock frame sends no cookie, so beyond loopback its URLs carry this pass in the path: made from the token, it opens mock folders only. */
@@ -2543,6 +2683,22 @@ async function route(req) {
             return [404, { error: 'Evidence is unavailable' }];
         }
     }
+    if (req.method === 'GET' && req.url?.startsWith('/api/attachment?')) {
+        const q = new URL(req.url, 'http://localhost').searchParams;
+        const a = loadDecisions(file).find((d) => d.key === q.get('key'))?.attachments?.[Number(q.get('i') || NaN)];
+        if (!a)
+            return [404, { error: 'Attachment is unavailable' }];
+        try {
+            // Only its size is checked per request: hashing a file of hundreds of MB on every download would block the board.
+            const actual = under(dirname(file), a.path);
+            if (statSync(actual).size !== a.bytes)
+                return [404, { error: 'Attachment changed since it was posted' }];
+            return [200, { attachment: { path: actual, name: a.name, bytes: a.bytes, type: attachTypes[extname(a.path)] ?? 'application/octet-stream' } }];
+        }
+        catch {
+            return [404, { error: 'Attachment is unavailable' }];
+        }
+    }
     if (req.method === 'GET' && req.url === '/api/board')
         return [200, { file, pid: process.pid }];
     if (req.method === 'GET' && req.url === '/api/decisions') {
@@ -2551,12 +2707,12 @@ 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', '/api/leash'].includes(req.url ?? ''))
+    if (req.method !== 'POST' || !['/api/answers', '/api/rounds', '/api/messages', '/api/annotations', '/api/dismiss', '/api/signin', '/api/leash', '/api/deeper', '/api/reads'].includes(req.url ?? ''))
         return [404, { error: 'Not found' }];
     if (readOnly())
         return [403, { error: 'This board is read-only' }];
     // Dismiss only hides an item on this page and sends nothing to the feeding program, so an answers-only board takes it too.
-    if (!['/api/answers', '/api/dismiss', '/api/signin'].includes(req.url) && answersOnly())
+    if (!['/api/answers', '/api/dismiss', '/api/signin', '/api/reads'].includes(req.url) && answersOnly())
         return [403, { error: 'This board takes answers only' }];
     if (!req.headers['content-type']?.startsWith('application/json'))
         return [415, { error: 'Send JSON' }];
@@ -2644,6 +2800,21 @@ async function route(req) {
         appendDismissed(file, [...new Set(keys)], dismissed);
         return [200, state()];
     }
+    if (req.url === '/api/reads' || req.url === '/api/deeper') {
+        const { key, part, q } = JSON.parse(body) ?? {}, d = loadDecisions(file).find((x) => x.key === key), about = typeof part === 'string' && d ? guidePart(d, part) : undefined;
+        if (!about)
+            return [404, { error: 'This part is no longer on the board' }];
+        if (req.url === '/api/reads') {
+            appendRead(file, key, part);
+            return [200, state()];
+        }
+        if (q !== undefined && (typeof q !== 'string' || [...q.trim()].length > NOTE_MAX))
+            return [400, { error: `The question must be text of ${NOTE_MAX} characters or fewer` }];
+        // One ask at a time per part: a second tap while the agent is answering keeps the first.
+        if (!readDeeper(file).some((x) => x.key === key && x.part === part && !x.done))
+            askDeeper(file, key, part, about.slice(0, 160), q?.trim() || undefined);
+        return [200, state()];
+    }
     if (req.url === '/api/rounds') {
         const { key, note = '' } = JSON.parse(body) ?? {};
         if (typeof note !== 'string' || [...note.trim()].length > NOTE_MAX)
@@ -2844,6 +3015,18 @@ const server = createServer(async (req, res) => {
         status = e instanceof InputError ? (req.method === 'GET' ? 422 : 409) : e instanceof SyntaxError ? 400 : 500;
         body = { error: e.message };
     }
+    if (body && typeof body === 'object' && 'attachment' in body) {
+        // Streamed from disk in the range asked for, so a file of hundreds of MB never sits in memory.
+        const { path, name, bytes, type } = body.attachment;
+        const range = /^bytes=(\d*)-(\d*)$/.exec(req.headers.range ?? ''), ranged = !!range && !!(range[1] || range[2]);
+        const start = !ranged ? 0 : range[1] ? Number(range[1]) : Math.max(0, bytes - Number(range[2]));
+        const end = ranged && range[1] && range[2] ? Math.min(Number(range[2]), bytes - 1) : bytes - 1;
+        if (ranged && start > end)
+            return res.writeHead(416, { 'content-range': `bytes */${bytes}` }).end();
+        res.writeHead(ranged ? 206 : 200, { 'content-type': type, 'content-disposition': `attachment; filename="${name}"`, 'x-content-type-options': 'nosniff', 'cache-control': 'private, no-store', 'accept-ranges': 'bytes',
+            'content-length': Math.max(0, end - start + 1), ...(ranged && { 'content-range': `bytes ${start}-${end}/${bytes}` }) });
+        return bytes ? pipeline(createReadStream(path, { start, end }), res, () => { }) : res.end();
+    }
     if (body && typeof body === 'object' && 'media' in body) {
         const { media: bytes, type, point } = body, media = point ? Buffer.concat([bytes, pointer]) : bytes;
         const headers = { 'content-type': type, 'x-content-type-options': 'nosniff', 'content-security-policy': FRAME_CSP, 'accept-ranges': 'bytes', 'content-length': media.length };
@@ -2870,7 +3053,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), dismiss: axi('dismiss', dismiss(false)), restore: axi('restore', dismiss(true)), refile: axi('refile', refile), doctor: axi('doctor', doctor), notify: axi('notify', notify), 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), deeper: axi('deeper', deeper), signin: axi('signin', signin), dismiss: axi('dismiss', dismiss(false)), restore: axi('restore', dismiss(true)), refile: axi('refile', refile), 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;