@alexkroman1/aai-cli 5.11.0 → 5.13.0

package/dist/{_agent-DS2PUJcl.mjs → _agent-C8Jk-ZcP.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as serverOrigin, i as readProjectConfig, n as ensureApiKey, r as readGlobalConfig, t as approveServer } from "./_config-DMyolIk9.mjs";
+import { a as serverOrigin, i as readProjectConfig, n as ensureApiKey, r as readGlobalConfig, t as approveServer } from "./_config-CzwAWOWr.mjs";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -107,7 +107,8 @@ async function getServerInfo(cwd, explicitServer) {
 	return {
 		serverUrl,
 		slug: config.slug,
-		apiKey
+		apiKey,
+		studioProject: config.studioProject
 	};
 }
 //#endregion

package/dist/_agent.d.ts

@@ -38,4 +38,5 @@ export declare function getServerInfo(cwd: string, explicitServer?: string): Pro
     serverUrl: string;
     slug: string;
     apiKey: string;
+    studioProject: string | undefined;
 }>;

package/dist/{_api-client-B-upMGkc.mjs → _api-client-BX8Qv51n.mjs}

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { omitUndefined } from "@alexkroman1/aai/utils";
 import { FetchError, ofetch } from "ofetch";
 //#region _api-client.ts
 /**
@@ -25,7 +26,7 @@ async function apiRequest(url, opts) {
 				Authorization: `Bearer ${opts.apiKey}`,
 				...opts.headers
 			},
-			...opts.body !== void 0 ? { body: opts.body } : {},
+			...omitUndefined({ body: opts.body }),
 			retry: opts.retry ?? 2,
 			retryDelay: opts.retryDelay ?? 300
 		});

package/dist/{_bundler-DC17suWN.mjs → _bundler-BuIyDdvs.mjs}

@@ -1,20 +1,20 @@
 #!/usr/bin/env node
-import { u as validateAgentExport } from "./_utils-8KKw-bzi.mjs";
-import { t as buildClient } from "./client-bundler-DONm-khu.mjs";
+import { u as validateAgentExport } from "./_utils-0DHbcqUb.mjs";
+import { t as buildClient } from "./client-bundler-C9qXL8A2.mjs";
 import { buildWorker } from "./worker-bundler.mjs";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { hash } from "node:crypto";
 import { tmpdir } from "node:os";
+import { hash } from "node:crypto";
 //#region _bundler.ts
 /**
 * Bundle an agent directory: build agent.ts into worker ESM + client files.
 *
 * agent.ts is the single entry point: `export default agent({...})`. The
 * worker self-describes (it exports `__aaiConfig` — see `worker-bundler.ts`),
-* so nothing here evaluates the bundle: the server extracts the config inside
-* a guest sandbox at deploy time.
+* which is what `evalWorkerConfig` reads back: the platform stores no agent
+* config and evaluates nothing, so every read of one happens here.
 */
 async function buildAgentBundle(cwd, opts = {}) {
 	const [worker, clientFiles] = await Promise.all([buildWorker(cwd, opts), buildClient(cwd)]);
@@ -42,21 +42,40 @@ async function buildAgentBundle(cwd, opts = {}) {
 * experimental.
 */
 async function evalWorkerBundle(code) {
+	const mod = await importWorkerModule(code);
+	const agentDef = mod.default ?? mod;
+	validateAgentExport(agentDef);
+	return agentDef;
+}
+/** Import a built worker from a temp file. See {@link evalWorkerBundle}. */
+async function importWorkerModule(code) {
 	const dir = await mkdtemp(path.join(tmpdir(), "aai-worker-"));
 	const file = path.join(dir, "worker.mjs");
-	let mod;
 	try {
 		await writeFile(file, code, "utf-8");
-		mod = await import(pathToFileURL(file).href);
+		return await import(pathToFileURL(file).href);
 	} finally {
 		await rm(dir, {
 			recursive: true,
 			force: true
 		}).catch(() => void 0);
 	}
-	const agentDef = mod.default ?? mod;
-	validateAgentExport(agentDef);
-	return agentDef;
+}
+/**
+* The config a built worker describes about itself — its `__aaiConfig`
+* export, generated by `buildWorker`'s wrapper entry (`toAgentConfig(def)`
+* plus the tool schemas).
+*
+* Importing it is also the deploy's SMOKE TEST: a bundle whose top level
+* throws fails here, in the directory that owns it, rather than as a sandbox
+* that never becomes ready after the upload. The platform performs no such
+* check — it evaluates nothing (see `_preflight.ts`).
+*
+* Returns undefined for a bundle built by a CLI old enough not to emit the
+* export; the caller treats that as "nothing to preflight", never an error.
+*/
+async function evalWorkerConfig(code) {
+	return (await importWorkerModule(code)).__aaiConfig;
 }
 /**
 * Memoizing wrapper around `evalWorkerBundle` for long-lived callers (the
@@ -79,4 +98,4 @@ function createWorkerEvaluator() {
 	};
 }
 //#endregion
-export { createWorkerEvaluator as n, evalWorkerBundle as r, buildAgentBundle as t };
+export { evalWorkerConfig as i, createWorkerEvaluator as n, evalWorkerBundle as r, buildAgentBundle as t };

package/dist/_bundler.d.ts

@@ -12,8 +12,8 @@ export type DirectoryBundleOutput = {
  *
  * agent.ts is the single entry point: `export default agent({...})`. The
  * worker self-describes (it exports `__aaiConfig` — see `worker-bundler.ts`),
- * so nothing here evaluates the bundle: the server extracts the config inside
- * a guest sandbox at deploy time.
+ * which is what `evalWorkerConfig` reads back: the platform stores no agent
+ * config and evaluates nothing, so every read of one happens here.
  */
 export declare function buildAgentBundle(cwd: string, opts?: BuildWorkerOptions): Promise<DirectoryBundleOutput>;
 /**
@@ -35,6 +35,20 @@ export declare function buildAgentBundle(cwd: string, opts?: BuildWorkerOptions)
  * experimental.
  */
 export declare function evalWorkerBundle(code: string): Promise<AgentDef>;
+/**
+ * The config a built worker describes about itself — its `__aaiConfig`
+ * export, generated by `buildWorker`'s wrapper entry (`toAgentConfig(def)`
+ * plus the tool schemas).
+ *
+ * Importing it is also the deploy's SMOKE TEST: a bundle whose top level
+ * throws fails here, in the directory that owns it, rather than as a sandbox
+ * that never becomes ready after the upload. The platform performs no such
+ * check — it evaluates nothing (see `_preflight.ts`).
+ *
+ * Returns undefined for a bundle built by a CLI old enough not to emit the
+ * export; the caller treats that as "nothing to preflight", never an error.
+ */
+export declare function evalWorkerConfig(code: string): Promise<unknown>;
 /**
  * Memoizing wrapper around `evalWorkerBundle` for long-lived callers (the
  * dev server): byte-identical worker code returns the previously evaluated

package/dist/{_config-DMyolIk9.mjs → _config-CzwAWOWr.mjs}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import { t as CliError } from "./_output-CC300DzW.mjs";
-import { a as errorMessage, c as readJson, d as writeJson } from "./_utils-8KKw-bzi.mjs";
+import { a as errorMessage, c as readJson, d as writeJson } from "./_utils-0DHbcqUb.mjs";
 import { mkdtempSync } from "node:fs";
 import path from "node:path";
 import fs from "node:fs/promises";
-import { setTimeout } from "node:timers/promises";
 import { tmpdir } from "node:os";
+import { setTimeout } from "node:timers/promises";
 import envPaths from "env-paths";
 import { z } from "zod";
 //#region _config.ts
@@ -239,4 +239,4 @@ async function ensureApiKey(configDir) {
 	throw new CliError("not_logged_in", "You're not logged in.", "Run `aai login` to link your account. Non-interactive setups can point AAI_CONFIG_DIR at a config dir holding a logged-in key.");
 }
 //#endregion
-export { serverOrigin as a, writeProjectConfig as c, readProjectConfig as i, ensureApiKey as n, updateGlobalConfig as o, readGlobalConfig as r, updateProjectConfig as s, approveServer as t };
+export { serverOrigin as a, writeGlobalConfig as c, readProjectConfig as i, writeProjectConfig as l, ensureApiKey as n, updateGlobalConfig as o, readGlobalConfig as r, updateProjectConfig as s, approveServer as t };

package/dist/_deploy.d.ts

@@ -7,14 +7,6 @@ export type DeployOpts = {
     /** Existing slug for redeployment. Omit for first deploy — server generates one. */
     slug?: string;
     apiKey: string;
-    /**
-     * Ask the server to WARN (in `warnings`) instead of rejecting when the
-     * agent's providers are missing credentials — `aai deploy
-     * --allow-missing-secrets`, for setting them post-deploy with
-     * `aai secret put` (the studio's publish flow relies on this: its Secrets
-     * panel needs a deployed slug to attach secrets to).
-     */
-    allowMissingSecrets?: boolean;
     /**
      * Ask the server to permit a `-preview`-suffixed slug (`aai deploy
      * --allow-preview-slug`). That suffix is reserved for the studio's
@@ -29,7 +21,5 @@ export type DeployOpts = {
 };
 export type DeployResult = {
     slug: string;
-    /** Server-side deploy warnings (e.g. the missing-credential preflight). */
-    warnings?: string[];
 };
 export declare function runDeploy(opts: DeployOpts): Promise<DeployResult>;

package/dist/_dev-restart.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Restart supervision for `aai dev`.
+ *
+ * The dev server's subtlest logic is not the wiring (chokidar, Vite, the
+ * bundler) but the small state machine that decides WHEN to rebuild and in
+ * what order to swap servers: an edit saved mid-boot must be queued rather
+ * than race the initial build, a failed build must leave the old server
+ * serving, a `listen` that loses the port race must retry, and teardown must
+ * be idempotent and win every race against an in-flight rebuild.
+ *
+ * That machine lives here, behind injected `build`/`listen`/`close`
+ * operations, so it can be exercised directly — no file watcher, no bundler,
+ * no debounce, no module mocks. `_dev-server.ts` supplies the real operations.
+ *
+ * The supervised server is opaque (`S`): the supervisor never touches it
+ * except through `ops`, so a test can use a plain label.
+ */
+export type NotifyLevel = "error" | "warn" | "info" | "success";
+export type RestartOps<S> = {
+    /** Build a replacement server. Rejections leave the current one serving. */
+    build(): Promise<S>;
+    /** Bind the port. Rejections are retried — see {@link LISTEN_ATTEMPTS}. */
+    listen(server: S): Promise<void>;
+    /** Release the port and any per-server resources. */
+    close(server: S): Promise<void>;
+    /** User-facing progress and failures. */
+    notify(level: NotifyLevel, message: string): void;
+    /**
+     * Extra teardown (file watcher, Vite) run once by {@link
+     * RestartSupervisor.close}, before the current server closes. Failures are
+     * swallowed so one leak can't strand the others.
+     */
+    teardown?: () => Promise<void>;
+    /** Injectable so retry specs don't sleep real wall-clock. */
+    sleep?: (ms: number) => Promise<void>;
+};
+export type RestartSupervisor<S> = {
+    /**
+     * A change was detected. Queues instead of racing when a restart (or the
+     * initial boot) is still in flight.
+     */
+    request(): void;
+    /**
+     * Startup finished with `server`. Releases the queue and runs the one
+     * restart an edit saved during boot asked for.
+     */
+    adopt(server: S): void;
+    /** The server currently serving, or `undefined` before {@link adopt}. */
+    current(): S | undefined;
+    /** Idempotent teardown. Concurrent callers join the in-flight run. */
+    close(): Promise<void>;
+};
+/**
+ * Create a {@link RestartSupervisor}. It starts in the "restarting" state:
+ * callers install their watcher and call {@link RestartSupervisor.request}
+ * freely while the initial build runs, then {@link RestartSupervisor.adopt}
+ * the built server (or {@link RestartSupervisor.close} on startup failure).
+ */
+export declare function createRestartSupervisor<S>(ops: RestartOps<S>): RestartSupervisor<S>;

package/dist/{_dev-server-B3ivqyEd.mjs → _dev-server-Ch7K8e8i.mjs}

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
-import { n as log, r as notify } from "./_ui-DfwfDbT-.mjs";
-import { a as errorMessage, r as errorCode } from "./_utils-8KKw-bzi.mjs";
-import { n as fallbackHtmlPlugin } from "./client-bundler-DONm-khu.mjs";
+import { i as outputSilenced, n as log, r as notify } from "./_ui-u7T4YooX.mjs";
+import { a as errorMessage, r as errorCode } from "./_utils-0DHbcqUb.mjs";
+import { n as fallbackHtmlPlugin } from "./client-bundler-C9qXL8A2.mjs";
 import { buildWorker } from "./worker-bundler.mjs";
-import { n as createWorkerEvaluator } from "./_bundler-DC17suWN.mjs";
-import { n as ensureApiKey } from "./_config-DMyolIk9.mjs";
-import { t as resolveServerEnv } from "./_server-common-DX8Bfrf5.mjs";
+import { n as ensureApiKey } from "./_config-CzwAWOWr.mjs";
+import { n as createWorkerEvaluator } from "./_bundler-BuIyDdvs.mjs";
+import { t as resolveServerEnv } from "./_server-common-61fL__39.mjs";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import { setTimeout } from "node:timers/promises";
-import { createRuntime, createServer, requiredProviderEnvVars, withHostCredentialFallback } from "@alexkroman1/aai/runtime";
+import { consoleLogger, createRuntime, createServer, requiredProviderEnvVars, withHostCredentialFallback } from "@alexkroman1/aai/runtime";
 import { defaultClientDir } from "@alexkroman1/aai-ui/client-dir";
 import { watch } from "chokidar";
 import getPort, { portNumbers } from "get-port";
@@ -65,6 +65,130 @@ function devWatchEnabled() {
 	return /^(1|true|yes|on)$/i.test(process.env.AAI_DEV_WATCH?.trim() ?? "");
 }
 //#endregion
+//#region _dev-restart.ts
+/**
+* Restart supervision for `aai dev`.
+*
+* The dev server's subtlest logic is not the wiring (chokidar, Vite, the
+* bundler) but the small state machine that decides WHEN to rebuild and in
+* what order to swap servers: an edit saved mid-boot must be queued rather
+* than race the initial build, a failed build must leave the old server
+* serving, a `listen` that loses the port race must retry, and teardown must
+* be idempotent and win every race against an in-flight rebuild.
+*
+* That machine lives here, behind injected `build`/`listen`/`close`
+* operations, so it can be exercised directly — no file watcher, no bundler,
+* no debounce, no module mocks. `_dev-server.ts` supplies the real operations.
+*
+* The supervised server is opaque (`S`): the supervisor never touches it
+* except through `ops`, so a test can use a plain label.
+*/
+/** Attempts to bind the port during the close→listen swap. */
+const LISTEN_ATTEMPTS = 3;
+/** Backoff between those attempts. */
+const LISTEN_RETRY_DELAY_MS = 250;
+/**
+* Create a {@link RestartSupervisor}. It starts in the "restarting" state:
+* callers install their watcher and call {@link RestartSupervisor.request}
+* freely while the initial build runs, then {@link RestartSupervisor.adopt}
+* the built server (or {@link RestartSupervisor.close} on startup failure).
+*/
+function createRestartSupervisor(ops) {
+	const wait = ops.sleep ?? setTimeout;
+	let restarting = true;
+	let pendingRestart = false;
+	let closed = false;
+	let current;
+	let cleanupPromise;
+	function request() {
+		if (restarting) {
+			pendingRestart = true;
+			return;
+		}
+		restarting = true;
+		restart().catch((err) => {
+			ops.notify("error", `Restart failed: ${errorMessage(err)}`);
+		}).finally(() => {
+			restarting = false;
+		});
+	}
+	async function restart() {
+		do {
+			pendingRestart = false;
+			await restartOnce();
+		} while (pendingRestart && !closed);
+	}
+	async function restartOnce() {
+		let newServer;
+		try {
+			newServer = await ops.build();
+		} catch (err) {
+			ops.notify("error", `Restart failed: ${errorMessage(err)} (previous server still running)`);
+			return;
+		}
+		if (closed) {
+			await closeQuietly(newServer);
+			return;
+		}
+		if (current !== void 0) {
+			const old = current;
+			current = void 0;
+			await closeQuietly(old);
+		}
+		try {
+			await listenWithRetry(newServer);
+		} catch (err) {
+			ops.notify("error", `Restart failed: ${errorMessage(err)} — dev server is down; save a file to retry.`);
+			await closeQuietly(newServer);
+			return;
+		}
+		current = newServer;
+		if (closed) {
+			await closeQuietly(newServer);
+			return;
+		}
+		ops.notify("success", "Restarted");
+	}
+	/**
+	* Listen with a few short-backoff retries. During the close→listen swap the
+	* port is momentarily free, so another process can snatch it (or the OS can
+	* hold it in TIME_WAIT); one blind attempt would leave the dev server down
+	* until the next file change.
+	*/
+	async function listenWithRetry(server) {
+		for (let attempt = 1;; attempt++) try {
+			await ops.listen(server);
+			return;
+		} catch (err) {
+			if (attempt >= LISTEN_ATTEMPTS || closed) throw err;
+			await wait(LISTEN_RETRY_DELAY_MS);
+		}
+	}
+	/** Best-effort close: a synchronous throw is swallowed alongside a rejection. */
+	async function closeQuietly(server) {
+		try {
+			await ops.close(server);
+		} catch {}
+	}
+	return {
+		request,
+		adopt(server) {
+			current = server;
+			restarting = false;
+			if (pendingRestart) request();
+		},
+		current: () => current,
+		close() {
+			cleanupPromise ??= (async () => {
+				closed = true;
+				await ops.teardown?.().catch(() => void 0);
+				if (current !== void 0) await closeQuietly(current);
+			})();
+			return cleanupPromise;
+		}
+	};
+}
+//#endregion
 //#region _dev-server.ts
 /**
 * Dev server for directory-based agents.
@@ -143,6 +267,33 @@ function isIgnoredPath(dir, filePath) {
 	});
 }
 /**
+* The logger the dev server's runtime writes through.
+*
+* The SDK's default logger is console-backed and `console.log` is STDOUT, so
+* in JSON mode the runtime's own diagnostics — the multi-line "Session mode
+* resolved" dump at startup, every later warning — landed on stdout ahead of
+* the single result line `aai dev` promises there. JSON mode is AUTO-DETECTED
+* on a pipe, so that is the normal case rather than an opt-in one:
+* `aai dev > dev.log`, a process supervisor, a container. It is the same
+* hazard `notify` exists for, one layer down: `silenceOutput()` only reaches
+* this CLI's own `log`, and the runtime is not using it.
+*
+* Human mode keeps the console logger exactly as it was — a TTY has nothing
+* to parse, and stdout is where people are already reading these.
+*/
+function createDevLogger(silenced) {
+	if (!silenced) return consoleLogger;
+	const write = (msg, ctx) => {
+		process.stderr.write(`${msg}${ctx === void 0 ? "" : ` ${JSON.stringify(ctx)}`}\n`);
+	};
+	return {
+		info: write,
+		warn: write,
+		error: write,
+		debug: () => void 0
+	};
+}
+/**
 * Watch the agent directory for changes and call `onChange` when detected.
 * Debounces to avoid rapid restarts. Uses chokidar for reliable recursive
 * watching across platforms (raw `fs.watch` misses events on Linux).
@@ -208,6 +359,7 @@ async function startDevServer(opts) {
 	const vitePort = port;
 	const clientDirOpt = hasClient ? {} : { clientDir: defaultClientDir() };
 	const evaluateWorker = createWorkerEvaluator();
+	const devLogger = createDevLogger(outputSilenced());
 	/** Full build sequence, shared by initial startup and every restart. */
 	async function buildServer() {
 		const agentDef = await loadAgentDef(cwd, evaluateWorker);
@@ -217,7 +369,8 @@ async function startDevServer(opts) {
 			runtime: createRuntime({
 				agent: agentDef,
 				env,
-				providerEnv
+				providerEnv,
+				logger: devLogger
 			}),
 			name: agentDef.name,
 			env: hostModeEnv(providerEnv),
@@ -226,27 +379,24 @@ async function startDevServer(opts) {
 			...clientDirOpt
 		});
 	}
-	let restarting = true;
-	let pendingRestart = false;
-	let closed = false;
-	let currentServer;
-	function kickRestart() {
-		if (restarting) {
-			pendingRestart = true;
-			return;
-		}
-		restarting = true;
-		restart().catch((err) => {
-			notify("error", `Restart failed: ${errorMessage(err)}`);
-		}).finally(() => {
-			restarting = false;
-		});
-	}
-	const watcher = devWatchEnabled() ? watchDirectory(cwd, kickRestart) : void 0;
 	let viteServer;
+	let watcher;
+	const supervisor = createRestartSupervisor({
+		build: buildServer,
+		listen: (server) => server.listen(backendPort, devBindHost()),
+		close: (server) => server.close(),
+		notify,
+		teardown: async () => {
+			await watcher?.close().catch(() => void 0);
+			await viteServer?.close().catch(() => void 0);
+		}
+	});
+	watcher = devWatchEnabled() ? watchDirectory(cwd, supervisor.request) : void 0;
+	let boundServer;
 	try {
-		currentServer = await buildServer();
-		await currentServer.listen(backendPort, devBindHost());
+		const initialServer = await buildServer();
+		await initialServer.listen(backendPort, devBindHost());
+		boundServer = initialServer;
 		if (hasClient) {
 			const { createServer: createViteServer } = await import("vite");
 			viteServer = await createViteServer(viteDevConfig(cwd, vitePort, backendPort));
@@ -255,74 +405,13 @@ async function startDevServer(opts) {
 				notify("error", `Vite dev server error: ${errorMessage(err)}`);
 			});
 		}
+		supervisor.adopt(initialServer);
 	} catch (err) {
-		await watcher?.close().catch(() => void 0);
-		await viteServer?.close().catch(() => void 0);
+		await supervisor.close();
+		await boundServer?.close().catch(() => void 0);
 		throw err;
 	}
-	restarting = false;
-	if (pendingRestart) kickRestart();
-	async function restart() {
-		do {
-			pendingRestart = false;
-			await restartOnce();
-		} while (pendingRestart && !closed);
-	}
-	async function restartOnce() {
-		let newServer;
-		try {
-			newServer = await buildServer();
-		} catch (err) {
-			notify("error", `Restart failed: ${errorMessage(err)} (previous server still running)`);
-			return;
-		}
-		if (closed) {
-			await newServer.close().catch(() => void 0);
-			return;
-		}
-		try {
-			await currentServer.close();
-		} catch {}
-		try {
-			await listenWithRetry(newServer);
-			currentServer = newServer;
-			if (closed) {
-				await newServer.close().catch(() => void 0);
-				return;
-			}
-			notify("success", "Restarted");
-		} catch (err) {
-			notify("error", `Restart failed: ${errorMessage(err)} — dev server is down; save a file to retry.`);
-			await newServer.close().catch(() => void 0);
-		}
-	}
-	/**
-	* Listen with a few short-backoff retries. During the close→listen swap the
-	* port is momentarily free, so another process can snatch it (or the OS can
-	* hold it in TIME_WAIT); one blind attempt would leave the dev server down
-	* until the next file change.
-	*/
-	async function listenWithRetry(server) {
-		const LISTEN_ATTEMPTS = 3;
-		const LISTEN_RETRY_DELAY_MS = 250;
-		for (let attempt = 1;; attempt++) try {
-			await server.listen(backendPort, devBindHost());
-			return;
-		} catch (err) {
-			if (attempt >= LISTEN_ATTEMPTS || closed) throw err;
-			await setTimeout(LISTEN_RETRY_DELAY_MS);
-		}
-	}
-	let cleanupPromise;
-	return () => {
-		cleanupPromise ??= (async () => {
-			closed = true;
-			await watcher?.close().catch(() => void 0);
-			await viteServer?.close().catch(() => void 0);
-			await currentServer.close().catch(() => void 0);
-		})();
-		return cleanupPromise;
-	};
+	return supervisor.close;
 }
 //#endregion
 export { startDevServer };

package/dist/_dev-server.d.ts

@@ -7,6 +7,7 @@
  * client SPA HMR.
  */
 import type { AgentDef } from "@alexkroman1/aai";
+import { type Logger } from "@alexkroman1/aai/runtime";
 import { type FSWatcher } from "chokidar";
 /**
  * Warnings about the agent's credentials, computed against the `.env`-derived
@@ -46,6 +47,22 @@ export declare function loadAgentDef(cwd: string, evaluate: (code: string) => Pr
  * restart the server with the new values.
  */
 export declare function isIgnoredPath(dir: string, filePath: string): boolean;
+/**
+ * The logger the dev server's runtime writes through.
+ *
+ * The SDK's default logger is console-backed and `console.log` is STDOUT, so
+ * in JSON mode the runtime's own diagnostics — the multi-line "Session mode
+ * resolved" dump at startup, every later warning — landed on stdout ahead of
+ * the single result line `aai dev` promises there. JSON mode is AUTO-DETECTED
+ * on a pipe, so that is the normal case rather than an opt-in one:
+ * `aai dev > dev.log`, a process supervisor, a container. It is the same
+ * hazard `notify` exists for, one layer down: `silenceOutput()` only reaches
+ * this CLI's own `log`, and the runtime is not using it.
+ *
+ * Human mode keeps the console logger exactly as it was — a TTY has nothing
+ * to parse, and stdout is where people are already reading these.
+ */
+export declare function createDevLogger(silenced: boolean): Logger;
 /**
  * Watch the agent directory for changes and call `onChange` when detected.
  * Debounces to avoid rapid restarts. Uses chokidar for reliable recursive

package/dist/{_init-5hHkHe-V.mjs → _init-CbkrE2wq.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-import { c as readJson, d as writeJson, s as isEexist } from "./_utils-8KKw-bzi.mjs";
-import { r as isDevMode, t as getMonorepoRoot } from "./_agent-DS2PUJcl.mjs";
-import { REPO_URL, downloadAndMergeTemplate } from "./_templates-DmdG-voA.mjs";
+import { c as readJson, d as writeJson, s as isEexist } from "./_utils-0DHbcqUb.mjs";
+import { r as isDevMode, t as getMonorepoRoot } from "./_agent-C8Jk-ZcP.mjs";
+import { REPO_URL, downloadAndMergeTemplate } from "./_templates-B1kt3BGt.mjs";
 import path from "node:path";
 import fs from "node:fs/promises";
 //#region _init.ts

package/dist/_preflight-BtfaYtbE.mjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import { requiredProviderEnvVars } from "@alexkroman1/aai/runtime";
+//#region _preflight.ts
+/**
+* The deploy-time credential preflight — the classic dev/prod failure, caught
+* before the upload instead of at the deployed agent's first session.
+*
+* An agent that ran locally on shell-exported provider keys dies after deploy
+* with what looks like a provider outage: `aai dev` falls back to the shell
+* (`withHostCredentialFallback`), and the platform never will. Naming the key
+* here turns that into one line of output while the developer is still in the
+* directory that owns the `.env`.
+*
+* **This lives in the CLI because the agent's config does.** The platform
+* stores no description of a bundle and never evaluates one (see "The
+* platform stores no agent config" in packages/aai-server/CLAUDE.md), so the
+* only place that knows an agent needs `CARTESIA_API_KEY` is the process that
+* just built it.
+*
+* **It WARNS, and must not be turned into a hard failure.** The CLI sees the
+* env it is about to upload; it cannot see what is already stored against the
+* slug from an earlier `aai secret put`, so a key the platform holds looks
+* missing from here. The server-side check this replaced could see both and
+* so could reject — moving the config to where it is authored costs that
+* accuracy, and a false rejection is worse than a false warning: it blocks a
+* deploy that would have worked.
+*/
+/**
+* Env var names the agent needs that the env being uploaded doesn't supply.
+* Empty values count as missing — an empty credential authenticates nothing.
+*
+* Two sources: provider credentials derived from the stt/llm/tts/s2s
+* descriptors (the same registry-backed derivation the runtime resolves keys
+* with), and the agent's own declared `requiredEnv` — an `agent()` field for
+* custom keys tools read from `ctx.env`, which no static derivation can see.
+*/
+function missingCredentials(config, env) {
+	return [.../* @__PURE__ */ new Set([...requiredProviderEnvVars(config), ...config.requiredEnv ?? []])].filter((name) => !env[name]);
+}
+/** 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).`;
+}
+//#endregion
+export { missingCredentialMessage, missingCredentials };