@ghostlytools/cli 1.3.9 → 1.4.0

package/dist/assets/{main-Dt7xrqtb.js → main-BWAwKY4f.js}

@@ -1,8 +1,8 @@
-import { $n as GROUP_FILE_LIMITS, Ja as PR_CHECKS, Xa as RUN_RESULTS, Ya as PR_STATES, Za as STATUS_CARD_LIMITS, qa as ITEM_STATES, to as cardUrl } from "./src-Dg1bvMNv.js";
-import { a as SECRET_RESULTS, i as ENGINE_READS, r as ENGINE_METHODS, t as turnRef } from "./turnRefs-WnggXm2T.js";
-import { i as localFileError, n as EXIT, r as asCliError, t as CliError } from "./errors-B-zMxbcd.js";
-import { t as CONTACT_KEY } from "./apiKit-B4qhnLQT.js";
-import { a as createProfile, c as listProfiles, d as profilePaths, f as selectProfile, i as checkProfileName, l as lockOwner, o as currentProfile, s as ghostlyHome, u as profileExists } from "./profiles-gPCjLOQq.js";
+import { Fa as ITEM_STATES, Ia as PR_CHECKS, La as PR_STATES, Ra as RUN_RESULTS, Ua as cardUrl, Un as GROUP_FILE_LIMITS, za as STATUS_CARD_LIMITS } from "./src-DzXL-GYu.js";
+import { a as ENGINE_PARAMS, c as SECRET_RESULTS, i as ENGINE_METHODS, o as ENGINE_READS, s as READ_PARAMS, t as turnRef } from "./turnRefs-BCtM10d3.js";
+import { i as localFileError, n as EXIT, r as asCliError, t as CliError } from "./errors-BLSPp0tK.js";
+import { t as CONTACT_KEY } from "./apiKit-BpIUCwa-.js";
+import { a as checkShownName, c as ghostlyHome, d as profileExists, f as profilePaths, i as checkProfileName, l as listProfiles, o as createProfile, p as selectProfile, s as currentProfile, u as lockOwner } from "./profiles-DSxPYdlU.js";
 import { a as provesDaemon, c as ownSocket, o as readDaemonSecret, r as newNonce, t as HELLO } from "./daemonProof-B53VnZ1Z.js";
 import { accessSync, constants, existsSync, openSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
@@ -12,7 +12,7 @@ import { createInterface } from "node:readline";
 import { format } from "node:util";
 var package_default = {
 	name: "@ghostlytools/cli",
-	version: "1.3.9",
+	version: "1.4.0",
 	type: "module",
 	description: "Ghostly for bots and terminals: the app's own engine, headless on Node, behind a daemon and a `ghostly` command with JSON output.",
 	license: "MIT",
@@ -28,6 +28,7 @@ var package_default = {
 	files: [
 		"dist",
 		"examples",
+		"skills",
 		"README.md",
 		"SKILL.md"
 	],
@@ -38,7 +39,7 @@ var package_default = {
 		"test": "vitest run"
 	},
 	dependencies: {
-		"@arkade-os/sdk": "0.4.78",
+		"@arkade-os/sdk": "0.4.79",
 		"@atproto/jwk-webcrypto": "^0.3.4",
 		"@atproto/oauth-client": "^0.8.9",
 		"@bitcoindevkit/bdk-wallet-web": "0.3.0",
@@ -57,7 +58,7 @@ var package_default = {
 		"@scure/btc-signer": "2.4.1",
 		"@secondts/bark": "0.25.0",
 		"@serenity-kit/opaque": "1.1.0",
-		"@synonymdev/pubky": "0.14.0",
+		"@synonymdev/pubky": "0.16.1",
 		"@tetherto/wdk-wallet-evm": "1.0.0-beta.20",
 		"b4a": "1.9.0",
 		"bittorrent-dht": "11.0.12",
@@ -76,10 +77,10 @@ var package_default = {
 		"@ghostly/browser": "*",
 		"@ghostly/core": "*",
 		"@ghostly/iroh-web": "*",
-		"@types/node": "^26.6.4",
+		"@types/node": "^26.6.5",
 		"typescript": "^5.9.3",
-		"vite": "^8.3.3",
-		"vitest": "^5.0.3"
+		"vite": "^8.3.4",
+		"vitest": "^5.0.4"
 	}
 };
 //#endregion
@@ -241,11 +242,12 @@ function isNotTheDaemon(error) {
 }
 /**
 * A connection to a profile's daemon over its socket (WISP 1100 § Local control API). `null` from `connectDaemon`
-* means no daemon answers there: a one-shot command runs the profile itself. *
+* means no daemon answers there: a one-shot command runs the profile itself.
+*
 * The first line on it is a `daemon.hello`, and no call is written until its answer proves the other end read the
-* profile's daemon secret (`daemonProof.ts`): until then every call waits, and a listener that does not prove it gets
-* every call refused (`refused`, `isNotTheDaemon`) having read nothing but the hello. Nothing it writes before that
-* is read either.
+* profile's daemon secret (`daemonProof.ts`): until then every call waits, under its own deadline, and a listener
+* that does not prove it gets every call refused (`refused`, `isNotTheDaemon`) having read nothing but the hello.
+* Nothing it writes before that is read either.
 */
 var DaemonClient = class {
 	socket;
@@ -254,6 +256,8 @@ var DaemonClient = class {
 	pending = /* @__PURE__ */ new Map();
 	eventListener = null;
 	closedListener = null;
+	/** While paused: the events of the chunk already read, given to the listener on resume. */
+	held = null;
 	verified = false;
 	refusal = null;
 	ready;
@@ -291,7 +295,8 @@ var DaemonClient = class {
 				return;
 			}
 			if (message.event) {
-				this.eventListener?.(message.event);
+				if (this.held) this.held.push(message.event);
+				else this.eventListener?.(message.event);
 				return;
 			}
 			const waiting = typeof message.id === "number" ? this.pending.get(message.id) : void 0;
@@ -319,14 +324,35 @@ var DaemonClient = class {
 		this.settle.reject(this.refusal);
 		this.socket.destroy();
 	}
-	call(method, params = {}) {
-		if (this.socket.destroyed && this.refusal) return Promise.reject(this.refusal);
+	/**
+	* `timeoutMs`: give up (code `timeout`, exit 4) when the daemon has not answered by then; without it the call waits
+	* for as long as the connection holds. A call that timed out closes the connection: its answer, if one ever comes,
+	* is of no use, and the process leaves once nothing else keeps it (not every caller reaches `exit`).
+	*/
+	call(method, params = {}, { timeoutMs } = {}) {
+		if (this.socket.destroyed) return Promise.reject(this.refusal ?? new CliError("unavailable", "The daemon went away"));
 		const id = this.nextId++;
 		return new Promise((resolve, reject) => {
-			this.pending.set(id, {
-				resolve,
-				reject
-			});
+			let timer;
+			if (timeoutMs !== void 0) {
+				timer = setTimeout(() => {
+					if (!this.pending.delete(id)) return;
+					reject(new CliError("timeout", `The daemon did not answer ${method} in ${timeoutMs / 1e3} s: \`ghostly daemon restart\` starts a fresh one`, { method }));
+					this.destroy();
+				}, timeoutMs);
+				timer.unref?.();
+			}
+			const settle = {
+				resolve: (value) => {
+					if (timer) clearTimeout(timer);
+					resolve(value);
+				},
+				reject: (error) => {
+					if (timer) clearTimeout(timer);
+					reject(error);
+				}
+			};
+			this.pending.set(id, settle);
 			this.ready.then(() => {
 				if (this.pending.has(id) && !this.socket.destroyed) this.socket.write(JSON.stringify({
 					id,
@@ -334,7 +360,7 @@ var DaemonClient = class {
 					params
 				}) + "\n");
 			}, (error) => {
-				if (this.pending.delete(id)) reject(error);
+				if (this.pending.delete(id)) settle.reject(error);
 			});
 		});
 	}
@@ -344,6 +370,29 @@ var DaemonClient = class {
 		this.closedListener = onClosed ?? null;
 		return this.call("events.subscribe", since === void 0 ? {} : { since });
 	}
+	/**
+	* Stops reading: what the daemon sends waits in the connection (and past its bound the daemon ends it), and no
+	* event reaches the listener until `resume`.
+	*/
+	pause() {
+		if (this.held) return;
+		this.held = [];
+		this.socket.pause();
+	}
+	/** Gives the listener the events held, then reads again; a listener that pauses again keeps the rest held. */
+	resume() {
+		const held = this.held;
+		if (!held) return;
+		this.held = null;
+		for (let i = 0; i < held.length; i++) {
+			this.eventListener?.(held[i]);
+			if (this.held) {
+				this.held.unshift(...held.slice(i + 1));
+				return;
+			}
+		}
+		this.socket.resume();
+	}
 	close() {
 		this.socket.end();
 	}
@@ -942,7 +991,7 @@ var commands$8 = {
 				description: "Replace the three files when they are there"
 			}
 		},
-		run: async ({ options }, a) => (await import("./apps-CpxENMgl.js")).initApp(a.dir, {
+		run: async ({ options }, a) => (await import("./apps-BdfyGVZ1.js")).initApp(a.dir, {
 			name: options.name,
 			title: options.title,
 			force: options.force === true
@@ -982,7 +1031,7 @@ var commands$8 = {
 				description: "This version's sequence, higher than the bundle at --out's (default: one more than it)"
 			}
 		},
-		run: async ({ options }, a) => (await import("./apps-CpxENMgl.js")).publishApp(a.dir, keyFile(options.key, "app publish <dir> --key <file> [--out <file>] [--sequence n]"), here(options.out), options.sequence)
+		run: async ({ options }, a) => (await import("./apps-BdfyGVZ1.js")).publishApp(a.dir, keyFile(options.key, "app publish <dir> --key <file> [--out <file>] [--sequence n]"), here(options.out), options.sequence)
 	},
 	"app revoke": {
 		method: "app.revoke",
@@ -1015,7 +1064,7 @@ var commands$8 = {
 				description: "Allow --up-to past the bundle's own sequence (versions published from elsewhere)"
 			}
 		},
-		run: async ({ options }, a) => (await import("./apps-CpxENMgl.js")).revokeApp(a.dir, keyFile(options.key, "app revoke <dir> --key <file> (--digest <digest>... | --up-to <sequence>) [--reason <text>]"), {
+		run: async ({ options }, a) => (await import("./apps-BdfyGVZ1.js")).revokeApp(a.dir, keyFile(options.key, "app revoke <dir> --key <file> (--digest <digest>... | --up-to <sequence>) [--reason <text>]"), {
 			digests: options.digest,
 			upTo: options["up-to"],
 			reason: options.reason,
@@ -1076,7 +1125,7 @@ var commands$8 = {
 		usage: "app verify <bundle|url>",
 		summary: "Check a .ghostlyapp as a client would, from a file or an https URL: its manifest and digest, or refused (exit 1) with the reason, revoked when the ghostly-revoke.json beside it revokes this version",
 		args: ["bundle"],
-		run: async (_, a) => (await import("./apps-CpxENMgl.js")).verifyApp(a.bundle)
+		run: async (_, a) => (await import("./apps-BdfyGVZ1.js")).verifyApp(a.bundle)
 	},
 	"store sign": {
 		method: "store.sign",
@@ -1093,7 +1142,7 @@ var commands$8 = {
 				description: "The folder to write ghostly-store.json and ghostly-store.sig in (default: the index's)"
 			}
 		},
-		run: async ({ options }, a) => (await import("./apps-CpxENMgl.js")).signStore(a.index, keyFile(options.key, "store sign <index> --key <file> [--out <dir>]"), here(options.out))
+		run: async ({ options }, a) => (await import("./apps-BdfyGVZ1.js")).signStore(a.index, keyFile(options.key, "store sign <index> --key <file> [--out <dir>]"), here(options.out))
 	}
 };
 //#endregion
@@ -1417,7 +1466,7 @@ var commands$6 = {
 	"invite join": {
 		method: "invite.join",
 		usage: "invite join [<invite-or-link> | -] [--label <name>]",
-		summary: "Join a chat from its invite; the invite on stdin keeps it out of ps",
+		summary: "Join a chat from its invite; stdin keeps it out of ps (without a daemon it waits up to 60 s for the inviter)",
 		args: ["invite?"],
 		options: { label: {
 			type: "string",
@@ -2167,7 +2216,7 @@ var commands$3 = {
 };
 //#endregion
 //#region src/commands/identities.ts
-/** Identity proofs: one entry per command, in alphabetical order (test/commands.test.ts checks). */
+/** Identity proofs and x401 credentials: one entry per command, in alphabetical order (test/commands.test.ts checks). */
 var commands$2 = {
 	"identity cancel": {
 		method: "identity.cancel",
@@ -2253,6 +2302,42 @@ var commands$2 = {
 			chat: a.chat,
 			id: a.id
 		})
+	},
+	"x401 credential add": {
+		method: "x401.credential.add",
+		usage: "x401 credential add <file|-> [--label <name>]",
+		summary: "Keep an issued SD-JWT VC bound to a key from x401 key new (a file, or - for stdin)",
+		args: ["file"],
+		options: { label: {
+			type: "string",
+			description: "Your name for it, up to 80 characters on one line (default: its type)"
+		} },
+		params: ({ options }, a) => ({
+			file: a.file === "-" ? "-" : here(a.file),
+			label: options.label
+		})
+	},
+	"x401 credential list": {
+		method: "x401.credential.list",
+		usage: "x401 credential list [--show-secret]",
+		summary: "This profile's x401 credentials: issuer, type, claim paths",
+		options: { "show-secret": {
+			type: "boolean",
+			description: "Print the claims' values too (a name, a document number...)"
+		} },
+		params: ({ options }) => secret(options)
+	},
+	"x401 credential remove": {
+		method: "x401.credential.remove",
+		usage: "x401 credential remove <id>",
+		summary: "Remove a credential and its holder key",
+		args: ["id"],
+		params: (_, a) => ({ id: a.id })
+	},
+	"x401 key new": {
+		method: "x401.key.new",
+		usage: "x401 key new",
+		summary: "A fresh P-256 holder key: its public JWK goes to the issuer (the 8 newest wait for a credential; past them, the oldest is dropped)"
 	}
 };
 //#endregion
@@ -2979,7 +3064,13 @@ function checkWebhook(url) {
 }
 function readCursor(path) {
 	if (!path || !existsSync(path)) return void 0;
-	const value = Number(readFileSync(path, "utf8").trim());
+	let text;
+	try {
+		text = readFileSync(path, "utf8");
+	} catch (error) {
+		throw localFileError(error, path) ?? error;
+	}
+	const value = Number(text.trim());
 	return Number.isInteger(value) && value >= 0 ? value : void 0;
 }
 /**
@@ -3211,7 +3302,7 @@ function eventHandler(options) {
 }
 /**
 * Bounds what a listener holds when its output or hooks fall behind (a stdout reader that hung, a slow --exec): past
-* `MAX_BEHIND` events not handled it stops taking events (`pause`: the subscription closes) and drops what still
+* `MAX_BEHIND` events not handled it stops taking events (`pause`: the subscription stops reading) and drops what still
 * arrives; once every event taken is handled, `resume` opens it again after the last one taken. The daemon's journal
 * keeps what came meanwhile (and says `events.gap` past what it keeps), so a consumer that hangs for a day does not
 * grow the listener by the day's traffic.
@@ -3245,6 +3336,64 @@ var Feed = class {
 		});
 	};
 };
+/** How long a feed that fell behind keeps its connection to the daemon open, unread, while its hooks take no event (`followDaemon`). */
+var PAUSE_HOLD_MS = 6e4;
+/**
+* Follows a daemon's events into `handle` until `close`; a daemon that restarts is picked up again after the last event
+* seen. A feed that falls behind stops reading the connection, not closes it: what the daemon sent meanwhile (a replay
+* written whole) is read on resume, so a catch-up reads the journal once, not once per pause. A connection the daemon
+* ended meanwhile (past what it lets a client leave unread) is opened again after the last event taken.
+* A feed whose hooks take no event for `holdMs` (`PAUSE_HOLD_MS`: a hook that hung) ends the connection, as a full one
+* does, so the daemon does not keep a replay and what came live for it while it hangs; resume opens it again after the
+* last event taken.
+* `subscribed`: the first subscription's answer (a journal that cannot be replayed rejects it).
+*/
+function followDaemon(address, client, handle, since, holdMs = PAUSE_HOLD_MS) {
+	let current = client;
+	let holding;
+	const reconnect = (wait) => void (async () => {
+		while (!current && !feed.paused) {
+			await new Promise((resolve) => setTimeout(resolve, wait));
+			wait = 1e3;
+			if (current || feed.paused) return;
+			const next = await connectDaemon(address, 1e3);
+			if (next) {
+				current = next;
+				await follow(next).catch(() => {
+					if (current === next) current = null;
+				});
+			}
+		}
+	})();
+	const hold = (behind) => {
+		holding = setTimeout(() => {
+			if (handle.behind() < behind) return hold(handle.behind());
+			const c = current;
+			current = null;
+			c?.destroy();
+		}, holdMs);
+	};
+	const feed = new Feed(handle, since, () => {
+		current?.pause();
+		hold(handle.behind());
+	}, () => {
+		clearTimeout(holding);
+		if (current) current.resume();
+		else reconnect(0);
+	});
+	const follow = (c) => c.subscribe(feed.since, feed.take, () => {
+		if (current !== c) return;
+		current = null;
+		reconnect(1e3);
+	});
+	return {
+		subscribed: follow(client),
+		close: () => {
+			clearTimeout(holding);
+			current?.close();
+		}
+	};
+}
 //#endregion
 //#region src/secretInput.ts
 /**
@@ -3267,7 +3416,14 @@ var JOINS = {
 		what: "An invite"
 	}
 };
-async function secretsFromStdin(method, params, read, tty = false) {
+/**
+* A join given no invite reads stdin, but a pipe nobody writes or closes (what Node's exec and most harnesses give a
+* child) would hold it for ever without a word: a note once nothing has come for a while, the usage error once nothing
+* has come at all. A producer that started writing is waited for to the end; `-` asked for stdin and waits as long.
+*/
+var STDIN_NOTE_MS = 2e3;
+var STDIN_GIVE_UP_MS = 6e4;
+async function secretsFromStdin(method, params, read, tty = false, note = () => {}) {
 	const warning = (what) => `${what} on the command line shows in ps and the shell's history: give it on stdin instead`;
 	if (method === "wallet.redeem") {
 		if (params.token !== void 0) return warning("A token");
@@ -3283,7 +3439,7 @@ async function secretsFromStdin(method, params, read, tty = false) {
 		if (params[join.param] !== void 0 && params[join.param] !== "-") return warning(join.what);
 		const missing = () => new CliError("usage", `Missing ${join.arg}: give it on stdin (… | ghostly ${join.command}) or as an argument`);
 		if (tty) throw missing();
-		const value = (await read()).trim();
+		const value = (params[join.param] === "-" ? await read() : await readUnasked(read, note, join)).trim();
 		if (!value) throw missing();
 		params[join.param] = value;
 		return;
@@ -3306,6 +3462,22 @@ async function secretsFromStdin(method, params, read, tty = false) {
 		return onLine ? warning("An API key") : void 0;
 	}
 }
+async function readUnasked(read, note, join) {
+	let noteTimer, giveUpTimer;
+	const stop = () => {
+		clearTimeout(noteTimer);
+		clearTimeout(giveUpTimer);
+	};
+	const nothingCame = new Promise((_, reject) => {
+		noteTimer = setTimeout(() => note(`Waiting for ${join.what.toLowerCase()} on stdin (… | ghostly ${join.command}): give it there or as an argument`), STDIN_NOTE_MS);
+		giveUpTimer = setTimeout(() => reject(new CliError("usage", `Missing ${join.arg}: nothing came on stdin in ${STDIN_GIVE_UP_MS / 1e3} s; give it there (… | ghostly ${join.command}) or as an argument`)), STDIN_GIVE_UP_MS);
+	});
+	try {
+		return await Promise.race([read(stop), nothingCame]);
+	} finally {
+		stop();
+	}
+}
 /**
 * `wallet create --value`: the names given on the command line that the chosen source's form marks `kind: "secret"`
 * (an NWC URI, a macaroon, a rune, an RPC password), as a warning. `list`: a `wallet.list` answer, where the forms are.
@@ -3326,8 +3498,8 @@ var VERSION = package_default.version;
 * command a running daemon answers loads none of them, and starts about as fast as Node does. Statically imported, they
 * cost every command ~100 ms before its socket was opened.
 */
-var engineApi = () => import("./api-Cp9GxjUO.js");
-var engineHost = () => import("./host-DPy0eaH9.js");
+var engineApi = () => import("./api-BqLfti32.js");
+var engineHost = () => import("./host-Drd-c4VO.js");
 var pretty = false;
 function print(value) {
 	process.stdout.write(JSON.stringify(value, null, pretty ? 2 : void 0) + "\n");
@@ -3371,6 +3543,11 @@ function versionWarning(daemon, cli) {
 	if (typeof daemon !== "string" || daemon === cli) return null;
 	return `ghostly: the daemon runs ${daemon} and this command is ${cli}: \`ghostly daemon restart\` runs the new code`;
 }
+/**
+* Never fails, and has no deadline of its own: a daemon that does not answer is the command's own call to find out,
+* at the command's deadline, which closes the connection and ends this check with it. A deadline here ended every
+* command on a wedged daemon at 15 s with `unavailable` ("The daemon went away"), whatever its own `--timeout` said.
+*/
 async function warnVersion(client) {
 	const warning = versionWarning((await client.call("status").catch(() => null))?.version, VERSION);
 	if (warning) process.stderr.write(warning + "\n");
@@ -3413,7 +3590,8 @@ var READS = /* @__PURE__ */ new Set([
 	"service.list",
 	"service.peer",
 	"call.list",
-	"app.served"
+	"app.served",
+	"x401.credential.list"
 ]);
 /** Whether a one-shot for this call opens the profile offline; test/readOnlyCommands.test.ts names every table command. */
 function readOnly(method, params) {
@@ -3421,15 +3599,66 @@ function readOnly(method, params) {
 	if (method === "call.auto") return params.on === void 0;
 	return READS.has(method);
 }
+/**
+* Calls whose change stays on this device: a chat's name here, a chat removed (nothing goes to the contact), auto-answer
+* (calls.json), a proof dropped, a web app added (shared with no one yet), an x401 key or credential (WISP 3xx: never
+* shared with a contact). Opened online, each put the profile's records on the relays and waited for them (6 PUT + 4
+* GET, 3.3 s with a relay that takes 1.5 s), and the contacts' apps saw this device come online. `message delete` stays
+* online: it settles a file offer already on the DHT.
+*/
+var LOCAL_WRITES = /* @__PURE__ */ new Set([
+	"chat.rename",
+	"chat.remove",
+	"call.auto",
+	"identity.cancel",
+	"service.add",
+	"x401.key.new",
+	"x401.credential.add",
+	"x401.credential.remove"
+]);
+/** Settings of this device only: no contact and no relay hears of them (nick, avatar and the relays' do). */
+var LOCAL_SETTINGS = /* @__PURE__ */ new Set([
+	"sendTyping",
+	"autoDownloads",
+	"serveFiles"
+]);
+/** Whether a one-shot for this call opens the profile offline: a read, or a change that stays on this device. */
+function offlineCall(method, params) {
+	return readOnly(method, params) || LOCAL_WRITES.has(method);
+}
+/** How long a daemon gets to answer before a command gives up: a read is in memory (15 s); a call that waits for the
+*  contact carries its own `--timeout` (or the daemon's default for it), plus a margin; anything else may take as long
+*  as it takes. */
+var ANSWER_MS = 15e3;
+function answerWithin(method, params) {
+	const waits = typeof params.timeout === "number" ? Math.min(Math.max(params.timeout, 1), 86400) : waitsFor(method, params);
+	if (waits !== void 0) return (waits + 10) * 1e3;
+	if (readOnly(method, params)) return ANSWER_MS;
+}
+/**
+* The seconds a call without `--timeout` waits for the contact: the daemon's defaults (`num(params, "timeout", …)` in
+* api.ts, files.ts, buttons.ts and statusCards.ts), so that a bot's `chat wait` or `send --wait sent` on a daemon that
+* stopped answering ends when the wait would have. A call that does not wait is none.
+*/
+function waitsFor(method, params) {
+	if (method === "chat.wait") return 60;
+	if (method === "file.wait" || method === "file.save" && params.wait === true) return 300;
+	if (typeof params.wait === "string" && params.wait !== "none") return 30;
+}
 async function session(g, options) {
 	requireProfile(g);
 	const client = await connectDaemon(g.paths);
-	if (client) await warnVersion(client);
-	if (client) return {
-		mode: "daemon",
-		call: (m, p) => client.call(m, p),
-		close: async () => client.close()
-	};
+	if (client) {
+		const warned = warnVersion(client);
+		return {
+			mode: "daemon",
+			call: (m, p) => client.call(m, p, { timeoutMs: answerWithin(m, p ?? {}) }),
+			close: async () => {
+				await warned;
+				client.close();
+			}
+		};
+	}
 	const [{ openHost }, { callApi }] = await Promise.all([engineHost(), engineApi()]);
 	const host = await openHost(g.paths, "one-shot", VERSION, options);
 	return {
@@ -3440,7 +3669,7 @@ async function session(g, options) {
 }
 /**
 * How a one-shot opens the profile: `deferGroups` when the command is about one 1:1 chat (`chatOnly`) and needs
-* nothing of the groups, `offline` when it only reads (`readOnly`).
+* nothing of the groups, `offline` when it only reads or changes only this device (`offlineCall`).
 */
 async function withSession(g, work, options = {}) {
 	const s = await session(g, options);
@@ -3450,9 +3679,43 @@ async function withSession(g, work, options = {}) {
 		await s.close();
 	}
 }
-async function readStdin() {
+/**
+* A one-shot join waits up to 60 s for the inviter. Its answer says whether the chat paired and at what stage it is; one
+* not paired yet comes with the next step, since nothing pairs once the command has left.
+*/
+async function oneShotJoinWait(s, result, label) {
+	const view = await s.call("chat.wait", {
+		chat: result.chat,
+		until: "paired",
+		timeout: 60
+	}).then((v) => ({
+		paired: true,
+		chat: v
+	}), () => null) ?? await s.call("chat.get", { chat: result.chat }).then((v) => ({
+		paired: false,
+		chat: v
+	}), () => ({
+		paired: false,
+		chat: null
+	}));
+	const stage = view.chat?.stage ?? null;
+	const answer = {
+		...result,
+		paired: view.paired,
+		stage
+	};
+	if (view.paired) return { answer };
+	return {
+		answer,
+		note: `Not paired yet: the inviter's app is offline. It pairs when both are online: keep this profile running (ghostly daemon --detach), then ghostly chat wait ${label?.trim() && !/\s/.test(label.trim()) ? label.trim() : String(result.chat)} --until paired`
+	};
+}
+async function readStdin(onData) {
 	const chunks = [];
-	for await (const chunk of process.stdin) chunks.push(chunk);
+	for await (const chunk of process.stdin) {
+		onData?.();
+		chunks.push(chunk);
+	}
 	return Buffer.concat(chunks).toString("utf8");
 }
 var o = (type, description) => ({
@@ -3509,7 +3772,11 @@ var SPECIAL = [
 			timeout: o("number", "Seconds --detach waits for it to start (default 60)")
 		}
 	],
-	["daemon status", "Whether a daemon runs the profile, its version, and its socket (for the socket API)"],
+	[
+		"daemon status [--timeout s]",
+		"Whether a daemon runs the profile, its version, and its socket (for the socket API)",
+		{ timeout: o("number", "Seconds to wait for its answer (default 15)") }
+	],
 	[
 		"daemon stop [--timeout s]",
 		"Stop the profile's daemon",
@@ -3542,15 +3809,20 @@ var SPECIAL = [
 	],
 	["settings set <key> <json-value>", "Change one: relays, irohRelays, hyperdhtRelay, readRelays, iceServers, publicProfiles, online, shareProfile, sendTyping, autoDownloads, serveFiles, nick"],
 	[
-		"engine <method> [json-params | -] [--confirm-real] [--show-secret] [--force]",
-		"Any call of the app's engine, with its own parameters",
+		"engine <method> [json-params | -] [--confirm-real] [--show-secret] [--yes] [--force]",
+		"Any call of the app's engine, with its own parameters (engine --list --verbose names them)",
 		{
 			"confirm-real": o("boolean", "Confirm a Mainnet (real money) spend"),
 			"show-secret": o("boolean", "Print a call's secrets"),
+			yes: o("boolean", "Confirm a call that deletes chats or groups"),
 			force: o("boolean", "Send a text that looks like a secret")
 		}
 	],
-	["engine --list", "The engine's calls"],
+	[
+		"engine --list [--verbose]",
+		"The engine's calls",
+		{ verbose: o("boolean", "With what each call takes: { linkId, label }, ? for an optional one") }
+	],
 	["call pipe [<chat|call>]", "A call's audio on stdin/stdout: raw s16le mono PCM at the call's rate (e.g. with sox or ffmpeg)"],
 	[
 		"identity add <provider> [subject] [--signer id] [--field name=value]... [--days n]",
@@ -3584,7 +3856,8 @@ function help() {
 		...Object.entries(GLOBAL_OPTIONS).map(([name, o]) => `  --${name}${o.short ? `, -${o.short}` : ""}`.padEnd(24) + o.description),
 		"",
 		"A <chat> is its id, a unique prefix of it, or its name; a <group> the same. Exit codes: 0 done, 1 failed,",
-		"2 usage, 3 not found, 4 timed out, 5 needs --force/--yes/--confirm-real. See packages/cli/README.md."
+		"2 usage, 3 not found, 4 timed out, 5 needs --force/--yes/--confirm-real.",
+		"More: https://ghostly.tools/cli, or the README.md beside this CLI."
 	].join("\n");
 }
 /** What `ghostly help help` answers. */
@@ -3611,7 +3884,7 @@ function helpRows() {
 function commandWords(usage) {
 	const words = [];
 	for (const word of usage.split(" ")) {
-		if (!/^[a-z][a-z-]*$/.test(word)) break;
+		if (!/^[a-z][a-z0-9-]*$/.test(word)) break;
 		words.push(word);
 	}
 	return words;
@@ -3632,7 +3905,7 @@ function commandHelp(words) {
 	const asked = words.join(" ");
 	if (!rows.length) throw new CliError("usage", `Unknown command: ${asked} (ghostly help)`);
 	const exact = rows.filter((row) => commandWords(row.usage).join(" ") === asked);
-	if (!exact.length && words.length < given.length) throw unknownCommand(given[0], given[1]);
+	if (!exact.length && words.length < given.length) throw unknownCommand(given[0], given[1], given[2]);
 	const lines = [];
 	for (const row of exact) {
 		lines.push(`Usage: ghostly ${row.usage}`, "", `  ${row.summary}`);
@@ -3714,14 +3987,23 @@ async function profileCommand(sub, argv) {
 		case "create": {
 			const [name] = parsed.positionals;
 			if (!name || parsed.positionals.length > 1) throw new CliError("usage", "ghostly profile create <name>");
+			const shownName = parsed.options.name === void 0 ? void 0 : checkShownName(parsed.options.name);
 			const paths = createProfile(g.home, name);
-			if (parsed.options.use) selectProfile(g.home, name);
 			let shown = null;
-			if (typeof parsed.options.name === "string") shown = await withSession({
-				...g,
-				profile: name,
-				paths
-			}, (s) => s.call("profile.set", { name: parsed.options.name }));
+			if (shownName !== void 0) try {
+				shown = await withSession({
+					...g,
+					profile: name,
+					paths
+				}, (s) => s.call("profile.set", { name: shownName }));
+			} catch (e) {
+				rmSync(paths.dir, {
+					recursive: true,
+					force: true
+				});
+				throw e;
+			}
+			if (parsed.options.use) selectProfile(g.home, name);
 			print({
 				created: name,
 				folder: paths.dir,
@@ -3791,7 +4073,7 @@ async function profileCommand(sub, argv) {
 			const [file, name] = parsed.positionals;
 			if (!file || !name) throw new CliError("usage", "ghostly profile restore <file> <new profile> [--passphrase-file f] [--use]");
 			noMoreThan(2, parsed.positionals, "profile restore <file> <new profile> [--passphrase-file f] [--use]");
-			const { backupFileProtection, restoreProfile } = await import("./backup-CqM-0-2v.js");
+			const { backupFileProtection, restoreProfile } = await import("./backup-BbO2zLjx.js");
 			const protection = await backupFileProtection(file);
 			const paths = await restoreProfile(g.home, checkProfileName(name), file, protection === "none" ? void 0 : backupPassphrase(parsed.options["passphrase-file"], RESTORE_PASSPHRASE));
 			if (parsed.options.use) selectProfile(g.home, name);
@@ -3901,7 +4183,7 @@ async function daemonCommand(argv) {
 		"status",
 		"stop",
 		"restart"
-	].includes(sub)) noMoreThan(0, parsed.positionals, sub === "status" ? "daemon status" : sub ? `daemon ${sub} [--timeout s]` : "daemon [--detach] [--timeout s]");
+	].includes(sub)) noMoreThan(0, parsed.positionals, sub ? `daemon ${sub} [--timeout s]` : "daemon [--detach] [--timeout s]");
 	if (sub === "status") {
 		knownProfile(g);
 		const client = await connectDaemon(g.paths);
@@ -3916,7 +4198,7 @@ async function daemonCommand(argv) {
 		try {
 			print({
 				running: true,
-				...await client.call("status"),
+				...await client.call("status", {}, { timeoutMs: seconds(parsed, 15) * 1e3 }),
 				socket: g.paths.socket
 			});
 		} finally {
@@ -3938,11 +4220,11 @@ async function daemonCommand(argv) {
 	if (sub === "restart") {
 		const stopFor = seconds(parsed, 20), startFor = seconds(parsed, 60);
 		const client = await connectDaemon(g.paths);
-		const before = client ? (await client.call("status").catch(() => null))?.version ?? null : null;
+		const probe = client ? client.call("status").catch(() => null) : null;
 		print({
 			restarted: true,
 			stopped: client ? await stopDaemon(g, client, stopFor) : null,
-			before,
+			before: (await probe)?.version ?? null,
 			version: VERSION,
 			...await startDetached(g, startFor)
 		});
@@ -3965,34 +4247,55 @@ function seconds(parsed, fallback) {
 }
 /**
 * Asks the daemon to stop and waits until its process is gone, not only until it let go of the profile (it releases
-* the lock a moment before it exits); its pid.
+* the lock a moment before it exits); its pid. One that does not answer the ask in `seconds` (its event loop wedged)
+* is sent SIGTERM, and SIGKILL when that did not end it either in as long: `daemon restart` then starts a fresh one,
+* as the timeout error promises. The pid is the profile lock's holder, which a daemon writes itself. On Windows
+* `process.kill` with either name is TerminateProcess: the first signal ends it, there is no second.
 */
 async function stopDaemon(g, client, seconds) {
-	let pid;
+	let pid, answered = true;
 	try {
-		({pid} = await client.call("daemon.stop"));
+		({pid} = await client.call("daemon.stop", {}, { timeoutMs: seconds * 1e3 }));
 	} catch (error) {
-		if (!isNotTheDaemon(error)) throw error;
+		const refused = isNotTheDaemon(error);
+		if (!(error instanceof CliError && error.code === "timeout") && !refused) throw error;
 		const holder = lockOwner(g.paths);
 		if (holder === null) throw error;
-		process.stderr.write(`ghostly: what answers on the socket did not prove it is this profile's daemon (an older release's cannot): stopping the process that holds the profile (${holder}) with SIGTERM\n`);
+		process.stderr.write(refused ? `ghostly: what answers on the socket did not prove it is this profile's daemon (an older release's cannot): stopping the process that holds the profile (${holder}) with SIGTERM\n` : `ghostly: the daemon (process ${holder}) did not answer daemon.stop in ${seconds} s: stopping it with SIGTERM\n`);
 		pid = holder;
-		try {
-			process.kill(pid, "SIGTERM");
-		} catch {}
+		answered = false;
+		signal(pid, "SIGTERM");
 	}
 	client.close();
-	const until = Date.now() + seconds * 1e3;
 	const running = () => lockOwner(g.paths) === pid || processAlive(pid);
-	while (running() && Date.now() < until) await new Promise((resolve) => setTimeout(resolve, 100));
-	if (running()) throw new CliError("timeout", `The daemon (process ${pid}) has not stopped yet`);
-	return pid;
+	const gone = async () => {
+		const until = Date.now() + seconds * 1e3;
+		while (running()) {
+			const left = until - Date.now();
+			if (left <= 0) break;
+			await new Promise((resolve) => setTimeout(resolve, Math.min(100, left)));
+		}
+		return !running();
+	};
+	if (await gone()) return pid;
+	if (!answered) {
+		process.stderr.write(`ghostly: the daemon (process ${pid}) did not stop on SIGTERM in ${seconds} s: killing it\n`);
+		signal(pid, "SIGKILL");
+		if (await gone()) return pid;
+	}
+	throw new CliError("timeout", `The daemon (process ${pid}) has not stopped yet`, { pid });
 }
 /** Throws busy, with its pid, when a process other than `except` holds the profile. */
 function heldBy(g, except) {
 	const owner = lockOwner(g.paths);
 	if (owner !== null && owner !== except) throw new CliError("busy", `Profile ${g.profile} is in use by process ${owner}`, { pid: owner });
 }
+/** Gone already, or not ours to signal: the wait that follows says so. */
+function signal(pid, name) {
+	try {
+		process.kill(pid, name);
+	} catch {}
+}
 function processAlive(pid) {
 	try {
 		process.kill(pid, 0);
@@ -4024,20 +4327,26 @@ async function startDetached(g, seconds) {
 		]
 	});
 	child.unref();
+	const spawned = { error: null };
+	child.once("error", (error) => {
+		spawned.error = error;
+	});
 	const until = Date.now() + seconds * 1e3;
 	let client = null;
-	while (!client && Date.now() < until) {
-		if (child.exitCode !== null) break;
-		await new Promise((resolve) => setTimeout(resolve, 200));
-		client = await connectDaemon(g.paths, 500);
+	while (child.exitCode === null && child.signalCode === null && !spawned.error) {
+		const left = until - Date.now();
+		if (left <= 0) break;
+		client = await connectDaemon(g.paths, Math.min(500, left));
+		if (client) break;
+		await new Promise((resolve) => setTimeout(resolve, Math.max(0, Math.min(200, until - Date.now()))));
 	}
 	if (!client) {
 		heldBy(g, child.pid);
-		if (child.exitCode === null && child.pid !== void 0 && processAlive(child.pid)) throw new CliError("timeout", `The daemon (process ${child.pid}) is still starting; ghostly daemon status shows when it is up`, {
+		if (child.exitCode === null && child.signalCode === null && child.pid !== void 0 && processAlive(child.pid)) throw new CliError("timeout", `The daemon (process ${child.pid}) is still starting; ghostly daemon status shows when it is up`, {
 			pid: child.pid,
 			log: g.paths.log
 		});
-		throw new CliError("engine", `The daemon did not start; see ${g.paths.log}`);
+		throw new CliError("engine", spawned.error ? `The daemon could not be spawned: ${spawned.error.message}` : `The daemon did not start; see ${g.paths.log}`);
 	}
 	client.close();
 	return {
@@ -4048,6 +4357,20 @@ async function startDetached(g, seconds) {
 		log: g.paths.log
 	};
 }
+/**
+* Nobody reads `listen`'s output any more (`listen | head -n 1`, a `grep -m1` that found its line): it stops as on
+* SIGTERM, exit 0. Through a daemon it died on an 'error' nobody handled; on its own profile it served on with nobody
+* to tell, holding the profile until `daemon stop`. Any other failure of the output is still an error.
+*/
+function onReaderGone(stop) {
+	let gone = false;
+	process.stdout.on("error", (error) => {
+		if (gone) return;
+		if (error.code !== "EPIPE") throw error;
+		gone = true;
+		stop();
+	});
+}
 async function listenCommand(argv) {
 	const parsed = parseArgs(argv, {
 		since: {
@@ -4134,7 +4457,7 @@ async function listenCommand(argv) {
 			const c = await connectDaemon(g.paths, 1e3);
 			if (!c) return null;
 			try {
-				return (await c.call("chat.get", { chat })).peer || null;
+				return (await c.call("chat.get", { chat }, { timeoutMs: ANSWER_MS })).peer || null;
 			} finally {
 				c.close();
 			}
@@ -4142,42 +4465,15 @@ async function listenCommand(argv) {
 			client.close();
 			throw error;
 		});
-		let current = client;
-		const reconnect = (wait) => void (async () => {
-			while (!current && !feed.paused) {
-				await new Promise((resolve) => setTimeout(resolve, wait));
-				wait = 1e3;
-				if (current || feed.paused) return;
-				const next = await connectDaemon(g.paths, 1e3);
-				if (next) {
-					current = next;
-					await follow(next).catch(() => {
-						if (current === next) current = null;
-					});
-				}
-			}
-		})();
-		const feed = new Feed(handle, since, () => {
-			const c = current;
-			current = null;
-			c?.destroy();
-		}, () => reconnect(0));
-		const follow = async (c) => {
-			await c.subscribe(feed.since, feed.take, () => {
-				if (current !== c) return;
-				current = null;
-				reconnect(1e3);
-			});
-		};
-		await follow(client);
-		process.on("SIGINT", () => {
-			current?.close();
-			process.exit(0);
-		});
-		process.on("SIGTERM", () => {
-			current?.close();
+		const following = followDaemon(g.paths, client, handle, since);
+		const stop = () => {
+			following.close();
 			process.exit(0);
-		});
+		};
+		onReaderGone(stop);
+		await following.subscribed;
+		process.on("SIGINT", stop);
+		process.on("SIGTERM", stop);
 		return;
 	}
 	const [{ keepServing, openHost, serve }, { callApi }] = await Promise.all([engineHost(), engineApi()]);
@@ -4198,6 +4494,7 @@ async function listenCommand(argv) {
 	});
 	host.ctx.stop = stop;
 	onStopSignals(stop);
+	onReaderGone(stop);
 	let off = null, left = [];
 	const open = (from) => {
 		for (;;) {
@@ -4236,6 +4533,10 @@ async function engineCommand(argv) {
 			type: "boolean",
 			description: ""
 		},
+		yes: {
+			type: "boolean",
+			description: ""
+		},
 		force: {
 			type: "boolean",
 			description: ""
@@ -4243,13 +4544,21 @@ async function engineCommand(argv) {
 		list: {
 			type: "boolean",
 			description: ""
+		},
+		verbose: {
+			type: "boolean",
+			description: ""
 		}
 	});
 	const g = globals(parsed);
 	pretty = g.pretty;
 	if (parsed.options.list) {
-		noMoreThan(0, parsed.positionals, "engine --list");
-		print({ methods: [...ENGINE_METHODS, ...ENGINE_READS].sort() });
+		noMoreThan(0, parsed.positionals, "engine --list [--verbose]");
+		const methods = [...ENGINE_METHODS, ...ENGINE_READS].sort();
+		print(parsed.options.verbose ? {
+			methods,
+			takes: Object.fromEntries(methods.map((m) => [m, ENGINE_PARAMS[m] ?? READ_PARAMS[m]]))
+		} : { methods });
 		return;
 	}
 	const [method, raw] = parsed.positionals;
@@ -4266,10 +4575,12 @@ async function engineCommand(argv) {
 	}
 	const confirmReal = parsed.options["confirm-real"] === true;
 	if (confirmReal && params && typeof params === "object") params.confirmedReal = true;
+	const yes = parsed.options.yes === true;
 	let result = await withSession(g, (s) => s.call("engine.call", {
 		method,
 		params,
 		confirmReal,
+		yes,
 		force: parsed.options.force === true
 	}), { offline: ENGINE_READS.includes(method) });
 	if (method === "getState" && !showSecret && result && typeof result === "object") {
@@ -4300,7 +4611,7 @@ async function settingsCommand(sub, argv) {
 			parsedValue = value;
 		}
 		if ((await engineApi()).SETTABLE[key] === "string" && typeof parsedValue !== "string") parsedValue = value;
-		printAnswer(await withSession(g, (s) => s.call("settings.set", { [key]: parsedValue })));
+		printAnswer(await withSession(g, (s) => s.call("settings.set", { [key]: parsedValue }), { offline: LOCAL_SETTINGS.has(key) }));
 		return;
 	}
 	throw unknownCommand("settings", sub);
@@ -4330,7 +4641,7 @@ async function textCommand(name, argv) {
 	};
 	if (spec.target === "group") params.mentions = parsed.options.mention ?? [];
 	if (parsed.options.reply !== void 0) params.reply = parsed.options.reply;
-	if (!spec.message) Object.assign(params, (await import("./buttons-CJqNkG-Q.js")).buttonsOf(parsed.options));
+	if (!spec.message) Object.assign(params, (await import("./buttons-_GBlxAti.js")).buttonsOf(parsed.options));
 	print(await withSession(g, (s) => {
 		if (spec.target === "chat") {
 			params.wait = parsed.options.wait ?? (s.mode === "one-shot" ? spec.message ? "confirmed" : "sent" : "none");
@@ -4438,8 +4749,17 @@ async function tableCommand(name, argv) {
 		delete params.evidenceFile;
 		delete params.stdin;
 	}
+	if (command.method === "x401.credential.add") {
+		try {
+			params.credential = params.file === "-" ? await readStdin() : readFileSync(params.file, "utf8");
+		} catch (error) {
+			throw localFileError(error, params.file) ?? new CliError("usage", `Cannot read the credential: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		if (!params.credential) throw new CliError("bad_request", params.file === "-" ? "Nothing on stdin: give the SD-JWT VC the issuer sent" : `${params.file} is empty: it holds the SD-JWT VC the issuer sent`);
+		delete params.file;
+	}
 	const lineValues = command.method === "wallet.create" ? Object.keys(params.values ?? {}) : [];
-	const secretWarning = await secretsFromStdin(command.method, params, readStdin, process.stdin.isTTY === true);
+	const secretWarning = await secretsFromStdin(command.method, params, readStdin, process.stdin.isTTY === true, (note) => process.stderr.write(`ghostly: ${note}\n`));
 	if (secretWarning) process.stderr.write(`ghostly: ${secretWarning}\n`);
 	printAnswer(await withSession(g, async (s) => {
 		if (lineValues.length) {
@@ -4447,15 +4767,15 @@ async function tableCommand(name, argv) {
 			if (warning) process.stderr.write(`ghostly: ${warning}\n`);
 		}
 		const result = await s.call(command.method, params);
-		if (command.method === "invite.join" && s.mode === "one-shot") await s.call("chat.wait", {
-			chat: result.chat,
-			until: "paired",
-			timeout: 60
-		}).catch(() => {});
+		if (command.method === "invite.join" && s.mode === "one-shot") {
+			const joined = await oneShotJoinWait(s, result, typeof params.label === "string" ? params.label : void 0);
+			if (joined.note) process.stderr.write(`ghostly: ${joined.note}\n`);
+			return joined.answer;
+		}
 		return result;
 	}, {
 		deferGroups: chatOnly(command.method, params),
-		offline: readOnly(command.method, params)
+		offline: offlineCall(command.method, params)
 	}));
 }
 /**
@@ -4470,7 +4790,7 @@ async function callPipeCommand(argv) {
 	if (!client) throw new CliError("unavailable", `No daemon runs profile ${g.profile}: calls need one (ghostly daemon --detach)`);
 	let call;
 	try {
-		call = await client.call("call.get", ref ? { call: ref } : {});
+		call = await client.call("call.get", ref ? { call: ref } : {}, { timeoutMs: ANSWER_MS });
 	} finally {
 		client.close();
 	}
@@ -4520,8 +4840,9 @@ async function main(input) {
 		print({ version: VERSION });
 		return 0;
 	}
-	const [first, second] = argv;
+	const [first, second, third] = argv;
 	const two = second && !second.startsWith("-") ? `${first} ${second}` : "";
+	const three = two && third && !third.startsWith("-") ? `${two} ${third}` : "";
 	const text = (name) => Object.hasOwn(TEXT_COMMANDS, name), table = (name) => Object.hasOwn(COMMANDS, name);
 	if (first === "profile" && !table(two)) {
 		await profileCommand(second, argv.slice(2));
@@ -4551,6 +4872,10 @@ async function main(input) {
 		await callPipeCommand(argv.slice(2));
 		return -1;
 	}
+	if (three && table(three)) {
+		await tableCommand(three, argv.slice(3));
+		return 0;
+	}
 	if (two && text(two)) {
 		await textCommand(two, argv.slice(2));
 		return 0;
@@ -4567,18 +4892,28 @@ async function main(input) {
 		await tableCommand(first, argv.slice(1));
 		return 0;
 	}
-	throw unknownCommand(first, two ? second : void 0);
+	throw unknownCommand(first, two ? second : void 0, three ? third : void 0);
 }
 /**
-* A command line that names no command. The first word of a group (`ghostly chat`, `ghostly wallet frob`) is answered
-* with the group's commands, as `ghostly help chat` lists them; before, it was only "Unknown command: chat".
+* A command line that names no command. The words of a group (`ghostly chat`, `ghostly wallet frob`, `ghostly x401
+* credential`) are answered with the group's commands, as `ghostly help chat` lists them; before, it was only "Unknown
+* command: chat". The longest group the words name answers: `x401 credential frob` lists add, list and remove.
 */
-function unknownCommand(first, second) {
-	const asked = [first, second].filter(Boolean).join(" ");
-	const subs = [...new Set(helpRows().map((row) => commandWords(row.usage)).filter((words) => words[0] === first && words.length > 1).map((words) => words[1]))];
-	if (!subs.length) return new CliError("usage", `Unknown command: ${asked} (ghostly help)`);
-	const list = `${subs.slice(0, -1).join(", ")}${subs.length > 1 ? " or " : ""}${subs.at(-1)}`;
-	return new CliError("usage", second ? `Unknown command: ${asked}: ghostly ${first} takes ${list} (ghostly help ${first})` : `ghostly ${first} takes a command: ${list} (ghostly help ${first})`);
+function unknownCommand(first, second, third) {
+	const asked = [
+		first,
+		second,
+		third
+	].filter((word) => !!word);
+	const all = helpRows().map((row) => commandWords(row.usage));
+	for (let depth = Math.min(asked.length, 2); depth >= 1; depth--) {
+		const group = asked.slice(0, depth), name = group.join(" "), extra = asked[depth];
+		const subs = [...new Set(all.filter((words) => words.length > depth && group.every((word, i) => words[i] === word)).map((words) => words[depth]))];
+		if (!subs.length) continue;
+		const list = `${subs.slice(0, -1).join(", ")}${subs.length > 1 ? " or " : ""}${subs.at(-1)}`;
+		return new CliError("usage", extra ? `Unknown command: ${name} ${extra}: ghostly ${name} takes ${list} (ghostly help ${name})` : `ghostly ${name} takes a command: ${list} (ghostly help ${name})`);
+	}
+	return new CliError("usage", `Unknown command: ${asked.slice(0, 2).join(" ")} (ghostly help)`);
 }
 /** Leaves once what was printed reached stdout (a pipe drains asynchronously). */
 function exit(code) {
@@ -4614,4 +4949,4 @@ async function run(argv) {
 //#endregion
 export { run };
 
-//# sourceMappingURL=main-Dt7xrqtb.js.map
+//# sourceMappingURL=main-BWAwKY4f.js.map