@alexkroman1/aai-cli 8.2.0 → 9.0.0

package/dist/templates/math-buddy/agent.eval.test.ts

@@ -12,16 +12,11 @@
 // different agent; and `run_code` refuses unless the EVAL supplies an executor,
 // which this suite does — so the cases below assert the answer the code came
 // back with as well as the code the tutor wrote.
-import { runInNewContext } from "node:vm";
-import { withSystemPrompt } from "@alexkroman1/aai/manifest";
-import { errorMessage } from "@alexkroman1/aai/utils";
-import type { RunCodeExecutor } from "@alexkroman1/aai-runtime/eval";
+
+import agentDef from "virtual:aai/agent";
+import { createVmRunCode, toolResultsIn } from "@alexkroman1/aai-runtime/eval";
 import { describeEval } from "@alexkroman1/aai-runtime/eval/vitest";
 import { expect } from "vitest";
-import authored from "./agent.ts";
-import systemPrompt from "./system-prompt.md?raw";
-
-const agentDef = withSystemPrompt(authored, systemPrompt);
 
 /** The code every `run_code` call in this turn carried, joined. */
 const codeIn = (turn: { toolCalls: readonly { name: string; args: Record<string, unknown> }[] }) =>
@@ -35,37 +30,13 @@ const codeIn = (turn: { toolCalls: readonly { name: string; args: Record<string,
  *
  * The builtin refuses without one — the Modal container is the security
  * boundary, and off-platform there is none — so a case could assert the CALL and
- * the code it carried, and never what the code came back with. A `node:vm`
- * context with a capturing `console.log` is what a developer would reach for on
- * their own machine, and it is enough here: what runs is arithmetic, not a
- * program. It is NOT a sandbox and does not pretend to be one; a deployed agent
- * still gets the refusal.
- *
- * A template eval imports from `@alexkroman1/aai-runtime/eval` and
- * `/eval/vitest` and nowhere else — the ROOT barrel drags the host runtime's
- * node-reaching module graph into this project's TypeScript program, which is
- * three errors in runtime files no eval ever calls. `RunCodeExecutor` is
- * re-exported from `/eval` for exactly that reason.
+ * the code it carried, and never what the code came back with.
+ * `createVmRunCode()` is a `node:vm` context with a capturing `console.log`,
+ * which is enough here: what runs is arithmetic, not a program. It is NOT a
+ * sandbox and does not pretend to be one; a deployed agent still gets the
+ * refusal.
  */
-const runCode: RunCodeExecutor = async (code) => {
-  const lines: string[] = [];
-  const log = (...args: unknown[]): void => {
-    lines.push(args.map((a) => (typeof a === "string" ? a : JSON.stringify(a))).join(" "));
-  };
-  try {
-    runInNewContext(code, { console: { log } }, { timeout: 1000 });
-  } catch (err) {
-    return { error: errorMessage(err) };
-  }
-  return lines.join("\n");
-};
-
-/** What every `run_code` call in this turn PRINTED, joined. */
-const outputIn = (turn: { toolCalls: readonly { name: string; result?: string }[] }) =>
-  turn.toolCalls
-    .filter((c) => c.name === "run_code")
-    .map((c) => c.result ?? "")
-    .join("\n");
+const runCode = createVmRunCode();
 
 describeEval(
   agentDef,
@@ -84,7 +55,7 @@ describeEval(
         expect(code).toMatch(/1\.60|1\.61|0\.621|8\.04/);
         // And the factor was applied rather than merely mentioned: five miles is
         // 8.0467 km, so whatever rounding the tutor chose the answer starts 8.0.
-        const output = outputIn(turn);
+        const output = toolResultsIn(turn.toolCalls, "run_code").join("\n");
         expect(output, `run_code printed: ${output}`).toMatch(/8\.0/);
       },
       { live: true },
@@ -108,7 +79,7 @@ describeEval(
         // face of a twenty-sided die. `Math.random` in the code says the tutor
         // asked for a roll; this says it GOT one — a `run_code` that refused
         // prints a sentence with no dice in it at all.
-        const output = outputIn(turn);
+        const output = toolResultsIn(turn.toolCalls, "run_code").join("\n");
         const rolled = [...output.matchAll(/\d+/g)].map((m) => Number(m[0]));
         expect(rolled.length, `run_code printed: ${output}`).toBeGreaterThanOrEqual(3);
         for (const face of rolled) {

package/dist/templates/night-owl/agent.eval.test.ts

@@ -1,5 +1,3 @@
-/// <reference types="vite/client" />
-
 // An EVAL: does the companion actually pick from its own shelf?
 //
 // `agent.test.ts` calls `recommend` directly, which settles what the tool does
@@ -12,24 +10,6 @@
 // SCRIPTED model (its `stubReply`): the real session, the real slot, the real
 // tool, a fake reply. That proves the wiring and nothing about the choice.
 
-import { runInNewContext } from "node:vm";
-import { withSystemPrompt } from "@alexkroman1/aai/manifest";
-import type { SessionEvent } from "@alexkroman1/aai/protocol";
-import { withDiscoveredTools } from "@alexkroman1/aai/testing";
-import { errorMessage } from "@alexkroman1/aai/utils";
-import {
-  customEventsIn,
-  lastStateIn,
-  type RunCodeExecutor,
-  toolResultIn,
-} from "@alexkroman1/aai-runtime/eval";
-import { describeEval } from "@alexkroman1/aai-runtime/eval/vitest";
-import { expect } from "vitest";
-import { z } from "zod";
-import authoredAgent from "./agent.ts";
-import { CATEGORIES, MOODS } from "./shared.ts";
-import systemPrompt from "./system-prompt.md?raw";
-
 /**
  * The def a DEPLOYED agent runs: authored, plus what `tools/` declares.
  *
@@ -44,10 +24,18 @@ import systemPrompt from "./system-prompt.md?raw";
  * different agent than the one that deploys, and every tool-choice claim below
  * then passes or fails for the wrong reason.
  */
-const agentDef = withSystemPrompt(
-  withDiscoveredTools(authoredAgent, import.meta.glob("./tools/*.ts", { eager: true })),
-  systemPrompt,
-);
+import agentDef from "virtual:aai/agent";
+import type { SessionEvent } from "@alexkroman1/aai/protocol";
+import {
+  createVmRunCode,
+  customEventsIn,
+  lastStateIn,
+  toolResultIn,
+} from "@alexkroman1/aai-runtime/eval";
+import { describeEval } from "@alexkroman1/aai-runtime/eval/vitest";
+import { expect } from "vitest";
+import { z } from "zod";
+import { CATEGORIES, MOODS } from "./shared.ts";
 
 /**
  * One `recommend` answer, and the whole projection, as the wire carries them.
@@ -84,27 +72,10 @@ const nudges = (events: readonly SessionEvent[]) => customEventsIn(events, "wind
  * boundary, and off-platform there is none — which left this template's
  * headline feature assertable as a CALL and never as a number. A `node:vm`
  * context with a capturing `console.log` is what a developer would reach for on
- * their own machine, and it is enough: the code under test is arithmetic the
- * model wrote, not a program.
- *
- * A template eval imports from `@alexkroman1/aai-runtime/eval` and
- * `/eval/vitest` and nowhere else — the ROOT barrel drags the host runtime's
- * node-reaching module graph into this project's TypeScript program, which is
- * three errors in runtime files no eval ever calls. `RunCodeExecutor` is
- * re-exported from `/eval` for exactly that reason.
+ * their own machine, and `createVmRunCode()` is exactly that: the code under
+ * test is arithmetic the model wrote, not a program.
  */
-const runCode: RunCodeExecutor = async (code) => {
-  const lines: string[] = [];
-  const log = (...args: unknown[]): void => {
-    lines.push(args.map((a) => (typeof a === "string" ? a : JSON.stringify(a))).join(" "));
-  };
-  try {
-    runInNewContext(code, { console: { log } }, { timeout: 1000 });
-  } catch (err) {
-    return { error: errorMessage(err) };
-  }
-  return lines.join("\n");
-};
+const runCode = createVmRunCode();
 
 /** Two-digit, for the clock arithmetic below. */
 const pad = (n: number): string => String(n).padStart(2, "0");

package/dist/templates/night-owl/agent.test.ts

@@ -1,28 +1,15 @@
-/// <reference types="vite/client" />
-
+/** The def a DEPLOYED agent runs: authored, plus what `tools/` declares. */
+import agentDef from "virtual:aai/agent";
 import { toAgentConfig } from "@alexkroman1/aai/manifest";
 import {
   createToolContext,
   parseToolInput,
   toolInputIssues,
   toolRunner,
-  withDiscoveredTools,
 } from "@alexkroman1/aai/testing";
 import { describe, expect, test } from "vitest";
-import authoredAgent from "./agent.ts";
 import { CATEGORIES, MOODS, nightProjection, nightSlot } from "./shared.ts";
 
-/**
- * The def a DEPLOYED agent runs: authored, plus what `tools/` declares.
- *
- * The glob is written HERE rather than reached for from a shared helper because
- * this file SHIPS — a scaffolded project has no repo helper to import.
- */
-const agentDef = withDiscoveredTools(
-  authoredAgent,
-  import.meta.glob("./tools/*.ts", { eager: true }),
-);
-
 /**
  * `runTool` takes the context in the ARGUMENTS' place when a tool needs none,
  * so `toolRunner`'s second parameter takes either — which is why it is one

package/dist/templates/personal-finance/agent.eval.test.ts

@@ -14,16 +14,11 @@
 // the answer as well as the code that was submitted. `fetch_json` is
 // unaffected — it makes a real request, so the currency case really does reach a
 // live rates API.
-import { runInNewContext } from "node:vm";
-import { withSystemPrompt } from "@alexkroman1/aai/manifest";
-import { errorMessage } from "@alexkroman1/aai/utils";
-import type { RunCodeExecutor } from "@alexkroman1/aai-runtime/eval";
+
+import agentDef from "virtual:aai/agent";
+import { createVmRunCode, toolResultsIn } from "@alexkroman1/aai-runtime/eval";
 import { describeEval } from "@alexkroman1/aai-runtime/eval/vitest";
 import { expect } from "vitest";
-import authored from "./agent.ts";
-import systemPrompt from "./system-prompt.md?raw";
-
-const agentDef = withSystemPrompt(authored, systemPrompt);
 
 type Turn = { toolCalls: readonly { name: string; args: Record<string, unknown> }[] };
 
@@ -43,37 +38,13 @@ const fetchedUrls = (turn: Turn) =>
  *
  * The builtin refuses without one — the Modal container is the security
  * boundary, and off-platform there is none — so a case could assert the CALL and
- * the code it carried, and never what the code came back with. A `node:vm`
- * context with a capturing `console.log` is what a developer would reach for on
- * their own machine, and it is enough here: what runs is arithmetic, not a
- * program. It is NOT a sandbox and does not pretend to be one; a deployed agent
- * still gets the refusal.
- *
- * A template eval imports from `@alexkroman1/aai-runtime/eval` and
- * `/eval/vitest` and nowhere else — the ROOT barrel drags the host runtime's
- * node-reaching module graph into this project's TypeScript program, which is
- * three errors in runtime files no eval ever calls. `RunCodeExecutor` is
- * re-exported from `/eval` for exactly that reason.
+ * the code it carried, and never what the code came back with.
+ * `createVmRunCode()` is a `node:vm` context with a capturing `console.log`,
+ * which is enough here: what runs is arithmetic, not a program. It is NOT a
+ * sandbox and does not pretend to be one; a deployed agent still gets the
+ * refusal.
  */
-const runCode: RunCodeExecutor = async (code) => {
-  const lines: string[] = [];
-  const log = (...args: unknown[]): void => {
-    lines.push(args.map((a) => (typeof a === "string" ? a : JSON.stringify(a))).join(" "));
-  };
-  try {
-    runInNewContext(code, { console: { log } }, { timeout: 1000 });
-  } catch (err) {
-    return { error: errorMessage(err) };
-  }
-  return lines.join("\n");
-};
-
-/** What every `run_code` call in this turn PRINTED, joined. */
-const outputIn = (turn: { toolCalls: readonly { name: string; result?: string }[] }) =>
-  turn.toolCalls
-    .filter((c) => c.name === "run_code")
-    .map((c) => c.result ?? "")
-    .join("\n");
+const runCode = createVmRunCode();
 
 describeEval(
   agentDef,
@@ -98,7 +69,7 @@ describeEval(
         // Without an executor `run_code` answers with a refusal, so every claim
         // above is satisfied by an agent that then divides in its head — which is
         // the failure this template's whole run_code rule exists to prevent.
-        const output = outputIn(turn);
+        const output = toolResultsIn(turn.toolCalls, "run_code").join("\n");
         expect(output, `run_code printed: ${output}`).toMatch(/\b36(\.0+)?\b/);
       },
       { live: true },

package/dist/templates/pipeline-simple/agent.test.ts

@@ -1,4 +1,8 @@
+import { agent } from "@alexkroman1/aai";
 import { toAgentConfig } from "@alexkroman1/aai/manifest";
+import { assemblyAIS2s, openaiS2s } from "@alexkroman1/aai/s2s";
+import { assemblyAIStt, deepgramStt, elevenLabsStt, sonioxStt } from "@alexkroman1/aai/stt";
+import { ASSEMBLYAI_TTS_VOICES, assemblyAITts, cartesiaTts, rimeTts } from "@alexkroman1/aai/tts";
 import { describe, expect, test } from "vitest";
 import agentDef from "./agent.ts";
 
@@ -30,3 +34,72 @@ describe("pipeline-simple template", () => {
     expect(config.llm?.kind).toBe("anthropic");
   });
 });
+
+/**
+ * The other stage swaps, as worked examples.
+ *
+ * `agent.ts` above declares one — the LLM — because an agent should declare one
+ * thing. But the rest of the provider surface had NO example anywhere: zero of
+ * the 26 templates set `stt:`, `tts:` or `s2s:`, so `@alexkroman1/aai/stt` and
+ * `/s2s` were 100% unexercised while carrying a semver promise. That is either
+ * an API nobody needs or an API nobody has run, and neither is a good place to
+ * leave a published surface.
+ *
+ * They live in the spec rather than in `agent.ts` for a reason worth copying:
+ * a deployed agent needs a key per vendor it names, and the all-AssemblyAI
+ * default is what makes the starter run the moment it is deployed. Declaring a
+ * stage here shows the shape and costs the template nothing.
+ */
+describe("swapping any other stage", () => {
+  test("STT: four providers, each one field on `agent()`", () => {
+    for (const [stt, kind] of [
+      [assemblyAIStt({ region: "eu" }), "assemblyai"],
+      [deepgramStt({ language: "en" }), "deepgram"],
+      [elevenLabsStt(), "elevenlabs"],
+      [sonioxStt({ languages: ["en", "es"] }), "soniox"],
+    ] as const) {
+      const config = toAgentConfig(agent({ name: "Line", stt }));
+      expect(config.stt?.kind).toBe(kind);
+      // Whatever the STT stage is, the two it does not touch still default.
+      expect(config.llm?.kind).toBe("assemblyai");
+      expect(config.tts?.kind).toBe("assemblyai");
+    }
+  });
+
+  test("TTS: three providers, and the AssemblyAI voice catalog is typed", () => {
+    for (const [tts, kind] of [
+      [assemblyAITts({ voice: "jane" }), "assemblyai"],
+      [cartesiaTts(), "cartesia"],
+      [rimeTts(), "rime"],
+    ] as const) {
+      expect(toAgentConfig(agent({ name: "Line", tts })).tts?.kind).toBe(kind);
+    }
+    // A voice outside the catalog still compiles — it may be one shipped after
+    // this release — and `agentConfigWarnings` is what says so. See its doc.
+    expect(Object.keys(ASSEMBLYAI_TTS_VOICES).length).toBeGreaterThan(0);
+  });
+
+  test("S2S: an explicit opt-in, and it REPLACES the pipeline rather than joining it", () => {
+    for (const [s2s, kind] of [
+      [assemblyAIS2s(), "assemblyai"],
+      [openaiS2s({ voice: "alloy" }), "openai-realtime"],
+    ] as const) {
+      const config = toAgentConfig(agent({ name: "Line", s2s }));
+      expect(config.s2s?.kind).toBe(kind);
+      expect(config.mode).toBe("s2s");
+      // No cascade is filled in: speech-to-speech has no separate STT or TTS,
+      // which is the whole difference and the reason `s2s` is never a default.
+      expect(config.stt).toBeUndefined();
+      expect(config.tts).toBeUndefined();
+    }
+  });
+
+  test("mixing S2S with a pipeline stage is refused, by the type AND by the config", () => {
+    // The type refuses it outright: `agent({ s2s, tts })` does not compile, which
+    // is why this reaches the runtime rule by spreading instead. Both halves
+    // matter — the second is what catches a raw `export default {...}` that
+    // never went through `agent()`.
+    const s2sAgent = agent({ name: "Line", s2s: assemblyAIS2s() });
+    expect(() => toAgentConfig({ ...s2sAgent, tts: cartesiaTts() })).toThrow();
+  });
+});

package/dist/templates/pizza-ordering/agent.eval.test.ts

@@ -1,7 +1,6 @@
-/// <reference types="vite/client" />
-
+/** The def a DEPLOYED agent runs: authored, plus what `tools/` declares. */
+import agentDef from "virtual:aai/agent";
 import type { SessionEvent } from "@alexkroman1/aai/protocol";
-import { withDiscoveredTools } from "@alexkroman1/aai/testing";
 // An EVAL: does the order-taker actually take the order?
 //
 // `agent.test.ts` drives the six tools directly, which settles what each one
@@ -18,22 +17,8 @@ import { lastStateIn, toolResultIn } from "@alexkroman1/aai-runtime/eval";
 import { describeEval } from "@alexkroman1/aai-runtime/eval/vitest";
 import { expect } from "vitest";
 import { z } from "zod";
-import authoredAgent from "./agent.ts";
 import { MENU } from "./shared.ts";
 
-/**
- * The def a DEPLOYED agent runs: authored, plus what `tools/` declares.
- *
- * The glob is written HERE rather than reached for from a shared helper because
- * this file SHIPS — a scaffolded project has no repo helper to import. Without
- * it the eval would drive an agent with no tools at all, which is the one
- * failure mode a green eval must not be able to hide.
- */
-const agentDef = withDiscoveredTools(
-  authoredAgent,
-  import.meta.glob("./tools/*.ts", { eager: true }),
-);
-
 /**
  * What the BROWSER is sent, as this eval reads it.
  *

package/dist/templates/pizza-ordering/agent.test.ts

@@ -1,28 +1,13 @@
-/// <reference types="vite/client" />
-
+/** The def a DEPLOYED agent runs: authored, plus what `tools/` declares. */
+import agentDef from "virtual:aai/agent";
 import type { ToolContext } from "@alexkroman1/aai";
 import {
   createToolContext,
   parseToolInput,
   toolInputIssues,
   toolRunner,
-  withDiscoveredTools,
 } from "@alexkroman1/aai/testing";
 import { describe, expect, test } from "vitest";
-import authoredAgent from "./agent.ts";
-
-/**
- * The def a DEPLOYED agent runs: authored, plus what `tools/` declares.
- *
- * The glob is written HERE rather than reached for from a shared helper because
- * this file SHIPS: it is what a scaffolded project runs, so it may not import
- * anything outside its own template, and `import.meta.glob` is expanded against
- * the file containing it either way. This is the pattern a user writes.
- */
-const agentDef = withDiscoveredTools(
-  authoredAgent,
-  import.meta.glob("./tools/*.ts", { eager: true }),
-);
 
 import {
   calculateTotal,

package/dist/templates/plan-and-execute/agent.eval.test.ts

@@ -1,5 +1,3 @@
-/// <reference types="vite/client" />
-
 // An EVAL: does the desk really plan, work one step, and replan? Run it with
 // `aai eval`.
 //
@@ -24,20 +22,12 @@
 // product questions from its own knowledge and skips the tools the prompt exists
 // to route it through, so a case run that way measures nothing it claims to.
 
-import { withSystemPrompt } from "@alexkroman1/aai/manifest";
-import { withDiscoveredTools } from "@alexkroman1/aai/testing";
+/** The def a DEPLOYED agent runs — see `agent.test.ts` on why the glob is here. */
+import agentDef from "virtual:aai/agent";
 import { type EvalSession, lastStateIn } from "@alexkroman1/aai-runtime/eval";
 import { describeEval } from "@alexkroman1/aai-runtime/eval/vitest";
 import { expect } from "vitest";
 import { z } from "zod";
-import authoredAgent from "./agent.ts";
-import systemPrompt from "./system-prompt.md?raw";
-
-/** The def a DEPLOYED agent runs — see `agent.test.ts` on why the glob is here. */
-const agentDef = withSystemPrompt(
-  withDiscoveredTools(authoredAgent, import.meta.glob("./tools/*.ts", { eager: true })),
-  systemPrompt,
-);
 
 /**
  * What the BROWSER is sent, as this eval reads it.

package/dist/templates/plan-and-execute/agent.test.ts

@@ -1,28 +1,8 @@
-/// <reference types="vite/client" />
-
+/** The def a DEPLOYED agent runs: authored, plus what `tools/` declares. */
+import agentDef from "virtual:aai/agent";
 import type { ToolContext } from "@alexkroman1/aai";
-import {
-  createToolContext,
-  okPosition,
-  stubGenerate,
-  toolRunner,
-  withDiscoveredTools,
-} from "@alexkroman1/aai/testing";
+import { createToolContext, okPosition, stubGenerate, toolRunner } from "@alexkroman1/aai/testing";
 import { describe, expect, test } from "vitest";
-import authoredAgent from "./agent.ts";
-
-/**
- * The def a DEPLOYED agent runs: authored, plus what `tools/` declares.
- *
- * The glob is written HERE rather than reached for from a shared helper because
- * this file SHIPS: it is what a scaffolded project runs, so it may not import
- * anything outside its own template, and `import.meta.glob` is expanded against
- * the file containing it either way. This is the pattern a user writes.
- */
-const agentDef = withDiscoveredTools(
-  authoredAgent,
-  import.meta.glob("./tools/*.ts", { eager: true }),
-);
 
 import { executeStep, MAX_STEP_SEARCHES, normalizeAct, planNode } from "./procedure.ts";
 import { EXECUTOR_SYSTEM, PLANNER_SYSTEM, REPLANNER_SYSTEM, REVISE_SYSTEM } from "./prompts.ts";

package/dist/templates/plan-and-execute/shared.ts

@@ -175,7 +175,7 @@ export const SEARCH_RESULTS = 4;
 export const liveSearch: SearchFn = async (query) => {
   const results = await webSearch<{ results?: { title?: string; url?: string }[] }>({
     query,
-    max_results: SEARCH_RESULTS,
+    maxResults: SEARCH_RESULTS,
   });
   // A REFUSED search is not an empty web, and `webSearch` answers with
   // `{ error }` rather than throwing — so an unnarrowed `?? []` below would tell

package/dist/templates/podcast-digest/agent.test.ts

@@ -92,7 +92,6 @@ const slackInput = (slackWebhookUrl: string) => ({
 describe("the declaration", () => {
   test("is a workflow app with one workflow and a static page", () => {
     expect(agentDef.name).toBe("Podcast Digest");
-    expect(agentDef.page).toBe("static");
     expect(Object.keys(agentDef.workflows ?? {})).toEqual(["dailyDigest"]);
     expect(agentDef.workflows?.dailyDigest).toBe(dailyDigest);
   });

package/dist/templates/podcast-digest/client.tsx

@@ -59,12 +59,8 @@ import "@alexkroman1/aai-ui/styles.css";
 // ERASED at build time, so naming the agent's own type costs the browser bundle
 // nothing — and it is what stops this file restating a shape `workflows/
 // digest.ts` already declares.
-import type { WorkflowOutputOf } from "@alexkroman1/aai/workflow-api";
 import type { dailyDigest } from "./agent.ts";
 
-/** What a completed run reports, derived from the workflow rather than restated. */
-type Digest = WorkflowOutputOf<typeof dailyDigest>;
-
 /** The workflow this page drives. Matches the key in `workflowApp({ workflows })`. */
 const WORKFLOW = "dailyDigest";
 
@@ -73,7 +69,8 @@ export function App() {
   // `run.output` instead of `unknown`. `error` is the agent's own sentence for a
   // rejected input — better copy than anything this page could write, and the
   // reason there is no `try`/`catch` here.
-  const { submit, run, pending, error, wake, cancel } = useWorkflowSubmit<Digest>(WORKFLOW);
+  const { submitForm, run, pending, error, wake, cancel } =
+    useWorkflowSubmit<typeof dailyDigest>(WORKFLOW);
 
   return (
     <main className="mx-auto flex max-w-2xl flex-col gap-6 p-8">
@@ -81,7 +78,7 @@ export function App() {
 
       {/* `submit()` resolves as soon as the run EXISTS — deliberately not when it
           finishes, which here could be a month away. */}
-      <Form onSubmit={(values) => submit(values)} error={error}>
+      <Form onSubmit={submitForm} error={error}>
         <WorkflowFields workflow={WORKFLOW} />
         <SubmitButton pending={pending}>
           {pending ? "Digest scheduled" : "Start digest"}

package/dist/templates/podcast-digest/workflows/digest.ts

@@ -29,12 +29,12 @@
  * ## Storage is not optional here, unlike everywhere else
  *
  * Every other template says "enable the database for durability, but it is fine
- * to build without it". For this one it is closer to a requirement: without
- * storage the run lives in the process, and a process does not survive a
- * multi-day sleep. Set `DATABASE_URL` under `aai dev`, or `aai storage enable`
- * once deployed. Build it with `intervalUnit: "minutes"` and you will see it
- * work either way; leave it on `days` without storage and the second digest
- * never arrives.
+ * to build without it". Deployed, that is settled for you: the platform keeps
+ * runs on its own database, so a multi-day sleep survives. Under `aai dev`
+ * without a `DATABASE_URL` the run lives in the process, and a process does not
+ * survive a multi-day sleep — build with `intervalUnit: "minutes"` and you will
+ * see it work either way; leave it on `days` locally and the second digest never
+ * arrives.
  *
  * ## Batch polling, which is this file's one genuinely new mechanism
  *
@@ -90,10 +90,18 @@ export const MAX_POLL_ATTEMPTS = 180;
  */
 const MAX_TRANSCRIPT_CHARS = 18_000;
 
-/** Submissions in flight at once — polite to the provider, still parallel. */
+/**
+ * Submissions in flight at once — polite to the provider, still parallel.
+ *
+ * Inside the workflow world's default worker concurrency (three on the
+ * `DATABASE_URL` path), so this width is what really runs — see "The WINDOW is
+ * not the concurrency" in `mapConcurrent`.
+ */
 const SUBMIT_CONCURRENCY = 2;
 
-/** Status checks in flight at once. Cheaper calls, so a wider gate. */
+/** Status checks in flight at once. Cheaper calls, so a wider gate — and three is
+ *  also where the world's default worker concurrency caps it, so this is the
+ *  widest a stock deployment executes. */
 const POLL_CONCURRENCY = 3;
 
 /**

package/dist/templates/recap-workflow/agent.eval.test.ts

@@ -1,5 +1,3 @@
-/// <reference types="vite/client" />
-
 // An EVAL: does this desk actually behave? Run it with `aai eval`.
 //
 // `agent.test.ts` drives the five tools against a STUBBED `ctx.workflows`, the
@@ -30,14 +28,6 @@
 //     model stays live and is what a live run measures.
 //
 // And what no eval here can see: anything below the audio boundary.
-import { withDiscoveredTools } from "@alexkroman1/aai/testing";
-import { installStubStepFetch } from "@alexkroman1/aai/testing/vitest";
-import type { EvalToolCall, EvalWorkflows } from "@alexkroman1/aai-runtime/eval";
-import { describeEval } from "@alexkroman1/aai-runtime/eval/vitest";
-import { expect } from "vitest";
-import { z } from "zod";
-import authoredAgent from "./agent.ts";
-import { recap, SAMPLE_RECORDING } from "./shared.ts";
 
 /**
  * The def a DEPLOYED agent runs: authored, plus what `tools/` declares.
@@ -50,10 +40,13 @@ import { recap, SAMPLE_RECORDING } from "./shared.ts";
  * The glob is written here rather than reached for from a shared helper because
  * this file SHIPS — see `agent.test.ts`.
  */
-const agentDef = withDiscoveredTools(
-  authoredAgent,
-  import.meta.glob("./tools/*.ts", { eager: true }),
-);
+import agentDef from "virtual:aai/agent";
+import { installStubStepFetch } from "@alexkroman1/aai/testing/vitest";
+import type { EvalToolCall, EvalWorkflows } from "@alexkroman1/aai-runtime/eval";
+import { describeEval } from "@alexkroman1/aai-runtime/eval/vitest";
+import { expect } from "vitest";
+import { z } from "zod";
+import { recap, SAMPLE_RECORDING } from "./shared.ts";
 
 /**
  * The key every step reads with `requireStepEnv` — the one name `agent.ts`