your-attention 0.1.0 → 0.1.1

package/dist/src/cli.js

@@ -0,0 +1,814 @@
+// your-attention <command>. Run it with no command for the list.
+import { execFile, spawn, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+import { Client, describeAnswer, loadConfig, notOwnerAdvice, ownerPairing } from './client.js';
+import { parseTagsFlag } from './integrations/tags.js';
+                                                                            
+import { homeDir, readHome, writePrivate } from './node/home.js';
+import { choosePin, httpPinApi, offerPin, terminal } from './node/pin-prompt.js';
+import { NOTICE, askYesNo, queryUsage, summarize } from './node/telemetry.js';
+import { keepEvent, unackedNotice, watchLine } from './watch.js';
+
+const HELP = `your-attention: one inbox for the questions your coding agents ask you.
+
+  serve [--port 4815] [--host ::] [--no-mdns]        run the inbox
+  start [options for serve]                           run the inbox in the background
+  stop                                                stop the inbox, or its service when one is installed
+  status                                              show the inbox, its files, and this machine's pairings
+  open [--link]                                       open the inbox page signed in, or print a one-time sign-in link
+  tui [--mono] [--ascii]                              answer cards full screen in this terminal, with the keyboard and mouse
+  clear                                               clear the cards you answered or that closed; search still finds them
+  reset --yes                                         remove every card, answer and file; tokens and templates stay
+  login-url                                           print a sign-in link that works once, like open --link
+  pin status|set|reset|clear                          read, set, reset or remove the PIN that each browser tab types
+  install [--from-source PATH]                        print the exact commands that connect this machine's harnesses, and ask nothing
+  install --help <harness>                            the full recipe for one harness, even when it is not installed
+  discover [--seconds 3]                              list inboxes on the LAN
+  pair <url> [--name NAME] [--role agent|owner]       pair this machine with an inbox
+  post --agent ID --title TEXT [--text TEXT] [--option LABEL]... [--priority now|soon|later] [--wait]
+                                                      post a card, and with --wait print the answer
+  ack <card> [<card>...]                              mark answers read, when a script took them out of band
+  watch [--agent ID] [--no-card] [--select FIELD,...] [--type TYPE,...] [--ack]
+                                                      print each answer for that agent as a line of JSON; --ack marks each
+                                                      read, and without it the card waits in the outbox as unread
+  watch --role owner [--agent ID] [--no-card] [--select FIELD,...] [--type TYPE,...]
+                                                      print each change to every card, or to that agent's, as the owner
+  subscribe --agent ID (--webhook URL | --webhook-file FILE) [--header 'NAME: VALUE']... [--header-file FILE|-]
+                                                      send each answer to that agent's cards to an https webhook, once you approve it
+  unsubscribe --agent ID                              stop sending that agent's answers to its webhook
+  pi [--tags repo=acme/api,topic=billing] -- [pi args]  run pi, and give every card it posts default tags
+                                                      (YOUR_ATTENTION_TAGS, read by the pi extension at session start)
+  claude-channel                                      the MCP channel server for Claude Code
+  claude-hook ask-pre|ask-post|ask-cancel|turn-end    the Claude Code hooks: AskUserQuestion, and the Stop request for a card
+  herdr-blocked                                       post a card for each herdr agent that is blocked
+  opencode-plugin [--write]                           print or write the OpenCode plugin file that loads the card tools
+  triage [--judge-cmd "claude -p" | --judge-url URL --judge-model M --judge-key-env VAR]
+                                                      check each card before you see it (OpenRouter by default)
+  triage login                                        sign in to OpenRouter for the default judge
+  service serve|triage [--write]                      print or write a launchd or systemd unit
+  bridge [--upstream URL] [--port 4815] [--mdns]      offer a remote inbox on this machine
+  offer ssh <host> [--remote-port 4815]               offer this inbox on another machine over SSH
+  relay [--port 4900] [--key-env VAR]                 run a relay that inboxes dial out to
+  serve --relay URL [--relay-key-env VAR]             also offer this inbox through a relay
+  telemetry status|on|off|show|reset-id               read or change the anonymous usage counts, off unless you turn them on
+  telemetry report [--days 30] [--invites FILE]       for the operator: usage per invite, from Analytics Engine
+
+Files live in ${homeDir()} (set YOUR_ATTENTION_HOME to move them).`;
+
+const [command, ...rest] = process.argv.slice(2);
+
+function fail(message        )        {
+  console.error(message);
+  process.exit(1);
+}
+
+function client()         {
+  const config = loadConfig();
+  if (!config) fail('No inbox found. Start one with `your-attention serve`, or pair with `your-attention pair <url>`.');
+  return new Client(config);
+}
+
+/** The address this machine's inbox wrote, when server.json holds one. Another program, or a file written halfway,
+ * can leave anything there, and every row of the report is a string. */
+function readServerInfo()                                            {
+  try {
+    const info = JSON.parse(fs.readFileSync(path.join(homeDir(), 'server.json'), 'utf8'))                                           ;
+    if (typeof info?.url !== 'string' || !info.url) return undefined;
+    return { url: info.url, ...(typeof info.pid === 'number' ? { pid: info.pid } : {}) };
+  } catch {
+    return undefined;
+  }
+}
+
+/** What a your-attention inbox at this address says about itself, from GET /v1/info, or undefined when none answers there.
+ * Another program on the address could answer 200 with JSON of its own, so the name has to match and each field has to hold
+ * what the report can print. */
+async function infoOf(url        )                                                                        {
+  try {
+    const res = await fetch(`${url}/v1/info`, { signal: AbortSignal.timeout(2000) });
+    if (!res.ok) return undefined;
+    const info = (await res.json())                                                               ;
+    if (info?.name !== 'your-attention') return undefined;
+    return {
+      name: 'your-attention',
+      ...(typeof info.id === 'string' ? { id: info.id } : {}),
+      ...(typeof info.protocol === 'number' ? { protocol: info.protocol } : {}),
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+/** Whether an inbox answers at this address. */
+const answers = async (url        )                   => (await infoOf(url)) !== undefined;
+
+/** The address of the inbox this machine runs, when one answers there. */
+async function runningUrl()                              {
+  const info = readServerInfo();
+  return info && (await answers(info.url)) ? info.url : undefined;
+}
+
+                                                                                                                                                                 
+
+/** Read or change the usage setting of the inbox on this machine. */
+async function telemetry(body                                                               )                           {
+  const { url, owner } = localServer();
+  const res = await fetch(`${url}/v1/telemetry`, { method: body ? 'PUT' : 'GET', headers: { authorization: `Bearer ${owner}`, 'content-type': 'application/json' }, body: body ? JSON.stringify(body) : undefined }).catch(() => undefined);
+  if (!res) fail('No inbox runs on this machine. Start one with `your-attention serve`.');
+  if (!res.ok) fail(`The inbox answered ${res.status}: ${((await res.json().catch(() => ({})))                      ).error ?? ''}`);
+  return (await res.json())                   ;
+}
+
+function describeTelemetry(t                 )         {
+  if (t.blocked) return `This machine sends no usage counts: ${t.blocked}.`;
+  if (!t.enabled) return `Usage counts are off.\n\n${NOTICE}`;
+  return `Usage counts are on. One anonymous report a day goes to ${t.destination}.\nInstall id: ${t.installId}\n\n${NOTICE}`;
+}
+
+/** The same setting as one line, for `status`. */
+function telemetryLine(t                 )         {
+  if (t.blocked) return `off: this machine sends none (${t.blocked})`;
+  if (!t.enabled) return 'off; turn them on with `your-attention telemetry on`';
+  return `on: one anonymous report a day goes to ${t.destination}`;
+}
+
+/** The rows of `status`, in two indented columns under a title. */
+function section(title        , rows                    )         {
+  const width = Math.max(...rows.map(([label]) => label.length));
+  const indent = ' '.repeat(width + 4);
+  return [title, ...rows.map(([label, value]) => `  ${label.padEnd(width)}  ${value.split('\n').join(`\n${indent}`)}`)].join('\n');
+}
+
+/** The inbox and token agents on this machine use, for `status`, which reports a pairing file it cannot read rather than failing on it. */
+function agentPairing()                                             {
+  try {
+    const c = loadConfig();
+    return typeof c?.url === 'string' && typeof c.token === 'string' ? { url: c.url, token: c.token } : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** One answer webhook, for `status`. */
+function describeHook(h                    )         {
+  // The paired address may answer with anything, and the report still prints.
+  let host        ;
+  try { host = new URL(h.url).host; } catch { return 'an entry this report cannot read'; }
+  if (!Array.isArray(h.headers) || !h.headers.every((n) => typeof n === 'string')) return 'an entry this report cannot read';
+  const parts = [h.status === 'approved' ? `approved, ${h.delivered} sent` : 'waiting for your approval on its card'];
+  if (h.headers.length) parts.push(`headers ${h.headers.join(', ')}`);
+  if (h.waiting) parts.push(`${h.waiting} waiting to send`);
+  if (h.lastError) parts.push(`last failure: ${h.lastError.reason}`);
+  return `${host} (${parts.join('; ')})`;
+}
+
+/** A file size in a short unit, for `status`. */
+function bytes(n        )         {
+  if (n < 1024) return `${n} bytes`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+/** Whether a PIN protects the inbox, and any lockout that wrong PINs started. */
+function describePin(pin                                                                 )         {
+  const how = pin.set ? 'set: each new browser tab types it' : pin.neverAsk ? 'none, and the page never asks for one' : 'none; set one with `your-attention pin set`';
+  return pin.lockedUntil && pin.lockedUntil > Date.now() ? `${how}\nwrong PINs lock the page until ${new Date(pin.lockedUntil).toLocaleTimeString()}` : how;
+}
+
+/** A one-time link that signs a browser in, so the owner token stays out of the address bar and the browser history.
+ * It signs in to the inbox this machine runs, or else to the inbox this machine paired with, such as a cloud inbox. */
+async function signInLink()                  {
+  const local = runningHere();
+  const paired = local ? undefined : ownerPairing();
+  const target = local ?? paired ?? fail('No inbox runs on this machine. Start one with `your-attention start`, or pair this machine with your inbox as owner: `your-attention pair <url> --role owner`.');
+  const res = await fetch(`${target.url}/v1/sign-in-codes`, { method: 'POST', headers: { authorization: `Bearer ${target.token}`, 'content-type': 'application/json', 'x-your-attention': '1' }, body: '{}' }).catch(() => undefined);
+  if (!res) fail(local ? 'No inbox runs on this machine. Start one with `your-attention start`.' : `The inbox this machine paired with, ${target.url}, did not answer.`);
+  // An agent token cannot sign a browser in: only the owner's can.
+  if (res.status === 403 && !local) fail(notOwnerAdvice(target.url));
+  const { code, error } = (await res.json().catch(() => ({})))                                     ;
+  if (!res.ok || !code) fail(`Could not make a sign-in code: ${error ?? res.status}`);
+  return `${target.url}/#signin=${encodeURIComponent(code)}`;
+}
+
+/** The inbox this machine runs, with its owner token, or undefined when it runs none. */
+function runningHere()                                             {
+  try {
+    const { url } = JSON.parse(fs.readFileSync(path.join(homeDir(), 'server.json'), 'utf8'))                   ;
+    return { url, token: fs.readFileSync(path.join(homeDir(), 'owner-token'), 'utf8').trim() };
+  } catch {
+    return undefined;
+  }
+}
+
+/** The inbox the PIN commands change: the one this machine runs, or else the one this machine paired with as owner. */
+function pinTarget()                                 {
+  return runningHere() ?? ownerPairing() ?? fail('No inbox runs on this machine. Start one with `your-attention serve`, or pair as owner with `your-attention pair <url> --role owner`.');
+}
+
+function localServer()                                 {
+  try {
+    const { url } = JSON.parse(fs.readFileSync(path.join(homeDir(), 'server.json'), 'utf8'))                   ;
+    return { url, owner: fs.readFileSync(path.join(homeDir(), 'owner-token'), 'utf8').trim() };
+  } catch {
+    fail('No inbox runs on this machine. Start one with `your-attention serve`.');
+  }
+}
+
+switch (command) {
+  case 'serve': {
+    const { values } = parseArgs({ args: rest, options: { port: { type: 'string', default: '4815' }, host: { type: 'string', default: '::' }, 'no-mdns': { type: 'boolean', default: false }, relay: { type: 'string' }, 'relay-key-env': { type: 'string', default: 'YOUR_ATTENTION_RELAY_KEY' } } });
+    const relayKey = values.relay ? process.env[String(values['relay-key-env'])] ?? fail(`--relay needs the relay key in $${values['relay-key-env']}`) : '';
+    const stop = async ()                => { await server.close(); process.exit(0); };
+    const { serve } = await import('./node/server.js');
+    const server = await serve({ port: Number(values.port), host: String(values.host), mdns: !values['no-mdns'], relay: values.relay ? { url: values.relay, key: relayKey } : undefined, onShutdown: () => void stop(), ...(process.stdin.isTTY && process.stderr.isTTY ? { ask: askYesNo } : {}) });
+    process.on('SIGINT', stop);
+    process.on('SIGTERM', stop);
+    // In a terminal, the inbox asks for a PIN until it has one or the person says never. A service has no terminal and never waits here.
+    if (process.stdin.isTTY && process.stderr.isTTY) {
+      const pin = server.inbox.pin;
+      const t = terminal();
+      await offerPin(t, { status: async () => pin.status(), set: (p) => pin.set(p), clear: async () => pin.clear(), neverAsk: async () => pin.setNeverAsk(true) });
+      t.close();
+    }
+    break;
+  }
+  case 'start': {
+    // `serve` in the background, with the same options. The shell gets its prompt back once the inbox answers.
+    const home = homeDir();
+    const already = await runningUrl();
+    if (already) { console.log(`The inbox already runs on ${already}.`); break; }
+    const log = path.join(home, 'serve.log');
+    fs.mkdirSync(home, { recursive: true, mode: 0o700 });
+    const out = fs.openSync(log, 'a', 0o600);
+    const from = fs.statSync(log).size;
+    const child = spawn(process.execPath, [...process.execArgv, process.argv[1] ?? '', 'serve', ...rest], { detached: true, stdio: ['ignore', out, out], windowsHide: true });
+    child.unref();
+    const end = Date.now() + 15_000;
+    for (;;) {
+      const info = readServerInfo();
+      if (info && info.pid === child.pid && (await answers(info.url))) {
+        console.log(`Started the inbox on ${info.url}. Its log is ${log}. Stop it with: your-attention stop`);
+        // The first start in a terminal offers usage counts. They stay off unless the person says yes.
+        if (process.stdin.isTTY && process.stdout.isTTY) {
+          const t = await telemetry();
+          if (t.notice) { console.log(`\n${NOTICE}`); await telemetry({ enabled: await askYesNo('Send anonymous usage counts?') }); }
+        }
+        if (process.stdin.isTTY && process.stdout.isTTY) {
+          const t = terminal(process.stdin, process.stdout);
+          await offerPin(t, httpPinApi(info.url, localServer().owner));
+          t.close();
+        }
+        break;
+      }
+      const tail = () => fs.readFileSync(log, 'utf8').slice(from).trim().split('\n').slice(-10).join('\n');
+      if (child.exitCode !== null || child.signalCode !== null) fail(`The inbox did not start:\n${tail()}`);
+      if (Date.now() > end) fail(`The inbox did not answer within 15 seconds. Its log is ${log}:\n${tail()}`);
+      await new Promise((r) => setTimeout(r, 100));
+    }
+    process.exit(0);
+  }
+  case 'stop': {
+    // A service restarts the inbox when it exits, so stop the service itself when there is one.
+    if (process.platform === 'darwin' || process.platform === 'linux') {
+      const { serviceFile } = await import('./node/service.js');
+      const unit = serviceFile('serve', []);
+      const sh = (cmd        ) => spawnSync('sh', ['-c', cmd], { stdio: 'ignore' }).status === 0;
+      if (fs.existsSync(unit.path) && sh(unit.running)) {
+        if (!sh(unit.stop)) fail(`The inbox service runs, and \`${unit.stop}\` did not stop it.`);
+        console.log(`Stopped the inbox service. It starts again at login, or now with: ${unit.start}`);
+        break;
+      }
+    }
+    const { url, owner } = localServer();
+    const res = await fetch(`${url}/v1/shutdown`, { method: 'POST', headers: { authorization: `Bearer ${owner}` } }).catch(() => undefined);
+    if (!res) {
+      fs.rmSync(path.join(homeDir(), 'server.json'), { force: true });
+      fail('No inbox runs on this machine. Start one with `your-attention serve`.');
+    }
+    if (res.status !== 202) fail(`The inbox on ${url} refused to stop: ${((await res.json().catch(() => ({})))                      ).error ?? res.status}`);
+    // The inbox stops answering before it closes its database, and removes its address file after.
+    const before = readServerInfo()?.pid;
+    const end = Date.now() + 10_000;
+    while ((await answers(url)) || (before !== undefined && readServerInfo()?.pid === before)) {
+      if (Date.now() > end) fail(`The inbox on ${url} is still running after 10 seconds.`);
+      await new Promise((r) => setTimeout(r, 100));
+    }
+    console.log(`Stopped the inbox on ${url}.`);
+    break;
+  }
+  case 'status': {
+    const home = homeDir();
+    const serverFile = path.join(home, 'server.json');
+    const here = readServerInfo();
+    const info = here ? await infoOf(here.url) : undefined;
+    const ownerToken = readHome('owner-token', home);
+
+    // The inbox this machine runs, and what it says about itself.
+    const inbox                     = [];
+    if (info && here) {
+      inbox.push(['state', 'running']);
+      inbox.push(['address', here.url]);
+      if (here.pid !== undefined) inbox.push(['pid', String(here.pid)]);
+      if (info.id) inbox.push(['inbox id', info.id]);
+      if (info.protocol !== undefined) inbox.push(['protocol', String(info.protocol)]);
+      if (ownerToken) {
+        const pin = await httpPinApi(here.url, ownerToken).status().catch(() => undefined);
+        if (pin) inbox.push(['PIN', describePin(pin)]);
+        // The usage setting lives in the inbox, and only its owner may read it.
+        const usage = await fetch(`${here.url}/v1/telemetry`, { headers: { authorization: `Bearer ${ownerToken}` }, signal: AbortSignal.timeout(2000) })
+          .then(async (r) => (r.ok ? (await r.json())                    : undefined))
+          .catch(() => undefined);
+        if (usage) inbox.push(['usage counts', telemetryLine(usage)]);
+      }
+    } else if (here) {
+      inbox.push(['state', `not running; ${serverFile} is left from an earlier run`]);
+      inbox.push(['address', here.url]);
+      inbox.push(['start it', 'your-attention start']);
+    } else if (fs.existsSync(serverFile)) {
+      inbox.push(['state', `not running; ${serverFile} holds no address`]);
+      inbox.push(['start it', 'your-attention start']);
+    } else {
+      inbox.push(['state', 'none on this machine']);
+      inbox.push(['start it', 'your-attention start, or pair with an inbox: your-attention pair <url>']);
+    }
+    // A service starts the inbox at login, and `stop` stops the service itself.
+    if (process.platform === 'darwin' || process.platform === 'linux') {
+      const { serviceFile } = await import('./node/service.js');
+      const unit = serviceFile('serve', []);
+      const installed = fs.existsSync(unit.path);
+      const running = installed && spawnSync('sh', ['-c', unit.running], { stdio: 'ignore' }).status === 0;
+      inbox.push(['service', running ? `running (${unit.path})` : installed ? `installed, not running (${unit.path})` : 'not installed']);
+    }
+    if (fs.existsSync(path.join(home, 'serve.log'))) inbox.push(['log', path.join(home, 'serve.log')]);
+
+    // The files this machine keeps, and the secrets they hold.
+    const tokens = ['owner-token', 'agent-token', 'extension-token'].filter((f) => fs.existsSync(path.join(home, f)));
+    const db = path.join(home, 'inbox.sqlite');
+    const files                     = [['home', home]];
+    if (fs.existsSync(db)) files.push(['database', `${db}, ${bytes(fs.statSync(db).size)}`]);
+    files.push(['tokens', tokens.length ? tokens.join(', ') : 'none yet']);
+
+    // The inboxes this machine paired with, and whether each one answers.
+    const pairings                     = [];
+    for (const [role, file] of [['agent', 'client.json'], ['owner', 'owner.json']]         ) {
+      const text = readHome(file, home);
+      // No such file means no such pairing. An empty file is there, and the person should see that it is.
+      if (text === undefined) continue;
+      if (!text) { pairings.push([role, `${file} is empty`]); continue; }
+      let pairing         ;
+      try { pairing = JSON.parse(text); } catch { pairings.push([role, `${file} is unreadable`]); continue; }
+      // The file parses to anything at all: `null` and a bare number parse without an error.
+      const url = typeof pairing === 'object' && pairing !== null ? (pairing                     ).url : undefined;
+      if (!url || typeof url !== 'string') { pairings.push([role, `${file} holds no address`]); continue; }
+      pairings.push([role, `${url} (${file}, ${(await answers(url)) ? 'answering' : 'not answering'})`]);
+    }
+    if (!pairings.length) pairings.push(['none', 'pair with `your-attention pair <url>`']);
+
+    // What the agent this machine resolves to was given and never acknowledged. This is the command an agent runs when
+    // it wonders whether an answer arrived while it was away.
+    // `client.json` can parse to anything at all, and `loadConfig` trusts it: a file holding `null` or `{"url":42}` is a
+    // pairing this machine cannot use, and `status` reports that below rather than failing on it.
+    const mine = loadConfig();
+    const usable = mine && typeof mine.url === 'string' && typeof mine.token === 'string' ? mine : undefined;
+    const left = usable ? await new Client(usable).unread().catch(() => undefined) : undefined;
+    if (left) {
+      const more = left.unread - left.cards.length;
+      const line = left.unread
+        ? `${left.unread}: your-attention ack ${left.cards.join(' ')}${more > 0 ? ` (and ${more} more)` : ''}`
+        : 'none';
+      console.log(`${section('Answers this machine has not read', [['not read', line]])}\n`);
+    }
+    // The answer webhooks: every one with the owner token of the inbox here, or the agent pairing's own.
+    const hookTarget = info && here && ownerToken ? { url: here.url, token: ownerToken } : agentPairing();
+    const hooks = hookTarget
+      ? await fetch(`${hookTarget.url.replace(/\/$/, '')}/v1/subscriptions`, { headers: { authorization: `Bearer ${hookTarget.token}` }, signal: AbortSignal.timeout(2000) })
+        .then(async (r) => (r.ok ? (await r.json())            : undefined)).catch(() => undefined)
+        .then((list) => (Array.isArray(list) ? (list             ).filter((h)                          => typeof h === 'object' && h !== null) : undefined))
+      : undefined;
+
+    console.log(section('Inbox on this machine', inbox));
+    console.log(`\n${section('Files on this machine', files)}`);
+    console.log(`\n${section('Paired inboxes', pairings)}`);
+    // The host only, since a webhook address can carry a secret in its path, as the header values do.
+    if (hooks) console.log(`\n${section('Answer webhooks', hooks.length ? hooks.map((h) => [String(h.agent ?? 'unknown agent'), describeHook(h)]) : [['none', 'add one with `your-attention subscribe --agent ID --webhook URL`']])}`);
+    // Environment variables win over the files, so an agent uses them before its pairing.
+    const url = process.env['YOUR_ATTENTION_URL'];
+    const token = process.env['YOUR_ATTENTION_TOKEN'];
+    if (url || token) {
+      const line = url && token ? `${url}, with YOUR_ATTENTION_TOKEN, before the files above` : `${url ? 'YOUR_ATTENTION_URL' : 'YOUR_ATTENTION_TOKEN'} is set alone, so agents ignore it`;
+      console.log(`\n${section('Environment', [['agents use', line]])}`);
+    }
+    break;
+  }
+  case 'login-url':
+    console.log(await signInLink());
+    break;
+  case 'pin': {
+    const [sub = 'status'] = rest;
+    const { url, token } = pinTarget();
+    const api = httpPinApi(url, token);
+    const s = await api.status().catch((e       ) => fail(`Could not read the PIN of the inbox on ${url}: ${e.message}`));
+    const t = terminal(process.stdin, process.stdout);
+    try {
+      if (sub === 'status') {
+        console.log(s.set ? 'This inbox has a PIN. Each new browser tab types it before it opens the inbox.' : s.neverAsk ? 'This inbox has no PIN, and it does not ask for one. Set one with: your-attention pin set' : 'This inbox has no PIN. Set one with: your-attention pin set');
+        if (s.lockedUntil) console.log(`Wrong PINs locked the page until ${new Date(s.lockedUntil).toLocaleTimeString()}. \`your-attention pin reset\` lifts it.`);
+      } else if (sub === 'set' || sub === 'reset') {
+        if (sub === 'set' && s.set) fail('This inbox has a PIN. Replace it with `your-attention pin reset`, which needs no current PIN.');
+        const pin = await choosePin(t);
+        if (!pin && sub === 'set') fail('No PIN set.');
+        if (pin) await api.set(pin); else await api.clear();
+        console.log(pin ? `PIN ${sub === 'set' ? 'set' : 'reset'}. Every open tab types it again.` : 'The PIN is gone, and so is the lockout. The page asks for a new PIN when it opens.');
+      } else if (sub === 'clear') {
+        await api.clear();
+        console.log('The PIN is gone. The inbox page opens without one.');
+      } else {
+        fail('Usage: your-attention pin status|set|reset|clear');
+      }
+    } catch (e) {
+      fail(`The inbox refused: ${(e         ).message}`);
+    } finally {
+      t.close();
+    }
+    break;
+  }
+  case 'clear':
+  case 'reset': {
+    if (command === 'reset' && !rest.includes('--yes')) fail('reset removes every card, answer and file, and cannot be undone. Run `your-attention reset --yes` to confirm, or `your-attention clear` to clear only the cards you dealt with.');
+    const { url, owner } = localServer();
+    const res = await fetch(`${url}/v1/${command === 'clear' ? 'archive' : 'reset'}`, { method: 'POST', headers: { authorization: `Bearer ${owner}`, 'content-type': 'application/json' }, body: JSON.stringify(command === 'reset' ? { confirm: 'reset' } : {}) }).catch(() => undefined);
+    if (!res) fail('No inbox runs on this machine. Start one with `your-attention start`.');
+    const body = (await res.json().catch(() => ({})))                                                           ;
+    if (!res.ok) fail(`The inbox refused: ${body.error ?? res.status}`);
+    console.log(command === 'clear' ? `Cleared ${body.archived} cards. Search still finds them.` : `Removed ${body.removed} cards and their answers.`);
+    break;
+  }
+  case 'open': {
+    const { values } = parseArgs({ args: rest, options: { link: { type: 'boolean', default: false } } });
+    const link = await signInLink();
+    if (values.link) {
+      console.log(`Open this link in the browser to sign in. It works once, within 5 minutes:\n${link}`);
+      break;
+    }
+    const opener = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'explorer' : 'xdg-open';
+    execFile(opener, [link]);
+    break;
+  }
+  case 'tui': {
+    const { values } = parseArgs({ args: rest, options: { mono: { type: 'boolean', default: false }, ascii: { type: 'boolean', default: false } } });
+    if ((!process.stdin.isTTY || !process.stdout.isTTY) && !process.env['YOUR_ATTENTION_TUI_SIZE']) fail('your-attention tui needs a terminal for its input and its output.');
+    const { runTui } = await import('./tui/app.js');
+    process.exit(await runTui({ env: process.env, io: { input: process.stdin, output: process.stdout }, mono: values.mono, ascii: values.ascii }));
+  }
+  case 'install': {
+    // An agent reads this, so nothing here prompts: every line it needs to run comes out as one command.
+    // `--help` takes a harness name. On its own it means "show me the report", and parseArgs would read the next
+    // flag as that missing value, so a `--help` followed by nothing or by another flag is answered before parsing.
+    const helpAt = rest.indexOf('--help');
+    const next = helpAt < 0 ? undefined : rest[helpAt + 1];
+    const bareHelp = helpAt >= 0 && (next === undefined || next.startsWith('-'));
+    let values                                           ;
+    try {
+      ({ values } = parseArgs({
+        args: bareHelp ? rest.filter((a) => a !== '--help') : rest,
+        options: { help: { type: 'string' }, 'from-source': { type: 'string' } },
+        allowPositionals: true,
+      }));
+    } catch (e) {
+      // An option without its value is a usage mistake, and a reader of this command is an agent: one clear line.
+      fail(`install: ${(e         ).message}. Usage: your-attention install [--from-source PATH], or install --help <harness>.`);
+    }
+    const { HARNESSES, detect, installHelp, installReport, which } = await import('./node/install.js');
+    const pathEnv = process.env['PATH'];
+    const facts = {
+      found: detect(pathEnv),
+      brew: which('brew', pathEnv) !== undefined,
+      self: which('your-attention', pathEnv),
+      ...(values['from-source'] ? { fromSource: values['from-source'] } : {}),
+    };
+    if (values.help !== undefined) {
+      const lines = installHelp(values.help, facts);
+      if (!lines) fail(`Unknown harness: ${values.help}. Known ones: ${HARNESSES.map((h) => h.name).join(', ')}.`);
+      console.log(lines.join('\n'));
+      break;
+    }
+    console.log(installReport(facts).join('\n'));
+    break;
+  }
+  case 'discover': {
+    const { values } = parseArgs({ args: rest, options: { seconds: { type: 'string', default: '3' } } });
+    const { discover } = await import('./adapters/mdns.js');
+    const found = await discover(Number(values.seconds) * 1000);
+    if (!found.length) console.log('No inbox found on this network.');
+    for (const f of found) console.log(`${f.name}\thttp://${f.addresses.find((a) => !a.includes(':')) ?? f.host}:${f.port}\tid=${f.txt['id'] ?? '?'}`);
+    break;
+  }
+  case 'pair': {
+    const { values, positionals } = parseArgs({ args: rest, allowPositionals: true, options: { name: { type: 'string', default: `${os.userInfo().username}@${os.hostname()}` }, role: { type: 'string', default: 'agent' } } });
+    const url = (positionals[0] ?? fail('Usage: your-attention pair <url>')).replace(/\/$/, '');
+    const res = await fetch(`${url}/v1/pair`, { method: 'POST', body: JSON.stringify({ name: values.name, role: values.role }) });
+    const req = (await res.json())                                                  ;
+    if (!res.ok || !req.id) fail(`Pairing refused: ${req.error ?? res.status}`);
+    console.log(`Pairing code: ${req.code}. Approve the card with this code in your inbox.`);
+    for (;;) {
+      await new Promise((r) => setTimeout(r, 1000));
+      const s = (await (await fetch(`${url}/v1/pair/${req.id}`)).json())                                      ;
+      if (s.status === 'denied') fail('The pairing was denied.');
+      if (s.token) {
+        const info = (await (await fetch(`${url}/v1/info`)).json())                   ;
+        // An owner pairing gets a file of its own, so it never replaces the agent pairing the agents on this machine use.
+        const file = path.join(homeDir(), values.role === 'owner' ? 'owner.json' : 'client.json');
+        writePrivate(file, JSON.stringify({ url, token: s.token, id: info.id }));
+        console.log(`Paired. The token is in ${file}.`);
+        break;
+      }
+    }
+    break;
+  }
+  case 'post': {
+    const { values } = parseArgs({ args: rest, options: { agent: { type: 'string' }, title: { type: 'string' }, text: { type: 'string' }, option: { type: 'string', multiple: true }, priority: { type: 'string', default: 'soon' }, wait: { type: 'boolean', default: false } } });
+    if (!values.agent || !values.title) fail('Usage: your-attention post --agent ID --title TEXT');
+    const c = client();
+    const options                       = values.option?.map((label, i) => ({ id: `o${i + 1}`, label }));
+    const card = await c.post({ agent: values.agent, title: values.title, text: values.text, options, priority: values.priority            , origin: { harness: 'cli', host: os.hostname(), cwd: process.cwd() } });
+    console.log(card.id);
+    if (!values.wait) break;
+    const stop = new AbortController();
+    await c.stream(values.agent, async (ev) => {
+      if (ev.type !== 'answer' || ev.card.id !== card.id) return;
+      console.log(describeAnswer(ev.card, ev.answer));
+      await c.ack(card.id);
+      stop.abort();
+    }, stop.signal);
+    break;
+  }
+  case 'ack': {
+    // A script that takes an answer out of band, as one reading `watch` does, marks it read with this. Without the ack
+    // the card waits in the page's outbox, and the person cannot tell what the agent consumed. It takes every id it is
+    // given, because the watcher's own advice names them all on one line.
+    const ids = rest.filter((a) => !a.startsWith('-'));
+    if (!ids.length) fail('Usage: your-attention ack <card> [<card>...]');
+    const c = client();
+    for (const id of ids) {
+      const answer = await c.ack(id).catch((e       ) => fail(`The inbox refused ${id}: ${e.message}`));
+      if (!answer.readAt) fail(`The inbox did not mark ${id} read`);
+      console.log(`Card ${id} is read.`);
+    }
+    break;
+  }
+  case 'watch': {
+    const { values } = parseArgs({ args: rest, options: {
+      role: { type: 'string', default: 'agent' },
+      agent: { type: 'string' },
+      type: { type: 'string' },
+      'no-card': { type: 'boolean', default: false },
+      select: { type: 'string' },
+      ack: { type: 'boolean', default: false },
+    } });
+    if (values.role !== 'agent' && values.role !== 'owner') fail(`--role is agent or owner, not ${values.role}.`);
+    const owner = values.role === 'owner';
+    if (values['no-card'] && values.select !== undefined) fail('Choose --no-card or --select, not both: one leaves the card out, and the other picks the fields to keep.');
+    const fields = values.select?.split(',').map((f) => f.trim()).filter(Boolean);
+    if (fields?.length === 0) fail('--select takes a comma-separated list of card fields, such as --select=id,title. Without it, each line carries the whole card.');
+    const types = values.type?.split(',').map((f) => f.trim()).filter(Boolean);
+    if (types?.length === 0) fail(`--type takes a comma-separated list of event types, such as --type=${owner ? 'change,presence' : 'answer,returned'}. Without it, the watcher prints every type.`);
+    // Only the token that posted a card may acknowledge its answer, so an owner watcher has nothing it could mark read.
+    if (owner && values.ack) fail('--ack marks an answer read for the agent that posted the card, and only that agent\'s token may. An owner watcher can\'t: drop --ack, or watch as the agent with --agent ID.');
+    const stop = new AbortController();
+    // What a watcher cannot see from its side: printing an answer does not acknowledge it, and its card waits in the
+    // person's outbox as unread until something does. Say so when the watch ends, rather than leaving it silent.
+    const unacked           = [];
+    let said = false;
+    const say = ()       => {
+      if (said || values.ack || !unacked.length) return;
+      said = true;
+      // The ids come from the event, not from the printed line: `--no-card` and `--select` leave the card out of that
+      // line, so advice naming `<card>` would be advice the reader cannot follow.
+      console.error(unackedNotice(unacked));
+    };
+    const end = ()       => {
+      say();
+      stop.abort();
+      // Closing a socket waits for the far end's answer, which a quiet inbox may never send, and the watch has nothing
+      // left to write. So the signal ends the watch on its own, and a stream that returns first ends it sooner.
+      setTimeout(() => process.exit(0), 500).unref();
+    };
+    for (const signal of ['SIGINT', 'SIGTERM']         ) process.on(signal, end);
+    // A reader that stops reading, as `watch | head -1` does, ends the watch: it is not an error.
+    process.stdout.on('error', (e                       ) => {
+      if (e.code !== 'EPIPE') return;
+      say();
+      process.exit(0);
+    });
+    const options = { noCard: values['no-card'], fields };
+    if (owner) {
+      // The owner token of the inbox this machine runs, or else the owner pairing, as for `login-url`.
+      const { checkOwner, watchOwner } = await import('./owner-watch.js');
+      const { ApiError } = await import('./tui/api.js');
+      const target = runningHere() ?? ownerPairing() ?? fail('This machine runs no inbox and is not paired with one as owner. Pair it as owner with `your-attention pair <url> --role owner`, or start an inbox with `your-attention start`.');
+      await checkOwner(target).catch((e         ) => {
+        if (e instanceof ApiError && e.status === 403) fail(notOwnerAdvice(target.url));
+        if (e instanceof ApiError && e.status === 401) fail(`The inbox at ${target.url} refused this machine's owner token. Pair it again with \`your-attention pair ${target.url} --role owner\`.`);
+        fail(`The inbox at ${target.url} did not answer: ${(e         ).message}`);
+      });
+      console.error(`Watching ${target.url} as the owner${values.agent ? ` for the cards of ${values.agent}` : ', for every card'}, one line of JSON each.`);
+      await watchOwner(target, { options, filter: { types, agent: values.agent }, write: (line) => process.stdout.write(`${JSON.stringify(line)}\n`), signal: stop.signal });
+      break;
+    }
+    const c = client();
+    const agent = values.agent ?? 'cli:watch';
+    console.error(`Watching ${c.url} for the answers to cards posted as ${agent}, one line of JSON each.`);
+    await c.stream(agent, async (ev) => {
+      if (!keepEvent(ev, { types })) return;
+      process.stdout.write(`${JSON.stringify(watchLine(ev, options, Date.now()))}\n`);
+      // Only when asked: a watcher that acknowledged every answer would mark read what the agent waiting for it has not seen.
+      if (ev.type !== 'answer') return;
+      if (!values.ack) {
+        unacked.push(ev.card.id);
+        return;
+      }
+      await c.ack(ev.card.id).catch((e       ) => console.error(`Could not mark card ${ev.card.id} read: ${e.message}`));
+    }, stop.signal);
+    say();
+    // The notice above covers what this process printed. A watcher that was down, or that started after an answer
+    // landed, learns the rest from the inbox: the count, and the cards to acknowledge.
+    // Every run asks, `--ack` or not: with `--ack` the stream acks what it prints, so anything still unread is an answer
+    // that arrived while nothing was listening, which is the case this line exists for.
+    const left = await c.unread(agent).catch(() => undefined);
+    if (left && left.unread > 0) console.error(`The inbox holds ${left.unread} unread answer${left.unread === 1 ? '' : 's'} for ${agent}: your-attention ack ${left.cards.join(' ')}${left.unread > left.cards.length ? ` (and ${left.unread - left.cards.length} more)` : ''}`);
+    break;
+  }
+  case 'subscribe': {
+    const { values } = parseArgs({ args: rest, options: { agent: { type: 'string' }, webhook: { type: 'string' }, 'webhook-file': { type: 'string' }, header: { type: 'string', multiple: true }, 'header-file': { type: 'string' } } });
+    const usage = "Usage: your-attention subscribe --agent ID (--webhook URL | --webhook-file FILE) [--header 'NAME: VALUE']... [--header-file FILE|-]";
+    if (!values.agent || (values.webhook === undefined) === (values['webhook-file'] === undefined)) fail(usage);
+    // A secret goes in a file or on stdin: an argument shows in `ps` to every user of this machine, and in the shell history.
+    const readText = (file        , what        )         => {
+      try { return file === '-' ? fs.readFileSync(0, 'utf8') : fs.readFileSync(file, 'utf8'); } catch (e) { return fail(`Could not read the ${what} in ${file === '-' ? 'stdin' : file}: ${(e                         ).code ?? (e         ).message}.`); }
+    };
+    const webhook = values.webhook ?? readText(values['webhook-file'] ?? '', 'webhook address').trim();
+    const file = values['header-file'];
+    const lines = file === undefined ? [] : readText(file, 'headers').split(/\r?\n/).filter((l) => l.trim());
+    const headers                         = {};
+    for (const [i, h] of [...(values.header ?? []), ...lines].entries()) {
+      const at = h.indexOf(':');
+      // The line may be a bare token, so the message never quotes it.
+      if (at < 0 || !h.slice(0, at).trim()) fail(`Header ${i + 1} has no name: each --header, and each line of --header-file, takes 'NAME: VALUE', such as 'Authorization: Bearer <token>'.`);
+      headers[h.slice(0, at).trim()] = h.slice(at + 1).trim();
+    }
+    const r = await client().subscribe(values.agent, { url: webhook, headers }).catch((e       ) => fail(`The inbox refused the webhook: ${e.message}`));
+    console.error(`Asked the inbox to send the answers for ${values.agent} to ${new URL(r.subscription.url).host}. Nothing goes out until you approve the card "${r.card.title}" in the inbox.`);
+    console.error('Each call carries x-your-attention-signature, an HMAC-SHA256 of the body keyed with the secret below. The inbox shows it only this once.');
+    console.log(JSON.stringify({ id: r.subscription.id, status: r.subscription.status, card: r.card.id, secret: r.secret }));
+    break;
+  }
+  case 'unsubscribe': {
+    const { values } = parseArgs({ args: rest, options: { agent: { type: 'string' } } });
+    if (!values.agent) fail('Usage: your-attention unsubscribe --agent ID');
+    const { removed } = await client().unsubscribe(values.agent).catch((e       ) => fail(`The inbox refused: ${e.message}`));
+    console.log(removed ? `Stopped sending the answers for ${values.agent} to its webhook.` : `${values.agent} had no webhook for this token.`);
+    break;
+  }
+  case 'triage': {
+    const triage = await import('./extensions/triage.js');
+    if (rest[0] === 'login') {
+      const opener = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'explorer' : 'xdg-open';
+      await triage.openRouterLogin((u) => { console.log(`Opening ${u}`); execFile(opener, [u]); });
+      console.log(`Signed in. The key is in ${triage.OPENROUTER_KEY_FILE()}.`);
+      break;
+    }
+    const { values } = parseArgs({ args: rest, options: { 'judge-cmd': { type: 'string' }, 'judge-url': { type: 'string' }, 'judge-model': { type: 'string' }, 'judge-key-env': { type: 'string' }, name: { type: 'string', default: 'triage' } } });
+    const { loadExtensionConfig } = await import('./client.js');
+    const config = loadExtensionConfig() ?? fail('No inbox found: start one, or set YOUR_ATTENTION_URL and YOUR_ATTENTION_TOKEN to an extension token.');
+    const judge = values['judge-cmd'] ? triage.commandJudge(values['judge-cmd'])
+      : values['judge-url'] ? triage.chatJudge({ baseUrl: values['judge-url'], model: values['judge-model'] ?? fail('--judge-model is required with --judge-url'), apiKey: process.env[values['judge-key-env'] ?? ''] ?? '' })
+      : triage.defaultJudge(values['judge-model']);
+    const stop = new AbortController();
+    process.on('SIGTERM', () => stop.abort());
+    process.on('SIGINT', () => stop.abort());
+    await triage.runTriage({ ...config, judge, name: values.name }, stop.signal);
+    break;
+  }
+  case 'service': {
+    // The options after the name go to the service as they were typed, without --write.
+    const [name, ...given] = rest;
+    const write = given.includes('--write');
+    const args = given.filter((a) => a !== '--write');
+    if (name !== 'serve' && name !== 'triage') fail('Usage: your-attention service serve|triage [--write] [options for the command]');
+    const { serviceFile } = await import('./node/service.js');
+    const unit = serviceFile(name, [name, ...args]);
+    if (!write) { console.log(`# ${unit.path}\n${unit.content}\n# then: ${unit.start}`); break; }
+    fs.mkdirSync(path.dirname(unit.path), { recursive: true });
+    fs.writeFileSync(unit.path, unit.content);
+    console.log(`Wrote ${unit.path}. Start it with: ${unit.start}`);
+    break;
+  }
+  case 'bridge': {
+    const { values } = parseArgs({ args: rest, options: { upstream: { type: 'string' }, port: { type: 'string', default: '4815' }, host: { type: 'string', default: '127.0.0.1' }, mdns: { type: 'boolean', default: false } } });
+    const upstream = values.upstream ?? loadConfig()?.url ?? ownerPairing()?.url ?? fail('Give the inbox with --upstream <url>, or pair this machine first.');
+    const b = await (await import('./node/links.js')).bridge({ upstream, port: Number(values.port), host: values.host, mdns: values.mdns });
+    console.error(`[bridge] ${b.url} leads to ${upstream}`);
+    break;
+  }
+  case 'offer': {
+    const { values, positionals } = parseArgs({ args: rest, allowPositionals: true, options: { 'remote-port': { type: 'string', default: '4815' } } });
+    if (positionals[0] !== 'ssh' || !positionals[1]) fail('Usage: your-attention offer ssh <host> [--remote-port 4815]');
+    const { url } = localServer();
+    (await import('./node/links.js')).offerOverSsh({ host: positionals[1], localPort: Number(new URL(url).port), remotePort: Number(values['remote-port']) });
+    break;
+  }
+  case 'relay': {
+    const { values } = parseArgs({ args: rest, options: { port: { type: 'string', default: '4900' }, host: { type: 'string', default: '0.0.0.0' }, 'key-env': { type: 'string', default: 'YOUR_ATTENTION_RELAY_KEY' } } });
+    const key = process.env[String(values['key-env'])] ?? fail(`The relay needs its key in $${values['key-env']}.`);
+    const r = await (await import('./node/links.js')).relayServer({ port: Number(values.port), host: values.host, key });
+    console.error(`[relay] listening on ${r.url}; inboxes are at /i/<inbox id>/`);
+    break;
+  }
+  case 'pi': {
+    // pi rejects a flag it does not know, such as --tags, so this launcher takes the flag and hands pi the rest.
+    const sep = rest.indexOf('--');
+    const own = sep === -1 ? rest : rest.slice(0, sep);
+    const piArgs = sep === -1 ? [] : rest.slice(sep + 1);
+    const { values } = parseArgs({ args: own, options: { tags: { type: 'string' } } });
+    const env                    = { ...process.env };
+    if (values.tags !== undefined) {
+      parseTagsFlag(values.tags);
+      env['YOUR_ATTENTION_TAGS'] = values.tags;
+    }
+    // pi draws in the terminal, so it inherits this one's input, output and errors, and it gets every argument after
+    // -- unchanged.
+    // Windows runs a `.cmd` only through the shell it belongs to.
+    const win = process.platform === 'win32';
+    const child = win
+      ? spawnSync(process.env['COMSPEC'] ?? 'cmd.exe', ['/d', '/s', '/c', 'pi', ...piArgs], { stdio: 'inherit', env })
+      : spawnSync('pi', piArgs, { stdio: 'inherit', env });
+    if (child.error) fail(`Could not run pi: ${child.error.message}`);
+    process.exit(child.status ?? 1);
+  }
+  case 'claude-channel':
+    await import('./integrations/claude/channel.js');
+    break;
+  case 'claude-hook':
+    if (rest[0] === 'turn-end') await (await import('./integrations/claude/turn-end-hook.js')).main();
+    else await (await import('./integrations/claude/ask-hook.js')).main(rest[0] ?? '');
+    break;
+  case 'opencode-plugin': {
+    const { values } = parseArgs({ args: rest, options: { write: { type: 'boolean', default: false } } });
+    const { pluginFile, pluginSource } = await import('./integrations/opencode/install.js');
+    const file = pluginFile();
+    if (!values.write) { console.log(`# ${file}\n${pluginSource()}`); break; }
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, pluginSource());
+    console.log(`Wrote ${file}. OpenCode loads it at its next start.`);
+    break;
+  }
+  case 'herdr-blocked':
+    await (await import('./integrations/herdr/blocked.js')).main();
+    break;
+  case 'telemetry': {
+    const [sub, ...args] = rest;
+    if (sub === 'report') {
+      // For the operator of the hosted service. Invite codes stay in the file: the report prints the label beside each one.
+      const { values } = parseArgs({ args, options: { days: { type: 'string', default: '30' }, invites: { type: 'string' } } });
+      const account = process.env['CLOUDFLARE_ACCOUNT_ID'];
+      const token = process.env['CLOUDFLARE_API_TOKEN'];
+      if (!account || !token) fail('Set CLOUDFLARE_ACCOUNT_ID and CLOUDFLARE_API_TOKEN, a token with Account Analytics Read.');
+      const labels = new Map                ();
+      if (values.invites) {
+        const { inviteId } = await import('./core/telemetry.js');
+        const lines = fs.readFileSync(values.invites, 'utf8').split(/\r?\n/);
+        for (const [i, line] of lines.entries()) {
+          const [code, ...label] = line.trim().split(/\s+/);
+          if (code && !code.startsWith('#')) labels.set(await inviteId(code), label.join(' ') || `line ${i + 1}`);
+        }
+      }
+      const rows = summarize(await queryUsage(account, token, Number(values.days)), labels);
+      if (!rows.length) { console.log(`No usage reports in the last ${values.days} days.`); break; }
+      const cols = ['invite', 'inboxes', 'days', 'cards', 'answers', 'pairings', 'pages', 'peakAgents', 'peakInstances', 'peakTokens', 'flag']         ;
+      const table = [cols.map(String), ...rows.map((r) => cols.map((c) => String(r[c])))];
+      const widths = cols.map((_, i) => Math.max(...table.map((row) => (row[i] ?? '').length)));
+      for (const row of table) console.log(row.map((cell, i) => cell.padEnd(widths[i] ?? 0)).join('  ').trimEnd());
+      break;
+    }
+    if (sub === undefined || sub === 'status') {
+      const t = await telemetry();
+      console.log(describeTelemetry(t));
+      if (t.notice) await telemetry({ notified: true });
+      break;
+    }
+    if (sub === 'on' || sub === 'off') {
+      const t = await telemetry({ enabled: sub === 'on' });
+      console.log(sub === 'on' ? describeTelemetry(t) : 'Usage counts are off. This inbox stops counting and deleted the days not yet sent.');
+      break;
+    }
+    if (sub === 'show') { console.log(JSON.stringify((await telemetry()).next, null, 2)); break; }
+    if (sub === 'reset-id') { console.log(`New install id: ${(await telemetry({ resetId: true })).installId}`); break; }
+    fail('Usage: your-attention telemetry status|on|off|show|reset-id, or telemetry report for the operator.');
+  }
+  default:
+    console.log(HELP);
+    if (command && command !== 'help' && command !== '--help') process.exit(1);
+}