@alexkroman1/aai-cli 6.11.0 → 7.0.0

package/dist/templates/solo-rpg/tools/save_game.ts

@@ -1,17 +1,26 @@
 import { z } from "zod";
-import { gameSlot, saveSlotKey, saveSlotParam, saveState } from "../shared.ts";
+import { gameSlot, saveSlotKey, saveSlotParam, saveState, storyFlow } from "../shared.ts";
 
 // Requires storage — `aai storage enable` (or DATABASE_URL in .env under
 // `aai dev`); the rest of the game works without it.
 //
-// `gameSlot.tool` even though the body AWAITS: the reading half places no
-// constraint on the body (only `updateTool` must be synchronous, because its
-// draft is stored when it returns). What it does place is the frozen value, and
-// a save is the purest read there is.
-export default gameSlot.tool({
+/**
+ * Gated on `playing` or `gameOver` — i.e. anything but `awaitingSetup`.
+ *
+ * Saving before a character exists writes an empty campaign under a slot name,
+ * and `load_game` would then cheerfully restore it over a real game. That is a
+ * position, so it is a `when`.
+ *
+ * The body AWAITS, which a flow tool allows: only `slot.updateTool` must be
+ * synchronous, because its draft is stored when it returns. What a save needs is
+ * the frozen value, and `gameSlot.get` is what hands it over.
+ */
+export default storyFlow.tool({
   description: "Save current game to persistent storage.",
   inputSchema: z.object({ slot: saveSlotParam }),
-  async execute(args, game, ctx) {
+  when: ["playing", "gameOver"],
+  async execute(args, ctx) {
+    const game = gameSlot.get(ctx);
     await saveState(ctx, saveSlotKey(args.slot), game);
     return {
       saved: true,

package/dist/templates/solo-rpg/tools/setup_character.ts

@@ -14,10 +14,24 @@ import {
   makeNpc,
   shuffle,
   stateSummary,
+  storyFlow,
   TIME_PHASES,
   TONES,
 } from "../shared.ts";
 
+/**
+ * **Not a `storyFlow.tool`, deliberately.** Setting up is legal in every state —
+ * a player may start over at any point, an ended story included — so a `when`
+ * listing all of them would be a gate that gates nothing. It drives the flow
+ * itself, which is what `dialog.reset` and `dialog.send` are public for, and reports
+ * the position it landed in so the narrator reads what the opening turn expects.
+ *
+ * **`reset` before `send`, because a restart is not a transition.** This body
+ * replaces the campaign with a pristine `DEFAULT_STATE`; resetting the flow is
+ * the same statement on the other side, and it is what makes starting over work
+ * from `gameOver` — a final state delivers no events, so a `SETUP` transition
+ * out of it would be dead config.
+ */
 export default tool({
   description:
     "Set up the entire game in one call. Starts a completely fresh game (any previous unsaved game is replaced), generates stats, initializes state, and marks the game as ready. After this returns, just narrate the opening scene. No need to call update_state — everything is already done.",
@@ -186,12 +200,16 @@ export default tool({
       storyComplete: false,
     };
 
-    // Mark initialized
+    // Mark initialized. `initialized` is the CLIENT's render flag; the flow is
+    // what gates the tools, and `SETUP` is what puts it in `playing` — so the
+    // roll tools become available in the same call that gives them stats to
+    // roll against.
     state.initialized = true;
-    state.phase = "playing";
     state.sceneCount = 1;
 
     gameSlot.set(ctx, state);
+    storyFlow.reset(ctx);
+    const at = storyFlow.send(ctx, { type: "SETUP" });
 
     return {
       success: true,
@@ -201,6 +219,8 @@ export default tool({
       archetypeLabel: ARCHETYPES[args.archetype as keyof typeof ARCHETYPES] || args.archetype,
       openingSituation: args.openingSituation,
       creativitySeed: creativitySeed(),
+      // The position spread verbatim — the same keys every gated tool reports.
+      ...at,
       // The real saved state — never hardcoded values
       ...stateSummary(state),
     };

package/dist/templates/solo-rpg/tools/update_state.ts

@@ -15,13 +15,23 @@ import {
   makeNpc,
   nextSeqId,
   stateSummary,
+  storyFlow,
   TIME_PHASES,
-  updateCrisisFlags,
 } from "../shared.ts";
 
-export default gameSlot.updateTool({
+/**
+ * Gated on `playing`: there is nothing to sync before a character exists (that
+ * is `setup_character`'s whole job, and the prompt says not to call this after
+ * it), and nothing to sync after the story has ended.
+ *
+ * It sends `SETTLED`, because moving the scene on is what SPENDS a standing
+ * roll: once the narrator has changed the location or logged the scene, the
+ * player's window to burn momentum on the last roll has closed.
+ */
+export default storyFlow.tool({
   description:
     "Lightweight state sync for during gameplay. Handles location changes, NPC additions, clock additions, time changes, and session log entries. Resource changes (health/spirit/supply/momentum) are auto-applied by action_roll — only use those fields here for manual adjustments like resting or trading. Pass only what changed.",
+  when: "playing",
   inputSchema: z.object({
     location: z.string().max(200).describe("New location name").optional(),
     locationDesc: z.string().max(500).describe("Short location description").optional(),
@@ -54,117 +64,120 @@ export default gameSlot.updateTool({
     storyComplete: z.boolean().describe("Mark story as complete").optional(),
     logEntry: z.string().max(500).describe("Short log entry for this scene").optional(),
   }),
-  execute(args, state) {
-    const warnings: string[] = [];
-    const clockEvents: { clock: string; trigger: string }[] = [];
+  execute: (args, ctx) =>
+    gameSlot.update(ctx, (state) => {
+      const warnings: string[] = [];
+      const clockEvents: { clock: string; trigger: string }[] = [];
 
-    // Resources
-    if (args.health !== undefined) state.health = Math.max(0, Math.min(MAX_RESOURCE, args.health));
-    if (args.spirit !== undefined) state.spirit = Math.max(0, Math.min(MAX_RESOURCE, args.spirit));
-    if (args.supply !== undefined) state.supply = Math.max(0, Math.min(MAX_RESOURCE, args.supply));
-    if (args.momentum !== undefined)
-      state.momentum = Math.max(MIN_MOMENTUM, Math.min(state.maxMomentum, args.momentum));
+      // Resources
+      if (args.health !== undefined)
+        state.health = Math.max(0, Math.min(MAX_RESOURCE, args.health));
+      if (args.spirit !== undefined)
+        state.spirit = Math.max(0, Math.min(MAX_RESOURCE, args.spirit));
+      if (args.supply !== undefined)
+        state.supply = Math.max(0, Math.min(MAX_RESOURCE, args.supply));
+      if (args.momentum !== undefined)
+        state.momentum = Math.max(MIN_MOMENTUM, Math.min(state.maxMomentum, args.momentum));
 
-    // Location
-    if (args.location !== undefined) state.currentLocation = args.location;
-    if (args.locationDesc !== undefined) state.currentSceneContext = args.locationDesc;
-    if (args.timeOfDay !== undefined) state.timeOfDay = args.timeOfDay;
+      // Location
+      if (args.location !== undefined) state.currentLocation = args.location;
+      if (args.locationDesc !== undefined) state.currentSceneContext = args.locationDesc;
+      if (args.timeOfDay !== undefined) state.timeOfDay = args.timeOfDay;
 
-    // Add NPC
-    if (args.addNpcName) {
-      if (state.npcs.length >= MAX_NPCS) {
-        warnings.push(
-          `NPC limit of ${MAX_NPCS} reached — mark an existing NPC deceased or background instead.`,
-        );
-      } else {
-        state.npcs.push(
-          makeNpc({
-            id: nextSeqId(state.npcs, "npc"),
-            name: args.addNpcName,
-            description: args.addNpcDesc,
-            disposition: args.addNpcDisposition,
-            agenda: args.addNpcAgenda,
-          }),
-        );
+      // Add NPC
+      if (args.addNpcName) {
+        if (state.npcs.length >= MAX_NPCS) {
+          warnings.push(
+            `NPC limit of ${MAX_NPCS} reached — mark an existing NPC deceased or background instead.`,
+          );
+        } else {
+          state.npcs.push(
+            makeNpc({
+              id: nextSeqId(state.npcs, "npc"),
+              name: args.addNpcName,
+              description: args.addNpcDesc,
+              disposition: args.addNpcDisposition,
+              agenda: args.addNpcAgenda,
+            }),
+          );
+        }
       }
-    }
 
-    // Update NPC
-    if (args.updateNpcId) {
-      const npc = state.npcs.find((n) => n.id === args.updateNpcId);
-      if (npc) {
-        if (args.updateNpcDisposition !== undefined) npc.disposition = args.updateNpcDisposition;
-        if (args.updateNpcBond !== undefined) npc.bond = args.updateNpcBond;
-        if (args.updateNpcStatus !== undefined) npc.status = args.updateNpcStatus;
-      } else {
-        warnings.push(`No NPC with id ${args.updateNpcId}.`);
+      // Update NPC
+      if (args.updateNpcId) {
+        const npc = state.npcs.find((n) => n.id === args.updateNpcId);
+        if (npc) {
+          if (args.updateNpcDisposition !== undefined) npc.disposition = args.updateNpcDisposition;
+          if (args.updateNpcBond !== undefined) npc.bond = args.updateNpcBond;
+          if (args.updateNpcStatus !== undefined) npc.status = args.updateNpcStatus;
+        } else {
+          warnings.push(`No NPC with id ${args.updateNpcId}.`);
+        }
       }
-    }
 
-    // Add clock
-    if (args.addClockName) {
-      if (state.clocks.length >= MAX_CLOCKS) {
-        warnings.push(`Clock limit of ${MAX_CLOCKS} reached — remove a finished clock first.`);
-      } else {
-        state.clocks.push({
-          id: nextSeqId(state.clocks, "clock"),
-          name: args.addClockName,
-          clockType: args.addClockType ?? "threat",
-          segments: args.addClockSegments ?? DEFAULT_CLOCK_SEGMENTS,
-          filled: 0,
-          triggerDescription: args.addClockTrigger ?? "",
-        });
+      // Add clock
+      if (args.addClockName) {
+        if (state.clocks.length >= MAX_CLOCKS) {
+          warnings.push(`Clock limit of ${MAX_CLOCKS} reached — remove a finished clock first.`);
+        } else {
+          state.clocks.push({
+            id: nextSeqId(state.clocks, "clock"),
+            name: args.addClockName,
+            clockType: args.addClockType ?? "threat",
+            segments: args.addClockSegments ?? DEFAULT_CLOCK_SEGMENTS,
+            filled: 0,
+            triggerDescription: args.addClockTrigger ?? "",
+          });
+        }
       }
-    }
 
-    // Advance clock
-    if (args.advanceClockName) {
-      const clock = state.clocks.find((c) => c.name === args.advanceClockName);
-      if (clock && clock.filled < clock.segments) {
-        clock.filled = Math.min(clock.segments, clock.filled + 1);
-        if (clock.filled >= clock.segments) {
-          clockEvents.push({ clock: clock.name, trigger: clock.triggerDescription });
+      // Advance clock
+      if (args.advanceClockName) {
+        const clock = state.clocks.find((c) => c.name === args.advanceClockName);
+        if (clock && clock.filled < clock.segments) {
+          clock.filled = Math.min(clock.segments, clock.filled + 1);
+          if (clock.filled >= clock.segments) {
+            clockEvents.push({ clock: clock.name, trigger: clock.triggerDescription });
+          }
         }
       }
-    }
-
-    // Remove clock
-    if (args.removeClockName) {
-      state.clocks = state.clocks.filter((c) => c.name !== args.removeClockName);
-    }
 
-    // Story arc
-    if (args.advanceAct && state.storyBlueprint) {
-      state.storyBlueprint.currentAct = Math.min(
-        state.storyBlueprint.acts.length,
-        state.storyBlueprint.currentAct + 1,
-      );
-    }
-    if (args.storyComplete && state.storyBlueprint) {
-      state.storyBlueprint.storyComplete = true;
-    }
+      // Remove clock
+      if (args.removeClockName) {
+        state.clocks = state.clocks.filter((c) => c.name !== args.removeClockName);
+      }
 
-    // Session log
-    if (args.logEntry) {
-      pushCapped(
-        state.sessionLog,
-        {
-          scene: state.sceneCount,
-          summary: args.logEntry,
-          location: state.currentLocation,
-        },
-        MAX_SESSION_LOG,
-      );
-    }
+      // Story arc
+      if (args.advanceAct && state.storyBlueprint) {
+        state.storyBlueprint.currentAct = Math.min(
+          state.storyBlueprint.acts.length,
+          state.storyBlueprint.currentAct + 1,
+        );
+      }
+      if (args.storyComplete && state.storyBlueprint) {
+        state.storyBlueprint.storyComplete = true;
+      }
 
-    // Crisis check
-    updateCrisisFlags(state);
+      // Session log
+      if (args.logEntry) {
+        pushCapped(
+          state.sessionLog,
+          {
+            scene: state.sceneCount,
+            summary: args.logEntry,
+            location: state.currentLocation,
+          },
+          MAX_SESSION_LOG,
+        );
+      }
 
-    return {
-      success: true,
-      ...(warnings.length > 0 ? { warnings } : {}),
-      clockEvents,
-      ...stateSummary(state),
-    };
-  },
+      return {
+        success: true,
+        ...(warnings.length > 0 ? { warnings } : {}),
+        clockEvents,
+        ...stateSummary(state),
+      };
+    }),
+  sendFrom: (result) =>
+    result.gameOver ? { type: "DOWNED" as const } : { type: "SETTLED" as const },
 });

package/dist/templates/spoken-summary/agent.test.ts

@@ -17,32 +17,31 @@
  * its return value, and audio in one is megabytes replayed on every resume.
  */
 
-import { stubReporter, stubSpeech, stubStepFetch, stubUploads } from "@alexkroman1/aai/testing";
-import { installStubGateway } from "@alexkroman1/aai/testing/vitest";
-import { readUpload, uploadInfo } from "@alexkroman1/aai/utils";
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { readUpload, uploadInfo } from "@alexkroman1/aai/step";
+import {
+  installStubGateway,
+  installStubReporter,
+  installStubSpeech,
+  installStubTranscribe,
+  installStubUploads,
+} from "@alexkroman1/aai/testing/vitest";
+import { beforeEach, describe, expect, test, vi } from "vitest";
 import { FatalError, RetryableError } from "workflow";
 import agentDef, { spokenSummary } from "./agent.ts";
 import { speak, spokenSummaryFlow, summarize } from "./workflows/summarize.ts";
-import { countWords, createJob, pollTranscript, uploadToProvider } from "./workflows/transcribe.ts";
+import { createJob, pollTranscript, uploadToProvider } from "./workflows/transcribe.ts";
 
 /** The id every spec below uploads under. */
 const UPLOAD_ID = "upl_test";
 
-/** Slots left published reach the next file, so every one is released here. */
-const restores: (() => void)[] = [];
-afterEach(() => {
-  while (restores.length > 0) restores.pop()?.();
-});
-
 beforeEach(() => {
   // WRITABLE, because this app's whole second half stores a file — and it is
   // opt-in precisely so a step that wrote one nobody meant it to would fail.
-  restores.push(
-    stubUploads(
-      { [UPLOAD_ID]: { bytes: new Uint8Array(64), name: "standup.wav", type: "audio/wav" } },
-      { writable: true },
-    ),
+  // `install*` rather than `stub*`: the fake registers its own `onTestFinished`,
+  // which is what replaced the hand-kept restore registry this file used to hold.
+  installStubUploads(
+    { [UPLOAD_ID]: { bytes: new Uint8Array(64), name: "standup.wav", type: "audio/wav" } },
+    { writable: true },
   );
   // The step env, which is where `requireStepEnv` and `stepSpeak` read the key.
   // `vi.stubEnv` rather than an assignment: `unstubEnvs` undoes it before every
@@ -84,40 +83,38 @@ describe("the declaration", () => {
 
 describe("transcribing", () => {
   test("streams the stored recording to the provider and keeps the URL it answered", async () => {
-    const fetches = stubStepFetch(() => ({ body: { upload_url: "https://cdn/aai/1" } }));
-    restores.push(fetches.restore, stubReporter().restore);
+    const provider = installStubTranscribe({ audioUrl: "https://cdn/aai/1" });
+    installStubReporter();
 
     await expect(uploadToProvider(UPLOAD_ID)).resolves.toEqual({
       audioUrl: "https://cdn/aai/1",
     });
-    expect(fetches.calls[0]?.url).toBe("https://api.assemblyai.com/v2/upload");
-    expect(fetches.calls[0]?.headers.Authorization).toBe("test-key");
+    expect(provider.calls[0]?.leg).toBe("upload");
     // The bytes really went, and they went as the file rather than as JSON.
-    expect(fetches.calls[0]?.body?.length).toBe(64);
+    expect(provider.calls[0]?.body?.length).toBe(64);
   });
 
   test("a 429 from the provider is RETRYABLE and a 400 is not", async () => {
-    const first = stubStepFetch(() => ({ status: 429, body: { error: "slow down" } }));
-    restores.push(first.restore, stubReporter().restore);
+    const first = installStubTranscribe({ failure: { status: 429, message: "slow down" } });
+    installStubReporter();
     await expect(createJob("https://cdn/aai/1")).rejects.toBeInstanceOf(RetryableError);
+    // Unpublished by hand: this is a boundary WITHIN one test, which the
+    // per-test auto-restore cannot give.
     first.restore();
 
-    const second = stubStepFetch(() => ({ status: 400, body: { error: "bad model" } }));
-    restores.push(second.restore);
+    installStubTranscribe({ failure: { status: 400, message: "bad model" } });
     await expect(createJob("https://cdn/aai/1")).rejects.toBeInstanceOf(FatalError);
   });
 
   test("a job the provider gave up on is FATAL — no number of polls changes it", async () => {
-    restores.push(
-      stubStepFetch(() => ({ body: { status: "error", error: "corrupt audio" } })).restore,
-    );
+    installStubTranscribe({ jobError: "corrupt audio" });
 
     await expect(pollTranscript(UPLOAD_ID, "t_1")).rejects.toThrow("corrupt audio");
     await expect(pollTranscript(UPLOAD_ID, "t_1")).rejects.toBeInstanceOf(FatalError);
   });
 
   test("`done` is decided here, so the body never reads a provider's vocabulary", async () => {
-    restores.push(stubStepFetch(() => ({ body: { status: "queued" } })).restore);
+    installStubTranscribe({ pendingPolls: 1 });
 
     await expect(pollTranscript(UPLOAD_ID, "t_1")).resolves.toEqual({ done: false });
   });
@@ -125,26 +122,21 @@ describe("transcribing", () => {
   test("a finished poll carries the transcript, named by the FILENAME", async () => {
     // ONE request, not two: this used to poll for a status and then fetch the
     // identical URL again for the text the poll already had in its hand.
-    const fetches = stubStepFetch(() => ({
-      body: { status: "completed", text: "  we shipped it  ", audio_duration: 12.4 },
-    }));
-    restores.push(fetches.restore, stubReporter().restore);
+    const provider = installStubTranscribe({ text: "  we shipped it  ", durationSec: 12.4 });
+    installStubReporter();
 
     await expect(pollTranscript(UPLOAD_ID, "t_1")).resolves.toEqual({
       done: true,
       transcript: { source: "standup.wav", durationMs: 12_400, text: "we shipped it" },
     });
-    expect(fetches.calls).toHaveLength(1);
+    expect(provider.calls).toHaveLength(1);
   });
 
   test("a recording of silence is FATAL rather than an empty summary", async () => {
     // The failure this template is most likely to meet: silence transcribes
     // successfully to nothing, and everything downstream would then be asked to
     // summarize and speak no words at all.
-    restores.push(
-      stubStepFetch(() => ({ body: { status: "completed", text: "   ", audio_duration: 3 } }))
-        .restore,
-    );
+    installStubTranscribe({ text: "   ", durationSec: 3 });
 
     await expect(pollTranscript(UPLOAD_ID, "t_1")).rejects.toThrow("no speech in that recording");
     await expect(pollTranscript(UPLOAD_ID, "t_1")).rejects.toBeInstanceOf(FatalError);
@@ -160,7 +152,7 @@ describe("summarizing", () => {
         spoken: "The launch is on for Tuesday, with two bugs still open.",
       }),
     );
-    restores.push(stubReporter().restore);
+    installStubReporter();
 
     const summary = await summarize("we ship tuesday");
 
@@ -181,14 +173,14 @@ describe("summarizing", () => {
         spoken: "Several things happened.",
       }),
     );
-    restores.push(stubReporter().restore);
+    installStubReporter();
 
     expect((await summarize("…")).points).toHaveLength(4);
   });
 
   test("a reply with no spoken script FAILS rather than defaulting to silence", async () => {
     installStubGateway(JSON.stringify({ headline: "Launch is on", points: ["Ship Tuesday"] }));
-    restores.push(stubReporter().restore);
+    installStubReporter();
 
     await expect(summarize("…")).rejects.toThrow(/did not match the shape/);
   });
@@ -196,8 +188,8 @@ describe("summarizing", () => {
 
 describe("speaking", () => {
   test("stores a WAV and returns its ID — never the bytes", async () => {
-    const speech = stubSpeech({ pcmBytes: 48_000 });
-    restores.push(speech.restore, stubReporter().restore);
+    const speech = installStubSpeech({ pcmBytes: 48_000 });
+    installStubReporter();
 
     const spoken = await speak("The launch is on for Tuesday.");
 
@@ -208,7 +200,8 @@ describe("speaking", () => {
   });
 
   test("what it stored is a real WAV, named and typed for the browser", async () => {
-    restores.push(stubSpeech({ pcmBytes: 4000 }).restore, stubReporter().restore);
+    installStubSpeech({ pcmBytes: 4000 });
+    installStubReporter();
 
     const { audio } = await speak("Hello.");
 
@@ -225,8 +218,8 @@ describe("speaking", () => {
   });
 
   test("passes a chosen voice through, and omits it entirely when none was chosen", async () => {
-    const speech = stubSpeech();
-    restores.push(speech.restore, stubReporter().restore);
+    const speech = installStubSpeech();
+    installStubReporter();
 
     await speak("Hello.", "michael");
     await speak("Hello.");
@@ -237,13 +230,6 @@ describe("speaking", () => {
   });
 });
 
-describe("countWords", () => {
-  test("counts words rather than characters, and answers 0 for nothing", () => {
-    expect(countWords("we shipped it on tuesday")).toBe(5);
-    expect(countWords("  ")).toBe(0);
-  });
-});
-
 describe("the whole run", () => {
   /**
    * Answer every leg's HTTP, so the BODY can be driven end to end.
@@ -261,38 +247,35 @@ describe("the whole run", () => {
    * **The model call goes through this too, not `installStubGateway`.** A
    * published `stepFetch` is what `stepGenerate` makes its request with, so a
    * global-fetch stub is never reached once one exists — which is exactly the
-   * point `stubStepFetch` exists to make.
+   * point a published `stepFetch` exists to make, and exactly why
+   * `stubTranscribe` takes an `otherwise`: publishing REPLACES, so a flow that
+   * transcribes AND calls a model cannot install two fakes.
+   *
+   * The three transcription legs are the SDK's fake rather than this file's
+   * hand-typed wire — it routes them off the SDK's own endpoint constants, so a
+   * spec cannot pass because the fake and the step agree on a typo.
    */
   function stubProvider(reply: { headline: string; points: string[]; spoken: string }) {
-    return stubStepFetch((request) => {
-      if (request.url.includes("llm-gateway")) {
-        return { body: { choices: [{ message: { content: JSON.stringify(reply) } }] } };
-      }
-      if (request.url.endsWith("/v2/upload")) return { body: { upload_url: "https://cdn/aai/1" } };
-      if (request.method === "POST") return { body: { id: "t_1" } };
-      // One GET, carrying both the status and the text. It used to take two —
-      // a poll that read a status and threw the transcript away, then a fetch
-      // of the identical URL for the text it had just discarded.
-      return {
-        body: {
-          status: "completed",
-          text: "we ship tuesday and two bugs are left",
-          audio_duration: 42,
-        },
-      };
+    return installStubTranscribe({
+      audioUrl: "https://cdn/aai/1",
+      jobIdPrefix: "t_",
+      text: "we ship tuesday and two bugs are left",
+      durationSec: 42,
+      otherwise: (request) =>
+        request.url.includes("llm-gateway")
+          ? { body: { choices: [{ message: { content: JSON.stringify(reply) } }] } }
+          : undefined,
     });
   }
 
   test("transcribes, summarizes, speaks, and reports the file it made", async () => {
-    restores.push(
-      stubProvider({
-        headline: "Launch is on",
-        points: ["Ship Tuesday"],
-        spoken: "The launch is on for Tuesday.",
-      }).restore,
-      stubReporter().restore,
-      stubSpeech().restore,
-    );
+    stubProvider({
+      headline: "Launch is on",
+      points: ["Ship Tuesday"],
+      spoken: "The launch is on for Tuesday.",
+    });
+    installStubReporter();
+    installStubSpeech();
 
     const summary = await spokenSummaryFlow({ recording: UPLOAD_ID });
 
@@ -312,13 +295,9 @@ describe("the whole run", () => {
   });
 
   test("the voice the form chose reaches the synthesizer", async () => {
-    const speech = stubSpeech();
-    restores.push(
-      stubProvider({ headline: "Launch is on", points: ["Ship Tuesday"], spoken: "Spoken." })
-        .restore,
-      stubReporter().restore,
-      speech.restore,
-    );
+    stubProvider({ headline: "Launch is on", points: ["Ship Tuesday"], spoken: "Spoken." });
+    installStubReporter();
+    const speech = installStubSpeech();
 
     await spokenSummaryFlow({ recording: UPLOAD_ID, voice: "michael" });
 
@@ -326,17 +305,9 @@ describe("the whole run", () => {
   });
 
   test("a recording the provider gave up on fails the run rather than half-summarizing", async () => {
-    restores.push(
-      stubStepFetch((request) =>
-        request.url.endsWith("/v2/upload")
-          ? { body: { upload_url: "https://cdn/aai/1" } }
-          : request.method === "POST"
-            ? { body: { id: "t_1" } }
-            : { body: { status: "error", error: "corrupt audio" } },
-      ).restore,
-      stubReporter().restore,
-      stubSpeech().restore,
-    );
+    installStubTranscribe({ jobError: "corrupt audio" });
+    installStubReporter();
+    installStubSpeech();
 
     await expect(spokenSummaryFlow({ recording: UPLOAD_ID })).rejects.toThrow("corrupt audio");
   });