@alexkroman1/aai-cli 9.2.0 → 10.0.0

package/dist/templates/redline/client.tsx

@@ -24,6 +24,31 @@
  * and a textarea holds a string where the workflow's schema wants `string[]`.
  * `toInput` is where the two meet — and it is the only place, so the split lives
  * in one function rather than in the field, the submit handler and the workflow.
+ *
+ * ## A reload used to lose the loop, which is minutes of model calls
+ *
+ * A `runId` names a run for as long as something holds it, and this page held it
+ * in React state — so a refresh lost it while the loop carried on writing,
+ * grading and revising without anywhere to report to. On a desk whose whole
+ * subject is a loop that runs several long-form model calls, that is the one
+ * failure worth two lines of wiring: `key` is the handle that survives a reload
+ * and `recover` is what reads it back, so the draft, the critique trail and the
+ * Clear button are all there again.
+ *
+ * **The key is opaque and lives in `sessionStorage`, and the brief is why.** A
+ * `?key=` parameter in the page's own URL would survive more — a new tab, a
+ * bookmark, a link sent to the person who asked for the piece — and that is
+ * exactly what it must not do here. There is no per-user filtering behind
+ * `find`, so the key IS the scoping mechanism, and a brief is the most private
+ * thing on this page: it is what somebody typed about their own product, their
+ * own incident or their own customers, and the critique trail beside it is
+ * working material nobody writes expecting an audience. The thing worth sending
+ * a colleague is the DRAFT, which is text on the page and travels by being
+ * copied; sending a run means sending the brief that produced it.
+ *
+ * Deriving the key from the brief is worse again: two people briefing the same
+ * thing would recover each other's runs, and the key would then carry what they
+ * typed into a lookup token the platform deliberately stopped logging.
  */
 
 import "@alexkroman1/aai-ui/styles.css";
@@ -35,12 +60,14 @@ import {
   page,
   SubmitButton,
   TextAreaField,
+  useRunKey,
   useWorkflowSubmit,
   WORKFLOW_STATUS_LABELS,
   WorkflowFields,
   WorkflowProgress,
   type WorkflowRun,
 } from "@alexkroman1/aai-ui";
+import { useState } from "react";
 import type { redline } from "./agent.ts";
 
 /**
@@ -55,6 +82,21 @@ type Redline = WorkflowOutputOf<typeof redline>;
 /** The workflow this page drives. Matches the key in `workflowApp({ workflows })`. */
 const WORKFLOW = "redline";
 
+/**
+ * What the desk says while the loop is turning — three situations, one line
+ * each.
+ *
+ * The reload case gets its own words deliberately: somebody who did not press
+ * the button is owed an explanation for a draft appearing in front of them, and
+ * the sentence a page reaches for instead ("you can close this tab") is the one
+ * that was true about the RUN and false about the page.
+ */
+function pendingNote(startedHere: boolean, found: boolean): string {
+  if (startedHere) return "Reloading is safe — this page will find the draft again.";
+  if (!found) return "Looking for a draft this tab started earlier…";
+  return "Still working on a draft this tab started earlier.";
+}
+
 /**
  * The submitted form as the workflow's input schema wants it.
  *
@@ -79,7 +121,19 @@ export function toInput(values: FormValues): WorkflowInputOf<typeof redline> {
 }
 
 function RedlineDesk() {
-  const { submit, run, pending, error, reset } = useWorkflowSubmit<typeof redline>(WORKFLOW);
+  // This tab's handle on its own drafts — opaque, short, and remembered for the
+  // next load, which is what `recover` produces to find the run again.
+  const key = useRunKey();
+  // Did THIS load start the run? A reload cannot have, and that is the only way
+  // the page can tell "writing what you just briefed" from "picking up where
+  // you left off" — the hook reports the run, not who asked for it.
+  const [startedHere, setStartedHere] = useState(false);
+  const { submit, run, pending, error, reset } = useWorkflowSubmit<typeof redline>(WORKFLOW, {
+    // Neither half is useful alone: without the key there is nothing to find
+    // the run by, and without `recover` the key is only ever written.
+    key,
+    recover: true,
+  });
 
   return (
     <main className="mx-auto flex max-w-2xl flex-col gap-8 p-8">
@@ -91,7 +145,13 @@ function RedlineDesk() {
         </p>
       </header>
 
-      <Form onSubmit={(values) => submit(toInput(values))} error={error}>
+      <Form
+        onSubmit={(values) => {
+          setStartedHere(true);
+          return submit(toInput(values));
+        }}
+        error={error}
+      >
         {/* The scalars: brief, audience, rounds. Declared, not written. */}
         <WorkflowFields workflow={WORKFLOW} />
         {/* The array the schema declares and no generic control can render. */}
@@ -104,7 +164,27 @@ function RedlineDesk() {
         <SubmitButton pending={pending}>Write it</SubmitButton>
       </Form>
 
-      {run && <RunPanel run={run} onClear={reset} />}
+      {/* `pending` covers the RUN rather than the request, and on a reload it is
+          also true while the run is being looked up by key — the stretch where a
+          form offering Submit would be inviting a second loop over the same
+          brief, which here is several long-form model calls of somebody's
+          money. */}
+      {pending && (
+        <p className="text-sm opacity-70">{pendingNote(startedHere, run !== undefined)}</p>
+      )}
+
+      {run && (
+        <RunPanel
+          run={run}
+          onClear={() => {
+            // The recovered run is dismissed as deliberately as one this load
+            // started: `reset()` is not undone by a second lookup (the lookup
+            // is a mount-time act), so Clear really does clear.
+            setStartedHere(false);
+            reset();
+          }}
+        />
+      )}
     </main>
   );
 }

package/dist/templates/redline/workflows/redline.ts

@@ -2,7 +2,7 @@
  * The durable half of the redline desk: write, critique, revise — in a loop
  * whose length the CRITIC decides.
  *
- * The rules a `"use workflow"` body lives under are spelled out in
+ * The rules a workflow body lives under are spelled out in
  * `research-workflow/workflows/research.ts` and `link-digest/workflows/digest.ts`:
  * the body is replayed from the top on every resume, so it holds no live handle
  * and makes no undurable decision, and a step's arguments and result cross a
@@ -16,9 +16,10 @@
  * different thing: `critique` returns a verdict, the body breaks on it, and a
  * replay reads that verdict back out of the journal and takes the same branch.
  * Deciding it any other way — a clock, a random draw, a re-read of something
- * outside the run — would let a replay diverge, and the DevKit correlates
- * journal entries to step calls by issue order, so a divergent branch is a
- * `ReplayDivergenceError` rather than a slightly different essay.
+ * outside the run — would let a replay diverge. A step is identified by its
+ * NAME plus the number of times that name has been reached in this run, so a
+ * branch that takes a different path on replay reads a journal entry that was
+ * written for a different call, rather than producing a slightly different essay.
  *
  * ## Why durability earns its keep here, specifically
  *
@@ -31,10 +32,14 @@
  * three functions read more tidily than one.
  */
 
+import type { WorkflowCtx } from "@alexkroman1/aai";
 import { report } from "@alexkroman1/aai/step";
-import { stepGenerateClassified, stepGenerateJsonClassified } from "@alexkroman1/aai/step-errors";
+import {
+  FatalError,
+  stepGenerateClassified,
+  stepGenerateJsonClassified,
+} from "@alexkroman1/aai/step-errors";
 import { countWords } from "@alexkroman1/aai/utils";
-import { FatalError } from "workflow";
 import { z } from "zod";
 import { CRITIC_SYSTEM, REVISER_SYSTEM, WRITER_SYSTEM } from "./prompts.ts";
 
@@ -93,15 +98,22 @@ export interface Round {
  * the page's render model — and `WorkflowOutputOf<typeof redline>` in
  * `client.tsx` is that type, derived rather than restated.
  */
-export async function redlineFlow(input: RedlineInput) {
-  "use workflow";
-
-  let draft = await writeDraft(input);
+export async function redlineFlow(input: RedlineInput, ctx: WorkflowCtx) {
+  // The three `maxAttempts` below were `maxRetries` properties on the functions
+  // (3, 5, 3 — retries AFTER the first attempt, so 4, 6, 4 in all). The policy
+  // is an argument to the CALL now, which is where it belongs: the same function
+  // called from two places may deserve different patience.
+  let draft = await ctx.step("writeDraft", () => writeDraft(input), { maxAttempts: 4 });
   const rounds: Round[] = [];
   let shipped = false;
 
   for (let round = 1; round <= input.rounds; round++) {
-    const critique = await critiqueDraft(draft, input, round);
+    // ONE call site in a loop, which is exactly what `(name, occurrence)` step
+    // identity is for: this is `critiqueDraft#0`, `critiqueDraft#1`, … so each
+    // round journals separately and a resume replays the rounds already done.
+    const critique = await ctx.step("critiqueDraft", () => critiqueDraft(draft, input, round), {
+      maxAttempts: 6,
+    });
 
     if (critique.verdict === "ship") {
       // The break is decided by a STEP'S JOURNALED RESULT, which is what makes
@@ -111,7 +123,9 @@ export async function redlineFlow(input: RedlineInput) {
       break;
     }
 
-    draft = await reviseDraft(draft, critique, input, round);
+    draft = await ctx.step("reviseDraft", () => reviseDraft(draft, critique, input, round), {
+      maxAttempts: 4,
+    });
     rounds.push({ round, critique, revisedWords: countWords(draft) });
   }
 
@@ -127,8 +141,6 @@ export async function redlineFlow(input: RedlineInput) {
 
 /** Their `generation_node`, first pass. */
 export async function writeDraft(input: RedlineInput): Promise<string> {
-  "use step";
-
   if (input.brief.trim().length < MIN_BRIEF_CHARS) {
     // Fatal rather than retryable: the same brief is the same brief on every
     // attempt, and four more model calls will not make it longer.
@@ -163,8 +175,6 @@ export async function critiqueDraft(
   input: RedlineInput,
   round: number,
 ): Promise<Critique> {
-  "use step";
-
   await report(`Round ${round}: reading it back critically.`);
   // `stepGenerateJson` owns the fence, the parse, the non-object case and the
   // shape — and throws PLAINLY when any of them misses, unlike the fatal one
@@ -197,8 +207,6 @@ export async function reviseDraft(
   input: RedlineInput,
   round: number,
 ): Promise<string> {
-  "use step";
-
   await report(`Round ${round}: revising.`);
   const revised = await stepGenerateClassified(
     [
@@ -239,8 +247,3 @@ export function clampScore(score: number): number {
 // `RetryableError` carrying the delay the gateway itself named, which beats
 // `RetryableError`'s own one-second default. Three templates each wrapped the
 // raw `/step` call to say that; the wrapper is a suffix on the import now.
-
-/** A rate limit — and a model that ignored the format — are both expected. */
-critiqueDraft.maxRetries = 5;
-writeDraft.maxRetries = 3;
-reviseDraft.maxRetries = 3;

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

@@ -28,6 +28,13 @@
 // And what no eval here can see at all: anything below the audio boundary —
 // endpointing, barge-in, whether two sentences merged into one turn.
 
+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 { research } from "./shared.ts";
 /**
  * The def a DEPLOYED agent runs: authored, plus what `tools/` declares.
  *
@@ -40,13 +47,7 @@
  * The glob is written here rather than reached for from a shared helper because
  * this file SHIPS — see `agent.test.ts`.
  */
-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 { research } from "./shared.ts";
+import { REVIEW_DELAY_MS } from "./workflows/research.ts";
 
 /**
  * The key the run's steps read with `requireStepEnv`.
@@ -249,7 +250,7 @@ describeEval(
         // durable `sleep` rather than suspending, so what a case can honestly
         // claim is that the body asked — and that is the assertion that fails
         // if the suspension is ever deleted.
-        expect(run?.slept).toEqual([{ duration: "30 seconds" }]);
+        expect(run?.slept).toEqual([{ duration: REVIEW_DELAY_MS }]);
 
         // Six model calls, all through the step slot: the fan-out's width came
         // from a journaled stage rather than from anything the body recomputed.

package/dist/templates/research-workflow/agent.test.ts

@@ -13,7 +13,7 @@
  * progress stream, the early wake) ask for what a voice reply can use.
  *
  * The STEPS are exercised separately, and directly: imported through vitest with
- * no bundler in the path, a `"use step"` function is an ordinary async function,
+ * a step is an ordinary exported async function,
  * so its prompt handling, its parsing and its `FatalError` guards are all
  * testable — while durability, suspension and replay are not. The body itself is
  * not driven here for that reason; `aai-cli`'s `dev-workflow.scenario.test.ts`
@@ -21,9 +21,11 @@
  */
 
 import type { WorkflowClient } from "@alexkroman1/aai";
+import { FatalError, RetryableError } from "@alexkroman1/aai/step-errors";
 import {
   createRunSnapshot,
   createToolContext,
+  createWorkflowCtx,
   parseSchemaInput,
   type StubGatewayCall,
   schemaInputIssues,
@@ -33,7 +35,6 @@ import { mockWorkflows, installStubGateway as stubGateway } from "@alexkroman1/a
 import { visitWebpage, webSearch } from "@alexkroman1/aai/tools";
 import type { WorkflowRunSnapshot } from "@alexkroman1/aai/workflow-api";
 import { beforeEach, describe, expect, test, vi } from "vitest";
-import { FatalError, RetryableError } from "workflow";
 import { research } from "./shared.ts";
 import {
   countSources,
@@ -41,6 +42,7 @@ import {
   findGaps,
   investigate,
   planAngles,
+  researchFlow,
   writeBrief,
   writeReport,
 } from "./workflows/research.ts";
@@ -422,13 +424,37 @@ describe("the steps that research", () => {
     expect(promptOf(calls, 2)).toContain("search is down");
   });
 
-  test("investigate retries beyond the default, because a rate limit is expected", () => {
-    expect(investigate.maxRetries).toBeGreaterThan(3);
+  test("both investigate waves are called with more attempts than the default", async () => {
+    // The retry policy is an argument to `ctx.step` now rather than a
+    // `maxRetries` property, so it is observable only at the CALL — and there
+    // are two calls, one per wave, which is exactly the kind of thing a property
+    // could not have said differently.
+    // `planAngles`' result is what the fan-out iterates, so it is supplied
+    // rather than run — the rest of the body needs no page and no model.
+    const ctx = createWorkflowCtx({
+      runSteps: false,
+      // Every step the body READS needs a value: with `runSteps: false` nothing
+      // runs, so this is the skeleton of a run rather than a run. That is the
+      // trade — no page, no model and no search, in exchange for spelling the
+      // shape out.
+      results: {
+        planAngles: ["Adoption", "Tooling"],
+        findGaps: ["Cost"],
+        investigate: { angle: "Adoption", findings: "f", sources: [] },
+        investigateGap: { angle: "Cost", findings: "f", sources: [] },
+        writeReport: { summary: "s", report: "r" },
+      },
+    });
+    await researchFlow({ topic: "Tool use", requestedBy: "Ada" }, ctx);
+
+    const investigations = ctx.steps.filter((step) => step.name.startsWith("investigate"));
+    expect(investigations.length).toBeGreaterThan(0);
+    for (const step of investigations) expect(step.maxAttempts).toBeGreaterThan(3);
   });
 
-  test("a rate limit is RETRYABLE, so the DevKit tries again", async () => {
+  test("a rate limit is RETRYABLE, so the engine tries again", async () => {
     // The message alone cannot say this — a 429 and a 401 read alike — so what
-    // is asserted is the class the DevKit actually branches on.
+    // is asserted is the class the engine actually branches on.
     stubGateway([""], { status: 429 });
     const err = await investigate(brief, "Tool use").catch((thrown: unknown) => thrown);
     expect(RetryableError.is(err)).toBe(true);

package/dist/templates/research-workflow/agent.ts

@@ -48,10 +48,10 @@
  *
  * ## What is NOT here
  *
- * No `ctx.step`, no `ctx.waitFor`. Steps are `"use step"` functions in
- * `workflows/research.ts` and waitpoints are the Workflow DevKit's own
- * `defineHook()`. The SDK's job is declaring the workflow and starting runs; the
- * durable execution belongs to `workflow`.
+ * No step function and no waitpoint. The body composes them with `ctx.step`
+ * and suspends with `ctx.sleep`; the functions themselves live in
+ * `workflows/research.ts`. What `agent.ts` owns is declaring the workflow and
+ * the two tools that start and read runs.
  *
  * ## The research is real, and it really searches the web
  *

package/dist/templates/research-workflow/shared.ts

@@ -10,9 +10,10 @@
  * so "both halves import the declaration" needs the declaration to have a home
  * that is neither half.
  *
- * The `"use workflow"` BODY stays in `workflows/research.ts`: the Workflow DevKit
- * builder scans that directory and rewrites what it finds, and a body written
- * anywhere else runs inline once with no durability and nothing saying so.
+ * The BODY stays in `workflows/research.ts` by CONVENTION rather than by
+ * mechanism — nothing scans that directory any more, and a body reached with a
+ * `ctx` is durable wherever it is written. Keeping it there is what makes the
+ * declaration, the tools and the body findable from one another.
  */
 
 import { workflow } from "@alexkroman1/aai";

package/dist/templates/research-workflow/workflows/prompts.ts

@@ -25,7 +25,7 @@
  *
  * They are ADAPTED rather than copied: theirs are written for a LangGraph agent
  * that calls tools by name and returns a long markdown report to a reader, and
- * ours are written for a `"use step"` function that calls `webSearch` itself,
+ * ours are written for a step that calls `webSearch` itself,
  * returns JSON a later step consumes, and ends at a voice agent reading two
  * sentences down a phone. What survives verbatim is the part that is the actual
  * finding: the numbered stop rules, "repeat the useful text rather than

package/dist/templates/research-workflow/workflows/research.ts

@@ -49,11 +49,11 @@
  * researcher CONCLUDED, which is exactly what the step returns.
  */
 
+import type { WorkflowCtx } from "@alexkroman1/aai";
 import { mapConcurrent, report } from "@alexkroman1/aai/step";
 import { stepGenerateClassified, stepGenerateJsonClassified } from "@alexkroman1/aai/step-errors";
 import { visitWebpage, webSearch } from "@alexkroman1/aai/tools";
 import { errorMessage, isToolFailure, plural } from "@alexkroman1/aai/utils";
-import { sleep } from "workflow";
 import { z } from "zod";
 import {
   BRIEF_SUMMARY_SYSTEM,
@@ -68,9 +68,8 @@ import {
 /**
  * Angles investigated at once. The far side of every one is a rate limit.
  *
- * 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`.
+ * Inside `DEFAULT_STEP_CONCURRENCY` (`aai-runtime`, 16), so this width is what
+ * really runs — see "The WINDOW is not the concurrency" in `mapConcurrent`.
  */
 const ANGLE_CONCURRENCY = 2;
 
@@ -82,7 +81,7 @@ const ANGLE_CONCURRENCY = 2;
  * use; what makes either affordable is that the run is SUSPENDED rather than
  * blocked, so the sandbox is free to exit and the run resumes when it comes due.
  */
-const REVIEW_DELAY = "30 seconds";
+export const REVIEW_DELAY_MS = 30_000;
 
 /** Most angles a wave may carry, whatever the supervisor asks for. */
 const MAX_ANGLES = 4;
@@ -208,35 +207,46 @@ export type Findings = {
  * is for. `agent.ts` starts this with `notify`, so the agent says so when it
  * lands rather than waiting to be asked.
  *
- * The `sleep` on top is the review wait — the one suspension in the template,
- * and what `file_it_now` skips with `wakeUp`.
+ * The `ctx.sleep` on top is the review wait — the one suspension in the template,
+ * and what `file_it_now` skips with `ctx.workflows.wakeUp`.
  */
-export async function researchFlow(input: { topic: string; requestedBy: string }) {
-  "use workflow";
-
-  const brief = await writeBrief(input.topic);
-  const angles = await planAngles(brief);
-
-  // One step per angle, bounded, in an order a replay reproduces exactly. A
-  // failed angle fails the RUN: its finished siblings are already journaled, so
-  // the resume replays them for free and re-issues only what is missing, where
-  // catching here would file a report with a silent hole in it.
+export async function researchFlow(
+  input: { topic: string; requestedBy: string },
+  ctx: WorkflowCtx,
+) {
+  const brief = await ctx.step("writeBrief", () => writeBrief(input.topic));
+  const angles = await ctx.step("planAngles", () => planAngles(brief));
+
+  // One step per angle, bounded, in an order a replay reproduces exactly —
+  // `mapConcurrent` hands out items from a monotonic cursor, so the Nth call
+  // ISSUED is item N whatever order they settle in, and the Nth call is
+  // `investigate#N`. A failed angle fails the RUN: its finished siblings are
+  // already journaled, so the resume replays them for free and re-issues only
+  // what is missing, where catching here would file a report with a silent hole
+  // in it. `maxAttempts: 5` was `investigate.maxRetries = 4`.
   const first = await mapConcurrent(angles, ANGLE_CONCURRENCY, (angle) =>
-    investigate(brief, angle),
+    ctx.step("investigate", () => investigate(brief, angle), { maxAttempts: 5 }),
   );
 
   // The supervisor's second look. Usually empty — a second wave costs the caller
   // minutes, and the prompt says so.
-  const gaps = await findGaps(brief, first);
-  const second = await mapConcurrent(gaps, ANGLE_CONCURRENCY, (angle) => investigate(brief, angle));
+  const gaps = await ctx.step("findGaps", () => findGaps(brief, first));
+  // A DIFFERENT step name from the first wave, though it calls the same
+  // function. Two waves under one name would share one occurrence counter, which
+  // is replay-safe (the waves are sequential, so the order is fixed) and reads
+  // terribly in a run's history: `investigate#7` would be the second wave's
+  // first angle with nothing saying so. The name is what an operator reads.
+  const second = await mapConcurrent(gaps, ANGLE_CONCURRENCY, (angle) =>
+    ctx.step("investigateGap", () => investigate(brief, angle), { maxAttempts: 5 }),
+  );
 
   const notes = [...first, ...second];
-  const written = await writeReport(input.topic, brief, notes);
+  const written = await ctx.step("writeReport", () => writeReport(input.topic, brief, notes));
 
   // Suspended, not blocked. On resume the body re-runs from the top and every
   // step above returns its journaled result rather than researching again —
-  // which is also what `file_it_now` ends early, through `wakeUp`.
-  await sleep(REVIEW_DELAY);
+  // which is also what `file_it_now` ends early, through `ctx.workflows.wakeUp`.
+  await ctx.sleep(REVIEW_DELAY_MS);
 
   // Whatever this returns is what `ctx.workflows.get(runId)` reports as `output`
   // on a completed run — so it is what the agent reads back, and what the
@@ -247,7 +257,7 @@ export async function researchFlow(input: { topic: string; requestedBy: string }
     report: written.report,
     sources: countSources(notes),
     angles: notes.map((note) => note.angle),
-    filedAt: await file(input.requestedBy, input.topic),
+    filedAt: await ctx.step("file", () => file(input.requestedBy, input.topic)),
   } satisfies Findings & { filedAt: string };
 }
 
@@ -260,8 +270,6 @@ export async function researchFlow(input: { topic: string; requestedBy: string }
  * later model call.
  */
 export async function writeBrief(topic: string): Promise<Brief> {
-  "use step";
-
   await report(`Working out what "${topic}" is really asking.`);
   const parsed = await stepGenerateJsonClassified(
     `Research request, as the caller said it: ${topic}`,
@@ -278,8 +286,6 @@ export async function writeBrief(topic: string): Promise<Brief> {
  * asking the model again and getting a different one.
  */
 export async function planAngles(brief: Brief): Promise<string[]> {
-  "use step";
-
   const parsed = await stepGenerateJsonClassified(briefText(brief), {
     system: PLAN_SYSTEM,
     schema: AnglesReply,
@@ -303,8 +309,6 @@ export async function planAngles(brief: Brief): Promise<string[]> {
  * at the end, which is where it becomes small enough to journal.
  */
 export async function investigate(brief: Brief, angle: string): Promise<Note> {
-  "use step";
-
   await report(`Looking into: ${angle}`);
   const seen: string[] = [];
   const sources: Source[] = [];
@@ -331,8 +335,7 @@ export async function investigate(brief: Brief, angle: string): Promise<Note> {
   return await compress(angle, seen, sources);
 }
 
-/** Retries beyond the default: the far side is a search engine and a model. */
-investigate.maxRetries = 4;
+/** UNUSED-ORPHAN-MARKER Retries beyond the default: the far side is a search engine and a model. */
 
 /**
  * The supervisor's second look.
@@ -342,8 +345,6 @@ investigate.maxRetries = 4;
  * caller who is told "still working" for twenty minutes.
  */
 export async function findGaps(brief: Brief, notes: readonly Note[]): Promise<string[]> {
-  "use step";
-
   if (notes.length === 0) return [];
   const parsed = await stepGenerateJsonClassified(
     `${briefText(brief)}\n\nWhat came back:\n${notes.map(noteText).join("\n\n")}`,
@@ -370,8 +371,6 @@ export async function writeReport(
   brief: Brief,
   notes: readonly Note[],
 ): Promise<{ report: string; summary: string }> {
-  "use step";
-
   await report(`Writing up ${notes.length} ${plural(notes.length, "angle")}.`);
   const written = await stepGenerateClassified(
     `${briefText(brief)}\n\nFindings:\n${notes.map(noteText).join("\n\n")}`,
@@ -391,8 +390,6 @@ export async function writeReport(
  * parameters carry `_` for the same reason.
  */
 export async function file(_requestedBy: string, _topic: string): Promise<string> {
-  "use step";
-
   await report("Filing the findings.");
   return "filed";
 }

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

@@ -41,7 +41,7 @@
 //     about the transcript and the summary rather than about audible audio.
 //
 // WHAT NO EVAL HERE COVERS: durability. Imported through vitest with no bundler
-// in the path, a `"use workflow"` body is an ordinary async function — no
+// in the path, a workflow body is an ordinary async function — no
 // journal, no replay, and no per-step retry, so a rate-limited live run FAILS
 // where a deployed one would have ridden it out, and the resume-replays-the-id
 // property that makes speak-and-store ONE step is argued here rather than
@@ -56,7 +56,7 @@ import {
 import { describeWorkflowEval } from "@alexkroman1/aai-runtime/eval/vitest";
 import { expect } from "vitest";
 import agentDef, { spokenSummary } from "./agent.ts";
-import { POLL_INTERVAL } from "./workflows/transcribe.ts";
+import { POLL_INTERVAL_MS } from "./workflows/transcribe.ts";
 
 /** The id every case uploads the recording under. */
 const UPLOAD_ID = "upl_eval";
@@ -271,7 +271,7 @@ describeWorkflowEval(
       expect(run.output?.transcript).toBe(TRANSCRIPT);
       // Two waits for three polls: asked for and — this being an eval rather
       // than a deployment — recorded rather than taken.
-      expect(run.slept).toEqual([{ duration: POLL_INTERVAL }, { duration: POLL_INTERVAL }]);
+      expect(run.slept).toEqual([{ duration: POLL_INTERVAL_MS }, { duration: POLL_INTERVAL_MS }]);
       expect(provider.calls.filter((call) => call.leg === "poll")).toHaveLength(3);
       // The expensive half happened ONCE, which is the whole reason the upload
       // and the submit are separate steps.