@alexkroman1/aai-cli 5.9.0 → 5.10.1

package/dist/templates/retail/seed.test.ts

@@ -90,18 +90,25 @@ describe("seed shape", () => {
     expect(Object.keys(seed.orders)).toHaveLength(22);
   });
 
+  // These four sweep the whole corpus, so they assert SOFTLY: one hand-edited
+  // order usually breaks several records at once, and a hard failure reports
+  // the first and hides how far the damage runs.
   test("every order belongs to a seeded user and is listed on that user", () => {
     for (const order of Object.values(seed.orders)) {
       const user = seed.users[order.user_id];
-      expect(user, `order ${order.order_id} has no seeded user`).toBeDefined();
-      expect(user?.orders).toContain(order.order_id);
+      expect.soft(user, `order ${order.order_id} has no seeded user`).toBeDefined();
+      expect
+        .soft(user?.orders ?? [], `${order.order_id} is not listed on its user`)
+        .toContain(order.order_id);
     }
   });
 
   test("every user's listed orders are all seeded", () => {
     for (const user of Object.values(seed.users)) {
       for (const orderId of user.orders) {
-        expect(seed.orders[orderId], `${user.user_id} lists unseeded ${orderId}`).toBeDefined();
+        expect
+          .soft(seed.orders[orderId], `${user.user_id} lists unseeded ${orderId}`)
+          .toBeDefined();
       }
     }
   });
@@ -110,11 +117,10 @@ describe("seed shape", () => {
     for (const order of Object.values(seed.orders)) {
       for (const item of order.items) {
         const variant = seed.products[item.product_id]?.variants[item.item_id];
-        expect(
-          variant,
-          `${order.order_id}: ${item.item_id} missing from its product`,
-        ).toBeDefined();
-        expect(variant?.price).toBe(item.price);
+        expect
+          .soft(variant, `${order.order_id}: ${item.item_id} missing from its product`)
+          .toBeDefined();
+        expect.soft(variant?.price, `${order.order_id}: ${item.item_id} price`).toBe(item.price);
       }
     }
   });
@@ -123,10 +129,12 @@ describe("seed shape", () => {
     for (const order of Object.values(seed.orders)) {
       const user = seed.users[order.user_id];
       for (const payment of order.payment_history) {
-        expect(
-          user?.payment_methods[payment.payment_method_id],
-          `${order.order_id}: unknown method ${payment.payment_method_id}`,
-        ).toBeDefined();
+        expect
+          .soft(
+            user?.payment_methods[payment.payment_method_id],
+            `${order.order_id}: unknown method ${payment.payment_method_id}`,
+          )
+          .toBeDefined();
       }
     }
   });
@@ -148,7 +156,7 @@ describe("seed coverage — each datum backs a specific test in agent.test.ts",
   test("every status the tools branch on is present", () => {
     const statuses = new Set(Object.values(seed.orders).map((o) => o.status));
     for (const s of ["pending", "processed", "delivered", "cancelled"]) {
-      expect(statuses, `no ${s} order seeded`).toContain(s);
+      expect.soft(statuses, `no ${s} order seeded`).toContain(s);
     }
   });
 

package/dist/templates/retail/shared.test.ts

@@ -57,7 +57,9 @@ describe("storeView", () => {
       "#W4316152",
       "#W1840144",
     ]) {
-      expect(json, `projection leaked ${leaked}`).not.toContain(leaked);
+      // Soft: a widened projection leaks several fields at once, and the full
+      // list is what says how much of the other customers' records got out.
+      expect.soft(json, `projection leaked ${leaked}`).not.toContain(leaked);
     }
   });
 
@@ -84,15 +86,17 @@ describe("DEMO_PERSONAS", () => {
     const users = Object.values((structuredClone(seedJson) as unknown as Store).users);
     for (const persona of DEMO_PERSONAS) {
       const user = users.find((u) => u.email === persona.email);
-      expect(user, `no seeded customer has email ${persona.email}`).toBeDefined();
-      expect(`${user?.name.first_name} ${user?.name.last_name}`).toBe(persona.name);
-      expect(user?.address.zip).toBe(persona.zip);
+      expect.soft(user, `no seeded customer has email ${persona.email}`).toBeDefined();
+      expect
+        .soft(`${user?.name.first_name} ${user?.name.last_name}`, persona.email)
+        .toBe(persona.name);
+      expect.soft(user?.address.zip, persona.email).toBe(persona.zip);
     }
   });
 
   test("every persona carries a hint, so a user can pick a path deliberately", () => {
     for (const persona of DEMO_PERSONAS) {
-      expect(persona.hint.length, persona.name).toBeGreaterThan(20);
+      expect.soft(persona.hint.length, persona.name).toBeGreaterThan(20);
     }
   });
 });

package/dist/templates/solo-rpg/agent.test.ts

@@ -167,11 +167,13 @@ describe("applyConsequences MISS matrix", () => {
     ] as const) {
       const state = playingState();
       const { deltas, clockEvents } = applyConsequences(state, miss, position, "standard", null);
-      expect(state.health).toBe(5 - dmg);
-      expect(deltas.health).toBe(-dmg);
-      expect(state.clocks[0]?.filled).toBe(ticks);
-      expect(deltas.clockTicks).toBe(ticks);
-      expect(clockEvents).toHaveLength(0); // 4-segment clock not full yet
+      // Each row starts from a fresh state, so they are independent — assert
+      // softly and a rebalanced table reports the whole matrix in one run.
+      expect.soft(state.health, position).toBe(5 - dmg);
+      expect.soft(deltas.health, position).toBe(-dmg);
+      expect.soft(state.clocks[0]?.filled, position).toBe(ticks);
+      expect.soft(deltas.clockTicks, position).toBe(ticks);
+      expect.soft(clockEvents, position).toHaveLength(0); // 4-segment clock not full yet
     }
   });
 

package/dist/templates/solo-rpg/shared.ts

@@ -341,8 +341,8 @@ export function saveGameState(ctx: ToolContext, state: GameState): void {
 
 // ── Persistent save slots (ctx.db) ───────────────────────────────────────────
 // save_game / load_game are genuine cross-session persistence, so they use
-// the app's SQL database. Requires storage: `aai storage enable` (or the
-// Storage toggle in the studio); under `aai dev`, set DATABASE_URL in .env.
+// the app's SQL database. Requires storage: `aai storage enable` (or
+// Settings → Database in the studio); under `aai dev`, set DATABASE_URL in .env.
 //
 // Slots are keyed by name alone — the whole point of a save is loading it in
 // a LATER session, whose sessionId differs, so the key can't embed one. The

package/dist/{test-CkXvfcpq.mjs → test-C-V98oC-.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { a as ok, n as fail } from "./_output-CC300DzW.mjs";
-import { n as log } from "./_ui-RZmPgrF6.mjs";
-import { a as errorMessage, n as binFromPackageJson, r as errorCode } from "./_utils-Ch0J4s6a.mjs";
+import { n as log } from "./_ui-DfwfDbT-.mjs";
+import { a as errorMessage, n as binFromPackageJson, r as errorCode } from "./_utils-8KKw-bzi.mjs";
 import { createRequire } from "node:module";
 import { existsSync } from "node:fs";
 import path from "node:path";
@@ -51,8 +51,7 @@ function runVitest(cwd) {
 		testFile
 	], {
 		cwd,
-		stdio: "inherit",
-		env: { NODE_OPTIONS: "--experimental-strip-types" }
+		stdio: "inherit"
 	});
 	return true;
 }

package/dist/typecheck.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { a as errorMessage, n as binFromPackageJson } from "./_utils-Ch0J4s6a.mjs";
-import { existsSync } from "node:fs";
+import { a as errorMessage, n as binFromPackageJson } from "./_utils-8KKw-bzi.mjs";
+import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { spawn } from "node:child_process";
 //#region typecheck.ts
@@ -56,13 +56,69 @@ function findTypescriptPackage(cwd) {
 		dir = parent;
 	}
 }
-/** Resolve the project's TypeScript compiler entry (its own `tsc` bin). */
-function resolveTscEntry(cwd) {
+/**
+* Resolve the project's TypeScript compiler entry (its own `tsc` bin), plus
+* its major version — see {@link tscArgs} for what the version decides.
+*/
+function resolveTsc(cwd) {
 	const dir = findTypescriptPackage(cwd);
 	if (dir === void 0) throw new Error("no typescript package in the project's node_modules");
-	const bin = binFromPackageJson(path.join(dir, "package.json"), "tsc");
+	const manifest = path.join(dir, "package.json");
+	const bin = binFromPackageJson(manifest, "tsc");
 	if (!bin) throw new Error("installed typescript package declares no tsc bin");
-	return bin;
+	return {
+		entry: bin,
+		major: readMajor(manifest)
+	};
+}
+/**
+* The resolved compiler's major version, or 0 when it can't be read.
+*
+* 0 is the safe answer: {@link tscArgs} only ADDS flags above a version
+* floor, so an unreadable manifest degrades to the flag set every TypeScript
+* accepts rather than failing a build over a cosmetic read.
+*/
+function readMajor(manifest) {
+	try {
+		const { version } = JSON.parse(readFileSync(manifest, "utf-8"));
+		return typeof version === "string" ? Number.parseInt(version, 10) || 0 : 0;
+	} catch {
+		return 0;
+	}
+}
+/**
+* The `tsc` argv for one project check.
+*
+* `--singleThreaded` is the interesting one, and it is a SPEEDUP here rather
+* than a throttle. TypeScript 7 parallelizes parse/check/emit by default,
+* which pays off on a repo-sized program and costs on a single agent project —
+* and this function only ever checks one of those. Measured on the templates
+* project (14 agents, the closest in-repo analogue of a studio workspace):
+*
+* - pinned to 1 core: 2.4–2.9s parallel vs 1.2–1.4s single — ~2x faster
+* - on 4 cores:       1.21–1.24s parallel vs 1.01–1.04s single
+*
+* The 1-core number is the one that matters: a guest sandbox RESERVES one CPU
+* (`SANDBOX_CPU`) and this same check runs after every settled write burst in
+* the studio (`aai-guest/studio-write-diagnostics.ts`), where the whole design
+* rests on it finishing in well under a second. Parallelism inside a one-core
+* reservation is oversubscription: the threads exist, contend, and the wall
+* clock doubles.
+*
+* Gated on major >= 7 because the flag is TS 7's, and an unknown compiler
+* option is a HARD error (TS5023) — a project pinning an older TypeScript
+* would fail its build on a flag it never asked for. `engines`/scaffold pin
+* `^7`, so in practice this floor is always met; it exists so a project that
+* pins otherwise degrades instead of breaking.
+*/
+function tscArgs(entry, major) {
+	return [
+		entry,
+		"--noEmit",
+		"--pretty",
+		"false",
+		...major >= 7 ? ["--singleThreaded"] : []
+	];
 }
 /**
 * Typecheck the project at `cwd` with its own tsconfig + compiler.
@@ -76,9 +132,9 @@ async function typecheckProject(cwd) {
 		ok: true,
 		skipped: true
 	};
-	let tscEntry;
+	let tsc;
 	try {
-		tscEntry = resolveTscEntry(cwd);
+		tsc = resolveTsc(cwd);
 	} catch (err) {
 		return {
 			ok: false,
@@ -86,12 +142,7 @@ async function typecheckProject(cwd) {
 		};
 	}
 	const result = await new Promise((resolve, reject) => {
-		const child = spawn(process.execPath, [
-			tscEntry,
-			"--noEmit",
-			"--pretty",
-			"false"
-		], {
+		const child = spawn(process.execPath, tscArgs(tsc.entry, tsc.major), {
 			cwd,
 			timeout: TYPECHECK_TIMEOUT_MS,
 			stdio: [

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@alexkroman1/aai-cli",
-  "version": "5.9.0",
+  "version": "5.10.1",
   "type": "module",
   "bin": {
-    "aai": "dist/cli.mjs"
+    "aai": "bin.mjs"
   },
   "exports": {
     "./client-bundler": {
@@ -23,6 +23,7 @@
     }
   },
   "files": [
+    "bin.mjs",
     "dist"
   ],
   "dependencies": {
@@ -37,8 +38,8 @@
     "p-timeout": "^7.0.1",
     "vite": "^8.1.5",
     "zod": "^4.4.3",
-    "@alexkroman1/aai": "5.9.0",
-    "@alexkroman1/aai-ui": "5.9.0"
+    "@alexkroman1/aai": "5.10.1",
+    "@alexkroman1/aai-ui": "5.10.1"
   },
   "devDependencies": {
     "playwright": "^1.61.1",