@needmoretruth/nmts-cli 0.17.2 → 0.34.2

package/dist/list-file.d.ts

@@ -0,0 +1,88 @@
+import { WRITTEN_BY, type ArtifactAbout } from "./artifact-about.ts";
+/** Wrapper format identifier, distinct from the recovery list's. */
+export declare const LIST_FILE_FORMAT = "nmts-file-list";
+/**
+ * The shell's version for a file holding ONE sealed blob. Not the file list's own version (`seq`).
+ *
+ * ⛔ A shell of version 1 means `sealed` is the whole list, and that has not changed. It is what an
+ *    account still on the single-blob format produces, and every reader that ever handled this file
+ *    goes on handling it.
+ */
+export declare const LIST_FILE_VERSION = 1;
+/**
+ * The shell's version for a file holding an INDEX and the chunks it names (NCF-3 §6.3).
+ *
+ * ⛔ WHY THE SHELL HAD TO MOVE TOO. At format version 2 the sealed blob the server stores is an
+ *    index: it carries the settings, the version and the parent link, and NOT the entries. A copy
+ *    of that blob alone is a copy of nothing anybody can use, so the chunks travel in the same
+ *    file — one artefact, as before, because the whole point of this file is that the person
+ *    holding it has everything.
+ */
+export declare const LIST_FILE_VERSION_CHUNKED = 2;
+/** Filename extension. Deliberately not the recovery list's: the two must not be confusable. */
+export declare const LIST_FILE_EXTENSION = "nmtslist";
+export { WRITTEN_BY };
+/** The on-disk document. */
+export interface FileListFile {
+    format: typeof LIST_FILE_FORMAT;
+    version: typeof LIST_FILE_VERSION | typeof LIST_FILE_VERSION_CHUNKED;
+    /** The list's own version number — higher is newer, the counter every device syncs by. */
+    seq: number;
+    /** RFC3339 — when the machine wrote its copy, on its own clock. Absent when it is not known. */
+    saved_at?: string;
+    /** Public account id, so a person holding several files knows which is which. */
+    account_id: string;
+    /** The sealed file list, base64url. At shell version 2 this is the INDEX. */
+    sealed: string;
+    /**
+     * The sealed chunks the index names, base64url, in the order it names them. Shell version 2 only.
+     *
+     * ⛔ IN THE INDEX'S OWN ORDER, and a reader must keep it. The index names each chunk by the hash
+     *    of its transport string, so a reader can pair them up by hashing — but it should not have
+     *    to, and a copy that arrived shuffled would be a copy nobody could check quickly.
+     */
+    chunks?: string[];
+    /** Plain-language lines for a finder. */
+    note: string[];
+    about: ArtifactAbout;
+}
+export interface BuildListFileInput {
+    accountId: string;
+    seq: number;
+    /** When the copy was taken, RFC3339. Omitted when the copy does not record one. */
+    savedAt?: string | undefined;
+    sealed: string;
+    /** The chunks the sealed index names. Absent or empty for a single-blob list. */
+    chunks?: readonly string[] | undefined;
+}
+/**
+ * Build the document and the name to offer it under.
+ *
+ * Pure on purpose: it touches no disk and no clock, so what it produces can be compared against
+ * the format itself rather than against whatever the machine running it happened to be doing.
+ *
+ * ⚠ THE VERSION IS IN THE FILENAME, ZERO-PADDED, so a folder holding several copies sorts into
+ *   the order they were written and the newest is the last one.
+ */
+export declare function buildFileListFile(input: BuildListFileInput): {
+    filename: string;
+    content: string;
+};
+/** What a `.nmtslist` turned out to hold, whichever shell version wrote it. */
+export interface ReadListFile {
+    /** The list's own version number. */
+    seq: number;
+    accountId: string;
+    /** The sealed blob: the whole list at shell version 1, the index at shell version 2. */
+    sealed: string;
+    /** The sealed chunks the index names, in its order. Empty for a single-blob file. */
+    chunks: string[];
+}
+/**
+ * Read one of these files back, accepting BOTH shells.
+ *
+ * ⛔ IT REFUSES RATHER THAN GUESSING. A file missing its sealed bytes, or naming chunks that are
+ *    not strings, is not a shorter list — it is a copy somebody has been keeping for years that
+ *    turns out not to be one, and the moment to say so is the moment they reach for it.
+ */
+export declare function parseFileListFile(text: string): ReadListFile;

package/dist/list-file.js

@@ -9,24 +9,47 @@
 //
 // ⛔ NOTHING SECRET IN THE HEADER, AND THAT INCLUDES SIZES. The plaintext part of this file says
 //    what the file IS — never what is inside it, not a file name, not a count, not a total. The
-//    contents are one sealed envelope that opens with the account code and nothing else, so a
+//    contents are one sealed envelope that opens with the NMTS key and nothing else, so a
 //    stranger who finds this learns which account it belongs to and no more.
 //
-// ⛔ THE ACCOUNT CODE IS NOT IN IT, and that is not an oversight to fix later. This file plus the
+// ⛔ THE NMTS KEY IS NOT IN IT, and that is not an oversight to fix later. This file plus the
 //    code is the account; keeping both in one place would make one theft into a total loss.
 //
-// ⚠ WHAT DIFFERS FROM THE BROWSER'S COPY, and neither is a format difference:
+// ⚠ WHAT DIFFERS FROM THE BROWSER'S COPY. The first two are not format differences:
 //    · The finder's note is English only. The browser ships it in English and Korean because it
 //      cannot know which language the person who finds the file years later reads; this package
 //      ships English strings only, and inventing a translation here would be worse than the gap.
 //    · `about.app_version` names THIS PROGRAM and its version rather than the site release. It is
 //      the field's own contract — a claim the writer makes about itself — and a person holding two
 //      copies of one account's list can then tell which program wrote each.
+//    · ⛔ THE THIRD ONE IS: this command writes shell version 2 — the index plus the chunks it
+//      names — for an account whose list is in chunks, and the browser does not yet. Both write
+//      shell version 1 for a single-blob list, and the reader below takes either. It was done here
+//      first because a copy of an index alone is a copy of nothing anybody can use, and this is
+//      the command whose whole job is that the copy is complete. ▶ The browser's writer has the
+//      same gap to close, and until it does, a `.nmtslist` saved from a browser on a chunked
+//      account is an index with no entries behind it.
 import { artifactAbout, WRITTEN_BY } from "./artifact-about.js";
 /** Wrapper format identifier, distinct from the recovery list's. */
 export const LIST_FILE_FORMAT = "nmts-file-list";
-/** The shell's version. Not the file list's own version, which is `seq`. */
+/**
+ * The shell's version for a file holding ONE sealed blob. Not the file list's own version (`seq`).
+ *
+ * ⛔ A shell of version 1 means `sealed` is the whole list, and that has not changed. It is what an
+ *    account still on the single-blob format produces, and every reader that ever handled this file
+ *    goes on handling it.
+ */
 export const LIST_FILE_VERSION = 1;
+/**
+ * The shell's version for a file holding an INDEX and the chunks it names (NCF-3 §6.3).
+ *
+ * ⛔ WHY THE SHELL HAD TO MOVE TOO. At format version 2 the sealed blob the server stores is an
+ *    index: it carries the settings, the version and the parent link, and NOT the entries. A copy
+ *    of that blob alone is a copy of nothing anybody can use, so the chunks travel in the same
+ *    file — one artefact, as before, because the whole point of this file is that the person
+ *    holding it has everything.
+ */
+export const LIST_FILE_VERSION_CHUNKED = 2;
 /** Filename extension. Deliberately not the recovery list's: the two must not be confusable. */
 export const LIST_FILE_EXTENSION = "nmtslist";
 // ⚠ THE HEADER BLOCK IS NOT SPELLED HERE. Three artefacts carry the same one — this file, the
@@ -37,11 +60,11 @@ export { WRITTEN_BY };
 /** Plain-language lines for whoever finds this file with no idea what it is. */
 const NOTE = [
     `This file is an encrypted copy of an NMTS (nmts.me) file list — the names, folders and file ` +
-        `keys of one account, locked with its account code.`,
+        `keys of one account, locked with its NMTS key.`,
     `It is written by the \`nmts\` command from the copy that machine keeps. A higher number in the ` +
         `filename is a newer copy.`,
     `It does not replace the recovery list: storage-network addresses live only in the recovery ` +
-        `list. Keep both, somewhere other than the account code.`,
+        `list. Keep both, somewhere other than the NMTS key.`,
 ];
 /**
  * Build the document and the name to offer it under.
@@ -53,13 +76,15 @@ const NOTE = [
  *   the order they were written and the newest is the last one.
  */
 export function buildFileListFile(input) {
+    const chunks = input.chunks === undefined ? [] : [...input.chunks];
     const doc = {
         format: LIST_FILE_FORMAT,
-        version: LIST_FILE_VERSION,
+        version: chunks.length > 0 ? LIST_FILE_VERSION_CHUNKED : LIST_FILE_VERSION,
         seq: input.seq,
         ...(input.savedAt === undefined ? {} : { saved_at: input.savedAt }),
         account_id: input.accountId,
         sealed: input.sealed,
+        ...(chunks.length > 0 ? { chunks } : {}),
         note: [...NOTE],
         about: artifactAbout("file-list"),
     };
@@ -69,3 +94,61 @@ export function buildFileListFile(input) {
         content: `${JSON.stringify(doc, null, 2)}\n`,
     };
 }
+function stringAt(doc, name) {
+    const value = doc[name];
+    return typeof value === "string" && value !== "" ? value : null;
+}
+/**
+ * Read one of these files back, accepting BOTH shells.
+ *
+ * ⛔ IT REFUSES RATHER THAN GUESSING. A file missing its sealed bytes, or naming chunks that are
+ *    not strings, is not a shorter list — it is a copy somebody has been keeping for years that
+ *    turns out not to be one, and the moment to say so is the moment they reach for it.
+ */
+export function parseFileListFile(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new Error("that is not an NMTS file-list copy: it is not JSON");
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error("that is not an NMTS file-list copy: it is not an object");
+    }
+    const doc = { ...parsed };
+    if (doc["format"] !== LIST_FILE_FORMAT) {
+        throw new Error(`that is not an NMTS file-list copy: format is ${String(doc["format"])}`);
+    }
+    const version = doc["version"];
+    if (version !== LIST_FILE_VERSION && version !== LIST_FILE_VERSION_CHUNKED) {
+        // A shell this build predates. Refusing by version is the honest answer: a newer writer may
+        // have put something beside `sealed` that this reader would silently drop.
+        throw new Error(`this NMTS file-list copy is shell version ${String(version)}, which this build cannot read`);
+    }
+    const seq = doc["seq"];
+    const sealed = stringAt(doc, "sealed");
+    const accountId = stringAt(doc, "account_id");
+    if (typeof seq !== "number" || !Number.isSafeInteger(seq) || seq < 1) {
+        throw new Error("this NMTS file-list copy does not say which version it is");
+    }
+    if (sealed === null)
+        throw new Error("this NMTS file-list copy carries no sealed list");
+    if (accountId === null)
+        throw new Error("this NMTS file-list copy does not say which account it is");
+    const raw = doc["chunks"];
+    if (raw !== undefined && !Array.isArray(raw)) {
+        throw new Error("this NMTS file-list copy has a broken list of parts");
+    }
+    const chunks = [];
+    for (const item of raw === undefined ? [] : raw) {
+        if (typeof item !== "string" || item === "") {
+            throw new Error("this NMTS file-list copy has a part that is not sealed bytes");
+        }
+        chunks.push(item);
+    }
+    if (version === LIST_FILE_VERSION_CHUNKED && chunks.length === 0) {
+        throw new Error("this NMTS file-list copy says it is in parts and carries none");
+    }
+    return { seq, accountId, sealed, chunks };
+}

package/dist/list-view-find.d.ts

@@ -0,0 +1,15 @@
+import { type ManifestIndex } from "./drive-paths.ts";
+import type { ManifestEntry } from "./shared/lib/drive/manifest-codec.ts";
+/** The text to look for, folded. Empty means the option carried nothing to search on. */
+export declare function needleOf(query: string): string;
+/** Does this name contain the (already folded) needle? */
+export declare function nameContains(name: string, needle: string): boolean;
+/**
+ * The ids to print for one query: the matching files, and the folders that lead to them.
+ *
+ * `entries` is what the listing was going to show anyway — live only, or everything under `--all`
+ * — and the ancestors added here are inside that same set by construction. Being in the trash is
+ * INHERITED, so a live file cannot sit under a trashed folder, and with `--all` there is nothing
+ * left to be outside the set.
+ */
+export declare function idsForQuery(index: ManifestIndex, entries: readonly ManifestEntry[], needle: string): Set<string>;

package/dist/list-view-order.d.ts

@@ -0,0 +1,32 @@
+export type SortKey = "name" | "size" | "date";
+export type SortDir = "asc" | "desc";
+/** What `--sort` accepts, in the order the help text names them. */
+export declare const SORT_KEYS: readonly SortKey[];
+/** The fields ordering reads. Everything else about a row is the listing's business. */
+export interface OrderableRow {
+    name: string;
+    /** Plaintext bytes. Folders carry 0. */
+    size: number;
+    /** Created, milliseconds since the Unix epoch. */
+    createdAt: number;
+    /** 0 folder · 1 file — the codes the sealed list stores. */
+    kind: number;
+    /** Held at the top of its group under every sort. Absent on rows that carry no mark. */
+    pinned?: boolean;
+}
+/**
+ * One of the three keys, or the refusal that names all three.
+ *
+ * ⛔ IT IS CHECKED BEFORE ANYTHING IS FETCHED. A misspelled key is a wrong command line, not a
+ *    failing account, and an agent that read "could not list your files" after typing `--sort
+ *    largest` would go looking at the account. Exit 2 says the same thing every other bad option
+ *    in this tool says.
+ */
+export declare function parseSortKey(input: string): SortKey;
+/**
+ * Rows in the browser's order: folders first, then files, each group by the chosen key.
+ *
+ * The input array is left alone — a caller printing one order and counting over another would
+ * otherwise depend on which of the two ran first.
+ */
+export declare function orderRows<T extends OrderableRow>(rows: readonly T[], sort: SortKey, dir: SortDir): T[];

package/dist/main.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * Commands the help text announces but this version cannot run.
+ *
+ * ⛔ ANNOUNCED-AND-UNFINISHED IS NOT THE SAME AS UNKNOWN, and an agent needs to tell them apart:
+ *    unknown means "you guessed the name wrong, try again", unfinished means "stop, this will not
+ *    work however you spell it". They get different exit codes for exactly that reason.
+ *
+ * ⛔ EMPTY IS THE GOAL, NOT AN OVERSIGHT. Everything help names, this version runs.
+ */
+export declare const NOT_BUILT_YET: readonly string[];
+export declare function run(argv: readonly string[]): Promise<number>;

package/dist/main.js

@@ -19,19 +19,15 @@
 //      0 done · 1 something went wrong · 2 the command line was wrong · 3 not signed in ·
 //      4 the command exists but could not do it · 5 waiting on the person's agreement ·
 //      130 cancelled.
-//    ⚠ 4 IS "COULD NOT", NOT "NOT BUILT". This block used to say "the command exists but is not
-//      built", which is not what any command means by it — "no such path", "that is a file", "a
-//      folder cannot go inside itself" are all 4. `NotBuiltYetError` shares the number and carries
-//      "do not retry"; nothing collides today because nothing is announced-and-unfinished, and if
-//      that list is ever repopulated the unfinished case needs a number of its own
-//      (2026-08-23).
+//    ⚠ 4 IS "COULD NOT", NOT "NOT BUILT" — "no such path", "that is a file" are 4;
+//      `NotBuiltYetError` shares the number and carries "do not retry" (2026-08-23).
 //
 // ⛔ `run` RETURNS A CODE AND NEVER EXITS. Only the bottom of this file calls process.exit, so the
 //    whole command surface can be driven from a test without ending the test runner.
 import { parseArgs } from "./args.js";
 import { NmtsError, NotBuiltYetError, renderError } from "./errors.js";
 import { endQuietlyOnClosedPipe, exitCodeFor, invokedDirectly, noteUpdateAfter } from "./exit.js";
-import { helpText } from "./help.js";
+import { printHelp } from "./help.js";
 import { BINARY_NAME, VERSION } from "./product.js";
 /**
  * Commands the help text announces but this version cannot run.
@@ -50,8 +46,7 @@ export async function run(argv) {
         return 0;
     }
     if (args.help || args.command === null || args.command === "help") {
-        process.stdout.write(helpText(VERSION));
-        return 0;
+        return await printHelp(args, (text) => process.stdout.write(text));
     }
     // ⛔ A MODE THAT STOPPED ANNOUNCING ITSELF IS ONE PEOPLE FORGET THEY TURNED ON, and this one
     //    decides whether anybody is asked before money is spent. So it is said on EVERY run, to
@@ -67,8 +62,10 @@ export async function run(argv) {
     //    SDK, which is the largest thing this package can load, and importing it at the top of this
     //    file made `nmts --help` pay for it: startup went from 0.13s to 0.20s the day `put` landed.
     //    An agent runs this tool in a loop, so a fixed cost per invocation is paid thousands of
-    //    times — and the cost grows with every command added, which is exactly the shape of problem
-    //    that is never noticed until it is large. `check:cli-startup` measures it.
+    //    times. `check:cli-startup` measures it.
+    // ⛔ THE TIER GATE, BEFORE ANY COMMAND LOADS (`risk.ts` · `gate.ts`): asked or refused by the
+    //    act's tier and this machine's mode, the same way for every command.
+    await (await import("./risk.js")).gateArgs(args);
     switch (args.command) {
         case "login": {
             const { login } = await import("./commands/login.js");
@@ -85,7 +82,12 @@ export async function run(argv) {
         }
         case "whoami": {
             const { whoami } = await import("./commands/whoami.js");
-            return await whoami({ server: args.server, network: args.network });
+            return await whoami({
+                server: args.server,
+                network: args.network,
+                reveal: args.reveal,
+                json: args.json,
+            });
         }
         case "ls": {
             const { ls } = await import("./commands/ls.js");
@@ -107,27 +109,38 @@ export async function run(argv) {
             const { balance } = await import("./commands/balance.js");
             return await balance({ server: args.server, network: args.network, json: args.json });
         }
+        case "credits": {
+            const { credits } = await import("./commands/credits.js");
+            return await credits(args.operands[0], args.operands[1], {
+                server: args.server, network: args.network, json: args.json, to: args.to,
+            });
+        }
         case "public-code": {
             const { publicCode } = await import("./commands/public-code.js");
-            return await publicCode({
-                server: args.server,
-                network: args.network,
-                publish: args.publish,
-                json: args.json,
-            });
+            return await publicCode({ server: args.server, network: args.network, publish: args.publish, json: args.json });
         }
         case "wallet": {
             const { wallet } = await import("./commands/wallet.js");
             return await wallet(args.operands[0], {
-                server: args.server,
-                network: args.network,
-                json: args.json,
+                server: args.server, network: args.network, json: args.json, qr: args.qr,
+                rest: args.operands.slice(1), yes: args.yes, dryRun: args.dryRun, feeCap: args.feeCap,
+                to: args.to, venue: args.venue, slippageBps: args.slippageBps, acceptExtremes: args.acceptExtremes, size: args.size, epochs: args.epochs, name: args.name, remove: args.remove,
             });
         }
         case "expiring": {
             const { expiring } = await import("./commands/expiring.js");
             return await expiring({ server: args.server, network: args.network, json: args.json });
         }
+        case "losses": {
+            const { losses } = await import("./commands/losses.js");
+            return await losses({
+                server: args.server,
+                network: args.network,
+                json: args.json,
+                recheck: args.recheck,
+                dismiss: args.dismiss,
+            });
+        }
         case "extend": {
             const { extend } = await import("./commands/extend.js");
             return await extend(args.operands[0], {
@@ -147,16 +160,12 @@ export async function run(argv) {
                 out: args.out,
                 acceptTerms: args.acceptTerms,
                 acceptPrivacy: args.acceptPrivacy,
-                json: args.json,
+                json: args.json, noWait: args.noWait,
             });
         }
         case "trial": {
             const { trial } = await import("./commands/trial.js");
-            return await trial(args.operands[0], {
-                server: args.server,
-                network: args.network,
-                json: args.json,
-            });
+            return await trial(args.operands[0], { server: args.server, network: args.network, json: args.json });
         }
         case "get": {
             const { get } = await import("./commands/get.js");
@@ -178,6 +187,10 @@ export async function run(argv) {
                 dryRun: args.dryRun,
                 partSize: args.partSize,
                 onCollision: args.onCollision,
+                deposit: args.deposit,
+                pay: args.pay,
+                epochs: args.epochs,
+                storage: args.storage,
                 json: args.json,
             });
         }
@@ -191,6 +204,10 @@ export async function run(argv) {
                 hidden: args.hidden,
                 partSize: args.partSize,
                 onCollision: args.onCollision,
+                deposit: args.deposit,
+                pay: args.pay,
+                epochs: args.epochs,
+                storage: args.storage,
                 json: args.json,
             });
         }
@@ -204,12 +221,15 @@ export async function run(argv) {
         }
         case "sweep": {
             const { sweep } = await import("./commands/sweep.js");
-            return await sweep({
-                server: args.server,
-                network: args.network,
-                json: args.json,
-                yes: args.yes,
-            });
+            return await sweep({ server: args.server, network: args.network, json: args.json, yes: args.yes });
+        }
+        case "key": {
+            const { key } = await import("./commands/key.js");
+            return await key(args.operands[0], args);
+        }
+        case "devices": {
+            const { devices } = await import("./commands/devices.js");
+            return await devices({ server: args.server, json: args.json, signOut: args.signOut, yes: args.yes });
         }
         case "rebuild": {
             const { rebuild } = await import("./commands/rebuild.js");
@@ -221,6 +241,18 @@ export async function run(argv) {
                 force: args.force,
             });
         }
+        case "padding": {
+            const { padding } = await import("./commands/padding.js");
+            return await padding(args.operands[0], { server: args.server, network: args.network, json: args.json });
+        }
+        case "deposit": {
+            const { deposit } = await import("./commands/deposit.js");
+            return await deposit(args.operands[0], { server: args.server, network: args.network, json: args.json });
+        }
+        case "rollback": {
+            const { rollback } = await import("./commands/rollback.js");
+            return await rollback({ server: args.server, network: args.network, json: args.json, yes: args.yes });
+        }
         case "listfile": {
             const { listfile } = await import("./commands/listfile.js");
             return await listfile({ out: args.out, force: args.force });
@@ -255,73 +287,48 @@ export async function run(argv) {
                 json: args.json,
             });
         }
-        case "star": {
-            const { star } = await import("./commands/marks.js");
-            return await star(args.operands, { server: args.server, network: args.network, json: args.json });
-        }
-        case "unstar": {
-            const { unstar } = await import("./commands/marks.js");
-            return await unstar(args.operands, { server: args.server, network: args.network, json: args.json });
-        }
-        case "pin": {
-            const { pin } = await import("./commands/marks.js");
-            return await pin(args.operands, { server: args.server, network: args.network, json: args.json });
-        }
-        case "unpin": {
-            const { unpin } = await import("./commands/marks.js");
-            return await unpin(args.operands, { server: args.server, network: args.network, json: args.json });
-        }
-        case "label": {
-            const { label } = await import("./commands/marks.js");
-            return await label(args.operands[0], args.operands.slice(1), {
-                server: args.server,
-                network: args.network,
-                json: args.json,
-            });
-        }
+        case "star":
+        case "unstar":
+        case "pin":
+        case "unpin":
+        case "label":
         case "unlabel": {
-            const { unlabel } = await import("./commands/marks.js");
-            return await unlabel(args.operands[0], args.operands.slice(1), {
-                server: args.server,
-                network: args.network,
-                json: args.json,
-            });
-        }
-        case "share": {
-            const { share } = await import("./commands/share.js");
-            return await share(args.operands[0], args.operands[1], {
-                server: args.server,
-                network: args.network,
-                json: args.json,
-            });
-        }
-        case "shares": {
-            const { shares } = await import("./commands/share.js");
-            return await shares({ server: args.server, network: args.network, json: args.json });
-        }
-        case "unshare": {
-            const { unshare } = await import("./commands/share.js");
-            return await unshare(args.operands[0], {
-                server: args.server,
-                network: args.network,
-                json: args.json,
-            });
+            const { runMarks } = await import("./commands/marks-dispatch.js");
+            return await runMarks(args.command, args);
         }
+        case "share":
+        case "shares":
+        case "unshare":
         case "receive": {
-            const { receive } = await import("./commands/receive.js");
-            return await receive(args.operands[0], {
-                server: args.server,
-                network: args.network,
-                out: args.out,
-                force: args.force,
-                json: args.json,
-            });
+            const { runShare } = await import("./commands/share-dispatch.js");
+            return await runShare(args.command, args);
+        }
+        case "support": {
+            // ⚠ Options passed whole, as `runSettings` below takes them: this one reads ten of them.
+            const { support } = await import("./commands/support.js");
+            return await support(args.operands[0], args.operands.slice(1), args);
+        }
+        case "notices":
+        case "erase":
+            return await (await import("./commands/erase.js")).erase(args.operands, { server: args.server, network: args.network, json: args.json, releaseStorage: args.releaseStorage, yes: args.yes });
+        case "tip":
+            return await (await import("./commands/tip.js")).tip(args.operands[0], { server: args.server, network: args.network, json: args.json, yes: args.yes });
+        case "delete-account":
+            return await (await import("./commands/delete-account.js")).deleteAccount({ server: args.server, yes: args.yes });
+        case "accept-terms":
+            return await (await import("./commands/accept-terms.js")).acceptTerms({ server: args.server, terms: args.acceptTerms, privacy: args.acceptPrivacy });
+        case "terms":
+        case "privacy": {
+            const { runDocuments } = await import("./commands/documents.js");
+            return await runDocuments(args.command, { ...args, id: args.operands[0] });
         }
         case "env": {
             const { env } = await import("./commands/env.js");
             return env({ json: args.json });
         }
         case "consent":
+        case "unlock":
+        case "lock":
         case "mode":
         case "on-collision": {
             const { runSettings } = await import("./commands/settings.js");
@@ -331,29 +338,11 @@ export async function run(argv) {
             const { verify } = await import("./commands/verify.js");
             return await verify({ server: args.server, json: args.json, status: args.status });
         }
-        case "recovery": {
-            const { recovery } = await import("./commands/recovery.js");
-            return await recovery({ out: args.out, force: args.force, json: args.json });
-        }
-        case "recovery-list": {
-            const { recoveryList } = await import("./commands/recovery-list.js");
-            return await recoveryList({
-                server: args.server,
-                network: args.network,
-                out: args.out,
-                force: args.force,
-                json: args.json,
-            });
-        }
+        case "recovery":
+        case "recovery-list":
         case "kit": {
-            const { kit } = await import("./commands/kit.js");
-            return await kit({
-                server: args.server,
-                network: args.network,
-                out: args.out,
-                force: args.force,
-                json: args.json,
-            });
+            const { runRecovery } = await import("./commands/recovery-dispatch.js");
+            return await runRecovery(args.command, args);
         }
         case "update": {
             const { update } = await import("./commands/update.js");
@@ -380,13 +369,23 @@ export async function run(argv) {
 async function main() {
     endQuietlyOnClosedPipe();
     const argv = process.argv.slice(2);
+    const started = Date.now();
+    let failed = null;
     try {
         process.exitCode = await run(argv);
     }
     catch (error) {
         process.stderr.write(`${renderError(error, BINARY_NAME)}\n`);
         process.exitCode = exitCodeFor(error);
+        failed = error instanceof Error ? error.message : String(error);
     }
+    // ⛔ LOADED AFTER THE COMMAND, LIKE EVERY COMMAND ABOVE: the run log's chain reaches the
+    //    credentials module and `--help` must not pay for it first (`check:cli-startup`). It is
+    //    outside `run` because the tests drive that directly, and it cannot throw.
+    const { noteFailure, recordRun } = await import("./run-log.js");
+    if (failed !== null)
+        noteFailure(failed);
+    recordRun(argv, typeof process.exitCode === "number" ? process.exitCode : 0, Date.now() - started);
     await noteUpdateAfter(argv, VERSION);
 }
 if (invokedDirectly(import.meta.filename)) {