@alexkroman1/aai-cli 9.1.0 → 10.0.0

package/dist/{_bundler-CDuYl5Gb.mjs → _bundler-B31MqYaD.mjs}

@@ -1,10 +1,9 @@
 #!/usr/bin/env node
 import { f as validateAgentExport } from "./_utils-B8QmtFhK.mjs";
 import { t as buildClient } from "./client-bundler-CWnG42cU.mjs";
-import { n as buildWorkflows, t as buildWorker } from "./worker-bundler-CCVEDjm1.mjs";
+import { buildWorker } from "./worker-bundler.mjs";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
-import { omitUndefined } from "@alexkroman1/aai/utils";
 import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { hash } from "node:crypto";
@@ -18,14 +17,10 @@ import { hash } from "node:crypto";
 * config and evaluates nothing, so every read of one happens here.
 */
 async function buildAgentBundle(cwd, opts = {}) {
-	const [workflows, clientFiles] = await Promise.all([buildWorkflows(cwd), buildClient(cwd)]);
+	const [clientFiles, worker] = await Promise.all([buildClient(cwd), buildWorker(cwd, opts)]);
 	return {
-		worker: await buildWorker(cwd, {
-			...opts,
-			workflows
-		}),
-		clientFiles,
-		...omitUndefined({ workflows })
+		worker,
+		clientFiles
 	};
 }
 /**
@@ -47,27 +42,10 @@ async function buildAgentBundle(cwd, opts = {}) {
 * experimental.
 */
 async function evalWorkerBundle(code) {
-	return (await evalWorkerWithWorkflows(code)).agent;
-}
-/**
-* {@link evalWorkerBundle}, keeping the workflow exports the AgentDef cannot
-* carry.
-*
-* A separate function rather than a wider return from `evalWorkerBundle`,
-* because every other caller wants the agent and nothing else — and the two
-* strings are ~76 KB that a deploy path has no use for.
-*/
-async function evalWorkerWithWorkflows(code) {
 	const mod = await importWorkerModule(code);
 	const agentDef = mod.default ?? mod;
 	validateAgentExport(agentDef);
-	const workflowCode = mod.__aaiWorkflowCode;
-	const stepCode = mod.__aaiStepCode;
-	return {
-		agent: agentDef,
-		workflowCode: typeof workflowCode === "string" ? workflowCode : void 0,
-		stepCode: typeof stepCode === "string" ? stepCode : void 0
-	};
+	return agentDef;
 }
 /** Import a built worker from a temp file. See {@link evalWorkerBundle}. */
 async function importWorkerModule(code) {
@@ -100,16 +78,12 @@ async function evalWorkerConfig(code) {
 	return (await importWorkerModule(code)).__aaiConfig;
 }
 /**
-* Memoizing wrapper around `evalWorkerWithWorkflows` for long-lived callers
+* Memoizing wrapper around {@link evalWorkerBundle} for long-lived callers
 * (the dev server): byte-identical worker code returns the previously
 * evaluated result without touching the ESM registry. No-op saves and formatter
 * churn are the common watcher events, so this caps the registry leak (see
 * `evalWorkerBundle`) to genuinely-new bundles — the residual one-module-per-
 * distinct-build leak is accepted for the reasons documented there.
-*
-* It evaluates the WORKFLOW-carrying variant because its one caller is
-* `aai dev`, which has no guest to re-read the bundle: dropping the two strings
-* here is what left the dev server unable to serve a workflow at all.
 */
 function createWorkerEvaluator() {
 	let lastHash;
@@ -117,7 +91,7 @@ function createWorkerEvaluator() {
 	return async (code) => {
 		const codeHash = hash("sha256", code);
 		if (lastWorker && codeHash === lastHash) return lastWorker;
-		const worker = await evalWorkerWithWorkflows(code);
+		const worker = await evalWorkerBundle(code);
 		lastHash = codeHash;
 		lastWorker = worker;
 		return worker;

package/dist/_bundler.d.ts

@@ -1,21 +1,11 @@
 import type { AgentDef } from "@alexkroman1/aai";
 import { type BuildWorkerOptions } from "./worker-bundler.ts";
-import { type WorkflowBundleOutput } from "./workflow-bundler.ts";
-/** Output from the bundler: worker ESM + client files + workflow artifacts. */
+/** Output from the bundler: worker ESM + client files. */
 export type DirectoryBundleOutput = {
     /** ESM bundle of agent.ts (tool execute functions + hook handlers). */
     worker: string;
     /** Static client files from Vite build. Empty if no client.tsx. */
     clientFiles: Record<string, string>;
-    /**
-     * The project's durable workflows, or undefined when it declares none.
-     *
-     * Built here rather than in the guest because the transform is per TENANT: the
-     * guest image is baked once and serves many agents, so there is no
-     * `workflows/` directory in existence when it is built. See
-     * `workflow-bundler.ts`.
-     */
-    workflows?: WorkflowBundleOutput;
 };
 /**
  * Bundle an agent directory: build agent.ts into worker ESM + client files.
@@ -45,30 +35,6 @@ export declare function buildAgentBundle(cwd: string, opts?: BuildWorkerOptions)
  * experimental.
  */
 export declare function evalWorkerBundle(code: string): Promise<AgentDef>;
-/**
- * The agent plus the compiled workflow surface a worker carries.
- *
- * `evalWorkerBundle` returns only the `AgentDef`, which is all a deploy needs —
- * the guest re-reads the bundle itself. `aai dev` never hands the bundle to a
- * guest, so this is the only path by which the workflow code reaches a running
- * server locally, and dropping it is why `aai dev` served no workflows at first.
- */
-export type EvaluatedWorker = {
-    agent: AgentDef;
-    /** `__aaiWorkflowCode` — the flow bundle, for `workflowEntrypoint`. */
-    workflowCode: string | undefined;
-    /** `__aaiStepCode` — evaluated to register the project's step functions. */
-    stepCode: string | undefined;
-};
-/**
- * {@link evalWorkerBundle}, keeping the workflow exports the AgentDef cannot
- * carry.
- *
- * A separate function rather than a wider return from `evalWorkerBundle`,
- * because every other caller wants the agent and nothing else — and the two
- * strings are ~76 KB that a deploy path has no use for.
- */
-export declare function evalWorkerWithWorkflows(code: string): Promise<EvaluatedWorker>;
 /**
  * The config a built worker describes about itself — its `__aaiConfig`
  * export, generated by `buildWorker`'s wrapper entry (`toAgentConfig(def)`
@@ -84,15 +50,11 @@ export declare function evalWorkerWithWorkflows(code: string): Promise<Evaluated
  */
 export declare function evalWorkerConfig(code: string): Promise<unknown>;
 /**
- * Memoizing wrapper around `evalWorkerWithWorkflows` for long-lived callers
+ * Memoizing wrapper around {@link evalWorkerBundle} for long-lived callers
  * (the dev server): byte-identical worker code returns the previously
  * evaluated result without touching the ESM registry. No-op saves and formatter
  * churn are the common watcher events, so this caps the registry leak (see
  * `evalWorkerBundle`) to genuinely-new bundles — the residual one-module-per-
  * distinct-build leak is accepted for the reasons documented there.
- *
- * It evaluates the WORKFLOW-carrying variant because its one caller is
- * `aai dev`, which has no guest to re-read the bundle: dropping the two strings
- * here is what left the dev server unable to serve a workflow at all.
  */
-export declare function createWorkerEvaluator(): (code: string) => Promise<EvaluatedWorker>;
+export declare function createWorkerEvaluator(): (code: string) => Promise<AgentDef>;

package/dist/{_dev-server-BAR8Ya43.mjs → _dev-server-Bo5dSBzQ.mjs}

@@ -3,18 +3,18 @@ import { i as outputSilenced, r as notify } from "./_ui-u7T4YooX.mjs";
 import { i as errorCode, o as errorMessage$1 } from "./_utils-B8QmtFhK.mjs";
 import { n as fallbackHtmlPlugin } from "./client-bundler-CWnG42cU.mjs";
 import { t as DEDUPED_PEERS } from "./_vite-env-BNveawd1.mjs";
-import { n as buildWorkflows, t as buildWorker } from "./worker-bundler-CCVEDjm1.mjs";
+import { buildWorker } from "./worker-bundler.mjs";
 import { typecheckProject } from "./typecheck.mjs";
 import { n as ensureApiKey } from "./_config-CmJOFsAP.mjs";
-import { n as createWorkerEvaluator } from "./_bundler-CDuYl5Gb.mjs";
+import { n as createWorkerEvaluator } from "./_bundler-B31MqYaD.mjs";
 import { t as resolveServerEnv } from "./_server-common-6e0QI4mq.mjs";
-import { existsSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import path from "node:path";
 import { omitUndefined } from "@alexkroman1/aai/utils";
-import { createCoalescingRunner, sleep } from "@alexkroman1/aai/internal";
+import { createCoalescingRunner, requestPath, sleep } from "@alexkroman1/aai/internal";
 import { agentConfigWarnings } from "@alexkroman1/aai/manifest";
-import { WORKFLOW_API_PREFIX, createRuntime, createServer, ensureSessionStateSchema, requiredProviderEnvVars, withHostCredentialFallback } from "@alexkroman1/aai-runtime";
-import { configureWorkflowWorld, consoleLogger, createWorkflowSurface, handleWorkflowRequest, publishStepEnv, startWorkflowWorldIfDeclared } from "@alexkroman1/aai-runtime/internal";
+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 { defaultClientDir } from "@alexkroman1/aai-ui/client-dir";
 import { watch } from "chokidar";
 import getPort, { portNumbers } from "get-port";
@@ -286,6 +286,77 @@ function createDevTypecheck(cwd, report = notify) {
 * file past the length cap.
 */
 /**
+* The request under {@link WORKFLOW_API_PREFIX} that VITE must answer, not the
+* proxy — or `undefined` for every request the workflow API owns.
+*
+* `/workflows` is a proxy prefix key AND the directory the SDK tells authors to
+* put workflow bodies in, so the two claim the same URL space. A string key
+* prefix-matches, which is what makes one entry cover `/runs/:id/events` — and
+* it also swallowed `transcription-workflow`'s `client.tsx:173`, a value import
+* of `./workflows/stitch.ts`. Vite rewrites that specifier to the absolute
+* `/workflows/stitch.ts` during import analysis, the proxy claimed it, and the
+* agent server answered the `404 {"error":"Not found"}` its workflow router
+* gives any unmatched path under the prefix. The browser refuses a module
+* served as `application/json`, so the page rendered BLANK — and this lands on
+* the naming convention every workflow template follows, not on one template's
+* bad luck.
+*
+* ## Why the filesystem decides, and not a route table
+*
+* The obvious fix is to narrow the proxy to the API's real shape: the fourteen
+* routes are enumerable (`/runs`, `/runs/:id`, `…/events`, `…/stream`,
+* `…/wake`, `/uploads`, `…/parts`, `…/info`). That restates `aai-runtime`'s
+* router here, in a package that cannot see it — and a route added there but
+* missing from the copy 404s under `aai dev` while working deployed, which is
+* the exact silent failure this proxy table exists to prevent and the reason
+* the entry is keyed off the SDK's own constant rather than a literal. The
+* drift runs the wrong way.
+*
+* Enumerating what VITE owns inverts it: a new API route has no file behind it
+* and is proxied with nothing to update. The only thing that can shadow the API
+* is a real file at a real route's exact path — `workflows/runs` with no
+* extension, or a `workflows/runs/` directory — where an unreachable API is the
+* lesser of the two failures and the author can see the file that caused it.
+* Note `workflows/runs.ts` is NOT such a file: `/workflows/runs.ts` is neither
+* `/workflows/runs` nor under `/workflows/runs/`.
+*
+* Moving the API off `/workflows` was the third option and is the expensive one
+* — it is a wire change reaching the SDK client, the platform's broker and
+* every deployed agent, to buy what a file check buys locally.
+*
+* ## Only an EXACT file counts
+*
+* No extension resolution, deliberately: `/workflows/runs` must not find
+* `workflows/runs.ts`, and a workflow body named `runs.ts` is entirely
+* plausible. Nothing is lost by it — Vite resolves specifiers SERVER-side and
+* rewrites them to paths that exist, so an extensionless `./workflows/stitch`
+* reaches the browser as `/workflows/stitch.ts` (verified: both the explicit
+* and the bare import in one module come back with `.ts` appended). The browser
+* only ever asks for files Vite already found.
+*
+* A path escaping the root is refused rather than served — a raw client can
+* 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) {
+	if (rawUrl === void 0) return void 0;
+	let decoded;
+	try {
+		decoded = decodeURIComponent(requestPath(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;
+	try {
+		if (!statSync(resolved).isFile()) return void 0;
+	} catch {
+		return;
+	}
+	return rawUrl;
+}
+/**
 * Vite dev-server config for the client SPA. Extracted so the proxy wiring
 * is unit-testable: `/websocket` MUST proxy with `ws: true` or `aai dev`
 * with a `client.tsx` serves a page whose WebSocket never connects.
@@ -314,6 +385,27 @@ function createDevTypecheck(cwd, report = notify) {
 * the port the user is told to open — on loopback, i.e. failing exactly the
 * case that variable exists for (`aai dev` in a container, reached from the host).
 *
+* ## With no `AAI_DEV_HOST` the bind host is the BACKEND's, not Vite's default
+*
+* Vite's default `server.host` is the hostname `localhost`, so Node binds
+* whatever `getaddrinfo` returns first — `::1` on macOS, usually `127.0.0.1` on
+* Linux. Measured here: `vite.httpServer.address()` reported
+* `{ address: "::1", family: "IPv6" }` and `http://127.0.0.1:<port>` was
+* ECONNREFUSED while `http://localhost:<port>` worked. So the same command
+* produced different reachability per machine, and `aai dev` reports
+* `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
+* {@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.
+*
+* IPv4 loopback is the SAFE side of that choice rather than a coin flip:
+* browsers, curl and undici all try every address `localhost` resolves to, so a
+* `127.0.0.1` bind stays reachable as `localhost`, while a `::1` bind is not
+* reachable at all from a client holding the IPv4 literal.
+*
 * ## The target is an IP LITERAL, and that is a fix rather than a style choice
 *
 * `127.0.0.1`, never `localhost`. Vite opens a FRESH upstream connection for
@@ -359,7 +451,7 @@ function viteDevConfig(cwd, vitePort, backendPort) {
 		server: {
 			port: vitePort,
 			strictPort: true,
-			...omitUndefined({ host: devBindHost() }),
+			host: devBindHost() ?? DEFAULT_LISTEN_HOST,
 			proxy: {
 				"/health": target,
 				"/client-config": target,
@@ -367,7 +459,10 @@ function viteDevConfig(cwd, vitePort, backendPort) {
 					target,
 					ws: true
 				},
-				[WORKFLOW_API_PREFIX]: target
+				[WORKFLOW_API_PREFIX]: {
+					target,
+					bypass: (req) => workflowPathServedByVite(cwd, req.url)
+				}
 			}
 		}
 	};
@@ -430,20 +525,9 @@ async function resolveAgentEnv(root, agentDef) {
 * keeps the old server. Evaluation goes through the memoizing evaluator so
 * a no-op save doesn't leak another module into the ESM registry.
 *
-* The project's `workflows/` directory is compiled by the same pass deploy
-* runs (`buildWorkflows`) and rides the bundle as two string exports, which is
-* how `aai dev` serves a workflow at all: nothing here hands the bundle to a
-* guest, so the CLI is both ends of that contract locally. A project with no
-* `workflows/` directory pays nothing — `buildWorkflows` resolves `undefined`
-* without starting a builder.
 */
 async function loadWorker(cwd, evaluate) {
-	const workflows = await buildWorkflows(cwd);
-	for (const warning of workflows?.warnings ?? []) notify("warn", warning);
-	return evaluate(await buildWorker(cwd, {
-		runtime: false,
-		workflows
-	}));
+	return evaluate(await buildWorker(cwd, { runtime: false }));
 }
 /**
 * True for paths that should never trigger a restart: anything inside
@@ -496,25 +580,38 @@ function watchDirectory(dir, onChange) {
 */
 async function startDevServer(opts) {
 	const { cwd, port } = opts;
+	if (!process.env[WORKFLOW_DATA_DIR_ENV]?.trim()) process.env[WORKFLOW_DATA_DIR_ENV] = path.join(cwd, ".workflow-data");
 	const hasClient = existsSync(path.join(cwd, "client.tsx"));
 	const backendPort = hasClient ? await getPort({ port: portNumbers(port + 1, port + 100) }) : port;
 	const vitePort = port;
 	const clientDirOpt = hasClient ? {} : { clientDir: defaultClientDir() };
 	const evaluateWorker = createWorkerEvaluator();
 	const devLogger = createDevLogger(outputSilenced());
-	let workflowWorldStarted = false;
 	/**
 	* Whether the session-state tables have been ensured this process.
 	*
-	* Once, like the workflow world above and for the same reason: a rebuild
-	* replaces the routes, not the storage behind them, and re-running the DDL on
-	* every file save would be two round trips per keystroke burst.
+	* Once per dev server rather than per restart: a rebuild replaces the routes,
+	* not the storage behind them, and re-running the DDL on every file save would
+	* be two round trips per keystroke burst.
 	*/
 	let sessionSchemaEnsured = false;
+	/**
+	* Where a databaseless project's durable runs live for this whole `aai dev`.
+	*
+	* STORAGE per PROCESS, CODE per BUILD — the split the deleted DevKit world
+	* made on our behalf. Every save rebuilds the runtime (that is what reloads a
+	* workflow BODY) and a rebuild handed no journal builds a fresh one inside the
+	* engine, so a run started before a save was gone after it and
+	* `GET /workflows/runs/:id` 404'd for a run the page was still polling.
+	* Deliberately NOT the whole client: reusing build 1's would freeze every body
+	* at build 1. `RuntimeOptions.journal` carries the rest, including what this
+	* does NOT restore (a `ctx.sleep` parked across the save still needs a
+	* delivery) and why it cannot demote a postgres or platform journal.
+	*/
+	const journal = createMemoryJournal();
 	/** Full build sequence, shared by initial startup and every restart. */
 	async function buildServer() {
-		const worker = await loadWorker(cwd, evaluateWorker);
-		const agentDef = worker.agent;
+		const agentDef = await loadWorker(cwd, evaluateWorker);
 		const env = await resolveAgentEnv(cwd, agentDef);
 		if (env.DATABASE_URL && !sessionSchemaEnsured) {
 			sessionSchemaEnsured = true;
@@ -522,33 +619,32 @@ async function startDevServer(opts) {
 				url: env.DATABASE_URL,
 				logger: devLogger
 			});
+			await ensureWorkflowJournalSchema({
+				url: env.DATABASE_URL,
+				logger: devLogger
+			});
 		}
-		const world = configureWorkflowWorld({
-			databaseUrl: env.DATABASE_URL,
-			port: backendPort,
-			dataDir: path.join(cwd, ".workflow-data")
-		});
 		publishStepEnv(env);
-		const workflows = await createWorkflowSurface(worker.workflowCode, worker.stepCode);
-		if (workflows && !workflowWorldStarted) {
-			workflowWorldStarted = true;
-			await startWorkflowWorldIfDeclared(true, world);
-		}
 		const providerEnv = withHostCredentialFallback(env);
+		const runtime = createRuntime({
+			agent: agentDef,
+			env,
+			providerEnv,
+			logger: devLogger,
+			journal,
+			publicUrl: process.env.PUBLIC_URL?.trim() || `http://localhost:${backendPort}`
+		});
 		return createServer({
-			runtime: createRuntime({
-				agent: agentDef,
-				env,
-				providerEnv,
-				logger: devLogger,
-				publicUrl: process.env.PUBLIC_URL?.trim() || `http://localhost:${backendPort}`
-			}),
+			runtime,
 			name: agentDef.name,
 			env: hostModeEnv(providerEnv),
 			hostBaseAgent: agentDef,
 			greeting: agentDef.greeting,
 			...omitUndefined({ page: agentDef.page }),
-			request: (req, res, url, method) => handleWorkflowRequest(workflows, req, res, url, method),
+			request: (req, res, url, method) => handleWorkflowRequest(req, res, url, method, {
+				deliver: () => runtime.deliverWorkflow,
+				logger: devLogger
+			}),
 			...clientDirOpt
 		});
 	}

package/dist/_dev-server.d.ts

@@ -8,7 +8,6 @@
  */
 import type { AgentDef } from "@alexkroman1/aai";
 import { type FSWatcher } from "chokidar";
-import { type EvaluatedWorker } from "./_bundler.ts";
 /**
  * Warnings about the agent's credentials, computed against the `.env`-derived
  * env and the shell. Pure so it is directly testable; `resolveAgentEnv` logs
@@ -36,14 +35,8 @@ export declare function agentEnvWarnings(agentDef: Pick<AgentDef, "stt" | "llm"
  * keeps the old server. Evaluation goes through the memoizing evaluator so
  * a no-op save doesn't leak another module into the ESM registry.
  *
- * The project's `workflows/` directory is compiled by the same pass deploy
- * runs (`buildWorkflows`) and rides the bundle as two string exports, which is
- * how `aai dev` serves a workflow at all: nothing here hands the bundle to a
- * guest, so the CLI is both ends of that contract locally. A project with no
- * `workflows/` directory pays nothing — `buildWorkflows` resolves `undefined`
- * without starting a builder.
  */
-export declare function loadWorker(cwd: string, evaluate: (code: string) => Promise<EvaluatedWorker>): Promise<EvaluatedWorker>;
+export declare function loadWorker(cwd: string, evaluate: (code: string) => Promise<AgentDef>): Promise<AgentDef>;
 /**
  * True for paths that should never trigger a restart: anything inside
  * `node_modules/` and any dot-entry (`.git/`, `.aai/`, `.DS_Store`, …).

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

@@ -35,6 +35,27 @@
  * the port the user is told to open — on loopback, i.e. failing exactly the
  * case that variable exists for (`aai dev` in a container, reached from the host).
  *
+ * ## With no `AAI_DEV_HOST` the bind host is the BACKEND's, not Vite's default
+ *
+ * Vite's default `server.host` is the hostname `localhost`, so Node binds
+ * whatever `getaddrinfo` returns first — `::1` on macOS, usually `127.0.0.1` on
+ * Linux. Measured here: `vite.httpServer.address()` reported
+ * `{ address: "::1", family: "IPv6" }` and `http://127.0.0.1:<port>` was
+ * ECONNREFUSED while `http://localhost:<port>` worked. So the same command
+ * produced different reachability per machine, and `aai dev` reports
+ * `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
+ * {@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.
+ *
+ * IPv4 loopback is the SAFE side of that choice rather than a coin flip:
+ * browsers, curl and undici all try every address `localhost` resolves to, so a
+ * `127.0.0.1` bind stays reachable as `localhost`, while a `::1` bind is not
+ * reachable at all from a client holding the IPv4 literal.
+ *
  * ## The target is an IP LITERAL, and that is a fix rather than a style choice
  *
  * `127.0.0.1`, never `localhost`. Vite opens a FRESH upstream connection for

package/dist/{_init-BNotRgV1.mjs → _init-BURbdHNM.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { c as isEexist, l as readJson, p as writeJson } from "./_utils-B8QmtFhK.mjs";
 import { r as isDevMode, t as getMonorepoRoot } from "./_agent-BTwZJu4P.mjs";
-import { REPO_URL, downloadAndMergeTemplate } from "./_templates-4WcKOjS5.mjs";
+import { REPO_URL, downloadAndMergeTemplate } from "./_templates-0Zr2z6yA.mjs";
 import path from "node:path";
 import fs from "node:fs/promises";
 //#region _init.ts

package/dist/{_slug-api--ZBmIGH-.mjs → _slug-api-CfGQq1Tt.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { n as getServerInfo } from "./_agent-BTwZJu4P.mjs";
-import { l as HINT_NOT_DEPLOYED, s as studioProjectApiUrl, u as apiRequest } from "./_studio-CKrsixd0.mjs";
+import { l as HINT_NOT_DEPLOYED, s as studioProjectApiUrl, u as apiRequest } from "./_studio-B1waXMuR.mjs";
 //#region _slug-api.ts
 /**
 * Authenticated request against a deployed agent's slug-scoped resource

package/dist/{_templates-4WcKOjS5.mjs → _templates-0Zr2z6yA.mjs}

@@ -5,6 +5,7 @@ import { existsSync } from "node:fs";
 import path from "node:path";
 import { isRecord } from "@alexkroman1/aai/utils";
 import fs from "node:fs/promises";
+import { IGNORED_WORKSPACE_DIRS, isLocalOnlyFile } from "@alexkroman1/aai/workspace-files";
 const REPO_URL = `https://github.com/alexkroman/agent`;
 /**
 * Templates as shipped inside the published tarball, copied into `dist/` by
@@ -144,11 +145,44 @@ async function layerScaffold(targetDir) {
 	await fs.cp(dir, targetDir, {
 		recursive: true,
 		force: false,
-		errorOnExist: false
+		errorOnExist: false,
+		filter: templateCopyFilter
 	});
 	await layerScaffoldManifest(dir, targetDir);
 }
 /**
+* `fs.cp` filter for every copy OUT of a template or the scaffold — the runtime
+* ones here and the build-time one in `bundle-templates.mjs`.
+*
+* A template directory is also a runnable project, so a developer who runs
+* `aai dev`, `aai build` or `aai publish` inside one leaves build output and
+* machine state in it: `.aai/` (which holds `project.json` — a SLUG and a
+* `serverUrl` — plus a built client), `.workflow-data/`, `node_modules/`, a
+* `.env`. None of it is git-tracked, and an unfiltered `fs.cp` copied all of it
+* anyway, to both destinations:
+*
+* - into every scaffolded project, so `aai init foo --template bar` produced a
+*   directory already LINKED to `bar`'s last local deploy. `aai init` publishes
+*   by default, so the first publish either targeted a slug the user never
+*   chose or — for the `http://localhost:8080` a dev checkout leaves behind —
+*   failed outright with "Refusing to send your API key to …", the project
+*   staying mis-linked for every later `push`/`publish`/`secret`.
+* - into `packages/aai-cli/dist/templates`, i.e. into the PUBLISHED tarball
+*   (`files: ["bin.mjs", "dist"]`). Measured on a real build: 26 stray
+*   `.aai/project.json` files and 9.4 MB of one developer's `.aai/client`
+*   bundles out of a 12 MB `templates/`.
+*
+* The vocabulary is the SDK's, not a fourth list: {@link IGNORED_WORKSPACE_DIRS}
+* is already "never walk this", and {@link isLocalOnlyFile} already means "this
+* exists only on a developer's machine" — including a `.env` that must not ship
+* to npm, and deliberately EXCLUDING `.env.example`, which the scaffold ships as
+* source and a scaffolded project cannot do without.
+*/
+function templateCopyFilter(src) {
+	const name = path.basename(src);
+	return !(IGNORED_WORKSPACE_DIRS.has(name) || isLocalOnlyFile(name));
+}
+/**
 * Copy a template into targetDir, merging scaffold files underneath.
 */
 async function downloadAndMergeTemplate(template, targetDir) {
@@ -158,7 +192,8 @@ async function downloadAndMergeTemplate(template, targetDir) {
 	if (!names.includes(template)) throw new Error(`Unknown template "${template}". Available templates: ${names.join(", ")}`);
 	await fs.cp(path.join(templatesDir, template), targetDir, {
 		recursive: true,
-		force: true
+		force: true,
+		filter: templateCopyFilter
 	});
 	await layerScaffold(targetDir);
 }

package/dist/_templates.d.ts

@@ -56,6 +56,35 @@ export declare function scaffoldDir(): string;
  * {@link layerScaffoldManifest}.
  */
 export declare function layerScaffold(targetDir: string): Promise<void>;
+/**
+ * `fs.cp` filter for every copy OUT of a template or the scaffold — the runtime
+ * ones here and the build-time one in `bundle-templates.mjs`.
+ *
+ * A template directory is also a runnable project, so a developer who runs
+ * `aai dev`, `aai build` or `aai publish` inside one leaves build output and
+ * machine state in it: `.aai/` (which holds `project.json` — a SLUG and a
+ * `serverUrl` — plus a built client), `.workflow-data/`, `node_modules/`, a
+ * `.env`. None of it is git-tracked, and an unfiltered `fs.cp` copied all of it
+ * anyway, to both destinations:
+ *
+ * - into every scaffolded project, so `aai init foo --template bar` produced a
+ *   directory already LINKED to `bar`'s last local deploy. `aai init` publishes
+ *   by default, so the first publish either targeted a slug the user never
+ *   chose or — for the `http://localhost:8080` a dev checkout leaves behind —
+ *   failed outright with "Refusing to send your API key to …", the project
+ *   staying mis-linked for every later `push`/`publish`/`secret`.
+ * - into `packages/aai-cli/dist/templates`, i.e. into the PUBLISHED tarball
+ *   (`files: ["bin.mjs", "dist"]`). Measured on a real build: 26 stray
+ *   `.aai/project.json` files and 9.4 MB of one developer's `.aai/client`
+ *   bundles out of a 12 MB `templates/`.
+ *
+ * The vocabulary is the SDK's, not a fourth list: {@link IGNORED_WORKSPACE_DIRS}
+ * is already "never walk this", and {@link isLocalOnlyFile} already means "this
+ * exists only on a developer's machine" — including a `.env` that must not ship
+ * to npm, and deliberately EXCLUDING `.env.example`, which the scaffold ships as
+ * source and a scaffolded project cannot do without.
+ */
+export declare function templateCopyFilter(src: string): boolean;
 /**
  * Copy a template into targetDir, merging scaffold files underneath.
  */

package/dist/{build-DvDdSwAS.mjs → build-DKC2e9o_.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { a as ok, t as CliError } from "./_output-CKkmWs7i.mjs";
 import { n as log, r as notify } from "./_ui-u7T4YooX.mjs";
-import { r as evalWorkerBundle, t as buildAgentBundle } from "./_bundler-CDuYl5Gb.mjs";
+import { r as evalWorkerBundle, t as buildAgentBundle } from "./_bundler-B31MqYaD.mjs";
 import { assertTypechecks } from "./_typecheck-gate-BXvUNnfs.mjs";
 import { classifyVitestError, runVitest } from "./test-CvwgeVSQ.mjs";
 import path from "node:path";
@@ -48,7 +48,6 @@ async function executeBuild(opts) {
 	}
 	if (!opts.skipTypecheck) await assertTypechecks(cwd);
 	const bundle = await buildAgentBundle(cwd, { minify: true });
-	for (const warning of bundle.workflows?.warnings ?? []) notify("warn", warning);
 	const agentDef = await evalWorkerBundle(bundle.worker);
 	for (const warning of agentConfigWarnings(agentDef)) notify("warn", warning);
 	const worker = path.join(cwd, WORKER_ARTIFACT_REL);