@desklink/axi 0.3.0

package/dist/cli/help.js

@@ -0,0 +1,28 @@
+// Per-subcommand --help rendered from CommandSpec (AXI principle 10).
+import { emitBlock, emitList } from "../output/toon.js";
+export function renderHelp(tool, spec) {
+    const parts = [];
+    parts.push(`command: ${[tool, spec.name].filter(Boolean).join(" ")}`);
+    parts.push(`summary: ${spec.summary}`);
+    const args = spec.args ?? [];
+    if (args.length > 0) {
+        parts.push(emitList("args", args.map((a) => ({
+            name: a.name,
+            required: a.required ? "yes" : "no",
+            description: a.description,
+        })), ["name", "required", "description"]));
+    }
+    const flagRows = spec.flags.map((f) => ({
+        flag: `--${f.name}`,
+        default: f.default === undefined ? "" : String(f.default),
+        description: f.values
+            ? `${f.description} (${f.values.join("|")})`
+            : f.description,
+    }));
+    flagRows.push({ flag: "--help", default: "", description: "show this help" });
+    parts.push(emitList("flags", flagRows, ["flag", "default", "description"]));
+    if (spec.examples.length > 0) {
+        parts.push(emitBlock("examples", spec.examples));
+    }
+    return parts.join("\n");
+}

package/dist/cli/router.js

@@ -0,0 +1,74 @@
+// Noun-verb command router. Generic over a Registry so scaffolded projects
+// reuse it verbatim with their own command set.
+import { parseArgs } from "./args.js";
+import { renderHelp } from "./help.js";
+import { AxiError, renderError, UsageError } from "../output/errors.js";
+import { emitList, print } from "../output/toon.js";
+function topLevelCommands(reg) {
+    const tops = new Set();
+    for (const key of Object.keys(reg.commands))
+        tops.add(key.split(" ")[0]);
+    return [...tops].sort().join(", ");
+}
+export async function dispatch(reg, argv) {
+    try {
+        const words = [];
+        for (const tok of argv) {
+            if (tok.startsWith("-"))
+                break;
+            words.push(tok);
+        }
+        let key = "";
+        let consumed = 0;
+        for (let n = Math.min(2, words.length); n >= 1; n--) {
+            const candidate = words.slice(0, n).join(" ");
+            if (reg.commands[candidate]) {
+                key = candidate;
+                consumed = n;
+                break;
+            }
+        }
+        if (!key) {
+            if (words.length === 0) {
+                const parsed = parseArgs(argv, reg.root.spec);
+                if (parsed.help) {
+                    print(reg.rootHelp());
+                    return 0;
+                }
+                return await reg.root.run(parsed);
+            }
+            const first = words[0];
+            const children = Object.keys(reg.commands).filter((c) => c.startsWith(first + " "));
+            if (children.length > 0) {
+                if (argv.includes("--help")) {
+                    print(emitList("commands", children.map((c) => ({
+                        command: `${reg.tool} ${c}`,
+                        summary: reg.commands[c].spec.summary,
+                    })), ["command", "summary"]));
+                    return 0;
+                }
+                throw new UsageError(`'${first}' requires a subcommand`, `valid: ${children.map((c) => `${reg.tool} ${c}`).join(", ")}`);
+            }
+            throw new UsageError(`unknown command '${words.join(" ")}'`, `valid commands: ${topLevelCommands(reg)}`);
+        }
+        const mod = reg.commands[key];
+        const parsed = parseArgs(argv.slice(consumed), mod.spec);
+        if (parsed.help) {
+            print(renderHelp(reg.tool, mod.spec));
+            return 0;
+        }
+        return await mod.run(parsed);
+    }
+    catch (err) {
+        if (err instanceof AxiError) {
+            print(renderError(err));
+            return err.exitCode;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        print(renderError(new AxiError(`unexpected failure: ${message}`, "re-run with the same arguments; report if it persists")));
+        if (err instanceof Error && err.stack) {
+            process.stderr.write(err.stack + "\n");
+        }
+        return 1;
+    }
+}

package/dist/cli/spec.js

@@ -0,0 +1,3 @@
+// CommandSpec is the single source of truth for a command: the parser
+// validates against it, --help renders from it, and SKILL.md docs cite it.
+export {};

package/dist/commands/home.js

@@ -0,0 +1,31 @@
+import { print } from "../output/toon.js";
+import { renderHome, rootHelpText } from "../skill/content.js";
+import { call } from '../bridge.js';
+import { readFileSync } from 'node:fs';
+const { version } = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+export const homeCommand = {
+    spec: {
+        name: "",
+        summary: "Home view: live content first (AXI principle 8)",
+        flags: [
+            { name: "version", type: "boolean", description: "print the tool version" },
+        ],
+        examples: ["desklink-axi", "desklink-axi --version"],
+    },
+    async run(parsed) {
+        if (parsed.flags["version"]) {
+            print(`desklink-axi: ${version}`);
+            return 0;
+        }
+        try {
+            print(`${renderHome(process.argv[1] ?? 'desklink-axi')}\n${await call('home')}`);
+        }
+        catch {
+            print(`${renderHome(process.argv[1] ?? 'desklink-axi')}\nsession: closed — run desklink-axi start`);
+        }
+        return 0;
+    },
+};
+export function rootHelp() {
+    return rootHelpText();
+}

package/dist/hooks.js

@@ -0,0 +1,18 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+export function installHooks() {
+    const directory = join(process.cwd(), '.claude');
+    mkdirSync(directory, { recursive: true });
+    const path = join(directory, 'settings.local.json');
+    const settings = existsSync(path) ? JSON.parse(readFileSync(path, 'utf8')) : {};
+    const hooks = settings.hooks ?? {};
+    const session = hooks.SessionStart ?? [];
+    const command = 'desklink-axi --session-hook';
+    if (!session.some((entry) => entry.hooks?.some(h => h.command === command))) {
+        session.push({ hooks: [{ type: 'command', command }] });
+        hooks.SessionStart = session;
+        settings.hooks = hooks;
+        writeFileSync(path, JSON.stringify(settings, null, 2) + '\n');
+    }
+    return `hooks: installed ${path}\nhelp[1]:\n  desklink-axi start --help`;
+}

package/dist/index.js

@@ -0,0 +1,71 @@
+import { dispatch } from './cli/router.js';
+import { homeCommand, rootHelp } from './commands/home.js';
+import { call, serve, socketPath } from './bridge.js';
+import { browserCommands } from './browser-lane.js';
+import { writeFileSync } from 'node:fs';
+import { print } from './output/toon.js';
+import { installHooks } from './hooks.js';
+import { UsageError } from './output/errors.js';
+if (process.argv[2] === '--bridge') {
+    try {
+        await serve(process.argv.slice(3));
+    }
+    catch (error) {
+        writeFileSync(`${socketPath}.error`, error.message);
+        process.exitCode = 1;
+    }
+}
+else if (process.argv[2] === '--session-hook') {
+    print('desklink-axi: desktop session available on request; run desklink-axi to check status');
+}
+else {
+    const definitions = [
+        ['start', [], ['control', 'source', 'display', 'timeout']], ['stop', [], []], ['health', [], []],
+        ['screen', [], ['query', 'region', 'full', 'fields']], ['diff', [], ['include-animating', 'fields']],
+        ['tree', [], ['query', 'full', 'fields']], ['marks', [], ['region', 'out']],
+        ['look', [], ['region', 'out']], ['click', ['target'], ['button', 'double', 'wait']],
+        ['type', ['text'], ['into', 'submit', 'wait']], ['press', ['key'], ['wait']],
+        ['scroll', ['direction'], ['at', 'amount', 'wait']], ['drag', ['from', 'to'], ['wait']],
+        ['batch', ['steps'], []],
+        ['wait', [], ['timeout']], ['clipboard read', [], ['full']],
+        ['clipboard write', ['text'], []], ['setup hooks', [], []],
+    ];
+    const commands = {};
+    Object.assign(commands, browserCommands());
+    for (const [name, required, flags] of definitions)
+        commands[name] = {
+            spec: { name, summary: `${name} on the live desktop`, args: required.map(arg => ({ name: arg, required: true, description: arg })), flags: flags.map(flag => ({ name: flag, type: ['control', 'full', 'double', 'submit', 'include-animating'].includes(flag) ? 'boolean' : 'string', values: flag === 'source' ? ['auto', 'portal', 'x11', 'display'] : flag === 'button' ? ['left', 'right'] : undefined, description: flag })), examples: [`desklink-axi ${name} ${required.map(arg => `<${arg}>`).join(' ')}`] },
+            async run(parsed) {
+                if (name === 'scroll' && !['up', 'down'].includes(parsed.positionals[0]))
+                    throw new UsageError('scroll direction must be up or down');
+                if (name === 'marks' && parsed.flags.region && !/^-?\d+,-?\d+,-?\d+,-?\d+$/.test(String(parsed.flags.region)))
+                    throw new UsageError('--region must be x,y,w,h integers');
+                if (typeof parsed.flags.wait === 'string' && !['none', 'change', 'settle'].includes(parsed.flags.wait) && !/^\d+$/.test(parsed.flags.wait))
+                    throw new UsageError('--wait must be none, change, settle, or milliseconds');
+                for (const key of ['timeout', 'amount'])
+                    if (typeof parsed.flags[key] === 'string' && (!/^\d+$/.test(parsed.flags[key]) || Number(parsed.flags[key]) <= 0))
+                        throw new UsageError(`--${key} must be a positive integer`);
+                const args = [...parsed.positionals];
+                for (const [key, value] of Object.entries(parsed.flags))
+                    if (value === true)
+                        args.push(`--${key}`);
+                    else if (typeof value === 'string')
+                        args.push(`--${key}`, value);
+                if (name === 'setup hooks') {
+                    print(installHooks());
+                    return 0;
+                }
+                try {
+                    const result = await call(name.startsWith('clipboard') ? 'clipboard' : name, name.startsWith('clipboard') ? [name.split(' ')[1], ...args] : args);
+                    print(result);
+                    return result.startsWith('error:') ? 1 : 0;
+                }
+                catch (error) {
+                    print(`error: ${error.message}\nsuggestion: desklink-axi start --help`);
+                    return 1;
+                }
+            },
+        };
+    const registry = { tool: 'desklink-axi', root: homeCommand, rootHelp, commands };
+    process.exit(await dispatch(registry, process.argv.slice(2)));
+}

package/dist/marks.js

@@ -0,0 +1,75 @@
+// Set-of-marks overlay: numbered boxes drawn onto an RGBA crop buffer.
+// Pure buffer math so it is unit-testable without a display; the caller
+// encodes the PNG (pngjs is already a dependency).
+// 3x5 pixel digits, rows packed as 3-bit lines, top row first.
+const DIGITS = {
+    '0': [7, 5, 5, 5, 7],
+    '1': [2, 6, 2, 2, 7],
+    '2': [7, 1, 7, 4, 7],
+    '3': [7, 1, 7, 1, 7],
+    '4': [5, 5, 7, 1, 1],
+    '5': [7, 4, 7, 1, 7],
+    '6': [7, 4, 7, 5, 7],
+    '7': [7, 1, 1, 1, 1],
+    '8': [7, 5, 7, 5, 7],
+    '9': [7, 5, 7, 1, 7],
+};
+export const MARK_BORDER = [255, 59, 48]; // red
+export const MARK_CHIP = [255, 214, 10]; // yellow
+export function estimateMarksCost(width, height) {
+    return Math.round(width * height / 750);
+}
+function putPixel(data, width, height, x, y, color) {
+    if (x < 0 || y < 0 || x >= width || y >= height)
+        return;
+    const at = (y * width + x) * 4;
+    data[at] = color[2];
+    data[at + 1] = color[1];
+    data[at + 2] = color[0];
+    data[at + 3] = 255;
+}
+function fillRect(data, width, height, x, y, w, h, color) {
+    for (let row = 0; row < h; row++)
+        for (let col = 0; col < w; col++)
+            putPixel(data, width, height, x + col, y + row, color);
+}
+function drawDigit(data, width, height, x, y, glyph, scale) {
+    const rows = DIGITS[glyph];
+    if (!rows)
+        return 0;
+    for (let r = 0; r < 5; r++)
+        for (let c = 0; c < 3; c++) {
+            if (rows[r] & (1 << (2 - c)))
+                fillRect(data, width, height, x + c * scale, y + r * scale, scale, scale, [0, 0, 0]);
+        }
+    return 3 * scale;
+}
+/** Draw numbered boxes (2px border + numbered chip above each box). Mutates data. */
+export function drawMarks(data, width, height, boxes, scale = 2) {
+    for (const box of boxes) {
+        const { x, y, w, h } = box;
+        if (w <= 0 || h <= 0)
+            continue;
+        for (let t = 0; t < 2; t++) {
+            fillRect(data, width, height, x + t, y + t, w - 2 * t, 1, MARK_BORDER);
+            fillRect(data, width, height, x + t, y + h - 1 - t, w - 2 * t, 1, MARK_BORDER);
+            fillRect(data, width, height, x + t, y + t, 1, h - 2 * t, MARK_BORDER);
+            fillRect(data, width, height, x + w - 1 - t, y + t, 1, h - 2 * t, MARK_BORDER);
+        }
+        const label = String(box.mark);
+        const textW = label.length * 3 * scale + 2 * scale;
+        const chipX = Math.min(Math.max(0, x), Math.max(0, width - textW));
+        const chipY = y >= 9 * scale + 2 ? y - 9 * scale - 2 : y;
+        fillRect(data, width, height, chipX, chipY, textW, 7 * scale + 2 * scale, MARK_CHIP);
+        let cursor = chipX + scale;
+        for (const glyph of label)
+            cursor += drawDigit(data, width, height, cursor, chipY + scale, glyph, scale) + scale;
+    }
+}
+/** Drop OCR candidates whose center falls inside an AX box (the AX ref is richer). */
+export function dedupeCandidates(axBoxes, ocr) {
+    return ocr.filter(item => {
+        const cx = item.x + item.w / 2, cy = item.y + item.h / 2;
+        return !axBoxes.some(b => cx >= b.x && cx <= b.x + b.w && cy >= b.y && cy <= b.y + b.h);
+    });
+}

package/dist/output/errors.js

@@ -0,0 +1,22 @@
+// Structured errors rendered as TOON on stdout (AXI principle 6).
+// Exit codes: 0 success/no-op, 1 error, 2 usage error.
+export class AxiError extends Error {
+    exitCode = 1;
+    suggestion;
+    constructor(message, suggestion) {
+        super(message);
+        this.suggestion = suggestion;
+    }
+}
+export class UsageError extends AxiError {
+    constructor(message, suggestion) {
+        super(message, suggestion);
+        this.exitCode = 2;
+    }
+}
+export function renderError(err) {
+    const lines = [`error: ${err.message}`];
+    if (err.suggestion)
+        lines.push(`suggestion: ${err.suggestion}`);
+    return lines.join("\n");
+}

package/dist/output/toon.js

@@ -0,0 +1,28 @@
+// TOON (Token-Oriented Object Notation) emitter. All stdout flows through
+// this module so every command stays consistent (AXI principle 1).
+export function print(text) {
+    process.stdout.write(text + "\n");
+}
+export function toonValue(value) {
+    if (value === null || value === undefined)
+        return "";
+    const s = String(value);
+    if (/[,"\n]/.test(s))
+        return '"' + s.replace(/"/g, '""') + '"';
+    return s;
+}
+export function emitList(name, rows, fields, opts = {}) {
+    const count = opts.total !== undefined && opts.total !== rows.length
+        ? `${rows.length} of ${opts.total} total`
+        : String(rows.length);
+    const header = `${name}[${count}]{${fields.join(",")}}:`;
+    const lines = rows.map((row) => "  " + fields.map((f) => toonValue(row[f])).join(","));
+    return [header, ...lines].join("\n");
+}
+/** A named block of pre-formatted lines, e.g. help[2]: or next[3]:. */
+export function emitBlock(name, lines) {
+    return [`${name}[${lines.length}]:`, ...lines.map((l) => "  " + l)].join("\n");
+}
+export function emitKV(pairs) {
+    return pairs.map(([k, v]) => `${k}: ${toonValue(v) === "" ? "" : String(v)}`.trimEnd()).join("\n");
+}

package/dist/skill/content.js

@@ -0,0 +1,8 @@
+import { homedir } from 'node:os';
+import { emitList } from '../output/toon.js';
+export const DESCRIPTION = "See and drive a live Linux or macOS desktop and an opted-in browser through desklink; text and changes by default, pixels on request";
+export const SPEC_VERSION = 'axi/1.0-2026-07';
+const commands = ['start', 'stop', 'health', 'screen', 'tree', 'marks', 'diff', 'look', 'click', 'type', 'press', 'scroll', 'drag', 'batch', 'wait', 'clipboard read', 'clipboard write', 'setup hooks', 'browser attach', 'browser launch', 'browser tabs', 'browser select', 'browser open', 'browser navigate', 'browser close', 'browser snapshot', 'browser click', 'browser fill', 'browser press', 'browser upload', 'browser detach'];
+export function renderHome(binPath) { return `desklink-axi: ${binPath.replace(homedir(), '~')} — ${DESCRIPTION}\nhelp[5]:\n  desklink-axi start --control --source x11 --display :97\n  desklink-axi screen --query "<words>"\n  desklink-axi tree --query "<words>"\n  desklink-axi look @r1\n  desklink-axi browser snapshot`; }
+export function rootHelpText() { return [`desklink-axi: ${DESCRIPTION}`, emitList('commands', commands.map(command => ({ command, summary: command.startsWith('browser') ? `${command} on the attached browser` : `${command} on the live desktop` })), ['command', 'summary']), 'flags[1]{flag,description}:\n  --help,show help for any command', 'examples[2]:\n  desklink-axi start --control --source x11 --display :97\n  desklink-axi screen --query "<words>"'].join('\n'); }
+export function renderSkill() { return `---\nname: desklink-axi\ndescription: "${DESCRIPTION}"\n---\n\n# desklink-axi\n\n${DESCRIPTION} (${SPEC_VERSION}).\n\n\`\`\`\n${renderHome('desklink-axi')}\n\`\`\`\n\nTwo lanes: the desktop lane (capture, OCR refs, AT-SPI tree, input) and the browser lane (semantic web control through an opted-in Chromium). On the desktop, \`tree --query "<words>"\` reads the AT-SPI accessibility tree into generation-tagged \`@a<gen>.<n>\` refs (values included), and \`marks\` overlays numbered candidates for icon-only controls. For web pages use the browser lane: \`desklink-axi browser attach --cdp 127.0.0.1:<port>\` for a browser you started with \`--remote-debugging-port\` (loopback only), or \`desklink-axi browser launch\` for an isolated task-owned profile. Then \`browser tabs\`, \`browser snapshot\` (compact accessibility refs, no screenshots), \`browser click/fill/upload @e<N>\`, \`browser select <tab>\`. Page selection (selected) and the browser's actually activated tab (front) are reported separately. OS-level dialogs are not-supported in the browser lane: fall back to the desktop lane (click/type on the dialog).\n\nRead with screen --query or --region before screen --full. Actions acknowledge input immediately; add --wait change|settle|<milliseconds> when needed. Batch sequential steps in one socket round trip: desklink-axi batch '[["press","Meta+l"],["type","https://example.com"],["press","Return"],["wait","change"]]'. Steps may be {verb,args?,name?,wait?} objects; a named snapshot binds OCR refs for later @name.n steps, and assert steps (\`["assert","text"]\`, \`["assert","--absent","text"]\`) make the batch outcome depend on observed screen text. The footer reports effects: asserted[n] or effects: unverified (input acknowledgements only) — an input ack is never a verified outcome.\n\nEvery command supports --help. Exit 0 success, 1 operational error, 2 usage error. No screen text at startup unless requested.\n`; }

package/dist/token.js

@@ -0,0 +1,44 @@
+import { closeSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+export function tokenPath() {
+    return process.env.DESKLINK_AXI_RESTORE_TOKEN_FILE ?? join(process.env.XDG_STATE_HOME ?? join(homedir(), '.local', 'state'), 'desklink-axi', 'portal-token');
+}
+// A portal token is single-use. Remove it from the reusable name before open;
+// a failed open must prompt again rather than replay a possibly consumed grant.
+export function takeToken(path) {
+    const claimed = `${path}.${randomUUID()}.used`;
+    try {
+        renameSync(path, claimed);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+    try {
+        return readFileSync(claimed, 'utf8').trim() || undefined;
+    }
+    finally {
+        rmSync(claimed);
+    }
+}
+export function saveToken(path, token) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    const fd = openSync(temporary, 'wx', 0o600);
+    try {
+        writeFileSync(fd, token);
+        closeSync(fd);
+        renameSync(temporary, path);
+    }
+    catch (error) {
+        try {
+            closeSync(fd);
+        }
+        catch { /* already closed */ }
+        rmSync(temporary, { force: true });
+        throw error;
+    }
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@desklink/axi",
+  "version": "0.3.0",
+  "description": "Agent-facing desktop control CLI",
+  "type": "module",
+  "bin": {
+    "desklink-axi": "bin/desklink-axi.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "skills",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "npm run build --workspace=@desklink/host && tsc",
+    "pretest": "npm run build",
+    "test": "vitest run",
+    "smoke": "node test/smoke.mjs",
+    "skill:gen": "node scripts/gen-skill.mjs",
+    "skill:check": "node scripts/gen-skill.mjs --check"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "@types/pngjs": "^6.0.5",
+    "typescript": "^5.6.0"
+  },
+  "dependencies": {
+    "@desklink/host": "0.3.0",
+    "node-datachannel": "^0.33.4",
+    "playwright-core": "1.62.1",
+    "pngjs": "^7.0.0"
+  },
+  "license": "Apache-2.0"
+}

package/skills/desklink-axi/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: desklink-axi
+description: "See and drive a live Linux or macOS desktop and an opted-in browser through desklink; text and changes by default, pixels on request"
+---
+
+# desklink-axi
+
+See and drive a live Linux or macOS desktop and an opted-in browser through desklink; text and changes by default, pixels on request (axi/1.0-2026-07).
+
+```
+desklink-axi: desklink-axi — See and drive a live Linux or macOS desktop and an opted-in browser through desklink; text and changes by default, pixels on request
+help[5]:
+  desklink-axi start --control --source x11 --display :97
+  desklink-axi screen --query "<words>"
+  desklink-axi tree --query "<words>"
+  desklink-axi look @r1
+  desklink-axi browser snapshot
+```
+
+Two lanes: the desktop lane (capture, OCR refs, AT-SPI tree, input) and the browser lane (semantic web control through an opted-in Chromium). On the desktop, `tree --query "<words>"` reads the AT-SPI accessibility tree into generation-tagged `@a<gen>.<n>` refs (values included), and `marks` overlays numbered candidates for icon-only controls. For web pages use the browser lane: `desklink-axi browser attach --cdp 127.0.0.1:<port>` for a browser you started with `--remote-debugging-port` (loopback only), or `desklink-axi browser launch` for an isolated task-owned profile. Then `browser tabs`, `browser snapshot` (compact accessibility refs, no screenshots), `browser click/fill/upload @e<N>`, `browser select <tab>`. Page selection (selected) and the browser's actually activated tab (front) are reported separately. OS-level dialogs are not-supported in the browser lane: fall back to the desktop lane (click/type on the dialog).
+
+Read with screen --query or --region before screen --full. Actions acknowledge input immediately; add --wait change|settle|<milliseconds> when needed. Batch sequential steps in one socket round trip: desklink-axi batch '[["press","Meta+l"],["type","https://example.com"],["press","Return"],["wait","change"]]'. Steps may be {verb,args?,name?,wait?} objects; a named snapshot binds OCR refs for later @name.n steps, and assert steps (`["assert","text"]`, `["assert","--absent","text"]`) make the batch outcome depend on observed screen text. The footer reports effects: asserted[n] or effects: unverified (input acknowledgements only) — an input ack is never a verified outcome.
+
+Every command supports --help. Exit 0 success, 1 operational error, 2 usage error. No screen text at startup unless requested.