@alexkroman1/aai-cli 13.3.0 → 14.0.0

package/dist/{_agent-Clbq3a4h.mjs → _agent-BzUeqOdj.mjs}

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { a as serverOrigin, i as readProjectConfig, n as ensureApiKey, r as readGlobalConfig, t as approveServer } from "./_config-ZY2euhdh.mjs";
+import { m as stripTrailingSlash } from "./_utils-D5JGcjiW.mjs";
+import { a as serverOrigin, i as readProjectConfig, n as ensureApiKey, r as readGlobalConfig, t as approveServer } from "./_config-DYzC6WMD.mjs";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -18,9 +19,6 @@ function isDevMode() {
 	if (process.env.AAI_NO_DEV === "1") return false;
 	return getMonorepoRoot() !== null;
 }
-function stripTrailingSlash(url) {
-	return url.replace(/\/+$/, "");
-}
 /**
 * Whether `origin` may receive a credential without prior user approval.
 *
@@ -82,14 +80,39 @@ function assertValidConfigSlug(slug) {
 	throw new Error(`Invalid slug in .aai/project.json: ${JSON.stringify(slug)}\n  Expected lowercase letters, digits, \`-\`, \`_\` (2-64 chars). Fix or delete the file — \`aai publish\` will create a fresh deployment.`);
 }
 /**
-* Resolve everything needed to talk to the platform: project config (null if
-* the project has never been deployed), server URL, and API key.
+* Everything `resolveDeployTarget` decides BEFORE a credential is involved:
+* the project config (null when never deployed, or when `cwd` is null), the
+* user's global config, and the trust-checked, approved server URL.
 */
-async function resolveDeployTarget(cwd, explicitServer) {
-	const [config, globalConfig] = await Promise.all([readProjectConfig(cwd), readGlobalConfig()]);
+async function resolveApprovedServer(cwd, explicitServer) {
+	const [config, globalConfig] = await Promise.all([cwd === null ? null : readProjectConfig(cwd), readGlobalConfig()]);
 	const serverUrl = resolveServerUrl(explicitServer, config?.serverUrl, globalConfig.approvedServers ?? []);
 	if (explicitServer) await approveServer(serverUrl);
 	assertValidConfigSlug(config?.slug);
+	return {
+		config,
+		globalConfig,
+		serverUrl
+	};
+}
+/**
+* Resolve everything needed to talk to the platform: project config (null if
+* the project has never been deployed), server URL, and API key.
+*
+* `resolveApprovedServer` plus the key, rather than one function, because
+* `aai login` needs the first half and cannot have the second — it is the
+* command that PUTS the key on disk. It had its own copy of the
+* read → `resolveServerUrl` → `approveServer` sequence, which is security
+* policy ("passing `--server` is what approves an origin"), so a change to that
+* policy landed here and silently missed the one command whose whole job is to
+* write a credential for the origin in question. Same shape as the slug-guard
+* incident `assertValidConfigSlug` was moved down here for.
+*
+* The key comes from the config document already in hand — `ensureApiKey` would
+* read and parse the same file a second time, on every platform command.
+*/
+async function resolveDeployTarget(cwd, explicitServer) {
+	const { config, serverUrl } = await resolveApprovedServer(cwd, explicitServer);
 	return {
 		config,
 		serverUrl,
@@ -126,4 +149,4 @@ async function getServerInfo(cwd, explicitServer) {
 	};
 }
 //#endregion
-export { resolveDeployTarget as a, requireDeployedSlug as i, getServerInfo as n, resolveServerUrl as o, isDevMode as r, getMonorepoRoot as t };
+export { resolveApprovedServer as a, requireDeployedSlug as i, getServerInfo as n, resolveDeployTarget as o, isDevMode as r, getMonorepoRoot as t };

package/dist/_agent.d.ts

@@ -1,3 +1,4 @@
+import { type GlobalConfig, type ProjectConfig } from "./_config.ts";
 export declare const DEFAULT_SERVER = "https://alexkroman--aai-server-web-server.modal.run";
 export declare const DEFAULT_DEV_SERVER = "http://localhost:8080";
 export declare function getMonorepoRoot(): string | null;
@@ -19,9 +20,31 @@ export declare function isDevMode(): boolean;
  * @param approvedOrigins - Origins from the user-owned global config.
  */
 export declare function resolveServerUrl(explicit?: string, configUrl?: string, approvedOrigins?: readonly string[]): string;
+/**
+ * Everything `resolveDeployTarget` decides BEFORE a credential is involved:
+ * the project config (null when never deployed, or when `cwd` is null), the
+ * user's global config, and the trust-checked, approved server URL.
+ */
+export declare function resolveApprovedServer(cwd: string | null, explicitServer?: string): Promise<{
+    config: ProjectConfig | null;
+    globalConfig: GlobalConfig;
+    serverUrl: string;
+}>;
 /**
  * Resolve everything needed to talk to the platform: project config (null if
  * the project has never been deployed), server URL, and API key.
+ *
+ * `resolveApprovedServer` plus the key, rather than one function, because
+ * `aai login` needs the first half and cannot have the second — it is the
+ * command that PUTS the key on disk. It had its own copy of the
+ * read → `resolveServerUrl` → `approveServer` sequence, which is security
+ * policy ("passing `--server` is what approves an origin"), so a change to that
+ * policy landed here and silently missed the one command whose whole job is to
+ * write a credential for the origin in question. Same shape as the slug-guard
+ * incident `assertValidConfigSlug` was moved down here for.
+ *
+ * The key comes from the config document already in hand — `ensureApiKey` would
+ * read and parse the same file a second time, on every platform command.
  */
 export declare function resolveDeployTarget(cwd: string, explicitServer?: string): Promise<{
     config: {

package/dist/{_bundler-DEkjO1d8.mjs → _bundler-DolUCMxu.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { f as validateAgentExport } from "./_utils-Dhd058D9.mjs";
-import { t as buildClient } from "./client-bundler-CT-_26c5.mjs";
+import { h as validateAgentExport } from "./_utils-D5JGcjiW.mjs";
+import { t as buildClient } from "./client-bundler-BJgREAh6.mjs";
 import { buildWorker } from "./worker-bundler.mjs";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
@@ -86,14 +86,15 @@ async function evalWorkerConfig(code) {
 * distinct-build leak is accepted for the reasons documented there.
 */
 function createWorkerEvaluator() {
-	let lastHash;
-	let lastWorker;
+	let last;
 	return async (code) => {
 		const codeHash = hash("sha256", code);
-		if (lastWorker && codeHash === lastHash) return lastWorker;
+		if (last?.hash === codeHash) return last.worker;
 		const worker = await evalWorkerBundle(code);
-		lastHash = codeHash;
-		lastWorker = worker;
+		last = {
+			hash: codeHash,
+			worker
+		};
 		return worker;
 	};
 }

package/dist/_cli-common.d.ts

@@ -17,6 +17,26 @@ export declare const sharedArgs: {
         readonly description: "Output JSON (auto-detected in non-TTY)";
     };
 };
+/**
+ * What every PLATFORM command accepts — the pair, as a group to spread.
+ *
+ * `sharedArgs` supplies the field VALUES, so each of the twelve credentialed
+ * commands still restated the shape (`server: sharedArgs.server, json:
+ * sharedArgs.json`). A flag all of them should take is then twelve edits, and
+ * `assertKnownArgv` refuses the flag on whichever one was missed — after
+ * release. `cli-workflow.ts`'s `workflowArgs` is the same pattern for its group.
+ */
+export declare const platformArgs: {
+    readonly server: {
+        readonly type: "string";
+        readonly alias: "s";
+        readonly description: "Platform server URL";
+    };
+    readonly json: {
+        readonly type: "boolean";
+        readonly description: "Output JSON (auto-detected in non-TTY)";
+    };
+};
 /**
  * Flags in `rawArgs` that `argsDef` doesn't declare, in the form the user
  * typed them.
@@ -44,15 +64,34 @@ type AnyCommandDef = CommandDef<ArgsDef>;
  * the narrowing.
  */
 export declare function commandPath<T extends ArgsDef>(cmd: CommandDef<T>, parent?: CommandDef<T>): string;
+/** What {@link resolveArgv} learned by walking the command tree once. */
+export type ArgvSelection = {
+    /** `["aai", "secret", "put"]` — the path walked, for a `--help` sentence. */
+    named: string[];
+    /**
+     * The first non-flag token that named no subcommand where one was expected,
+     * i.e. a mistyped command. `undefined` when the walk reached a real command.
+     */
+    unknownCommand?: string;
+    /** Args declared by the command the argv selected. */
+    argsDef: ArgsDef;
+    /** argv from the first token that is not a subcommand — flags and positionals. */
+    rest: string[];
+};
 /**
- * Unknown flags in `argv` for whichever (possibly nested) subcommand it
- * selects — `[]` when everything is declared.
+ * Walk the real command tree for `argv` and report everything the pre-parse
+ * guards in `cli.ts` need: which command it selects, what that command
+ * declares, and whether a token mistyped a subcommand.
  *
- * Walks the real command tree rather than re-listing flags, so this cannot
- * drift from what the commands accept. An unknown SUBCOMMAND is not reported:
- * citty already answers that with usage text and a non-zero exit.
+ * ONE walk, because there used to be two — this one and a copy in `cli.ts`,
+ * each with its own `Resolvable` narrowing, whose only difference was the
+ * terminal action. The copies also had an ORDERING dependency nothing
+ * enforced: the flag guard reports nothing for a mistyped subcommand (the
+ * flags would be matched against the wrong command's definition), which is
+ * only safe because the command guard ran first. Answering both from one
+ * result removes the ordering rather than documenting it.
  */
-export declare function unknownFlagsForArgv(root: AnyCommandDef, argv: string[]): Promise<string[]>;
+export declare function resolveArgv(root: AnyCommandDef, argv: string[]): Promise<ArgvSelection>;
 /** Shared command setup: resolve cwd, optionally require agent.ts. */
 export declare function setup(opts?: {
     agent?: boolean;

package/dist/{_config-ZY2euhdh.mjs → _config-DYzC6WMD.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { t as CliError } from "./_output-DbJt9gsl.mjs";
-import { c as isEexist, l as readJson, o as errorMessage, p as writeJson } from "./_utils-Dhd058D9.mjs";
+import { t as CliError } from "./_output-DBP9Op_d.mjs";
+import { d as readJson, g as writeJson, s as errorMessage, u as isEexist } from "./_utils-D5JGcjiW.mjs";
 import { mkdtempSync } from "node:fs";
 import path from "node:path";
 import fs from "node:fs/promises";

package/dist/_dev-env.d.ts

@@ -17,7 +17,7 @@
  */
 import type { Logger } from "@alexkroman1/aai-runtime";
 /**
- * The env handed to `createServer` for host-mode connections: provider
+ * The env handed to `createRuntimeServer` for host-mode connections: provider
  * credentials plus the `AAI_ALLOW_HOST` gate read straight from the shell
  * (it is a control variable, not something an agent declares in `.env`).
  */

package/dist/{_dev-server-C13xuGB1.mjs → _dev-server-CSMqF8PN.mjs}

@@ -1,27 +1,27 @@
 #!/usr/bin/env node
 import { i as outputSilenced, r as notify } from "./_ui-DCt4qZrk.mjs";
-import { i as errorCode, o as errorMessage$1 } from "./_utils-Dhd058D9.mjs";
-import { n as fallbackHtmlPlugin } from "./client-bundler-CT-_26c5.mjs";
+import { a as errorCode, s as errorMessage$1 } from "./_utils-D5JGcjiW.mjs";
+import { n as fallbackHtmlPlugin } from "./client-bundler-BJgREAh6.mjs";
 import { t as DEDUPED_PEERS } from "./_vite-env-kejF0p2L.mjs";
 import { buildWorker } from "./worker-bundler.mjs";
 import { typecheckProject } from "./typecheck.mjs";
-import { n as ensureApiKey } from "./_config-ZY2euhdh.mjs";
-import { n as createWorkerEvaluator } from "./_bundler-DEkjO1d8.mjs";
-import { t as resolveServerEnv } from "./_server-common-BV4_CrP3.mjs";
+import { n as ensureApiKey } from "./_config-DYzC6WMD.mjs";
+import { n as createWorkerEvaluator } from "./_bundler-DolUCMxu.mjs";
+import { t as resolveServerEnv } from "./_server-common-vILJp3it.mjs";
 import { existsSync, statSync } from "node:fs";
 import path from "node:path";
-import { omitUndefined } from "@alexkroman1/aai/utils";
+import { omitUndefined, plural } from "@alexkroman1/aai/utils";
 import { createCoalescingRunner, requestPath, sleep } from "@alexkroman1/aai/internal";
 import { agentConfigWarnings } from "@alexkroman1/aai/manifest";
-import { DEFAULT_LISTEN_HOST, WORKFLOW_API_PREFIX, createRuntime, createServer, ensureSessionStateSchema, ensureWorkflowJournalSchema, requiredProviderEnvVars, withHostCredentialFallback } from "@alexkroman1/aai-runtime";
-import { WORKFLOW_DATA_DIR_ENV, consoleLogger, createMemoryJournal, handleWorkflowRequest, publishStepEnv } from "@alexkroman1/aai-runtime/internal";
+import { DEFAULT_LISTEN_HOST, WORKFLOW_API_PREFIX, createRuntime, createRuntimeServer, ensureSessionStateSchema, ensureWorkflowJournalSchema, requiredProviderEnvVars, withHostCredentialFallback } from "@alexkroman1/aai-runtime";
+import { WORKFLOW_DATA_DIR_ENV, consoleLogger, createMemoryJournal, handleWorkflowRequest, isPathInside, publishStepEnv } from "@alexkroman1/aai-runtime/internal";
 import { defaultClientDir } from "@alexkroman1/aai-ui/client-dir";
 import { watch } from "chokidar";
 import getPort, { portNumbers } from "get-port";
 import pDebounce from "p-debounce";
 //#region src/_dev-env.ts
 /**
-* The env handed to `createServer` for host-mode connections: provider
+* The env handed to `createRuntimeServer` for host-mode connections: provider
 * credentials plus the `AAI_ALLOW_HOST` gate read straight from the shell
 * (it is a control variable, not something an agent declares in `.env`).
 */
@@ -338,7 +338,7 @@ function createDevTypecheck(cwd, report = notify) {
 * send `..` where a browser would normalize it — and a malformed percent-escape
 * is left to the API, which is where a path we cannot resolve belongs.
 */
-function workflowPathServedByVite(root, rawUrl) {
+function workflowPathServedByVite(base, rawUrl) {
 	if (rawUrl === void 0) return void 0;
 	let decoded;
 	try {
@@ -346,9 +346,8 @@ function workflowPathServedByVite(root, rawUrl) {
 	} catch {
 		return;
 	}
-	const base = path.resolve(root);
 	const resolved = path.resolve(base, `.${decoded}`);
-	if (resolved !== base && !resolved.startsWith(base + path.sep)) return void 0;
+	if (!isPathInside(base, resolved)) return void 0;
 	try {
 		if (!statSync(resolved).isFile()) return void 0;
 	} catch {
@@ -362,13 +361,13 @@ function workflowPathServedByVite(root, rawUrl) {
 * with a `client.tsx` serves a page whose WebSocket never connects.
 *
 * **This table is the whole agent API as the browser can see it**, which is
-* the thing to hold in mind before adding a route to `createServer`. Vite owns
+* the thing to hold in mind before adding a route to `createRuntimeServer`. Vite owns
 * the port the user is told to open and answers everything not listed here
 * itself — with a bare 404 carrying none of the agent server's headers, so the
 * failure looks like a missing route rather than a missing proxy entry.
 *
 * `/workflows` is why that matters beyond voice. A WORKFLOW APP
-* (`workflowApp()`) has no session and no socket: `page()` mounts a
+* (`workflowApp()`) has no session and no socket: `mountPage()` mounts a
 * form and every single thing it does — listing workflows, starting a run,
 * polling it, streaming its events — is a same-origin `fetch` under that
 * prefix. Unproxied, the two workflow-app templates were dead on arrival under
@@ -396,7 +395,7 @@ function workflowPathServedByVite(root, rawUrl) {
 * `http://localhost:<port>` either way — a caller that resolves IPv4-only, or
 * dials the literal, gets a connection refused against a server that is up.
 *
-* The two halves of `aai dev` also disagreed: `createServer` binds
+* The two halves of `aai dev` also disagreed: `createRuntimeServer` binds
 * {@link DEFAULT_LISTEN_HOST} explicitly, Vite took its own default, and only a
 * set `AAI_DEV_HOST` brought them back together. Taking the same constant is
 * what makes them agree by construction rather than by two matching literals.
@@ -444,6 +443,7 @@ function workflowPathServedByVite(root, rawUrl) {
 */
 function viteDevConfig(cwd, vitePort, backendPort) {
 	const target = `http://127.0.0.1:${backendPort}`;
+	const viteRoot = path.resolve(cwd);
 	return {
 		root: cwd,
 		plugins: [fallbackHtmlPlugin(cwd)],
@@ -461,7 +461,7 @@ function viteDevConfig(cwd, vitePort, backendPort) {
 				},
 				[WORKFLOW_API_PREFIX]: {
 					target,
-					bypass: (req) => workflowPathServedByVite(cwd, req.url)
+					bypass: (req) => workflowPathServedByVite(viteRoot, req.url)
 				}
 			}
 		}
@@ -491,16 +491,14 @@ function viteDevConfig(cwd, vitePort, backendPort) {
 *   can't mask one that would be missing both here and after deploy.
 */
 function agentEnvWarnings(agentDef, env, shellEnv = process.env) {
-	const s = (names) => names.length > 1 ? "s" : "";
-	const them = (names) => names.length > 1 ? "them" : "it";
 	const required = requiredProviderEnvVars(agentDef);
 	const warnings = [];
 	const missing = required.filter((name) => !(env[name] || shellEnv[name]));
-	if (missing.length > 0) warnings.push(`Missing provider credential${s(missing)}: ${missing.join(", ")}. Set ${them(missing)} in .env or the environment.`);
+	if (missing.length > 0) warnings.push(`Missing provider ${plural(missing.length, "credential")}: ${missing.join(", ")}. Set ${plural(missing.length, "it", "them")} in .env or the environment.`);
 	const shellOnly = required.filter((name) => !env[name] && shellEnv[name]);
-	if (shellOnly.length > 0) warnings.push(`${shellOnly.join(", ")} resolved from your shell, not .env — deployed agents won't have ${them(shellOnly)}. Declare ${them(shellOnly)} in .env before \`aai publish\`.`);
+	if (shellOnly.length > 0) warnings.push(`${shellOnly.join(", ")} resolved from your shell, not .env — deployed agents won't have ${plural(shellOnly.length, "it", "them")}. Declare ${plural(shellOnly.length, "it", "them")} in .env before \`aai publish\`.`);
 	const declared = (agentDef.requiredEnv ?? []).filter((name) => !env[name]);
-	if (declared.length > 0) warnings.push(`Missing requiredEnv key${s(declared)} declared by the agent: ${declared.join(", ")}. Set ${them(declared)} in .env — ctx.env will not contain ${them(declared)} otherwise.`);
+	if (declared.length > 0) warnings.push(`Missing requiredEnv ${plural(declared.length, "key")} declared by the agent: ${declared.join(", ")}. Set ${plural(declared.length, "it", "them")} in .env — ctx.env will not contain ${plural(declared.length, "it", "them")} otherwise.`);
 	return warnings;
 }
 async function resolveAgentEnv(root, agentDef) {
@@ -634,7 +632,7 @@ async function startDevServer(opts) {
 			journal,
 			publicUrl: process.env.PUBLIC_URL?.trim() || `http://localhost:${backendPort}`
 		});
-		return createServer({
+		return createRuntimeServer({
 			runtime,
 			name: agentDef.name,
 			env: hostModeEnv(providerEnv),

package/dist/_dev-vite-config.d.ts

@@ -12,13 +12,13 @@
  * with a `client.tsx` serves a page whose WebSocket never connects.
  *
  * **This table is the whole agent API as the browser can see it**, which is
- * the thing to hold in mind before adding a route to `createServer`. Vite owns
+ * the thing to hold in mind before adding a route to `createRuntimeServer`. Vite owns
  * the port the user is told to open and answers everything not listed here
  * itself — with a bare 404 carrying none of the agent server's headers, so the
  * failure looks like a missing route rather than a missing proxy entry.
  *
  * `/workflows` is why that matters beyond voice. A WORKFLOW APP
- * (`workflowApp()`) has no session and no socket: `page()` mounts a
+ * (`workflowApp()`) has no session and no socket: `mountPage()` mounts a
  * form and every single thing it does — listing workflows, starting a run,
  * polling it, streaming its events — is a same-origin `fetch` under that
  * prefix. Unproxied, the two workflow-app templates were dead on arrival under
@@ -46,7 +46,7 @@
  * `http://localhost:<port>` either way — a caller that resolves IPv4-only, or
  * dials the literal, gets a connection refused against a server that is up.
  *
- * The two halves of `aai dev` also disagreed: `createServer` binds
+ * The two halves of `aai dev` also disagreed: `createRuntimeServer` binds
  * {@link DEFAULT_LISTEN_HOST} explicitly, Vite took its own default, and only a
  * set `AAI_DEV_HOST` brought them back together. Taking the same constant is
  * what makes them agree by construction rather than by two matching literals.

package/dist/{_init-Ci4QGjp8.mjs → _init-CQ8idAwo.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-import { c as isEexist, l as readJson, p as writeJson } from "./_utils-Dhd058D9.mjs";
-import { r as isDevMode, t as getMonorepoRoot } from "./_agent-Clbq3a4h.mjs";
-import { REPO_URL, downloadAndMergeTemplate } from "./_templates-V4l5sZJy.mjs";
+import { d as readJson, g as writeJson, i as compareCodeUnits, u as isEexist } from "./_utils-D5JGcjiW.mjs";
+import { r as isDevMode, t as getMonorepoRoot } from "./_agent-BzUeqOdj.mjs";
+import { REPO_URL, downloadAndMergeTemplate } from "./_templates-CK4oKoeX.mjs";
 import path from "node:path";
 import fs from "node:fs/promises";
 //#region src/_init.ts
@@ -119,17 +119,6 @@ async function patchPackageJsonForWorkspace(targetDir) {
 	await pinSharedDeps(targetDir, packagesDir, pkgJson);
 }
 /**
-* Code-unit ordering, never `localeCompare`.
-*
-* With no explicit locale that answers to the runtime's ICU default, so the same
-* project would scaffold a differently-ordered file on a different machine —
-* which is the reason the repo's own generated artifacts sort this way too.
-*/
-function compareNames(a, b) {
-	if (a === b) return 0;
-	return a < b ? -1 : 1;
-}
-/**
 * Pin every THIRD-PARTY dependency this project shares with a linked workspace
 * package to the copy that workspace package resolved.
 *
@@ -162,17 +151,14 @@ async function pinSharedDeps(targetDir, packagesDir, pkgJson) {
 		...pkgJson.devDependencies
 	};
 	const linked = Object.entries(WORKSPACE_PKG_DIRS).filter(([name]) => name in declared).map(([, dir]) => dir);
-	const pins = /* @__PURE__ */ new Map();
-	for (const name of Object.keys(declared)) {
-		if (name in WORKSPACE_PKG_DIRS) continue;
+	const resolved = await Promise.all(Object.keys(declared).filter((name) => !(name in WORKSPACE_PKG_DIRS)).map(async (name) => {
 		for (const dir of linked) {
 			const manifest = await readJson(path.join(packagesDir, dir, "node_modules", name, "package.json"));
-			if (typeof manifest?.version === "string") {
-				pins.set(name, manifest.version);
-				break;
-			}
+			if (typeof manifest?.version === "string") return [name, manifest.version];
 		}
-	}
+		return null;
+	}));
+	const pins = new Map(resolved.filter((entry) => entry !== null));
 	if (pins.size === 0) return;
 	const file = path.join(targetDir, "pnpm-workspace.yaml");
 	let existing;
@@ -181,7 +167,7 @@ async function pinSharedDeps(targetDir, packagesDir, pkgJson) {
 	} catch {
 		return;
 	}
-	const block = [...pins].sort(([a], [b]) => compareNames(a, b)).map(([name, version]) => `  "${name}": "${version}"`).join("\n");
+	const block = [...pins].sort(([a], [b]) => compareCodeUnits(a, b)).map(([name, version]) => `  "${name}": "${version}"`).join("\n");
 	await fs.writeFile(file, `${existing.trimEnd()}\n\n# Added by \`aai init\` in DEV MODE only — see pinSharedDeps in\n# packages/aai-cli/src/_init.ts. The @alexkroman1/* packages above are LINKED to
 # this checkout, so anything they and this project both depend on has to be
 # ONE copy: two copies of xstate are two incompatible sets of types, and the

package/dist/{_output-DbJt9gsl.mjs → _output-DBP9Op_d.mjs}

@@ -1,6 +1,13 @@
 #!/usr/bin/env node
+import { stripVTControlCharacters } from "node:util";
 //#region src/_output.ts
 /**
+* Structured output support for CLI commands.
+*
+* In JSON mode (non-TTY or --json), commands emit exactly one JSON line to
+* stdout. In human mode (TTY, default), commands use @clack/prompts as before.
+*/
+/**
 * Determine output mode from CLI flags and TTY state.
 *
 * Priority: --json flag > --no-json flag > TTY auto-detection.
@@ -11,27 +18,29 @@ function getOutputMode(args, isTTY = Boolean(process.stdout.isTTY)) {
 	return isTTY ? "human" : "json";
 }
 /**
-* A CSI sequence — `ESC [ params intermediates final` — which covers every SGR
-* colour pair a diagnostic can arrive wearing (`\u001B[31m` … `\u001B[0m`,
-* `\u001B[38;5;246m`) as well as cursor moves.
-*/
-const ANSI_RAW = new RegExp(`${String.fromCharCode(27)}\\[[0-?]*[ -/]*[@-~]`, "g");
-/**
-* The same sequence AFTER `JSON.stringify`, which escapes the ESC byte as the
-* six characters `\u001b`. Both forms are needed because a caller stringifies
-* a whole result and hands the line here — see {@link writeLine}.
+* A terminal escape sequence AFTER `JSON.stringify`, which escapes the ESC
+* byte as the six characters `\u001b`. Needed alongside the raw form because a
+* caller stringifies a whole result and hands the line here — see
+* {@link writeLine} — and no builtin reads that spelling.
 */
 const ANSI_JSON = /\\u001[bB]\[[0-?]*[ -/]*[@-~]/g;
 /**
 * Remove ANSI escape sequences, in raw or JSON-escaped form.
 *
 * A bundler colours its own diagnostics unconditionally, so `aai build`'s
-* failure reached the JSON envelope as per-character SGR pairs
-* (`[38;5;246m1 │[0m [38;5;249mi[0m[38;5;249mm[0m…`) — illegible in a CI log
-* and meaningless to a `jq` consumer, which is the audience JSON mode has.
+* failure reached the JSON envelope as per-character SGR pairs — illegible in a
+* CI log and meaningless to a `jq` consumer, which is the audience JSON mode
+* has.
+*
+* The raw half is `node:util`'s, not a local CSI regex. A/B'd on Node 26: the
+* two agree on every SGR pair and cursor move the hand-built pattern was
+* written for, and the builtin ALSO strips OSC-8 hyperlinks (`ESC ] 8 ;; url`)
+* and charset selects (`ESC ( B`), which that pattern left in the envelope — so
+* its claim to cover what a diagnostic arrives wearing was the incomplete part.
+* The JSON-escaped half has no builtin and stays.
 */
 function stripAnsi(text) {
-	return text.replace(ANSI_RAW, "").replace(ANSI_JSON, "");
+	return stripVTControlCharacters(text).replace(ANSI_JSON, "");
 }
 /**
 * Write a machine-readable line to stdout, resolving only once it has been

package/dist/_output.d.ts

@@ -1,9 +1,3 @@
-/**
- * Structured output support for CLI commands.
- *
- * In JSON mode (non-TTY or --json), commands emit exactly one JSON line to
- * stdout. In human mode (TTY, default), commands use @clack/prompts as before.
- */
 export type OutputMode = "json" | "human";
 export type CommandResult<T> = {
     ok: true;
@@ -26,9 +20,16 @@ export declare function getOutputMode(args: {
  * Remove ANSI escape sequences, in raw or JSON-escaped form.
  *
  * A bundler colours its own diagnostics unconditionally, so `aai build`'s
- * failure reached the JSON envelope as per-character SGR pairs
- * (`[38;5;246m1 │[0m [38;5;249mi[0m[38;5;249mm[0m…`) — illegible in a CI log
- * and meaningless to a `jq` consumer, which is the audience JSON mode has.
+ * failure reached the JSON envelope as per-character SGR pairs — illegible in a
+ * CI log and meaningless to a `jq` consumer, which is the audience JSON mode
+ * has.
+ *
+ * The raw half is `node:util`'s, not a local CSI regex. A/B'd on Node 26: the
+ * two agree on every SGR pair and cursor move the hand-built pattern was
+ * written for, and the builtin ALSO strips OSC-8 hyperlinks (`ESC ] 8 ;; url`)
+ * and charset selects (`ESC ( B`), which that pattern left in the envelope — so
+ * its claim to cover what a diagnostic arrives wearing was the incomplete part.
+ * The JSON-escaped half has no builtin and stays.
  */
 export declare function stripAnsi(text: string): string;
 /**

package/dist/{_preflight-B2laWPdU.mjs → _preflight-CcAR577V.mjs}

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { plural } from "@alexkroman1/aai/utils";
 import { requiredProviderEnvVars } from "@alexkroman1/aai-runtime";
 //#region src/_preflight.ts
 /**
@@ -39,8 +40,7 @@ function missingCredentials(config, env) {
 }
 /** One line naming the missing keys and what to do about them. */
 function missingCredentialMessage(missing) {
-	const plural = missing.length > 1;
-	return `Missing credential${plural ? "s" : ""} the agent needs to start: ${missing.join(", ")}. Declare ${plural ? "them" : "it"} in .env and redeploy (already set on the platform with \`aai secret put\`? then this is already handled).`;
+	return `Missing ${plural(missing.length, "credential")} the agent needs to start: ${missing.join(", ")}. Declare ${plural(missing.length, "it", "them")} in .env and redeploy (already set on the platform with \`aai secret put\`? then this is already handled).`;
 }
 //#endregion
 export { missingCredentialMessage, missingCredentials };

package/dist/_resource-commands.d.ts

@@ -1,5 +1,14 @@
 export declare const secret: import("citty").CommandDef<import("citty").ArgsDef>;
 export declare const logs: import("citty").CommandDef<{
+    readonly server: {
+        readonly type: "string";
+        readonly alias: "s";
+        readonly description: "Platform server URL";
+    };
+    readonly json: {
+        readonly type: "boolean";
+        readonly description: "Output JSON (auto-detected in non-TTY)";
+    };
     readonly dir: {
         readonly type: "positional";
         readonly description: "Project directory";
@@ -10,13 +19,4 @@ export declare const logs: import("citty").CommandDef<{
         readonly alias: "f";
         readonly description: "Keep printing new output";
     };
-    readonly server: {
-        readonly type: "string";
-        readonly alias: "s";
-        readonly description: "Platform server URL";
-    };
-    readonly json: {
-        readonly type: "boolean";
-        readonly description: "Output JSON (auto-detected in non-TTY)";
-    };
 }>;

package/dist/{_server-common-BV4_CrP3.mjs → _server-common-vILJp3it.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { i as errorCode } from "./_utils-Dhd058D9.mjs";
+import { a as errorCode } from "./_utils-D5JGcjiW.mjs";
 import path from "node:path";
 import { parseEnv } from "node:util";
 import fs from "node:fs/promises";

package/dist/{_slug-api-DlKpj91X.mjs → _slug-api-CGvc2YSQ.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { n as getServerInfo } from "./_agent-Clbq3a4h.mjs";
-import { l as HINT_NOT_DEPLOYED, s as studioProjectApiUrl, u as apiRequest } from "./_studio-DTi3EdXQ.mjs";
+import { n as getServerInfo } from "./_agent-BzUeqOdj.mjs";
+import { l as HINT_NOT_DEPLOYED, s as studioProjectApiUrl, u as apiRequest } from "./_studio-DnR_BqFp.mjs";
 //#region src/_slug-api.ts
 /**
 * Authenticated request against a deployed agent's slug-scoped resource
@@ -43,12 +43,21 @@ async function secretRequest(cwd, resourcePath, init, server) {
 		target: studioProject ?? slug
 	};
 }
-async function slugRequest(cwd, resourcePath, init, server) {
-	const { serverUrl, slug, apiKey } = await getServerInfo(cwd, server);
-	return {
-		data: await deployedAgentRequest(`${serverUrl}/${slug}${resourcePath}`, init, apiKey),
-		slug
-	};
+/**
+* A slug-scoped request against an ALREADY-resolved target.
+*
+* {@link slugRequest} resolves per call, which is right for a command that
+* issues one request and wrong for one that POLLS. `aai logs --follow` re-entered
+* `getServerInfo` on every tick — a read and zod parse of `.aai/project.json`, a
+* read of the global config, a `new URL` trust check, a slug-shape test, and with
+* `--server` an `approveServer` that takes the CROSS-PROCESS config lock — once a
+* second for the life of the follow, all of it re-deriving an immutable answer.
+* `delete.ts` documents the same cost and answers it the same way, by hand; this
+* is the general version, so the next polling command inherits it.
+*/
+async function slugRequestOn(target, resourcePath, init) {
+	const { serverUrl, slug, apiKey } = target;
+	return deployedAgentRequest(`${serverUrl}/${slug}${resourcePath}`, init, apiKey);
 }
 //#endregion
-export { slugRequest as n, secretRequest as t };
+export { slugRequestOn as n, secretRequest as t };