@duyquangnvx/create-agent-cli 0.10.1 → 0.11.1

package/CHANGELOG.md

@@ -4,6 +4,22 @@ What changed in each release of `@duyquangnvx/agent-cli` (the Runtime) and `@duy
 
 ## Unreleased
 
+## v0.11.1 (2026-10-22)
+
+### Changed
+
+- The agent-cli skill explains `ctx.secret` and the CLI's `.env`, lists idempotence among what a finished write Command's tests cover (its example `links archive` gains that test), triggers on releasing a CLI and on choosing a Global or a Dependency install, and leaves out Runtime behaviour an author cannot change, such as the stdin stall and how spilled output reads; the `--json` stderr format moves to its testing reference.
+
+## v0.11.0 (2026-10-22)
+
+### Added
+
+- A Dependency install, `install: { mode: "dependency", package, lockstep? }`, for a CLI each project pins as a devDependency. It gets no Built-in `update`, so the CLI may define its own. `doctor`'s `install` row checks that the project's own copy runs, and its `registry` row asks npm at the project root, which reads the project's `.npmrc`, for the latest release, giving `pnpm up --latest …` or `npm install …@latest` with the `lockstep` packages.
+
+### Changed
+
+- `doctor`'s `install` and `registry` rows are `skipped` ("not checked: <cli> declares no install") for a CLI that declares no `install`, instead of an `ok` that checked nothing.
+
 ## v0.10.1 (2026-10-22)
 
 ### Changed

package/dist/bin.js

@@ -3206,7 +3206,7 @@ function registry() {
 	return new $ZodRegistry();
 }
 (_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
-const globalRegistry = globalThis.__zod_globalRegistry;
+const globalRegistry$1 = globalThis.__zod_globalRegistry;
 //#endregion
 //#region ../../node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/core/api.js
 function snapshotChecks(def) {
@@ -3728,7 +3728,7 @@ function initializeContext(params) {
 	if (target === "draft-7") target = "draft-07";
 	return {
 		processors: params.processors ?? {},
-		metadataRegistry: params?.metadata ?? globalRegistry,
+		metadataRegistry: params?.metadata ?? globalRegistry$1,
 		target,
 		unrepresentable: params?.unrepresentable ?? "throw",
 		override: params?.override ?? (() => {}),
@@ -4855,6 +4855,7 @@ const initializer = (inst, issues) => {
 		}
 	});
 };
+const ZodError = /*@__PURE__*/ $constructor("ZodError", initializer);
 const ZodRealError = /*@__PURE__*/ $constructor("ZodError", initializer, void 0, { Parent: Error });
 //#endregion
 //#region ../../node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/classic/parse.js
@@ -4959,13 +4960,13 @@ const ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def) => {
 	},
 	describe(description) {
 		const cl = this.clone();
-		globalRegistry.add(cl, { description });
+		globalRegistry$1.add(cl, { description });
 		return cl;
 	},
 	meta(...args) {
-		if (args.length === 0) return globalRegistry.get(this);
+		if (args.length === 0) return globalRegistry$1.get(this);
 		const cl = this.clone();
-		globalRegistry.add(cl, args[0]);
+		globalRegistry$1.add(cl, args[0]);
 		return cl;
 	},
 	isOptional() {
@@ -5041,7 +5042,7 @@ const ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def) => {
 		return createToJSONSchemaMethod(this, {})(params);
 	},
 	get description() {
-		return globalRegistry.get(this)?.description;
+		return globalRegistry$1.get(this)?.description;
 	},
 	get _def() {
 		return this._zod.def;
@@ -5882,7 +5883,7 @@ function formatRuntimeError(error, format) {
 //#region ../agent-cli/dist/stdin.js
 const STDIN_META = "stdin";
 function isStdinSchema(schema) {
-	return globalRegistry.get(schema)?.[STDIN_META] === true;
+	return globalRegistry$1.get(schema)?.[STDIN_META] === true;
 }
 function endOfInputKeys(platform) {
 	return platform === "win32" ? "Ctrl-Z then Enter" : "Ctrl-D";
@@ -6813,7 +6814,7 @@ function compareVersions(a, b) {
 	return comparePrerelease(left[4], right[4]);
 }
 /** Where `version` stands against `latest`. */
-function standingOf(version, latest) {
+function standingOf$1(version, latest) {
 	const difference = compareVersions(version, latest);
 	if (difference < 0) return "behind";
 	return difference > 0 ? "ahead" : "current";
@@ -6838,10 +6839,11 @@ const REGISTRY_AUTH = "REGISTRY_AUTH";
 const INSTALL_FAILED = "INSTALL_FAILED";
 const NPM_FAILED = "NPM_FAILED";
 const NO_LATEST = "NO_LATEST";
-function npmContext(cli, install, ctx, node) {
+function npmContext(cli, registry, ctx, node, cwd) {
 	return {
 		cliName: cli.name,
-		install,
+		registry,
+		cwd,
 		env: ctx.env,
 		signal: ctx.signal,
 		node
@@ -6862,20 +6864,40 @@ const NETWORK_CODES = /* @__PURE__ */ new Set([
 ]);
 const AUTH_CODES = /* @__PURE__ */ new Set(["E401", "E403"]);
 const NPM_CODE = /^npm (?:error|ERR!) code (\S+)$/m;
+/** The `@scope` of a scoped package name. */
+function scopeOf(name) {
+	return /^(@[^/]+)\//.exec(name)?.[1];
+}
 /** 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 = /^(@[^/]+)\//.exec(name)?.[1];
+	const scope = scopeOf(name);
 	return [scope === void 0 ? `--registry=${registry}` : `--${scope}:registry=${registry}`];
 }
+/** The registry a Global install declares. */
+function globalRegistry(install) {
+	const { package: name, registry } = install;
+	return {
+		package: name,
+		label: registry,
+		flags: registryFlags(install),
+		unreachableHint: "check the network or VPN, then run it again",
+		loginHint: `log in to ${registry} (npm login --registry=${registry}) or set its token in ~/.npmrc, then run it again`,
+		missingHint: `check that ${name} is published on ${registry}`
+	};
+}
+/** npm for a Global install, run where the CLI was started. */
+function globalNpm(cli, install, ctx, node) {
+	return npmContext(cli, globalRegistry(install), ctx, node, process.cwd());
+}
 /** The command a person runs to install the CLI globally from its registry. */
-function installCommandLine(install, version = "latest") {
+function installCommandLine(registry, version = "latest") {
 	return [
 		"npm",
 		"install",
 		"--global",
-		`${install.package}@${version}`,
-		...registryFlags(install)
+		`${registry.package}@${version}`,
+		...registry.flags
 	].join(" ");
 }
 function npmOf(ctx, windows) {
@@ -6900,7 +6922,7 @@ function npmOf(ctx, windows) {
 function spawnNpm(args, ctx, signal) {
 	const npm = npmOf(ctx, process.platform === "win32");
 	return spawnChild(npm.path, args, {
-		cwd: process.cwd(),
+		cwd: ctx.cwd,
 		env: npm.env,
 		signal: signal ?? new AbortController().signal,
 		detached: signal === null
@@ -6911,24 +6933,24 @@ function tail$1(stderr) {
 	return lines === "" ? "" : `\n${lines}`;
 }
 function failureOf(call, answer, ctx) {
-	const { registry, package: name } = ctx.install;
+	const { label: registry, package: name, loginHint, unreachableHint } = ctx.registry;
 	const code = NPM_CODE.exec(answer.stderr)?.[1];
 	const output = tail$1(answer.stderr);
 	if (code !== void 0 && NETWORK_CODES.has(code)) return new CliError({
 		code: REGISTRY_UNREACHABLE,
 		message: `npm could not reach ${registry} (${code})${output}`,
-		hint: "check the network or VPN, then run it again"
+		hint: unreachableHint
 	});
 	if (code !== void 0 && AUTH_CODES.has(code)) return new CliError({
 		code: REGISTRY_AUTH,
 		message: `${registry} refused npm's credentials (${code})${output}`,
-		hint: `log in to ${registry} (npm login --registry=${registry}) or set its token in ~/.npmrc, then run it again`
+		hint: loginHint
 	});
 	if (call === "view" && code === "E404") return noLatest(ctx, `npm found no ${name}@latest on ${registry}: no version of it is published there`);
 	if (call === "install") return new CliError({
 		code: INSTALL_FAILED,
 		message: `npm could not install ${name}${code === void 0 ? "" : ` (${code})`}${output}`,
-		hint: `fix what npm reports, then run it again, or install it yourself: ${installCommandLine(ctx.install)}`
+		hint: `fix what npm reports, then run it again, or install it yourself: ${installCommandLine(ctx.registry)}`
 	});
 	return new CliError({
 		code: NPM_FAILED,
@@ -6940,7 +6962,7 @@ function noLatest(ctx, message) {
 	return new CliError({
 		code: NO_LATEST,
 		message,
-		hint: `check that ${ctx.install.package} is published on ${ctx.install.registry}`
+		hint: ctx.registry.missingHint
 	});
 }
 /**
@@ -6991,18 +7013,18 @@ async function installGlobally(version, ctx) {
 		"--global",
 		"--no-audit",
 		"--no-fund",
-		`${ctx.install.package}@${version}`,
-		...registryFlags(ctx.install)
+		`${ctx.registry.package}@${version}`,
+		...ctx.registry.flags
 	], ctx, null);
 }
 async function latestVersion(ctx) {
-	const { package: name, registry } = ctx.install;
+	const { package: name, label: registry, flags } = ctx.registry;
 	const answer = await runNpm("view", [
 		"view",
 		`${name}@latest`,
 		"version",
 		"--json",
-		...registryFlags(ctx.install)
+		...flags
 	], ctx);
 	const version = versionInViewAnswer(answer);
 	if (version === void 0) throw noLatest(ctx, `npm answered no version for ${name}@latest on ${registry}: ${answer.trim()}`);
@@ -7019,7 +7041,7 @@ function notGlobal(ctx, message) {
 	return new CliError({
 		code: NOT_GLOBAL_INSTALL,
 		message,
-		hint: `install it with npm, so \`${ctx.cliName} update\` can replace it: ${installCommandLine(ctx.install)}`
+		hint: `install it with npm, so \`${ctx.cliName} update\` can replace it: ${installCommandLine(ctx.registry)}`
 	});
 }
 async function realpathOrUndefined(path) {
@@ -7028,6 +7050,7 @@ async function realpathOrUndefined(path) {
 		throw error;
 	});
 }
+/** Whether `path` lies strictly inside `dir`. */
 function isInside(dir, path) {
 	const inner = relative(dir, path);
 	return inner !== "" && !inner.startsWith("..") && !isAbsolute(inner);
@@ -7039,7 +7062,7 @@ function isInside(dir, path) {
 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.install.package);
+	const packageDir = join(globalModulesDir(prefix), ctx.registry.package);
 	const installed = await realpathOrUndefined(packageDir);
 	const here = await realpathOrUndefined(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}`);
@@ -7050,6 +7073,196 @@ async function globalInstallOf(bin, ctx) {
 	};
 }
 //#endregion
+//#region ../agent-cli/dist/built-ins/dependency-install.js
+const MANAGERS = [
+	"pnpm",
+	"npm",
+	"yarn",
+	"bun"
+];
+const LOCKFILES = [
+	["pnpm-lock.yaml", "pnpm"],
+	["package-lock.json", "npm"],
+	["yarn.lock", "yarn"],
+	["bun.lock", "bun"],
+	["bun.lockb", "bun"]
+];
+const LINES = {
+	pnpm: {
+		upgrade: (packages) => `pnpm up --latest ${packages.join(" ")}`,
+		add: (packages) => `pnpm add -D ${packages.join(" ")}`,
+		reinstall: "pnpm install",
+		exec: (cli) => `pnpm exec ${cli}`
+	},
+	npm: {
+		upgrade: (packages) => `npm install ${packages.map((name) => `${name}@latest`).join(" ")}`,
+		add: (packages) => `npm install -D ${packages.join(" ")}`,
+		reinstall: "npm install",
+		exec: (cli) => `npx ${cli}`
+	}
+};
+const manifestSchema$1 = object({ packageManager: string().optional() });
+const packageSchema = object({ version: string() });
+/** `dir` and every folder above it, nearest first. */
+function ancestorsOf(dir) {
+	const parent = dirname(dir);
+	return parent === dir ? [dir] : [dir, ...ancestorsOf(parent)];
+}
+async function exists(path) {
+	try {
+		await stat(path);
+		return true;
+	} catch (error) {
+		if (isMissingFile(error)) return false;
+		throw error;
+	}
+}
+async function declaredManager(dir) {
+	let text;
+	try {
+		text = await readFile(join(dir, "package.json"), "utf8");
+	} catch (error) {
+		if (isMissingFile(error)) return void 0;
+		throw error;
+	}
+	let manifest;
+	try {
+		manifest = JSON.parse(text);
+	} catch {
+		return;
+	}
+	const name = manifestSchema$1.safeParse(manifest).data?.packageManager?.split("@")[0];
+	return MANAGERS.find((manager) => manager === name);
+}
+async function lockfileRootOf(cwd) {
+	for (const dir of ancestorsOf(cwd)) for (const [file, kind] of LOCKFILES) if (await exists(join(dir, file))) return {
+		dir,
+		manager: await declaredManager(dir) ?? kind
+	};
+}
+async function versionIn(manifest) {
+	try {
+		return packageSchema.parse(JSON.parse(await readFile(manifest, "utf8"))).version;
+	} catch (error) {
+		if (error instanceof SyntaxError || error instanceof ZodError) return { reason: messageOf(error) };
+		throw error;
+	}
+}
+async function standingOf(install, bin, cwd) {
+	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");
+		if (!await exists(manifest)) continue;
+		const version = await versionIn(manifest);
+		if (typeof version !== "string") return {
+			kind: "unreadable",
+			manifest,
+			...version
+		};
+		const copy = {
+			projectDir,
+			realDir: await realpath(folder),
+			version
+		};
+		if (!copy.realDir.split(sep).includes("node_modules")) return {
+			kind: "linked",
+			copy
+		};
+		const runningFrom = await realpath(bin).catch((error) => {
+			if (isMissingFile(error)) return bin;
+			throw error;
+		});
+		return isInside(copy.realDir, runningFrom) ? {
+			kind: "installed",
+			copy
+		} : {
+			kind: "other",
+			copy,
+			runningFrom
+		};
+	}
+	return { kind: "missing" };
+}
+async function surveyDependency(install, bin, cwd) {
+	const [root, standing] = await Promise.all([lockfileRootOf(cwd), standingOf(install, bin, cwd)]);
+	return {
+		cwd,
+		root,
+		standing
+	};
+}
+function packagesOf(install) {
+	return [install.package, ...install.lockstep ?? []];
+}
+function isUnchecked(standing) {
+	return standing.kind === "source" || standing.kind === "linked";
+}
+function skippedFor(cli, install, standing) {
+	return {
+		state: "skipped",
+		message: standing.kind === "source" ? `not checked: ${cli.name} runs from source, not from an install` : `not checked: ${install.package} links to ${standing.copy.realDir}, so the workspace decides its version`
+	};
+}
+function problem(message, fix) {
+	return fix === void 0 ? {
+		state: "problem",
+		message
+	} : {
+		state: "problem",
+		message,
+		fix
+	};
+}
+/** The `install` row of a Dependency install. */
+function dependencyInstallFinding(cli, install, { cwd, root, standing }) {
+	const lines = root === void 0 ? void 0 : LINES[root.manager];
+	switch (standing.kind) {
+		case "source":
+		case "linked": return skippedFor(cli, install, standing);
+		case "missing": return problem(`no package at or above ${cwd} depends on ${install.package}`, lines?.add(packagesOf(install)));
+		case "unreadable": return problem(`${standing.manifest} is not a package.json with a version: ${standing.reason}`, lines?.reinstall);
+		case "other": {
+			const { copy, runningFrom } = standing;
+			return problem(`${cli.name} runs from ${runningFrom}, not from this project's ${install.package} ${copy.version} at ${copy.realDir}`, lines?.exec(cli.name));
+		}
+		case "installed": {
+			const { copy } = standing;
+			const where = root === void 0 ? copy.projectDir : `${root.dir} with ${root.manager}`;
+			return {
+				state: "ok",
+				message: `${install.package} ${copy.version}, installed in ${where}`
+			};
+		}
+	}
+}
+function registryOf({ package: name }, root) {
+	const npmrc = root === void 0 ? "the project's .npmrc" : join(root, ".npmrc");
+	const scope = scopeOf(name);
+	return {
+		package: name,
+		label: `the registry npm uses for ${name}`,
+		flags: [],
+		unreachableHint: scope === void 0 ? "check the network or VPN, then run it again" : `check the network or VPN and the ${scope}:registry that ${npmrc} sets, then run it again`,
+		loginHint: `log in to it (npm login${scope === void 0 ? "" : ` --scope=${scope}`}) or set its token in ${npmrc}, then run it again`,
+		missingHint: scope === void 0 ? `check that ${name} is published on the registry ${npmrc} names` : `check that ${name} is published, and that ${npmrc} maps ${scope} to its registry: ${scope}:registry=<url>`
+	};
+}
+function adviceFor(install, root, latest) {
+	const packages = packagesOf(install);
+	const lines = root === void 0 ? void 0 : LINES[root.manager];
+	if (lines !== void 0) return { fix: lines.upgrade(packages) };
+	return { note: `move ${packages.length === 1 ? packages[0] : `${packages.slice(0, -1).join(", ")} and ${packages.at(-1)}`} to ${latest} with ${root?.manager ?? "the project's package manager"}` };
+}
+function dependencyRelease(cli, install, { cwd, root, standing }) {
+	if (isUnchecked(standing)) return { skipped: skippedFor(cli, install, standing) };
+	return {
+		registry: registryOf(install, root?.dir),
+		cwd: root?.dir ?? cwd,
+		advise: (latest) => adviceFor(install, root, latest)
+	};
+}
+//#endregion
 //#region ../agent-cli/dist/built-ins/skills.js
 const SKILL_DIRS = [[".claude", "skills"], [".agents", "skills"]];
 const FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---/;
@@ -7083,7 +7296,7 @@ async function copyAt(path, version) {
 	return {
 		path,
 		version: stated,
-		state: standingOf(stated, version)
+		state: standingOf$1(stated, version)
 	};
 }
 async function skillCopies(cliName, version, { cwd, env }) {
@@ -7123,6 +7336,12 @@ function ok(message) {
 		message
 	};
 }
+function noInstall(cli) {
+	return {
+		state: "skipped",
+		message: `not checked: ${cli.name} declares no install`
+	};
+}
 function buildRow(cli) {
 	return {
 		name: "build",
@@ -7189,41 +7408,75 @@ function projectRow({ file }, read) {
 		}
 	};
 }
-function installRow(cli, { bin, node }) {
+function surveyOnce(bin) {
+	let survey;
+	return (install, cwd) => {
+		survey ??= surveyDependency(install, bin, cwd);
+		return survey;
+	};
+}
+function installRow(cli, { bin, node }, survey) {
 	return {
 		name: "install",
 		advisory: true,
 		run: async (ctx) => {
 			const { install } = cli;
-			if (install === void 0) return ok(`${cli.name} declares no install, so it has no \`update\``);
+			if (install === void 0) return noInstall(cli);
+			if (install.mode === "dependency") return dependencyInstallFinding(cli, install, await survey(install, ctx.cwd));
+			const npm = globalNpm(cli, install, ctx, node);
 			try {
-				return ok(`a global npm install under ${(await globalInstallOf(bin, npmContext(cli, install, ctx, node))).prefix}`);
+				return ok(`a global npm install under ${(await globalInstallOf(bin, npm)).prefix}`);
 			} catch (error) {
 				if (error instanceof CliError && error.code === "NOT_GLOBAL_INSTALL") return {
 					state: "problem",
 					message: error.message,
-					fix: installCommandLine(install)
+					fix: installCommandLine(npm.registry)
 				};
 				throw error;
 			}
 		}
 	};
 }
-function registryRow(cli, node) {
+async function releaseLookupOf(cli, install, ctx, node, survey) {
+	if (install.mode === "global") {
+		const fix = `${cli.name} update`;
+		return {
+			npm: globalNpm(cli, install, ctx, node),
+			advise: () => ({ fix })
+		};
+	}
+	const release = dependencyRelease(cli, install, await survey(install, ctx.cwd));
+	if ("skipped" in release) return release;
+	return {
+		npm: npmContext(cli, release.registry, ctx, node, release.cwd),
+		advise: release.advise
+	};
+}
+function registryRow(cli, { node }, survey) {
 	return {
 		name: "registry",
 		advisory: true,
 		run: async (ctx) => {
 			const { install } = cli;
-			if (install === void 0) return ok(`${cli.name} declares no registry to compare this build with`);
-			const latest = await latestVersion(npmContext(cli, install, ctx, node));
-			const standing = standingOf(cli.version, latest);
-			const head = `${install.registry} has ${latest} as latest: this build`;
-			if (standing === "behind") return {
-				state: "problem",
-				message: `${head} (${cli.version}) is older`,
-				fix: `${cli.name} update`
-			};
+			if (install === void 0) return noInstall(cli);
+			const lookup = await releaseLookupOf(cli, install, ctx, node, survey);
+			if ("skipped" in lookup) return lookup.skipped;
+			const { npm, advise } = lookup;
+			const latest = await latestVersion(npm);
+			const standing = standingOf$1(cli.version, latest);
+			const head = `${npm.registry.label} has ${latest} as latest: this build`;
+			if (standing === "behind") {
+				const message = `${head} (${cli.version}) is older`;
+				const advice = advise(latest);
+				return "fix" in advice ? {
+					state: "problem",
+					message,
+					fix: advice.fix
+				} : {
+					state: "problem",
+					message: `${message}; ${advice.note}`
+				};
+			}
 			return ok(`${head} is ${standing === "current" ? "current" : `newer (${cli.version})`}`);
 		}
 	};
@@ -7254,14 +7507,15 @@ function skillRow(cli) {
 }
 /** Every row `doctor` reports, in order: the fixed rows around the CLI's own and its tools'. */
 function doctorChecks(cli, launch, read) {
+	const survey = surveyOnce(launch.bin);
 	return [
 		buildRow(cli),
 		nodeRow(cli),
 		...cli.project === void 0 ? [] : [projectRow(cli.project, read)],
 		...cli.doctor ?? [],
 		...toolRows(cli.tools ?? [], cli.commands),
-		installRow(cli, launch),
-		registryRow(cli, launch.node),
+		installRow(cli, launch, survey),
+		registryRow(cli, launch, survey),
 		skillRow(cli)
 	];
 }
@@ -7592,7 +7846,7 @@ const updateSchema = object({
 	next: array(string())
 });
 function nothingToInstall({ from, latest }) {
-	return standingOf(from, latest) === "current" ? `already on ${from}, the latest release: nothing to install` : `${from} is newer than the latest release ${latest}: nothing to install`;
+	return standingOf$1(from, latest) === "current" ? `already on ${from}, the latest release: nothing to install` : `${from} is newer than the latest release ${latest}: nothing to install`;
 }
 function renderUpgrade(upgrade) {
 	return "steps" in upgrade ? [`\nupgrade steps for ${upgrade.version}:`, ...upgrade.steps.map((step) => `- ${step}`)].join("\n") : `\nchanges in ${upgrade.version}:\n${upgrade.notes}`;
@@ -7633,7 +7887,7 @@ function updateCommand(cli, install, { bin, node }) {
 		effect: "write",
 		output: updateSchema,
 		plan: async (_input, ctx) => {
-			const npm = npmContext(cli, install, ctx, node);
+			const npm = globalNpm(cli, install, ctx, node);
 			const copy = await globalInstallOf(bin, npm);
 			return {
 				package: install.package,
@@ -7645,7 +7899,7 @@ function updateCommand(cli, install, { bin, node }) {
 		},
 		apply: async (plan, ctx) => {
 			const { from, latest, prefix } = plan;
-			if (standingOf(from, latest) !== "behind") return {
+			if (standingOf$1(from, latest) !== "behind") return {
 				from,
 				latest,
 				installed: null,
@@ -7654,7 +7908,7 @@ function updateCommand(cli, install, { bin, node }) {
 			};
 			ctx.signal.throwIfAborted();
 			ctx.progress(`installing ${plan.package}@${latest} with the npm under ${prefix}…`);
-			await ctx.runToEnd(`installing ${plan.package}@${latest}`, () => installGlobally(latest, npmContext(cli, install, ctx, node)));
+			await ctx.runToEnd(`installing ${plan.package}@${latest}`, () => installGlobally(latest, globalNpm(cli, install, ctx, node)));
 			const update = {
 				from,
 				latest,
@@ -7672,16 +7926,16 @@ function updateCommand(cli, install, { bin, node }) {
 			return update;
 		},
 		render: (update) => renderUpdate(cli, install, update),
-		renderPlan: (plan) => standingOf(plan.from, plan.latest) === "behind" ? `would install ${plan.package}@${plan.latest} with the npm under ${plan.prefix}, replacing ${plan.from}` : nothingToInstall(plan)
+		renderPlan: (plan) => standingOf$1(plan.from, plan.latest) === "behind" ? `would install ${plan.package}@${plan.latest} with the npm under ${plan.prefix}, replacing ${plan.from}` : nothingToInstall(plan)
 	});
 }
 //#endregion
 //#region ../agent-cli/dist/built-ins/commands.js
-/** The Commands the Runtime adds to a multi-Command CLI: `update` only when it declares an install. */
+/** The Commands the Runtime adds to a multi-Command CLI: `update` only for a Global install. */
 function builtInCommands(cli, launch) {
 	return {
 		doctor: doctorCommand(cli, launch),
-		...cli.install === void 0 ? {} : { update: updateCommand(cli, cli.install, launch) }
+		...cli.install?.mode === "global" ? { update: updateCommand(cli, cli.install, launch) } : {}
 	};
 }
 //#endregion
@@ -9421,14 +9675,14 @@ async function runProcess(cli) {
 }
 //#endregion
 //#region package.json
-var version$1 = "0.10.1";
+var version$1 = "0.11.1";
 var description = "Creates a new Agent CLI repository wired to @duyquangnvx/agent-cli.";
 //#endregion
 //#region src/build.ts
 const build = {
-	"sha": "0e1aa22",
+	"sha": "92df9c6",
 	"dirty": false,
-	"builtAt": "2026-10-22T01:43:18.000Z"
+	"builtAt": "2026-10-22T10:48:39.000Z"
 };
 //#endregion
 //#region src/steps.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duyquangnvx/create-agent-cli",
-  "version": "0.10.1",
+  "version": "0.11.1",
   "description": "Creates a new Agent CLI repository wired to @duyquangnvx/agent-cli.",
   "type": "module",
   "engines": {
@@ -19,7 +19,7 @@
     "access": "public"
   },
   "devDependencies": {
-    "@duyquangnvx/agent-cli": "0.10.1",
+    "@duyquangnvx/agent-cli": "0.11.1",
     "tsdown": "0.23.0",
     "zod": "4.6.7"
   },