@duyquangnvx/create-agent-cli 0.30.1 → 0.32.0

package/dist/bin.js

@@ -6,6 +6,7 @@ import { parseArgs, parseEnv } from "node:util";
 import { constants as constants$1, existsSync, readFileSync, realpathSync } from "node:fs";
 import { access, chmod, link, mkdir, mkdtemp, open, readFile, readdir, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { createHash } from "node:crypto";
 import { fileURLToPath } from "node:url";
 //#region ../../node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/util.js
 function getEnumValues(entries) {
@@ -418,7 +419,7 @@ function hide(inst, key, value) {
 }
 /** Adds members a table derives from the instance: each builds on first read and shadows as own data, and assignment shadows the same way, as when these were own properties. */
 /* @__NO_SIDE_EFFECTS__ */
-function derived(computes, table) {
+function derived$1(computes, table) {
 	for (const key in computes) {
 		const compute = computes[key];
 		Object.defineProperty(table, key, {
@@ -1075,7 +1076,7 @@ function timeSource(args) {
 function time(args) {
 	return new RegExp(`^${timeSource(args)}$`);
 }
-function datetime(args) {
+function datetime$1(args) {
 	const opts = ["Z"];
 	if (args.offset) opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
 	const qualified = `${timeSource({
@@ -1087,7 +1088,7 @@ function datetime(args) {
 }
 const anyString = /^[\s\S]{0,}$/;
 const integer = /^-?\d+$/;
-const number$1 = /^-?\d+(?:\.\d+)?$/;
+const number$2 = /^-?\d+(?:\.\d+)?$/;
 const boolean$1 = /^(?:true|false)$/i;
 const lowercase = /^[^A-Z]*$/;
 const uppercase = /^[^a-z]*$/;
@@ -1725,7 +1726,7 @@ const $ZodKSUID = /*@__PURE__*/ $constructor("$ZodKSUID", (inst, def) => {
 	$ZodStringFormat.init(inst, def);
 });
 const $ZodISODateTime = /*@__PURE__*/ $constructor("$ZodISODateTime", (inst, def) => {
-	def.pattern ?? (def.pattern = datetime(def));
+	def.pattern ?? (def.pattern = datetime$1(def));
 	$ZodStringFormat.init(inst, def);
 });
 const $ZodISODate = /*@__PURE__*/ $constructor("$ZodISODate", (inst, def) => {
@@ -1870,7 +1871,7 @@ const $ZodJWT = /*@__PURE__*/ $constructor("$ZodJWT", (inst, def) => {
 });
 const $ZodNumber = /*@__PURE__*/ $constructor("$ZodNumber", (inst, def) => {
 	$ZodType.init(inst, def);
-	inst._zod.pattern = number$1;
+	inst._zod.pattern = number$2;
 	inst._zod.parse = (payload, _ctx) => {
 		if (def.coerce) try {
 			payload.value = Number(payload.value);
@@ -2507,7 +2508,7 @@ const $ZodRecord = /*@__PURE__*/ $constructor("$ZodRecord", (inst, def) => {
 					issues: []
 				}, ctx);
 				if (keyResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
-				if (typeof key === "string" && number$1.test(key) && keyResult.issues.length) {
+				if (typeof key === "string" && number$2.test(key) && keyResult.issues.length) {
 					const retryResult = def.keyType._zod.run({
 						value: Number(key),
 						issues: []
@@ -3497,6 +3498,15 @@ function _number(Class, params) {
 	}));
 }
 // @__NO_SIDE_EFFECTS__
+function _coercedNumber(Class, params) {
+	return new Class(snapshotChecks({
+		type: "number",
+		coerce: true,
+		checks: [],
+		...normalizeParams(params)
+	}));
+}
+// @__NO_SIDE_EFFECTS__
 function _int(Class, params) {
 	return new Class({
 		type: "number",
@@ -4572,7 +4582,7 @@ function stringifyKeyNames(bySchema, json, visited) {
 	else if (typeof rest.const === "number") rest.const = String(rest.const);
 	if (!numericType) return rest;
 	rest.type = "string";
-	if (!values) rest.pattern = (types.includes("number") ? number$1 : integer).source;
+	if (!values) rest.pattern = (types.includes("number") ? number$2 : integer).source;
 	return rest;
 }
 /** Every record of one conversion, so the carriers are found in a single pass rather than once per record. */
@@ -5053,7 +5063,7 @@ const _ZodString = /*@__PURE__*/ $constructor("_ZodString", (inst, def) => {
 	$ZodString.init(inst, def);
 	ZodType.init(inst, def);
 	inst._zod.processJSONSchema = (ctx, json, params) => stringProcessor(inst, ctx, json, params);
-}, /*@__PURE__*/ derived({
+}, /*@__PURE__*/ derived$1({
 	format: (inst) => aggregateChecks(inst).format ?? null,
 	minLength: (inst) => aggregateChecks(inst).minimum ?? null,
 	maxLength: (inst) => aggregateChecks(inst).maximum ?? null
@@ -5299,7 +5309,7 @@ const ZodNumber = /*@__PURE__*/ $constructor("ZodNumber", (inst, def) => {
 	ZodType.init(inst, def);
 	inst._zod.processJSONSchema = (ctx, json, params) => numberProcessor(inst, ctx, json, params);
 	inst.isFinite = true;
-}, /*@__PURE__*/ derived({
+}, /*@__PURE__*/ derived$1({
 	minValue: (inst) => {
 		const { minimum, exclusiveMinimum } = aggregateChecks(inst);
 		return Math.max(minimum ?? Number.NEGATIVE_INFINITY, exclusiveMinimum ?? Number.NEGATIVE_INFINITY);
@@ -5360,7 +5370,7 @@ const ZodNumber = /*@__PURE__*/ $constructor("ZodNumber", (inst, def) => {
 		return this;
 	}
 }));
-function number(params) {
+function number$1(params) {
 	return /* @__PURE__ */ _number(ZodNumber, params);
 }
 const ZodNumberFormat = /*@__PURE__*/ $constructor("ZodNumberFormat", (inst, def) => {
@@ -5728,6 +5738,16 @@ function superRefine(fn, params) {
 	return /* @__PURE__ */ _superRefine(fn, params);
 }
 //#endregion
+//#region ../../node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/classic/iso.js
+function datetime(params) {
+	return /* @__PURE__ */ _isoDateTime(ZodISODateTime, params);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/classic/coerce.js
+function number(params) {
+	return /* @__PURE__ */ _coercedNumber(ZodNumber, params);
+}
+//#endregion
 //#region ../agent-cli/dist/abort.js
 /** Never resolves; rejects with the signal's reason once it aborts. */
 function untilAborted(signal) {
@@ -5741,6 +5761,7 @@ function untilAborted(signal) {
 }
 //#endregion
 //#region ../agent-cli/dist/clock.js
+const MS_PER_S = 1e3;
 const realClock = {
 	now: () => Date.now(),
 	sleep: (ms, signal) => new Promise((resolve, reject) => {
@@ -6098,12 +6119,152 @@ function lastLines(output, count) {
 	return output.trim().split("\n").slice(-count).join("\n");
 }
 //#endregion
+//#region ../agent-cli/dist/context/fetch.js
+const UNREACHABLE = "UNREACHABLE";
+const UNAVAILABLE = "UNAVAILABLE";
+const UNANSWERED = "UNANSWERED";
+/** How long a request may take, body included, when the Command gives no `timeoutMs`. */
+const FETCH_TIMEOUT_MS = 3e4;
+const HTTP_REQUEST_TIMEOUT = 408;
+const HTTP_TOO_MANY_REQUESTS = 429;
+const HTTP_SERVER_ERROR = 500;
+const HTTP_SERVICE_UNAVAILABLE = 503;
+const NOT_SENT_CODES = /* @__PURE__ */ new Set([
+	"ECONNREFUSED",
+	"ENOTFOUND",
+	"EAI_AGAIN",
+	"EHOSTUNREACH",
+	"ENETUNREACH",
+	"UND_ERR_CONNECT_TIMEOUT"
+]);
+const ONCE_METHODS = /* @__PURE__ */ new Set(["POST", "PATCH"]);
+function headersOf(input, init) {
+	return new Headers(init.headers ?? (input instanceof Request ? input.headers : void 0));
+}
+function methodOf(input, init) {
+	return (init.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
+}
+/** The `check` of a request that must not be resent, or `undefined` for one that may be. */
+function onceOf(method, once) {
+	if (once === false) return void 0;
+	return once ?? (ONCE_METHODS.has(method) ? {} : void 0);
+}
+function originOf$1(input) {
+	return new URL(input instanceof Request ? input.url : input).origin;
+}
+/** 5xx, 408 and 429: the server cannot answer now, whatever the request. */
+function isUnavailable(status) {
+	return status === HTTP_REQUEST_TIMEOUT || status === HTTP_TOO_MANY_REQUESTS || status >= HTTP_SERVER_ERROR;
+}
+/** 408 and every 5xx but 503: the server or a gateway failed on a request it may have applied. */
+function isUnanswered(status) {
+	return status === HTTP_REQUEST_TIMEOUT || status >= HTTP_SERVER_ERROR && status !== HTTP_SERVICE_UNAVAILABLE;
+}
+function retryAtOf(header, clock) {
+	const value = header?.trim();
+	if (value === void 0 || value === "") return void 0;
+	const at = /^\d+$/.test(value) ? clock.now() + Number(value) * MS_PER_S : Date.parse(value);
+	return Number.isNaN(at) ? void 0 : new Date(at).toISOString();
+}
+function reasonOf(error) {
+	return error instanceof Error && error.cause instanceof Error ? error.cause : error;
+}
+function wasNotSent(error) {
+	const reason = reasonOf(error);
+	return reason instanceof Error && "code" in reason && NOT_SENT_CODES.has(reason.code);
+}
+function unreachable(origin, error, rerun) {
+	return new CliError({
+		code: UNREACHABLE,
+		message: `could not reach ${origin}: ${messageOf(reasonOf(error))}`,
+		hint: `check the network and that ${origin} is up, then run the Next step`,
+		details: { origin },
+		next: [rerun]
+	}, { cause: error });
+}
+function unavailable(origin, response, scope) {
+	const { status } = response;
+	const retryAt = retryAtOf(response.headers.get("retry-after"), scope.clock);
+	const when = retryAt === void 0 ? "in a minute" : "at retryAt";
+	return new CliError({
+		code: UNAVAILABLE,
+		message: `${origin} answered ${status}: it cannot take requests now`,
+		hint: `${origin} is down or busy, not your request: run the Next step ${when}`,
+		details: {
+			origin,
+			status
+		},
+		retryAt,
+		next: [scope.rerun]
+	});
+}
+function unanswered({ origin, method, once }, status, cause) {
+	const check = once?.check;
+	const what = `a ${method} request it may have applied`;
+	return new CliError({
+		code: UNANSWERED,
+		message: status === void 0 ? `${origin} gave no answer to ${what}` : `${origin} answered ${status} to ${what}`,
+		hint: check === void 0 ? `${origin} may have applied it: ask whoever runs ${origin} whether it took before sending it again` : `${origin} may have applied it: run the Next step to see whether it took before sending it again`,
+		details: {
+			origin,
+			status
+		},
+		next: check === void 0 ? [] : [check]
+	}, { cause });
+}
+/** What a request that got no answer fails with; `bound` is the Runtime's part of `signal`. */
+function noAnswer(error, sent, { bound, signal }, rerun) {
+	if (sent.once !== void 0 && bound.aborted) return unanswered(sent, void 0, error);
+	if (signal.aborted) return error;
+	if (sent.once !== void 0 && !wasNotSent(error)) return unanswered(sent, void 0, error);
+	return unreachable(sent.origin, error, rerun);
+}
+/** What an answer the Command must not get fails with, or `undefined` for one it gets. */
+function refusal$1(response, sent, scope) {
+	if (sent.once !== void 0 && isUnanswered(response.status)) return unanswered(sent, response.status);
+	return isUnavailable(response.status) ? unavailable(sent.origin, response, scope) : void 0;
+}
+function contextFetch(scope) {
+	return async (input, { timeoutMs = FETCH_TIMEOUT_MS, once, ignoreStop, ...init } = {}) => {
+		const method = methodOf(input, init);
+		const sent = {
+			origin: originOf$1(input),
+			method,
+			once: onceOf(method, once)
+		};
+		const headers = headersOf(input, init);
+		if (!headers.has("user-agent")) headers.set("user-agent", scope.userAgent);
+		const bound = scope.deadline(timeoutMs, ignoreStop === true ? { ignoreStop } : {});
+		const signal = init.signal == null ? bound : AbortSignal.any([bound, init.signal]);
+		signal.throwIfAborted();
+		let response;
+		try {
+			response = await scope.fetch(input, {
+				...init,
+				headers,
+				signal
+			});
+		} catch (error) {
+			throw noAnswer(error, sent, {
+				bound,
+				signal
+			}, scope.rerun);
+		}
+		const failure = refusal$1(response, sent, scope);
+		if (failure === void 0) return response;
+		await response.body?.cancel();
+		throw failure;
+	};
+}
+//#endregion
 //#region ../agent-cli/dist/context/interrupts.js
 const INTERRUPTED = "INTERRUPTED";
 const DEADLINE_EXCEEDED = "DEADLINE_EXCEEDED";
 /** How long an interrupted Command may take to settle before the run ends without it. */
 const GRACE_MS = 3e3;
 const GRACE_OVER = Symbol("grace over");
+/** The codes a run ends with although it was stopped, since they say more than the stop does. */
+const OUTRANKS_STOP = /* @__PURE__ */ new Set([INTERRUPTED, UNANSWERED]);
 function interruptedError(rerun) {
 	return new CliError({
 		code: INTERRUPTED,
@@ -6203,12 +6364,13 @@ var RunControl = class {
 	}
 	/**
 	* The error a run ends with: an interrupt or the run deadline outranks what the Command threw,
-	* unless the Command threw its own `INTERRUPTED`, saying what it finished before it stopped.
+	* unless the Command threw its own `INTERRUPTED`, saying what it finished before it stopped, or
+	* `ctx.fetch` threw `UNANSWERED`, since a rerun would send its request twice.
 	* Otherwise each leaf that is not a `CliError` and whose cause chain holds a deadline's abort is
 	* reported as that abort, so a declared error keeps its own code.
 	*/
 	errorAfter(error) {
-		if (this.signal.aborted) return error instanceof CliError && error.code === "INTERRUPTED" ? error : this.signal.reason;
+		if (this.signal.aborted) return error instanceof CliError && OUTRANKS_STOP.has(error.code) ? error : this.signal.reason;
 		const leaves = errorsOf(error).map((leaf) => this.#abortIn(leaf) ?? leaf);
 		return leaves.length === 1 ? leaves[0] : new AggregateError(leaves);
 	}
@@ -6868,7 +7030,7 @@ const SEPARATOR = ",";
 const COLUMN_SEPARATOR = "	";
 const UNSAFE_IN_COLUMN = /[\t\n\r]/;
 const PAGE_INPUT = object({
-	limit: number().int().positive().default(DEFAULT_PAGE_LIMIT),
+	limit: number$1().int().positive().default(DEFAULT_PAGE_LIMIT),
 	cursor: string().min(1).optional()
 });
 var Page = class {
@@ -7029,6 +7191,17 @@ const FORCE_FLAG = standardFlag("--force", {
 	takes: "nothing",
 	schema: boolean()
 });
+const WAIT_SECONDS = number().int().nonnegative();
+const WAIT_FLAG = standardFlag("--wait", {
+	placeholder: "<seconds>",
+	description: "seconds to wait for a pending Approval to be approved",
+	takes: "value",
+	schema: WAIT_SECONDS
+});
+/** Whether `--wait` is a Standard flag of the Command: it is of one that declares a Login or Grant. */
+function takesWait(command) {
+	return (command.logins ?? []).length > 0 || (command.grants ?? []).length > 0;
+}
 const EFFECT_FLAGS = {
 	read: [JSON_FLAG],
 	act: [JSON_FLAG],
@@ -7048,7 +7221,7 @@ const RESERVED = new Map([
 	...LIST_FLAGS
 ].map((flag) => [nameOf$1(flag), flag]));
 /** The Standard flags of a Command with this Effect and declarations, and of a List Command. */
-function standardFlagsFor(effect, { outputs, force, cost }, list) {
+function standardFlagsFor(effect, { outputs, force, cost, wait }, list) {
 	const forceFlag = force === void 0 ? FORCE_FLAG : {
 		...FORCE_FLAG,
 		description: force
@@ -7057,19 +7230,22 @@ function standardFlagsFor(effect, { outputs, force, cost }, list) {
 		...EFFECT_FLAGS[effect],
 		...outputs || force !== void 0 ? [forceFlag] : [],
 		...cost ? [YES_FLAG] : [],
+		...wait ? [WAIT_FLAG] : [],
 		...list?.standardFlags ?? []
 	];
 }
 /** Throws when the Command declares an arg or option under a Standard flag's name. */
 function checkNoStandardFlags(command, label) {
-	const lines = [...argFields(command.args).map(({ key }) => ({
+	const declared = [...argFields(command.args).map(({ key }) => ({
 		kind: "arg",
 		key
 	})), ...optionFields(command.options).map(({ key }) => ({
 		kind: "option",
 		key
-	}))].flatMap(({ kind, key }) => {
-		const flag = RESERVED.get(kebab(key));
+	}))];
+	const wait = takesWait(command);
+	const lines = declared.flatMap(({ kind, key }) => {
+		const flag = RESERVED.get(kebab(key)) ?? (wait && kebab(key) === nameOf$1(WAIT_FLAG.flag) ? WAIT_FLAG.flag : void 0);
 		return flag === void 0 ? [] : [`  ${kind} '${key}' is the Standard flag ${flag}`];
 	});
 	if (lines.length > 0) throw new Error([`Command '${label}' declares Standard flags the Runtime adds; rename them:`, ...lines].join("\n"));
@@ -7508,7 +7684,7 @@ function readText(path, fileError) {
 		});
 	}
 }
-function parsed(path, text, schema, rerun) {
+function parsed$1(path, text, schema, rerun) {
 	let json;
 	try {
 		json = JSON.parse(text);
@@ -7524,7 +7700,7 @@ function projectFrom(projectFile, folder, scope) {
 	const text = readText(path, scope.fileError);
 	if (text !== void 0) return {
 		root: folder,
-		settings: parsed(path, text, projectFile.schema, scope.rerun)
+		settings: parsed$1(path, text, projectFile.schema, scope.rerun)
 	};
 	const parent = dirname(folder);
 	return parent === folder ? void 0 : projectFrom(projectFile, parent, scope);
@@ -7633,6 +7809,95 @@ function secretRows(secrets, commands) {
 	}];
 }
 //#endregion
+//#region ../agent-cli/dist/login/errors.js
+const LOGIN_REQUIRED = "LOGIN_REQUIRED";
+const APPROVAL_PENDING = "APPROVAL_PENDING";
+const APPROVAL_DENIED = "APPROVAL_DENIED";
+const APPROVAL_EXPIRED = "APPROVAL_EXPIRED";
+const LOGIN_REJECTED = "LOGIN_REJECTED";
+function loginStep(name) {
+	return ["login", name];
+}
+/** Fails a Command whose Logins are found neither as a Secret nor stored. */
+function loginRequired(names, rerun) {
+	const listed = names.join(", ");
+	return new CliError({
+		code: LOGIN_REQUIRED,
+		message: `not signed in to ${listed}`,
+		hint: "run the Next steps in order: the person who runs this CLI approves a code in a browser, then the Command runs again",
+		details: { logins: names },
+		next: [...names.map(loginStep), rerun]
+	});
+}
+function loginAsking(name) {
+	return {
+		subject: `signing in to ${name}`,
+		denied: () => approvalDenied(name),
+		expired: () => approvalExpired(name)
+	};
+}
+/** A Grant's Approval, whose expiry the rerun of the Command heals with a new code. */
+function grantAsking(name, scope, rerun) {
+	const subject = `the grant of ${scope} from ${name}`;
+	return {
+		subject,
+		denied: () => new CliError({
+			code: APPROVAL_DENIED,
+			message: `the person refused ${subject}`,
+			hint: "ask the person whether to go ahead, and run the Command again only if they agree"
+		}),
+		expired: () => new CliError({
+			code: APPROVAL_EXPIRED,
+			message: `the code for ${subject} expired before it was approved`,
+			hint: "run the Next step for a new code, and pass its link and code to the person",
+			next: [rerun]
+		})
+	};
+}
+/** The wait ran out before the person approved: the same Approval stays pending for the rerun. */
+function approvalPending({ subject }, approval, rerun) {
+	const { verificationUri, userCode, verificationUriComplete } = approval;
+	return new CliError({
+		code: APPROVAL_PENDING,
+		message: `${subject} waits for the code ${userCode} to be approved at ${verificationUriComplete ?? verificationUri}`,
+		hint: "the person sees only your reply: write the link and the code in it, then run the Next step, which waits for the approval",
+		details: {
+			verificationUri,
+			userCode,
+			...verificationUriComplete === void 0 ? {} : { verificationUriComplete }
+		},
+		next: [rerun]
+	});
+}
+function approvalDenied(name) {
+	return new CliError({
+		code: APPROVAL_DENIED,
+		message: `the person refused to sign in to ${name}`,
+		hint: "ask the person whether to sign in, and run the Next step only if they agree",
+		next: [loginStep(name)]
+	});
+}
+/** A Command's `LOGIN_REJECTED` of a token from a Secret, which only the operator can replace. */
+function secretRejected(name, secret, rejected) {
+	return new CliError({
+		code: LOGIN_REJECTED,
+		message: rejected.message,
+		hint: `the server refused the token in ${secret.name}: ask the person who runs this CLI to set ${secret.name} to a valid token from ${secret.get}, or to unset it so the CLI signs in through a browser`,
+		details: {
+			login: name,
+			secret: secret.name
+		}
+	}, { cause: rejected });
+}
+function approvalExpired(name) {
+	return new CliError({
+		code: APPROVAL_EXPIRED,
+		message: `the code to sign in to ${name} expired before it was approved`,
+		hint: "run the Next step for a new code, and pass its link and code to the person",
+		next: [loginStep(name)]
+	});
+}
+//#endregion
 //#region ../agent-cli/dist/runtime-codes.js
 const DOCTOR_PROBLEMS = "DOCTOR_PROBLEMS";
 const NOT_GLOBAL_INSTALL = "NOT_GLOBAL_INSTALL";
@@ -7642,6 +7907,7 @@ const REGISTRY_AUTH = "REGISTRY_AUTH";
 const INSTALL_FAILED = "INSTALL_FAILED";
 const NPM_FAILED = "NPM_FAILED";
 const NO_LATEST = "NO_LATEST";
+const RELEASE_TOO_OLD = "RELEASE_TOO_OLD";
 /** The Runtime codes any Command can meet, which no Command declares. */
 const anyCommandErrors = {
 	[INVALID_INPUT]: { class: "caller" },
@@ -7665,7 +7931,16 @@ const anyCommandErrors = {
 	[TOOL_FAILED]: { class: "operator" },
 	[TOOL_MISSING]: { class: "operator" },
 	[SECRET_MISSING]: { class: "operator" },
-	[PROJECT_INVALID]: { class: "operator" }
+	[PROJECT_INVALID]: { class: "operator" },
+	[UNREACHABLE]: { class: "wait" },
+	[UNAVAILABLE]: { class: "wait" },
+	[UNANSWERED]: { class: "source" },
+	[RELEASE_TOO_OLD]: { class: "caller" },
+	[LOGIN_REQUIRED]: { class: "operator" },
+	[APPROVAL_PENDING]: { class: "wait" },
+	[APPROVAL_DENIED]: { class: "operator" },
+	[APPROVAL_EXPIRED]: { class: "operator" },
+	[LOGIN_REJECTED]: { class: "operator" }
 };
 /**
 * The Runtime codes only some Commands reach: each Command that throws one, Built-in or the CLI's
@@ -7700,7 +7975,8 @@ function mustDeclare(code, table) {
 //#endregion
 //#region ../agent-cli/dist/define-command.js
 /** Throws when the Command's declaration breaks a rule its type cannot express; `label` names it. */
-function checkCommand(command, label, table) {
+function checkCommand(command, label, table, logins) {
+	checkLogins([...command.logins ?? [], ...command.grants ?? []], label, logins);
 	checkNoStandardFlags(command, label);
 	checkForce(command, label);
 	checkArrayArgLast(label, command.args);
@@ -7708,6 +7984,10 @@ function checkCommand(command, label, table) {
 	checkNoBooleanArrayOption(label, command.options);
 	checkErrors(command.errors ?? [], label, table);
 }
+function checkLogins(names, label, logins) {
+	const unknown = names.filter((name) => !Object.hasOwn(logins, name));
+	if (unknown.length > 0) throw new Error(`${label} declares the Login ${unknown.join(", ")}, which the CLI does not declare in logins`);
+}
 /** Throws on a code in `errors` that is neither in `table` nor a Runtime code some Commands declare. */
 function checkErrors(errors, label, table) {
 	const unknown = errors.filter((code) => !mustDeclare(code, table));
@@ -7744,13 +8024,227 @@ function cliErrorOf(code, init, options) {
 	}, options);
 }
 //#endregion
+//#region ../agent-cli/dist/login/declared.js
+/** The declaration of the Login `name` for a run in `env`. */
+function declaredLogin(logins, name, env) {
+	const login = logins[name];
+	if (login === void 0) throw new Error(`${name} is not a Login the CLI declares`);
+	return typeof login === "function" ? login(env) : login;
+}
+//#endregion
+//#region ../agent-cli/dist/login/store.js
+const storedLoginSchema = object({
+	accessToken: string(),
+	refreshToken: string().optional(),
+	expiresAt: datetime().optional()
+});
+const approvalSchema = object({
+	deviceCode: string(),
+	userCode: string(),
+	verificationUri: string(),
+	verificationUriComplete: string().optional(),
+	expiresAt: datetime(),
+	/** Seconds between polls of the token endpoint. */
+	interval: number$1()
+});
+const KEY_LENGTH = 16;
+function keyOf(...parts) {
+	return createHash("sha256").update(parts.join("\n")).digest("hex").slice(0, KEY_LENGTH);
+}
+function loginFilesOf(userFile, login) {
+	const key = keyOf(login.tokenEndpoint, login.clientId);
+	return {
+		stored: userFile(`login-${key}`, storedLoginSchema),
+		approval: userFile(`approval-${key}`, approvalSchema)
+	};
+}
+/** The Approval pending for a Grant of `scope`, kept apart from the Login's and every other scope's. */
+function grantApprovalOf(userFile, { tokenEndpoint, clientId }, scope) {
+	return userFile(`grant-${keyOf(tokenEndpoint, clientId, scope)}`, approvalSchema);
+}
+/** The file's value, or `undefined` once its `expiresAt` has passed, removing the file then. */
+async function readUnexpired(file, clock) {
+	const value = await file.read();
+	if (value?.expiresAt === void 0 || Date.parse(value.expiresAt) > clock.now()) return value;
+	await file.remove();
+}
+/**
+* The stored Login, unless its access token expired with no refresh token to renew it, removing
+* the file then.
+*/
+async function readStored(file, clock) {
+	const stored = await file.read();
+	return stored?.refreshToken === void 0 ? await readUnexpired(file, clock) : stored;
+}
+//#endregion
+//#region ../agent-cli/dist/login/token-endpoint.js
+const tokenSchema = object({
+	access_token: string(),
+	refresh_token: string().optional(),
+	expires_in: number$1().optional()
+});
+const errorSchema = object({ error: string() });
+function isoAfter(clock, seconds) {
+	return new Date(clock.now() + seconds * MS_PER_S).toISOString();
+}
+/** POSTs `form` to an OAuth endpoint and parses its JSON answer, whatever its status. */
+async function postForm(fetch, url, form, { ignoreStop } = {}) {
+	const response = await fetch(url, {
+		method: "POST",
+		once: false,
+		...ignoreStop === void 0 ? {} : { ignoreStop },
+		headers: { accept: "application/json" },
+		body: new URLSearchParams(form)
+	});
+	const text = await response.text();
+	try {
+		return JSON.parse(text);
+	} catch (error) {
+		throw new Error(`${url} answered ${response.status} with a body that is not JSON`, { cause: error });
+	}
+}
+function parsedAnswer(schema, body, url) {
+	const parsed = schema.safeParse(body);
+	if (!parsed.success) throw new Error(`${url} answered ${JSON.stringify(body)}, not an OAuth answer`);
+	return parsed.data;
+}
+function storedLoginOf({ access_token, refresh_token, expires_in }, clock) {
+	return {
+		accessToken: access_token,
+		...refresh_token === void 0 ? {} : { refreshToken: refresh_token },
+		...expires_in === void 0 ? {} : { expiresAt: isoAfter(clock, expires_in) }
+	};
+}
+/** Whether the stored Login has a refresh token and its access token expires within the margin. */
+function nearExpiry({ refreshToken, expiresAt }, clock) {
+	return refreshToken !== void 0 && expiresAt !== void 0 && Date.parse(expiresAt) - clock.now() < 3e5;
+}
+/**
+* Refreshes the stored Login per RFC 6749 §6 under `ctx.runToEnd`, so a single-use refresh token is
+* never spent without its successor stored. `invalid_grant` removes the stored Login and gives `undefined`.
+*/
+async function refreshed(name, login, file, refreshToken, ctx) {
+	ctx.signal.throwIfAborted();
+	const form = {
+		grant_type: "refresh_token",
+		refresh_token: refreshToken,
+		client_id: login.clientId
+	};
+	return await ctx.runToEnd(`refreshing the Login ${name}`, async () => {
+		const body = await postForm(ctx.fetch, login.tokenEndpoint, form, { ignoreStop: true });
+		const granted = tokenSchema.safeParse(body);
+		if (granted.success) {
+			const stored = {
+				refreshToken,
+				...storedLoginOf(granted.data, ctx.clock)
+			};
+			await file.write(stored);
+			return stored;
+		}
+		const { error } = parsedAnswer(errorSchema, body, login.tokenEndpoint);
+		if (error !== "invalid_grant") throw new Error(`${login.tokenEndpoint} refused the refresh of ${name} with ${error}`);
+		await file.remove();
+	});
+}
+//#endregion
+//#region ../agent-cli/dist/login/token.js
+function setSecretOf(login, secret) {
+	const name = login.secret?.name;
+	const found = name === void 0 ? void 0 : secret(name);
+	return name === void 0 || found === void 0 ? void 0 : {
+		name,
+		secret: found
+	};
+}
+function secretTokenOf(login, scope) {
+	const set = setSecretOf(login, scope.secret);
+	return set && {
+		value: set.secret.value,
+		source: {
+			kind: "secret",
+			name: set.name
+		}
+	};
+}
+function storedToken({ accessToken }) {
+	return {
+		value: accessToken,
+		source: { kind: "stored" }
+	};
+}
+function unexpired({ expiresAt }, clock) {
+	return expiresAt === void 0 || Date.parse(expiresAt) > clock.now();
+}
+/**
+* The Login's token without sending anything: its Secret's value when set, else the stored Login's
+* while its access token has not expired.
+*/
+async function currentTokenOf(login, scope) {
+	const fromSecret = secretTokenOf(login, scope);
+	if (fromSecret !== void 0) return fromSecret;
+	const stored = await readStored(loginFilesOf(scope.userFile, login).stored, scope.clock);
+	return stored && unexpired(stored, scope.clock) ? storedToken(stored) : void 0;
+}
+/** The Login's token: its Secret's value when set, else the stored Login's, refreshed near expiry. */
+async function freshTokenOf(name, login, ctx) {
+	const fromSecret = secretTokenOf(login, tokenScopeOf(ctx));
+	if (fromSecret !== void 0) return fromSecret;
+	const file = loginFilesOf(ctx.userFile, login).stored;
+	const stored = await readStored(file, ctx.clock);
+	if (stored?.refreshToken === void 0 || !nearExpiry(stored, ctx.clock)) return stored && storedToken(stored);
+	const renewed = await refreshed(name, login, file, stored.refreshToken, ctx);
+	return renewed && storedToken(renewed);
+}
+function tokenScopeOf(ctx) {
+	const { env, envFile, fileError } = ctx;
+	return {
+		secret: (name) => secretOf({
+			env,
+			envFile,
+			fileError
+		}, name),
+		userFile: ctx.userFile,
+		clock: ctx.clock
+	};
+}
+//#endregion
+//#region ../agent-cli/dist/login/doctor-rows.js
+function loginRow(name, logins, runAs) {
+	return {
+		name: `login ${name}`,
+		advisory: true,
+		run: async (ctx) => {
+			const login = declaredLogin(logins, name, ctx.env);
+			const set = setSecretOf(login, tokenScopeOf(ctx).secret);
+			if (set !== void 0) return {
+				state: "ok",
+				message: `the token in ${set.name}, from ${originOf(set.secret)}`
+			};
+			if (await readStored(loginFilesOf(ctx.userFile, login).stored, ctx.clock) !== void 0) return {
+				state: "ok",
+				message: "signed in: a stored Login"
+			};
+			const secretName = login.secret?.name;
+			return {
+				state: "problem",
+				message: `not signed in${secretName === void 0 ? "" : `, and ${secretName} is not set`}; a Command that needs ${name} fails until the person approves a code`,
+				fix: lineOf(loginStep(name), runAs)
+			};
+		}
+	};
+}
+/** One `doctor` row per Login: where its token comes from, and `login` as the fix with none. */
+function loginRows(logins, runAs) {
+	return Object.keys(logins).map((name) => loginRow(name, logins, runAs));
+}
+//#endregion
 //#region ../agent-cli/dist/version.js
 /** The bundler's stamp, absent when the CLI runs unbundled. Read per call, so a test can define it. */
 function buildStamp() {
 	return {
-		"sha": "7f79c40",
+		"sha": "8907e9d",
 		"dirty": false,
-		"builtAt": "2026-11-09T07:03:37.000Z"
+		"builtAt": "2026-11-10T09:08:31.000Z"
 	};
 }
 /** The first line of `--version`: the version, and the commit and time of a stamped build. */
@@ -8105,90 +8599,325 @@ async function projectRootOf(files, cwd) {
 	return (await lockfileRootOf(files, cwd))?.dir ?? cwd;
 }
 //#endregion
-//#region ../agent-cli/dist/built-ins/install/run-as.js
-/** The Run-as: the bare name, or `npx -q --no-install <bin>` for a Dependency install (ADR 0011). */
-function runAsOf({ name, install }) {
-	return install?.mode === "dependency" ? `npx -q --no-install ${name}` : name;
-}
-//#endregion
-//#region ../agent-cli/dist/built-ins/install/dependency.js
-const LINES = {
-	pnpm: {
-		upgrade: (packages) => `pnpm up --latest ${packages.join(" ")}`,
-		add: (packages) => `pnpm add -D ${packages.join(" ")}`,
-		install: "pnpm install"
-	},
-	npm: {
-		upgrade: (packages) => `npm install ${packages.map((name) => `${name}@latest`).join(" ")}`,
-		add: (packages) => `npm install -D ${packages.join(" ")}`,
-		install: "npm install"
-	}
-};
-const packageSchema = object({ version: string() });
-async function manifestListing(files, name, cwd, root) {
-	const dirs = ancestorsOf(cwd);
-	const top = root === void 0 ? dirs.length : dirs.indexOf(root.dir) + 1;
-	for (const dir of dirs.slice(0, top)) {
-		const manifest = await manifestIn(files, dir);
-		if (manifest?.dependencies?.[name] !== void 0 || manifest?.devDependencies?.[name] !== void 0) return join(dir, "package.json");
-	}
+//#region ../agent-cli/dist/built-ins/install/global-npm.js
+/** Where npm puts global packages under its global prefix. */
+function globalModulesDir(prefix, platform) {
+	return platform === "win32" ? join(prefix, "node_modules") : join(prefix, "lib", "node_modules");
 }
-function versionIn(text) {
-	try {
-		return packageSchema.parse(JSON.parse(text)).version;
-	} catch (error) {
-		if (error instanceof SyntaxError || error instanceof ZodError) return { reason: messageOf(error) };
-		throw error;
-	}
+/** Whether `path` itself is a symlink, which a link in a folder above it does not make it. */
+async function isLink(files, path) {
+	const real = await files.realPath(path);
+	if (real === void 0) return false;
+	const folder = await files.realPath(dirname(path));
+	return folder === void 0 || real !== join(folder, basename(path));
 }
-async function standingOf(files, install, bin, cwd, root) {
-	if (bin === void 0) return { kind: "source" };
-	for (const projectDir of ancestorsOf(cwd)) {
-		const folder = join(projectDir, "node_modules", install.package);
-		const manifest = join(folder, "package.json");
-		const text = await readIfAny(files, manifest);
-		if (text === void 0) continue;
-		const version = versionIn(text);
-		if (typeof version !== "string") return {
-			kind: "unreadable",
-			manifest,
-			...version
-		};
-		const copy = {
-			projectDir,
-			realDir: await files.realPath(folder) ?? folder,
-			version
-		};
-		if (!copy.realDir.split(sep).includes("node_modules")) return {
-			kind: "linked",
-			copy
-		};
-		const runningFrom = await files.realPath(bin) ?? bin;
-		return isInside(copy.realDir, runningFrom) ? {
-			kind: "installed",
-			copy
-		} : {
-			kind: "other",
-			copy,
-			runningFrom
-		};
-	}
-	const manifest = await manifestListing(files, install.package, cwd, root);
-	return manifest === void 0 ? { kind: "missing" } : {
-		kind: "listed",
-		manifest
-	};
+function notGlobal(ctx, message) {
+	return runtimeError({
+		code: NOT_GLOBAL_INSTALL,
+		message,
+		hint: "install it by running the Next step, so its update Command can replace it",
+		next: [wholeLine(setupCommandLine(ctx.registry))]
+	});
 }
-async function surveyDependency(install, bin, { files, cwd }) {
-	const root = await lockfileRootOf(files, cwd);
+/**
+* The global npm install this copy runs from, found by asking npm for its global prefix.
+* `bin` is the script that started the CLI; throws `NOT_GLOBAL_INSTALL` when it is not inside that install.
+*/
+async function globalInstallOf(bin, ctx) {
+	if (bin === void 0) throw notGlobal(ctx, `${ctx.cliName} runs from source, not from an npm install`);
+	const prefix = await globalPrefix(ctx);
+	const packageDir = join(globalModulesDir(prefix, ctx.platform), ctx.registry.package);
+	const installed = await ctx.files.realPath(packageDir);
+	const here = await ctx.files.realPath(bin) ?? bin;
+	if (installed === void 0 || !isInside(installed, here)) throw notGlobal(ctx, `${ctx.cliName} runs from ${here}, not from npm's global install at ${packageDir}`);
+	if (await isLink(ctx.files, packageDir)) throw notGlobal(ctx, `${ctx.cliName} runs from a link to ${installed} (npm link), not from an npm install`);
 	return {
-		cwd,
-		root,
-		standing: await standingOf(files, install, bin, cwd, root)
+		prefix,
+		packageDir
 	};
 }
-function packagesOf(install) {
-	return [install.package, ...install.lockstep ?? []];
+const NPMJS = "https://registry.npmjs.org/";
+/** The flag that points npm at the CLI's registry; none for npmjs, npm's default. */
+function registryFlags({ package: name, registry }) {
+	if (registry === NPMJS) return [];
+	const scope = scopeOf(name);
+	return [scope === void 0 ? `--registry=${registry}` : `--${scope}:registry=${registry}`];
+}
+/** The line that sets a Global install up, run before the CLI is on the machine. */
+function setupLineOf(install) {
+	return setupCommandLine(globalRegistry(install));
+}
+function globalRegistry(install) {
+	const { package: name, registry } = install;
+	return {
+		package: name,
+		label: registry,
+		flags: registryFlags(install),
+		unreachableHint: "check the network or VPN",
+		loginHint: `log in to ${registry} (\`npm login --registry=${registry}\`) or set its token in ~/.npmrc`,
+		missingHint: `check that ${name} is published on ${registry}`
+	};
+}
+/** npm for a Global install, run in the working directory. */
+function globalNpm(cli, install, ctx, launch) {
+	return npmContext(cli, globalRegistry(install), ctx, launch, ctx.cwd);
+}
+//#endregion
+//#region ../agent-cli/dist/built-ins/install/release-check.js
+const CHECK_INTERVAL_MS = 864e5;
+const checkSchema = object({
+	checkedAt: number$1(),
+	latest: string().optional(),
+	/** The highest release the CLI's server named, which started a check sooner. */
+	named: string().optional(),
+	error: string().optional()
+});
+const CHECK_SCRIPT = `
+const { spawnSync } = require("node:child_process");
+const { mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync } = require("node:fs");
+const { tmpdir } = require("node:os");
+const { join } = require("node:path");
+const [file, checkedAt, previous, npm, ...args] = process.argv.slice(1);
+const windows = process.platform === "win32";
+const cache = mkdtempSync(join(tmpdir(), "release-check-"));
+const namedNow = () => {
+  try {
+    return JSON.parse(readFileSync(file, "utf8")).named;
+  } catch {
+    return undefined;
+  }
+};
+const write = (check) => {
+  const temp = file + "." + process.pid + ".tmp";
+  const named = namedNow();
+  writeFileSync(temp, JSON.stringify({ checkedAt: Number(checkedAt), named, ...check }));
+  renameSync(temp, file);
+};
+const latestOf = (stdout) => {
+  try {
+    const parsed = JSON.parse(stdout);
+    const latest = Array.isArray(parsed) ? parsed.at(-1) : parsed;
+    return typeof latest === "string" && /^\\d+\\.\\d+\\.\\d+/.test(latest) ? latest : undefined;
+  } catch {
+    return undefined;
+  }
+};
+// cmd.exe resolves %~dp0 against the working directory for a quoted batch name found on PATH, so
+// only a full path, which may hold a space, is quoted.
+const command = windows && /[\\\\/]/.test(npm) ? '"' + npm + '"' : npm;
+try {
+  const answer = spawnSync(command, args, {
+    encoding: "utf8",
+    shell: windows,
+    windowsHide: true,
+    env: { ...process.env, npm_config_cache: join(cache, "cache"), npm_config_logs_max: "0" },
+  });
+  const latest = answer.status === 0 ? latestOf(answer.stdout) : undefined;
+  if (latest !== undefined) {
+    write({ latest });
+  } else {
+    const said = (answer.stderr || "").trim().split(/\\r?\\n/).slice(0, 5).join("; ");
+    const error = answer.error ? answer.error.message : said || "npm answered " + answer.stdout.trim();
+    write({ latest: previous || undefined, error });
+  }
+} finally {
+  rmSync(cache, { recursive: true, force: true });
+}
+`;
+function isOff(cliName, env) {
+	return Boolean(env[cliVariable(cliName, "NO_RELEASE_CHECK")] || env.CI);
+}
+function cacheFileOf(cliName, env) {
+	const cache = env.XDG_CACHE_HOME || join(env.HOME || env.USERPROFILE || homedir(), ".cache");
+	return join(cache, cliName, "release-check.json");
+}
+function parsedCheck(text) {
+	try {
+		return checkSchema.safeParse(JSON.parse(text)).data;
+	} catch {
+		return;
+	}
+}
+async function lastCheck(files, file) {
+	const text = await readIfAny(files, file);
+	return text === void 0 ? void 0 : parsedCheck(text);
+}
+async function startCheck(cli, install, file, last, named, launch, ctx) {
+	const checkedAt = ctx.clock.now();
+	const previous = last?.latest ?? "";
+	await ctx.files.write(file, JSON.stringify({
+		checkedAt,
+		latest: last?.latest,
+		named
+	}));
+	const npm = globalNpm(cli, install, ctx, launch);
+	const { path, env } = await npmOf(npm);
+	await ctx.spawnDetached(process.execPath, [
+		"-e",
+		CHECK_SCRIPT,
+		file,
+		String(checkedAt),
+		previous,
+		path,
+		...latestViewArgs(npm.registry)
+	], { env });
+}
+function debugLine(cli, ctx, text) {
+	if (isDebug({
+		env: ctx.env,
+		cliName: cli.name
+	})) ctx.progress(`release check failed: ${text}`);
+}
+const NO_RELEASE_CHECK = {
+	notice: async () => {},
+	latestRelease: async () => {}
+};
+function isHigher(version, than) {
+	return than === void 0 || !isVersion(than) || compareVersions(version, than) > 0;
+}
+/**
+* Tells the caller of a newer release that an earlier Release check found, and starts the next
+* check once the last is a day old, or sooner when the CLI's server names a release higher than
+* any it named before (ADR 0019).
+*/
+function releaseCheck(cli, install, runAs, launch) {
+	const guarded = async (ctx, work) => {
+		if (launch.builtIn || launch.bin === void 0 || cli.commands === void 0) return;
+		if (isOff(cli.name, ctx.env)) return;
+		try {
+			await work();
+		} catch (error) {
+			if (errnoOf(error) === void 0 && !(error instanceof CliError)) throw error;
+			debugLine(cli, ctx, messageOf(error));
+		}
+	};
+	let startedInRun = false;
+	let naming = Promise.resolve();
+	const named = async (version, ctx) => {
+		if (!isVersion(version) || !isHigher(version, cli.version)) return;
+		const file = cacheFileOf(cli.name, ctx.env);
+		const last = await lastCheck(ctx.files, file);
+		if (!isHigher(version, last?.named)) return;
+		if (startedInRun) {
+			await ctx.files.write(file, JSON.stringify({
+				...last,
+				named: version
+			}));
+			return;
+		}
+		await startCheck(cli, install, file, last, version, launch, ctx);
+		startedInRun = true;
+	};
+	return {
+		notice: (ctx) => guarded(ctx, async () => {
+			startedInRun = await checkAndTell(cli, install, runAs, launch, ctx);
+		}),
+		latestRelease: (version, ctx) => {
+			naming = naming.then(() => guarded(ctx, () => named(version, ctx)));
+			return naming;
+		}
+	};
+}
+/** Whether it started a check. */
+async function checkAndTell(cli, install, runAs, launch, ctx) {
+	const file = cacheFileOf(cli.name, ctx.env);
+	const last = await lastCheck(ctx.files, file);
+	if (last?.error !== void 0) debugLine(cli, ctx, last.error);
+	const due = last === void 0 || ctx.clock.now() - last.checkedAt >= CHECK_INTERVAL_MS;
+	if (due) await startCheck(cli, install, file, last, last?.named, launch, ctx);
+	tell(cli, runAs, last, ctx);
+	return due;
+}
+function tell(cli, runAs, last, ctx) {
+	const latest = last?.latest;
+	if (latest === void 0 || !isVersion(latest) || compareVersions(latest, cli.version) <= 0) return;
+	ctx.notice(`${cli.name} ${latest} is out, this is ${cli.version}; run \`${runAs} update\``);
+}
+//#endregion
+//#region ../agent-cli/dist/built-ins/install/run-as.js
+/** The Run-as: the bare name, or `npx -q --no-install <bin>` for a Dependency install (ADR 0011). */
+function runAsOf({ name, install }) {
+	return install?.mode === "dependency" ? `npx -q --no-install ${name}` : name;
+}
+//#endregion
+//#region ../agent-cli/dist/built-ins/install/dependency.js
+const LINES = {
+	pnpm: {
+		upgrade: (packages) => `pnpm up --latest ${packages.join(" ")}`,
+		add: (packages) => `pnpm add -D ${packages.join(" ")}`,
+		install: "pnpm install"
+	},
+	npm: {
+		upgrade: (packages) => `npm install ${packages.map((name) => `${name}@latest`).join(" ")}`,
+		add: (packages) => `npm install -D ${packages.join(" ")}`,
+		install: "npm install"
+	}
+};
+const packageSchema = object({ version: string() });
+async function manifestListing(files, name, cwd, root) {
+	const dirs = ancestorsOf(cwd);
+	const top = root === void 0 ? dirs.length : dirs.indexOf(root.dir) + 1;
+	for (const dir of dirs.slice(0, top)) {
+		const manifest = await manifestIn(files, dir);
+		if (manifest?.dependencies?.[name] !== void 0 || manifest?.devDependencies?.[name] !== void 0) return join(dir, "package.json");
+	}
+}
+function versionIn(text) {
+	try {
+		return packageSchema.parse(JSON.parse(text)).version;
+	} catch (error) {
+		if (error instanceof SyntaxError || error instanceof ZodError) return { reason: messageOf(error) };
+		throw error;
+	}
+}
+async function standingOf(files, install, bin, cwd, root) {
+	if (bin === void 0) return { kind: "source" };
+	for (const projectDir of ancestorsOf(cwd)) {
+		const folder = join(projectDir, "node_modules", install.package);
+		const manifest = join(folder, "package.json");
+		const text = await readIfAny(files, manifest);
+		if (text === void 0) continue;
+		const version = versionIn(text);
+		if (typeof version !== "string") return {
+			kind: "unreadable",
+			manifest,
+			...version
+		};
+		const copy = {
+			projectDir,
+			realDir: await files.realPath(folder) ?? folder,
+			version
+		};
+		if (!copy.realDir.split(sep).includes("node_modules")) return {
+			kind: "linked",
+			copy
+		};
+		const runningFrom = await files.realPath(bin) ?? bin;
+		return isInside(copy.realDir, runningFrom) ? {
+			kind: "installed",
+			copy
+		} : {
+			kind: "other",
+			copy,
+			runningFrom
+		};
+	}
+	const manifest = await manifestListing(files, install.package, cwd, root);
+	return manifest === void 0 ? { kind: "missing" } : {
+		kind: "listed",
+		manifest
+	};
+}
+async function surveyDependency(install, bin, { files, cwd }) {
+	const root = await lockfileRootOf(files, cwd);
+	return {
+		cwd,
+		root,
+		standing: await standingOf(files, install, bin, cwd, root)
+	};
+}
+function packagesOf(install) {
+	return [install.package, ...install.lockstep ?? []];
 }
 function isUnchecked(standing) {
 	return standing.kind === "source" || standing.kind === "linked";
@@ -8264,88 +8993,29 @@ function checkOf$1(cli, install, runAs, launch) {
 		install: async (ctx) => installFinding(cli, runAs, install, await surveyed(ctx)),
 		release: async (ctx) => {
 			const { cwd, root, standing } = await surveyed(ctx);
-			if (isUnchecked(standing)) return { skipped: skippedFor$1(cli, install, standing) };
-			return {
-				npm: npmContext(cli, registryOf(install, root?.dir), ctx, launch, root?.dir ?? cwd),
-				advise: (latest) => adviceFor(install, root, latest)
-			};
-		}
-	};
-}
-/** The Install of a CLI each project pins as a dependency, run through npx (ADR 0011). */
-function dependencyInstall(cli, install) {
-	const runAs = runAsOf(cli);
-	return {
-		runAs,
-		builtIns: () => ({}),
-		check: (launch) => checkOf$1(cli, install, runAs, launch),
-		notice: async () => {}
-	};
-}
-//#endregion
-//#region ../agent-cli/dist/built-ins/install/global-npm.js
-/** Where npm puts global packages under its global prefix. */
-function globalModulesDir(prefix, platform) {
-	return platform === "win32" ? join(prefix, "node_modules") : join(prefix, "lib", "node_modules");
-}
-/** Whether `path` itself is a symlink, which a link in a folder above it does not make it. */
-async function isLink(files, path) {
-	const real = await files.realPath(path);
-	if (real === void 0) return false;
-	const folder = await files.realPath(dirname(path));
-	return folder === void 0 || real !== join(folder, basename(path));
-}
-function notGlobal(ctx, message) {
-	return runtimeError({
-		code: NOT_GLOBAL_INSTALL,
-		message,
-		hint: "install it by running the Next step, so its update Command can replace it",
-		next: [wholeLine(setupCommandLine(ctx.registry))]
-	});
-}
-/**
-* The global npm install this copy runs from, found by asking npm for its global prefix.
-* `bin` is the script that started the CLI; throws `NOT_GLOBAL_INSTALL` when it is not inside that install.
-*/
-async function globalInstallOf(bin, ctx) {
-	if (bin === void 0) throw notGlobal(ctx, `${ctx.cliName} runs from source, not from an npm install`);
-	const prefix = await globalPrefix(ctx);
-	const packageDir = join(globalModulesDir(prefix, ctx.platform), ctx.registry.package);
-	const installed = await ctx.files.realPath(packageDir);
-	const here = await ctx.files.realPath(bin) ?? bin;
-	if (installed === void 0 || !isInside(installed, here)) throw notGlobal(ctx, `${ctx.cliName} runs from ${here}, not from npm's global install at ${packageDir}`);
-	if (await isLink(ctx.files, packageDir)) throw notGlobal(ctx, `${ctx.cliName} runs from a link to ${installed} (npm link), not from an npm install`);
-	return {
-		prefix,
-		packageDir
-	};
-}
-const NPMJS = "https://registry.npmjs.org/";
-/** The flag that points npm at the CLI's registry; none for npmjs, npm's default. */
-function registryFlags({ package: name, registry }) {
-	if (registry === NPMJS) return [];
-	const scope = scopeOf(name);
-	return [scope === void 0 ? `--registry=${registry}` : `--${scope}:registry=${registry}`];
-}
-/** The line that sets a Global install up, run before the CLI is on the machine. */
-function setupLineOf(install) {
-	return setupCommandLine(globalRegistry(install));
+			if (isUnchecked(standing)) return { skipped: skippedFor$1(cli, install, standing) };
+			return {
+				npm: npmContext(cli, registryOf(install, root?.dir), ctx, launch, root?.dir ?? cwd),
+				advise: (latest) => adviceFor(install, root, latest)
+			};
+		}
+	};
 }
-function globalRegistry(install) {
-	const { package: name, registry } = install;
+/** The Install of a CLI each project pins as a dependency, run through npx (ADR 0011). */
+function dependencyInstall(cli, install) {
+	const runAs = runAsOf(cli);
 	return {
-		package: name,
-		label: registry,
-		flags: registryFlags(install),
-		unreachableHint: "check the network or VPN",
-		loginHint: `log in to ${registry} (\`npm login --registry=${registry}\`) or set its token in ~/.npmrc`,
-		missingHint: `check that ${name} is published on ${registry}`
+		runAs,
+		builtIns: () => ({}),
+		check: (launch) => checkOf$1(cli, install, runAs, launch),
+		releaseCheck: () => NO_RELEASE_CHECK,
+		updateLine: async ({ files, cwd }) => {
+			const root = await lockfileRootOf(files, cwd);
+			const lines = root === void 0 ? void 0 : LINES[root.manager];
+			return lines === void 0 ? void 0 : wholeLine(lines.upgrade(packagesOf(install)));
+		}
 	};
 }
-/** npm for a Global install, run in the working directory. */
-function globalNpm(cli, install, ctx, launch) {
-	return npmContext(cli, globalRegistry(install), ctx, launch, ctx.cwd);
-}
 //#endregion
 //#region ../agent-cli/dist/built-ins/skill/sync.js
 async function walk$1(files, dir, inner) {
@@ -8826,121 +9496,6 @@ function updateCommand(cli, install, launch) {
 	});
 }
 //#endregion
-//#region ../agent-cli/dist/built-ins/install/release-check.js
-const CHECK_INTERVAL_MS = 864e5;
-const checkSchema = object({
-	checkedAt: number(),
-	latest: string().optional(),
-	error: string().optional()
-});
-const CHECK_SCRIPT = `
-const { spawnSync } = require("node:child_process");
-const { mkdtempSync, renameSync, rmSync, writeFileSync } = require("node:fs");
-const { tmpdir } = require("node:os");
-const { join } = require("node:path");
-const [file, checkedAt, previous, npm, ...args] = process.argv.slice(1);
-const windows = process.platform === "win32";
-const cache = mkdtempSync(join(tmpdir(), "release-check-"));
-const write = (check) => {
-  const temp = file + "." + process.pid + ".tmp";
-  writeFileSync(temp, JSON.stringify({ checkedAt: Number(checkedAt), ...check }));
-  renameSync(temp, file);
-};
-const latestOf = (stdout) => {
-  try {
-    const parsed = JSON.parse(stdout);
-    const latest = Array.isArray(parsed) ? parsed.at(-1) : parsed;
-    return typeof latest === "string" && /^\\d+\\.\\d+\\.\\d+/.test(latest) ? latest : undefined;
-  } catch {
-    return undefined;
-  }
-};
-try {
-  const answer = spawnSync(windows ? '"' + npm + '"' : npm, args, {
-    encoding: "utf8",
-    shell: windows,
-    windowsHide: true,
-    env: { ...process.env, npm_config_cache: join(cache, "cache"), npm_config_logs_max: "0" },
-  });
-  const latest = answer.status === 0 ? latestOf(answer.stdout) : undefined;
-  if (latest !== undefined) {
-    write({ latest });
-  } else {
-    const said = (answer.stderr || "").trim().split(/\\r?\\n/).slice(0, 5).join("; ");
-    const error = answer.error ? answer.error.message : said || "npm answered " + answer.stdout.trim();
-    write({ latest: previous || undefined, error });
-  }
-} finally {
-  rmSync(cache, { recursive: true, force: true });
-}
-`;
-function isOff(cliName, env) {
-	return Boolean(env[cliVariable(cliName, "NO_RELEASE_CHECK")] || env.CI);
-}
-function cacheFileOf(cliName, env) {
-	const cache = env.XDG_CACHE_HOME || join(env.HOME || env.USERPROFILE || homedir(), ".cache");
-	return join(cache, cliName, "release-check.json");
-}
-function parsedCheck(text) {
-	try {
-		return checkSchema.safeParse(JSON.parse(text)).data;
-	} catch {
-		return;
-	}
-}
-async function lastCheck(files, file) {
-	const text = await readIfAny(files, file);
-	return text === void 0 ? void 0 : parsedCheck(text);
-}
-async function startCheck(cli, install, file, last, launch, ctx) {
-	const checkedAt = ctx.clock.now();
-	const previous = last?.latest ?? "";
-	await ctx.files.write(file, JSON.stringify({
-		checkedAt,
-		latest: last?.latest
-	}));
-	const npm = globalNpm(cli, install, ctx, launch);
-	const { path, env } = await npmOf(npm);
-	await ctx.spawnDetached(process.execPath, [
-		"-e",
-		CHECK_SCRIPT,
-		file,
-		String(checkedAt),
-		previous,
-		path,
-		...latestViewArgs(npm.registry)
-	], { env });
-}
-function debugLine(cli, ctx, text) {
-	if (isDebug({
-		env: ctx.env,
-		cliName: cli.name
-	})) ctx.progress(`release check failed: ${text}`);
-}
-/**
-* Tells the caller of a newer release that an earlier Release check found, and starts the next
-* check once the last is a day old.
-*/
-async function releaseCheck(cli, install, runAs, launch, ctx) {
-	if (launch.builtIn || launch.bin === void 0 || cli.commands === void 0) return;
-	if (isOff(cli.name, ctx.env)) return;
-	try {
-		await checkAndTell(cli, install, runAs, launch, ctx);
-	} catch (error) {
-		if (errnoOf(error) === void 0 && !(error instanceof CliError)) throw error;
-		debugLine(cli, ctx, messageOf(error));
-	}
-}
-async function checkAndTell(cli, install, runAs, launch, ctx) {
-	const file = cacheFileOf(cli.name, ctx.env);
-	const last = await lastCheck(ctx.files, file);
-	if (last?.error !== void 0) debugLine(cli, ctx, last.error);
-	if (last === void 0 || ctx.clock.now() - last.checkedAt >= CHECK_INTERVAL_MS) await startCheck(cli, install, file, last, launch, ctx);
-	const latest = last?.latest;
-	if (latest === void 0 || !isVersion(latest) || compareVersions(latest, cli.version) <= 0) return;
-	ctx.notice(`${cli.name} ${latest} is out, this is ${cli.version}; run \`${runAs} update\``);
-}
-//#endregion
 //#region ../agent-cli/dist/built-ins/install/global.js
 function checkOf(cli, install, launch) {
 	return {
@@ -8978,13 +9533,13 @@ function globalInstall(cli, install) {
 			update: updateCommand(cli, install, launch)
 		}),
 		check: (launch) => checkOf(cli, install, launch),
-		notice: (launch, ctx) => releaseCheck(cli, install, adapter.runAs, launch, ctx)
+		releaseCheck: (launch) => releaseCheck(cli, install, adapter.runAs, launch),
+		updateLine: async () => ["update"]
 	};
 	return adapter;
 }
 //#endregion
 //#region ../agent-cli/dist/built-ins/install/install.js
-const noNotice = async () => {};
 function noInstall(cli) {
 	const skipped = async () => ({
 		state: "skipped",
@@ -8997,7 +9552,8 @@ function noInstall(cli) {
 			install: skipped,
 			release: async () => ({ skipped: await skipped() })
 		}),
-		notice: noNotice
+		releaseCheck: () => NO_RELEASE_CHECK,
+		updateLine: async () => void 0
 	};
 }
 function installOf(cli) {
@@ -9114,7 +9670,7 @@ const SECTION_VERBS = {
 	add: "add the Agents section to",
 	rewrite: "rewrite the Agents section in"
 };
-function renderPlan(cli, plan) {
+function renderPlan$1(cli, plan) {
 	const files = [
 		...plan.write.map((file) => `  write ${file}`),
 		...plan.replace.map((file) => `  replace ${file}`),
@@ -9168,7 +9724,7 @@ function skillInstallCommand(cli, folder, agents) {
 			};
 		},
 		render: (data) => renderInstalled(cli, data),
-		renderPlan: (plan) => renderPlan(cli, plan)
+		renderPlan: (plan) => renderPlan$1(cli, plan)
 	});
 }
 //#endregion
@@ -9368,6 +9924,7 @@ function doctorChecks(cli, launch, scope) {
 			...cli.doctor ?? [],
 			...tools,
 			...secretRows(cli.secrets ?? [], cli.commands),
+			...loginRows(cli.logins ?? {}, scope.runAs),
 			installRow(check),
 			registryRow(cli, check),
 			...skillOf(cli, install).rows
@@ -9378,7 +9935,6 @@ function doctorChecks(cli, launch, scope) {
 //#endregion
 //#region ../agent-cli/dist/built-ins/doctor.js
 const DEFAULT_DEADLINE_MS = 1e4;
-const MS_PER_SECOND = 1e3;
 const MIN_LABEL_WIDTH = 8;
 const reportSchema = object({
 	rows: array(object({
@@ -9397,7 +9953,7 @@ const reportSchema = object({
 function problemOf(check, error, { signal, deadline, ms, runAs }) {
 	if (!signal.aborted && deadline.aborted && error === deadline.reason) return {
 		state: "problem",
-		message: `${check.name} did not answer within ${ms / MS_PER_SECOND} s`
+		message: `${check.name} did not answer within ${ms / MS_PER_S} s`
 	};
 	return problemOfError(check.name, error, runAs);
 }
@@ -9532,17 +10088,342 @@ function doctorCommand(cli, launch) {
 	};
 }
 //#endregion
+//#region ../agent-cli/dist/login/device-flow.js
+const DEVICE_CODE_GRANT = "urn:ietf:params:oauth:grant-type:device_code";
+/** RFC 8628 §3.2: the interval when the server gives none. */
+const DEFAULT_INTERVAL_S = 5;
+/** RFC 8628 §3.5: what each `slow_down` adds to the interval. */
+const SLOW_DOWN_S = 5;
+const deviceSchema = object({
+	device_code: string(),
+	user_code: string(),
+	verification_uri: string(),
+	verification_uri_complete: string().optional(),
+	expires_in: number$1(),
+	interval: number$1().optional()
+});
+async function startApproval(login, { fetch, clock }) {
+	const form = {
+		client_id: login.clientId,
+		...login.scope === void 0 ? {} : { scope: login.scope }
+	};
+	const device = parsedAnswer(deviceSchema, await postForm(fetch, login.deviceEndpoint, form), login.deviceEndpoint);
+	return {
+		deviceCode: device.device_code,
+		userCode: device.user_code,
+		verificationUri: device.verification_uri,
+		...device.verification_uri_complete === void 0 ? {} : { verificationUriComplete: device.verification_uri_complete },
+		expiresAt: isoAfter(clock, device.expires_in),
+		interval: device.interval ?? DEFAULT_INTERVAL_S
+	};
+}
+async function pollApproval(asking, login, { approval, takenUp }, scope, signal) {
+	const form = {
+		grant_type: DEVICE_CODE_GRANT,
+		device_code: approval.deviceCode,
+		client_id: login.clientId
+	};
+	let intervalS = approval.interval;
+	for (let first = true;; first = false) {
+		if (!(first && takenUp)) await scope.clock.sleep(intervalS * MS_PER_S, signal);
+		const body = await postForm(scope.fetch, login.tokenEndpoint, form);
+		const granted = tokenSchema.safeParse(body);
+		if (granted.success) return storedLoginOf(granted.data, scope.clock);
+		const { error } = parsedAnswer(errorSchema, body, login.tokenEndpoint);
+		if (error === "slow_down") intervalS += SLOW_DOWN_S;
+		else if (error !== "authorization_pending") throw refusal(asking, login, error);
+	}
+}
+/** The error a token endpoint's answer other than pending or slow down ends the polling with. */
+function refusal(asking, login, error) {
+	if (error === "access_denied") return asking.denied();
+	if (error === "expired_token" || error === "invalid_grant") return asking.expired();
+	return /* @__PURE__ */ new Error(`${login.tokenEndpoint} refused the device code with ${error}`);
+}
+function endsApproval(error) {
+	return error instanceof CliError && (error.code === "APPROVAL_DENIED" || error.code === "APPROVAL_EXPIRED");
+}
+/** Takes up the pending Approval, or asks for one and keeps it as a User file, and prints its code. */
+async function askedApproval(login, file, scope) {
+	const pending = await readUnexpired(file, scope.clock);
+	const approval = pending ?? await startApproval(login, scope);
+	if (pending === void 0) await file.write(approval);
+	scope.progress(`open ${approval.verificationUriComplete ?? approval.verificationUri} and approve code ${approval.userCode}`);
+	return {
+		approval,
+		takenUp: pending !== void 0
+	};
+}
+/** The `APPROVAL_PENDING` of the pending Approval, or of a new one, without polling it. */
+async function pendingApproval(name, login, files, scope, rerun) {
+	const { approval } = await askedApproval(login, files.approval, scope);
+	return approvalPending(loginAsking(name), approval, rerun);
+}
+/**
+* Polls the Approval pending in `file`, or a new one, until the person approves, removing it once
+* refused or expired. An approved one stays until what it granted is kept, so a cut-off run loses nothing.
+*/
+async function approved(asking, login, file, scope, { waitS, rerun }) {
+	const asked = await askedApproval(login, file, scope);
+	const wait = scope.deadline(waitS * MS_PER_S);
+	let granted;
+	try {
+		granted = await pollApproval(asking, login, asked, scope, wait);
+	} catch (error) {
+		if (wait.aborted && !scope.signal.aborted) throw approvalPending(asking, asked.approval, rerun);
+		if (endsApproval(error)) await file.remove();
+		throw error;
+	}
+	return granted;
+}
+/** Polls the pending Approval, or a new one, until the person approves, and stores the Login. */
+async function signIn(name, login, files, scope, wait) {
+	const stored = await approved(loginAsking(name), login, files.approval, scope, wait);
+	await files.stored.write(stored);
+	await files.approval.remove();
+	return stored;
+}
+/** Polls the Approval of the Grant's scope, or a new one, until the person approves: its token. */
+async function grant(asking, login, file, scope, wait) {
+	const { accessToken } = await approved(asking, login, file, scope, wait);
+	await file.remove();
+	return accessToken;
+}
+//#endregion
+//#region ../agent-cli/dist/built-ins/login-name.js
+/** The Login a `login` or `logout` run names, or the only one; with several, the name is needed. */
+function chosenName(run, given, names) {
+	const [only, ...others] = names;
+	if (given !== void 0) return given;
+	if (others.length === 0) return only;
+	throw new CliError({
+		code: INVALID_INPUT,
+		message: `\`${run.cliName} ${run.command}\` needs the name of a Login: ${names.join(", ")}`,
+		hint: "run the Next step for the Login the task needs",
+		next: names.map((name) => [run.command, name])
+	});
+}
+/** The optional `name` arg of `login` and `logout`; `purpose` reads as "the Login to <purpose>". */
+function nameArgs(names, purpose) {
+	return object({ name: _enum(names).optional().describe(`the Login to ${purpose}, of ${names.join(", ")}; needed only with several`) });
+}
+/** The name an example passes: none with one Login, the first with several. */
+function exampleName(names) {
+	return names.length === 1 ? [] : [names[0]];
+}
+//#endregion
+//#region ../agent-cli/dist/built-ins/logout.js
+const logoutSchema = object({
+	login: string(),
+	stored: _enum([
+		"revoked",
+		"removed",
+		"none"
+	]),
+	/** The Secret still set for this Login, which logout never touches. */
+	secret: string().optional()
+});
+function renderLogout({ login, stored, secret }) {
+	const head = stored === "none" ? `not signed in to ${login}: nothing to do` : `signed out of ${login}${stored === "revoked" ? ", and the server revoked its token" : ""}`;
+	return secret === void 0 ? head : `${head}; ${login} still uses the token in ${secret}`;
+}
+function renderPlan({ login, stored, revokeEndpoint, secret }) {
+	if (!stored) return renderLogout({
+		login,
+		stored: "none",
+		...secret === void 0 ? {} : { secret }
+	});
+	return `would sign out of ${login}${revokeEndpoint === void 0 ? "" : `, revoking its token at ${revokeEndpoint}`}`;
+}
+/**
+* RFC 7009 §2.1: revoking the refresh token ends the grant, so the server should drop its access
+* tokens too; a Login without one revokes its access token.
+*/
+async function revoke(endpoint, { clientId }, { accessToken, refreshToken }, ctx) {
+	const [token, hint] = refreshToken === void 0 ? [accessToken, "access_token"] : [refreshToken, "refresh_token"];
+	const response = await ctx.fetch(endpoint, {
+		method: "POST",
+		once: false,
+		body: new URLSearchParams({
+			token,
+			token_type_hint: hint,
+			client_id: clientId
+		})
+	});
+	if (!response.ok) throw new Error(`${endpoint} answered ${response.status} to the revocation of a token`);
+}
+/** The Built-in `logout`: revokes and removes the stored Login, never touching its Secret. */
+function logoutCommand(cli, logins, names) {
+	const named = exampleName(names);
+	return defineCommand$1.write({
+		description: "sign out: revoke the stored Login and remove it",
+		help: "Revokes the stored Login at the server when it has a revoke endpoint, then removes it for this user. A Secret set for the Login stays set, so the Commands keep using it. It does nothing when no Login is stored.",
+		examples: [{
+			command: [
+				cli.name,
+				"logout",
+				...named
+			].join(" "),
+			note: "sign out"
+		}],
+		args: nameArgs(names, "sign out of"),
+		output: logoutSchema,
+		plan: async ({ name: given }, ctx) => {
+			const name = chosenName({
+				cliName: cli.name,
+				command: "logout"
+			}, given, names);
+			const login = declaredLogin(logins, name, ctx.env);
+			return {
+				login: name,
+				stored: await loginFilesOf(ctx.userFile, login).stored.read() !== void 0,
+				revokeEndpoint: login.revokeEndpoint,
+				secret: setSecretOf(login, tokenScopeOf(ctx).secret)?.name
+			};
+		},
+		apply: async ({ login: name, secret }, ctx) => {
+			const login = declaredLogin(logins, name, ctx.env);
+			const file = loginFilesOf(ctx.userFile, login).stored;
+			const stored = await file.read();
+			const kept = secret === void 0 ? {} : { secret };
+			if (stored === void 0) return {
+				login: name,
+				stored: "none",
+				...kept
+			};
+			if (login.revokeEndpoint !== void 0) await revoke(login.revokeEndpoint, login, stored, ctx);
+			await file.remove();
+			return {
+				login: name,
+				stored: login.revokeEndpoint === void 0 ? "removed" : "revoked",
+				...kept
+			};
+		},
+		render: renderLogout,
+		renderPlan
+	});
+}
+//#endregion
+//#region ../agent-cli/dist/built-ins/login.js
+const loginSchema = object({
+	login: string(),
+	source: _enum([
+		"approved",
+		"stored",
+		"secret"
+	]),
+	secret: string().optional()
+});
+function renderLogin({ login, source, secret }) {
+	if (source === "approved") return `signed in to ${login}`;
+	if (source === "stored") return `already signed in to ${login}: nothing to do`;
+	return `${login} uses the token in ${secret}: nothing to do`;
+}
+function foundData(login, { source }) {
+	return source.kind === "secret" ? {
+		login,
+		source: "secret",
+		secret: source.name
+	} : {
+		login,
+		source: "stored"
+	};
+}
+function loginCommand(cli, logins, names) {
+	const named = exampleName(names);
+	return defineCommand$1.write({
+		description: "sign in through a browser, so the Commands that need a Login can run",
+		help: "Prints a link and a code for the person who runs this CLI to approve, then waits for the approval and keeps the Login for this user. A rerun takes up the same code. It does nothing when its Secret is set or the stored Login's access token has not expired, and refreshes one that has.",
+		examples: [{
+			command: [
+				cli.name,
+				"login",
+				...named
+			].join(" "),
+			note: `sign in, waiting at most 100 s for the code to be approved`
+		}, {
+			command: [
+				cli.name,
+				"login",
+				...named,
+				WAIT_FLAG.flag,
+				"30"
+			].join(" "),
+			note: "wait at most 30 s for the approval"
+		}],
+		args: nameArgs(names, "sign in to"),
+		options: object({ wait: number$1().int().nonnegative().optional().describe(`${WAIT_FLAG.description}; 100 when absent`) }),
+		output: loginSchema,
+		plan: async ({ name: given, wait }, ctx) => {
+			const name = chosenName({
+				cliName: cli.name,
+				command: "login"
+			}, given, names);
+			const login = declaredLogin(logins, name, ctx.env);
+			const token = await currentTokenOf(login, tokenScopeOf(ctx));
+			const stored = await readStored(loginFilesOf(ctx.userFile, login).stored, ctx.clock);
+			return {
+				login: name,
+				wait,
+				found: token && foundData(name, token),
+				renew: stored?.refreshToken !== void 0
+			};
+		},
+		apply: async ({ login: name, wait, found }, ctx) => {
+			if (found !== void 0) return found;
+			const login = declaredLogin(logins, name, ctx.env);
+			const files = loginFilesOf(ctx.userFile, login);
+			const stored = await readStored(files.stored, ctx.clock);
+			if (stored?.refreshToken !== void 0 && await refreshed(name, login, files.stored, stored.refreshToken, ctx) !== void 0) return {
+				login: name,
+				source: "stored"
+			};
+			await signIn(name, login, files, ctx, {
+				waitS: wait ?? 100,
+				rerun: [
+					"login",
+					name,
+					WAIT_FLAG.flag,
+					String(100)
+				]
+			});
+			return {
+				login: name,
+				source: "approved"
+			};
+		},
+		render: renderLogin,
+		renderPlan: ({ login, found, renew }) => {
+			if (found !== void 0) return renderLogin(found);
+			return renew ? `would refresh the Login ${login}, or sign in through a browser if the server refuses` : `would sign in to ${login} through a browser`;
+		}
+	});
+}
+/** The Built-in `login` and `logout`, for a CLI that declares a Login. */
+function loginBuiltIns(cli) {
+	const logins = cli.logins ?? {};
+	const [first, ...rest] = Object.keys(logins);
+	if (first === void 0) return {};
+	const names = [first, ...rest];
+	return {
+		login: loginCommand(cli, logins, names),
+		logout: logoutCommand(cli, logins, names)
+	};
+}
+//#endregion
 //#region ../agent-cli/dist/built-ins/commands.js
 /**
 * The Commands the Runtime adds to a multi-Command CLI: `setup` and `update` only for a Global
-* install, and `skill install` only for a skill whose copy goes under the project.
+* install, `skill install` only for a skill whose copy goes under the project, and `login` only
+* for a CLI that declares a Login.
 */
 function builtInCommands(cli, launch) {
 	const install = installOf(cli);
 	return {
 		doctor: doctorCommand(cli, launch),
 		...install.builtIns(launch),
-		...skillOf(cli, install).builtIns
+		...skillOf(cli, install).builtIns,
+		...loginBuiltIns(cli)
 	};
 }
 //#endregion
@@ -9556,15 +10437,18 @@ function commandLabel(path, cliName) {
 	return path.length === 0 ? [cliName] : path;
 }
 function declaredOf(command) {
+	const wait = takesWait(command);
 	if (!hasPlan(command)) return {
 		outputs: false,
 		force: void 0,
-		cost: false
+		cost: false,
+		wait
 	};
 	return {
 		outputs: command.outputs !== void 0,
 		force: command.force,
-		cost: command.cost !== void 0
+		cost: command.cost !== void 0,
+		wait
 	};
 }
 function withRunAs(example, { name, runAs }) {
@@ -9679,11 +10563,11 @@ function checkOwnCodes(errors) {
 	const redeclared = runtimeCodesIn(errors);
 	if (redeclared.length > 0) throw new Error(`The Error table declares ${redeclared.join(", ")}, an error code the Runtime already declares`);
 }
-function checkTree(commands, path, table) {
+function checkTree(commands, path, table, logins) {
 	for (const [key, node] of Object.entries(commands)) {
 		const at = [...path, key];
-		if (isCommand(node)) checkCommand(node, at.join(" "), table);
-		else checkTree(node, at, table);
+		if (isCommand(node)) checkCommand(node, at.join(" "), table, logins);
+		else checkTree(node, at, table, logins);
 	}
 }
 function checkSkill({ name, skill, install }) {
@@ -9702,13 +10586,13 @@ function checkDeclared(cli) {
 	const table = errorTableOf(cli);
 	checkDocs(cli);
 	if (cli.commands === void 0) {
-		checkCommand(cli.command, commandLabel([], cli.name).join(" "), table);
+		checkCommand(cli.command, commandLabel([], cli.name).join(" "), table, {});
 		if (cli.skill !== void 0) throw new Error(`${cli.name} declares a skill, which only a CLI with several Commands can install`);
 		return cli;
 	}
 	checkSkill(cli);
 	const { commands } = cli;
-	checkTree(commands, [], table);
+	checkTree(commands, [], table, cli.logins ?? {});
 	for (const row of cli.doctor ?? []) checkErrors(row.errors ?? [], `the ${row.name} row of doctor`, table);
 	const taken = Object.keys(builtInCommands(cli, {
 		bin: void 0,
@@ -10018,6 +10902,12 @@ async function parseInput(spec, words, invocation, readStdin) {
 	if (only !== void 0 && unknown.length === 1 && otherLines.length === 0) throw unknownOptionError(spec.commandLine, invocation, only.flag, only.suggestion === void 0 ? [] : [only.suggestion]);
 	throw invalidInput(spec.commandLine, invocation, unknown, otherLines);
 }
+function waitOf(given, commandLine) {
+	if (given === void 0) return void 0;
+	const parsed = WAIT_SECONDS.safeParse(given === true ? void 0 : given);
+	if (!parsed.success) throw invalidInputError(commandLine, `option '${WAIT_FLAG.usage}' takes a whole number of seconds, not ${given === true ? "nothing" : JSON.stringify(given)}`);
+	return parsed.data;
+}
 /**
 * The validated input and Standard flag values of the routed Command, or one usage error; the arg
 * given `-` takes its text from `readStdin`.
@@ -10033,6 +10923,7 @@ async function parseCommand({ spec, words, json }, invocation, readStdin) {
 			confirm: typeof confirm === "string" ? confirm : void 0,
 			yes: values.get(YES_FLAG.flag) === true,
 			force: values.get(FORCE_FLAG.flag) === true,
+			wait: waitOf(values.get(WAIT_FLAG.flag), spec.commandLine),
 			page,
 			fields: spec.list === void 0 ? void 0 : selectedFields(values, spec.list.rowFields, spec.commandLine)
 		}
@@ -10710,6 +11601,28 @@ function rootSpec(cli, launch) {
 	} : groupSpec(names, cli.commands, builtInCommands(cli, launch));
 }
 //#endregion
+//#region ../agent-cli/dist/built-ins/install/release-too-old.js
+function isTooOld(error) {
+	return error instanceof CliError && error.code === "RELEASE_TOO_OLD";
+}
+function mapLeaves(error, map) {
+	if (error instanceof AggregateError && error.errors.length > 0) return new AggregateError(error.errors.map((inner) => mapLeaves(inner, map)), error.message, { cause: error.cause });
+	return map(error);
+}
+/** `error` with the Install's update line leading the Next steps of each `RELEASE_TOO_OLD` in it. */
+async function withUpdateLine(error, install, ctx) {
+	if (!errorsOf(error).some(isTooOld)) return error;
+	const line = await install.updateLine(ctx);
+	if (line === void 0) return error;
+	return mapLeaves(error, (leaf) => isTooOld(leaf) ? runtimeError({
+		code: leaf.code,
+		message: leaf.message,
+		hint: leaf.hint,
+		details: leaf.details,
+		next: [line, ...leaf.next]
+	}, { cause: leaf.cause }) : leaf);
+}
+//#endregion
 //#region ../agent-cli/dist/context/spill.js
 const STDOUT_BUDGET_CHARS = 3e4;
 const SPILL_RETENTION_MS = 6048e5;
@@ -11290,6 +12203,114 @@ function resolveOptions(options) {
 	};
 }
 //#endregion
+//#region ../agent-cli/dist/context/derived.js
+/**
+* `base` with `extra`'s properties over it, built on `base` as its prototype, so a lazy getter of
+* `base` such as `ctx.ports` is not read, as a spread would.
+*/
+function derived(base, extra) {
+	const child = Object.create(base);
+	return Object.assign(child, extra);
+}
+//#endregion
+//#region ../agent-cli/dist/login/with-logins.js
+/** The rerun of an `APPROVAL_PENDING`, which waits for the approval. */
+function approvalRerun(ctx) {
+	return ctx.rerun({
+		remove: [WAIT_FLAG.flag],
+		add: [WAIT_FLAG.flag, String(100)]
+	});
+}
+async function tokensOf(names, logins, ctx, waitS) {
+	const found = await Promise.all(names.map(async (name) => {
+		const login = declaredLogin(logins, name, ctx.env);
+		return {
+			name,
+			token: ctx.dryRun ? await currentTokenOf(login, tokenScopeOf(ctx)) : await freshTokenOf(name, login, ctx)
+		};
+	}));
+	const missing = found.flatMap(({ name, token }) => token === void 0 ? [name] : []);
+	if (missing.length > 0 && ctx.dryRun) throw loginRequired(missing, ctx.rerun());
+	const tokens = /* @__PURE__ */ new Map();
+	for (const { name, token } of found) {
+		if (token !== void 0) {
+			tokens.set(name, token);
+			continue;
+		}
+		const login = declaredLogin(logins, name, ctx.env);
+		const stored = await signIn(name, login, loginFilesOf(ctx.userFile, login), ctx, {
+			waitS,
+			rerun: approvalRerun(ctx)
+		});
+		tokens.set(name, storedToken(stored));
+	}
+	ctx.signal.throwIfAborted();
+	return tokens;
+}
+/** The Login a `LOGIN_REJECTED` names in `details.login`, or the Command's only one. */
+function rejectedName(rejected, tokens) {
+	const { details } = rejected;
+	if (typeof details === "object" && details !== null && "login" in details) return typeof details.login === "string" ? details.login : void 0;
+	const [only, ...rest] = tokens.keys();
+	return rest.length === 0 ? only : void 0;
+}
+/**
+* What a run whose Command threw `error` fails with: a `LOGIN_REJECTED` of a stored Login drops
+* it for a new Approval, one of a Secret's token fails as the operator's to fix.
+*/
+async function afterRejection(error, tokens, logins, ctx) {
+	if (!(error instanceof CliError && error.code === "LOGIN_REJECTED")) return error;
+	const name = rejectedName(error, tokens);
+	const token = name === void 0 ? void 0 : tokens.get(name);
+	if (name === void 0 || token === void 0) return new Error(`the Command threw ${LOGIN_REJECTED} naming no Login it declares in details.login`, { cause: error });
+	const login = declaredLogin(logins, name, ctx.env);
+	if (token.source.kind === "secret" && login.secret !== void 0) return secretRejected(name, login.secret, error);
+	const files = loginFilesOf(ctx.userFile, login);
+	await files.stored.remove();
+	if (ctx.dryRun) return loginRequired([name], ctx.rerun());
+	return await pendingApproval(name, login, files, ctx, approvalRerun(ctx));
+}
+/** `ctx.grant`: polls the Approval of `scope` for at most `waitS` seconds, and keeps no token. */
+function granting(ctx, grants, logins, waitS) {
+	return async (name, { scope }) => {
+		if (!grants.includes(name)) undeclaredGrant(name);
+		if (ctx.dryRun) throw new Error(`ctx.grant("${name}") in a dry run, which asks for nothing: ask in apply`);
+		const login = {
+			...declaredLogin(logins, name, ctx.env),
+			scope
+		};
+		return await grant(grantAsking(name, scope, ctx.rerun({ remove: [WAIT_FLAG.flag] })), login, grantApprovalOf(ctx.userFile, login, scope), ctx, {
+			waitS,
+			rerun: approvalRerun(ctx)
+		});
+	};
+}
+/**
+* Runs `work` with a `ctx` whose `login` gives each named Login's token, signing in first, for at
+* most `waitS` seconds, where one is missing, and whose `grant` asks for a Grant. A
+* `LOGIN_REJECTED` from `work` drops the stored Login.
+*/
+async function withLogins(ctx, { logins: names, grants }, logins, waitS, work) {
+	const tokens = names.length === 0 ? /* @__PURE__ */ new Map() : await tokensOf(names, logins, ctx, waitS ?? 0);
+	const loggedIn = derived(ctx, {
+		login: (name) => tokens.get(name)?.value ?? undeclaredLogin(name),
+		grant: granting(ctx, grants, logins, waitS ?? 0)
+	});
+	try {
+		return await work(loggedIn);
+	} catch (error) {
+		throw await afterRejection(error, tokens, logins, ctx);
+	}
+}
+/** `ctx.grant` of a name the Command does not declare in `grants`, which only a cast reaches. */
+function undeclaredGrant(name) {
+	throw new Error(`ctx.grant("${name}") names a Login the Command does not declare in grants`);
+}
+/** `ctx.login` of a name the Command does not declare, which only a cast reaches. */
+function undeclaredLogin(name) {
+	throw new Error(`ctx.login("${name}") names a Login the Command does not declare`);
+}
+//#endregion
 //#region ../agent-cli/dist/execute.js
 const PLAN_INDENT = "  ";
 function outcomeOf(value, render) {
@@ -11334,17 +12355,22 @@ function dryRunOutcome(command, plan, commandLine) {
 	};
 }
 function serveContextOf(ctx, end) {
-	const serveCtx = Object.create(ctx);
-	return Object.assign(serveCtx, { end });
+	return derived(ctx, { end });
 }
-async function execute(command, input, ctx, { flags, commandLine, started, outputs: runOutputs }) {
-	await checkTools(command.tools ?? [], ctx, ctx.rerun());
-	const { env, envFile, fileError } = ctx;
+async function execute(command, input, unlogged, run) {
+	await checkTools(command.tools ?? [], unlogged, unlogged.rerun());
+	const { env, envFile, fileError } = unlogged;
 	checkSecrets(command.secrets ?? [], {
 		env,
 		envFile,
 		fileError
-	}, ctx.rerun());
+	}, unlogged.rerun());
+	return await withLogins(unlogged, {
+		logins: command.logins ?? [],
+		grants: command.grants ?? []
+	}, run.logins, run.flags.wait, (ctx) => executeLoggedIn(command, input, ctx, run));
+}
+async function executeLoggedIn(command, input, ctx, { flags, commandLine, started, outputs: runOutputs }) {
 	if (command.rows !== void 0) {
 		const { render } = command;
 		return outcomeOf(await command.run({
@@ -11401,6 +12427,66 @@ function manifestAt(packageRoot) {
 	return parsed.success ? parsed.data : NO_MANIFEST;
 }
 //#endregion
+//#region ../agent-cli/dist/context/user-file.js
+const FOLDER_MODE = 448;
+const FILE_MODE = 384;
+/** `$XDG_STATE_HOME/<cli>`, with `~/.local/state` when the variable is unset or empty. */
+function stateFolderOf(cliName, env) {
+	const state = env.XDG_STATE_HOME || join(env.HOME || homedir(), ".local", "state");
+	return join(state, cliName);
+}
+function parsed(bytes, schema) {
+	let json;
+	try {
+		json = JSON.parse(new TextDecoder().decode(bytes));
+	} catch {
+		return;
+	}
+	const result = schema.safeParse(json);
+	return result.success ? result.data : void 0;
+}
+function userFileOf({ folder, files, fileError }) {
+	return (name, schema) => {
+		const path = join(folder, `${name}.json`);
+		return {
+			read: async () => {
+				let bytes;
+				try {
+					bytes = await files.read(path);
+				} catch (error) {
+					if (isMissingFile(error)) return void 0;
+					throw fileError(error, {
+						path,
+						access: "read"
+					});
+				}
+				return parsed(bytes, schema);
+			},
+			write: async (value) => {
+				try {
+					await files.mkdir(dirname(path), { mode: FOLDER_MODE });
+					await files.write(path, `${JSON.stringify(value)}\n`, { mode: FILE_MODE });
+				} catch (error) {
+					throw fileError(error, {
+						path,
+						access: "write"
+					});
+				}
+			},
+			remove: async () => {
+				try {
+					await files.remove(path);
+				} catch (error) {
+					throw fileError(error, {
+						path,
+						access: "write"
+					});
+				}
+			}
+		};
+	};
+}
+//#endregion
 //#region ../agent-cli/dist/run-scope.js
 function selfOf(name, bin) {
 	return bin === void 0 ? [name] : [
@@ -11439,12 +12525,19 @@ function runScopeOf(cli, routed, settings, write, baseInvocation) {
 		env,
 		platform
 	});
-	const outputs = outputsOf(settings.files ?? realFiles(), {
+	const files = settings.files ?? realFiles();
+	const outputs = outputsOf(files, {
 		cwd,
 		fileError
 	});
 	const packageRoot = packageRootOf(settings.bin, cwd);
 	const progress = (message) => write.stderr(progressLine(message, routed.json));
+	const noticed = /* @__PURE__ */ new Set();
+	const notice = (text) => {
+		if (noticed.has(text)) return;
+		noticed.add(text);
+		write.stderr(noticeLine(text, routed.json));
+	};
 	const envFile = envFileOf(cli.name, env);
 	const spawning = {
 		fileError,
@@ -11458,8 +12551,15 @@ function runScopeOf(cli, routed, settings, write, baseInvocation) {
 		platform,
 		outputs,
 		progress,
-		notice: (text) => write.stderr(noticeLine(text, routed.json)),
+		notice,
 		packageRoot,
+		fetch: settings.fetch ?? ((input, init) => globalThis.fetch(input, init)),
+		userAgent: `${cli.name}/${cli.version}`,
+		userFile: userFileOf({
+			folder: stateFolderOf(cli.name, env),
+			files,
+			fileError
+		}),
 		ports: portsOf(cli, settings.ports),
 		portsBase: (signal) => ({
 			cwd,
@@ -11493,7 +12593,7 @@ function runScopeOf(cli, routed, settings, write, baseInvocation) {
 		})
 	};
 }
-function contextOf(scope, control, { command, flags, project, deliver }) {
+function contextOf(scope, control, { command, flags, project, deliver, latestRelease }) {
 	const portsBase = scope.portsBase(control.signal);
 	const ports = once(() => scope.ports(portsBase));
 	const declared = new Map((command.secrets ?? []).map((declaration) => [declaration.name, declaration]));
@@ -11507,8 +12607,18 @@ function contextOf(scope, control, { command, flags, project, deliver }) {
 	return {
 		...portsBase,
 		secret,
+		login: undeclaredLogin,
+		grant: async (name) => undeclaredGrant(name),
+		userFile: scope.userFile,
 		fail: cliErrorOf,
 		deadline: (ms, options) => control.deadline(ms, options),
+		fetch: contextFetch({
+			fetch: scope.fetch,
+			userAgent: scope.userAgent,
+			deadline: (ms, options) => control.deadline(ms, options),
+			clock: scope.clock,
+			rerun: scope.rerun()
+		}),
 		runToEnd: (name, work) => control.runToEnd(name, work),
 		get ports() {
 			return ports();
@@ -11519,7 +12629,8 @@ function contextOf(scope, control, { command, flags, project, deliver }) {
 		rerun: scope.rerun,
 		poll: (check, { intervalMs, signal: stop }) => poll(portsBase.clock, check, intervalMs, stop === void 0 ? control.signal : AbortSignal.any([control.signal, stop])),
 		deliver,
-		notice: scope.notice
+		notice: scope.notice,
+		latestRelease
 	};
 }
 /** `build` runs on the first call; later calls give its value or throw its error again. */
@@ -11644,10 +12755,17 @@ async function runCommand(cli, routed, options, write, baseFormat) {
 		return ran(await failed(error), sideTask);
 	}
 	let delivered;
+	const release = installOf(cli).releaseCheck({
+		builtIn,
+		bin: options.bin,
+		node: options.node,
+		platform
+	});
 	const ctx = contextOf(scope, control, {
 		command,
 		flags,
 		project,
+		latestRelease: (version) => release.latestRelease(version, ctx),
 		deliver: (data) => {
 			delivered = () => dataOutcome(command, data, commandLine);
 		}
@@ -11663,19 +12781,15 @@ async function runCommand(cli, routed, options, write, baseFormat) {
 	let served = false;
 	let settled;
 	try {
-		const outcome = await control.settle(noticesOf(cli, {
-			builtIn,
-			bin: options.bin,
-			node: options.node,
-			platform
-		}, ctx).then(() => execute(command, input, ctx, {
+		const outcome = await control.settle(release.notice(ctx).then(() => execute(command, input, ctx, {
 			flags,
 			commandLine,
 			started: async (outcome) => {
 				write.stdout(await startedOutput(outcome, format, spill));
 				served = true;
 			},
-			outputs
+			outputs,
+			logins: cli.logins ?? {}
 		})));
 		if (served) return ran(STOPPED, sideTask);
 		settled = {
@@ -11686,7 +12800,7 @@ async function runCommand(cli, routed, options, write, baseFormat) {
 		if (served && control.signal.aborted) return ran(STOPPED, sideTask);
 		settled = {
 			ok: false,
-			error,
+			error: await withUpdateLine(error, installOf(cli), ctx),
 			delivered
 		};
 	}
@@ -11695,9 +12809,6 @@ async function runCommand(cli, routed, options, write, baseFormat) {
 		fields: flags.fields
 	}, spill), sideTask);
 }
-async function noticesOf(cli, launch, ctx) {
-	await installOf(cli).notice(launch, ctx);
-}
 //#endregion
 //#region ../agent-cli/dist/style.js
 function colourEnabled(env, stdoutIsTTY) {
@@ -11856,7 +12967,7 @@ async function runProcess(cli) {
 //#region package.json
 var package_default = {
 	name: "@duyquangnvx/create-agent-cli",
-	version: "0.30.1",
+	version: "0.32.0",
 	description: "Creates a new Agent CLI repository wired to @duyquangnvx/agent-cli.",
 	type: "module",
 	engines: { "node": ">=22.12.0" },