@alexkroman1/aai-cli 10.0.0 → 11.0.0

package/dist/templates/call-audit/workflows/audit.ts

@@ -3,13 +3,13 @@
  * The workflow body, and the fan-out it plans.
  *
  * ```text
- *   now                 one step   →  when the run began
+ *   ctx.now()           journaled  →  when the run began
  *   ingestRecording     one step   →  levelled PCM + every pause   (ingest.ts)
  *   planSegments        the BODY   →  where to cut                 (media.ts, pure)
  *   transcribeSegment   N steps    →  one sync API request each, bounded
  *   summarize           one step   →  headline, risks, actions      (summarize.ts)
  *   narrate             one step   →  an MP3 of the summary         (summarize.ts)
- *   now                 one step   →  when it finished
+ *   ctx.now()           journaled  →  when it finished
  * ```
  *
  * Read `transcription-workflow` first: it owns the fan-out — why the sync
@@ -163,10 +163,11 @@ export async function auditFlow(
   // of this expression — the two calls go out synchronously, left to right — which
   // is what a replay reproduces.
   //
-  // `clockStart` and `clockEnd` are two NAMES for one function, deliberately.
-  // `(name, occurrence)` step identity would tell two `now` calls apart on its
-  // own (`now#0`, `now#1`), but a run's history is read by a person: `clockEnd`
-  // says which end it is where `now#1` makes the reader count call sites.
+  // `ctx.now()` rather than a step of its own: the engine journals the read under
+  // its own key, so it is the moment the run really reached this line however
+  // many times the line is walked. This was a `ctx.step("clockStart", now)` over
+  // an exported one-line clock read, which is what everybody writes until the
+  // affordance exists.
   // `maxAttempts: 6` was `ingestRecording.maxRetries = 5` — five retries AFTER
   // the first, so six in all. More than the default 3, and not because a
   // conversion is flaky: a corrupt file fails identically forever, and
@@ -175,7 +176,7 @@ export async function auditFlow(
   // out of the store and writes a whole one back, and either can lose a
   // connection on a file this size.
   const [startedAt, ingested] = await Promise.all([
-    ctx.step("clockStart", () => now()),
+    ctx.now(),
     ctx.step("ingestRecording", () => ingestRecording(input.recording), { maxAttempts: 6 }),
   ]);
 
@@ -206,7 +207,7 @@ export async function auditFlow(
     summarize(transcript, ingested.source, ingested.durationMs),
   );
   const spoken = await ctx.step("narrate", () => narrate(summary.spoken, input.voice));
-  const finishedAt = await ctx.step("clockEnd", () => now());
+  const finishedAt = await ctx.now();
 
   // Whatever this returns is what a caller reads as `output` on a completed run —
   // so it is what the page renders, typed through `WorkflowOutputOf`. Assembled in
@@ -273,24 +274,6 @@ export async function transcribeSegment(audioId: string, segment: Segment): Prom
   return { index: segment.index, text };
 }
 
-/**
- * When it is now, as epoch ms.
- *
- * A STEP, and that is the whole reason it exists rather than a `Date.now()` in the
- * body: a body replays from the top on every resume, so a clock read there returns
- * a different value each time and every duration derived from it would be a
- * different duration. A step's result is journaled, so this is the moment the run
- * really reached this line however many times it is replayed.
- *
- * Called twice — once at each end — rather than a `startClock`/`elapsed` pair,
- * because the alternative is a step taking every field of the output so it can
- * subtract inside itself. Two journal entries and a subtraction in the body is the
- * smaller thing.
- */
-export async function now(): Promise<number> {
-  return Date.now();
-}
-
 /**
  * Join the segment transcripts into one.
  *

package/dist/templates/dispatch-center/client.tsx

@@ -1,5 +1,5 @@
 import "@alexkroman1/aai-ui/styles.css";
-import type { AgentState, ConversationItem } from "@alexkroman1/aai-ui";
+import type { AgentState, ConversationItem, Session } from "@alexkroman1/aai-ui";
 import {
   AutoScroll,
   client,
@@ -314,8 +314,21 @@ function ErrorBanner() {
   );
 }
 
+/**
+ * Start a fresh conversation without leaving the console.
+ *
+ * Written out here rather than reached for on the session, because there is no
+ * one method that does it: `reset()` clears the CONVERSATION and keeps the
+ * session, which is wrong for any agent that also keeps session-scoped state —
+ * this one's incident board would come back with the next tool call.
+ */
+function newConversation(session: Session): void {
+  session.end();
+  session.start();
+}
+
 /** The shift controls. The one place a whole-session read is what is wanted:
- *  it needs `started`, `running` and three methods, and it is three buttons. */
+ *  it needs `started`, `running` and four methods, and it is four buttons. */
 function ShiftControls({ logged }: { logged: number }) {
   const session = useSession();
   return (
@@ -345,6 +358,27 @@ function ShiftControls({ logged }: { logged: number }) {
           >
             {session.running ? "Pause" : "Resume"}
           </button>
+          {/* The one-click new conversation the default shell's
+              `<Controls>` gives every other template — a custom
+              `component:` renders no `<Controls>`, so a console like
+              this one has to say it itself.
+
+              end() then start(), NOT reset(): reset() clears the
+              conversation and leaves the agent's own session-scoped
+              state behind, so the next tool call would repopulate the
+              shift that was just abandoned. end() drops the resume
+              identity, so the redial is a brand-new session (fresh
+              incident board, greeting included), and start() puts the
+              console straight back on the call rather than at the
+              "Start Dispatch" screen. */}
+          <button
+            type="button"
+            className="px-4 py-2 border-none rounded-md font-mono text-xs font-semibold uppercase tracking-wider cursor-pointer"
+            style={{ background: "#1e293b", color: "#e2e8f0" }}
+            onClick={() => newConversation(session)}
+          >
+            New Conversation
+          </button>
           {/* end() hangs up and flips `started` back, so the UI
               returns to "Start Dispatch" and the next start is a
               brand-new shift (fresh incident board, greeting

package/dist/templates/infocom-adventure/client.tsx

@@ -1,5 +1,5 @@
 import "@alexkroman1/aai-ui/styles.css";
-import type { AgentState } from "@alexkroman1/aai-ui";
+import type { AgentState, Session } from "@alexkroman1/aai-ui";
 import {
   AutoScroll,
   client,
@@ -220,9 +220,26 @@ function ErrorBanner() {
   );
 }
 
-/** Pause/resume and hang-up. The only place a whole-session subscription is
- *  still needed: the ACTIONS live on `useSession()`, and `useSessionCore` — the
- *  narrow way `<Controls>` reaches them — is not on the public surface. */
+/**
+ * Start a fresh conversation without leaving the game screen.
+ *
+ * Written out here rather than reached for on the session, because there is no
+ * one method that does it: `reset()` clears the CONVERSATION and keeps the
+ * session, which is wrong for any agent that also keeps session-scoped state —
+ * this game's world would come back with the next tool call. `end()` drops the
+ * resume identity, so the redial is a brand-new session (fresh world, opening
+ * scene included), and `start()` puts the player straight into it rather than
+ * back at the title screen.
+ */
+function newConversation(session: Session): void {
+  session.end();
+  session.start();
+}
+
+/** Pause/resume, new game and hang-up. The only place a whole-session
+ *  subscription is still needed: the ACTIONS live on `useSession()`, and
+ *  `useSessionCore` — the narrow way `<Controls>` reaches them — is not on the
+ *  public surface. */
 function Footer() {
   const session = useSession();
   return (
@@ -240,18 +257,29 @@ function Footer() {
         >
           {session.running ? "[P]ause" : "[R]esume"}
         </button>
-        {/* end() hangs up and drops the sessionId, so the
-            session-scoped game state starts over and the title
-            screen returns. (session.reset() keeps the same
-            sessionId and would resume the old game.) */}
+        {/* The one-click new conversation the default shell's `<Controls>`
+            gives every other template — a custom `component:` renders no
+            `<Controls>`, so this screen has to say it itself. Here that is a
+            new game: end() drops the sessionId, so the session-scoped game
+            state starts over, and start() deals the player straight into it. */}
         <button
           type="button"
           className="px-4 py-1 bg-transparent cursor-pointer uppercase tracking-wider font-mono text-[11px]"
           style={{ color: GREEN_DIM, border: `1px solid ${GREEN_DARK}` }}
-          onClick={() => session.end()}
+          onClick={() => newConversation(session)}
         >
           [N]ew Game
         </button>
+        {/* The hang-up: end() alone flips `started` back, so the title screen
+            returns and nothing is dialled until the player asks for it. */}
+        <button
+          type="button"
+          className="px-4 py-1 bg-transparent cursor-pointer uppercase tracking-wider font-mono text-[11px]"
+          style={{ color: GREEN_DIM, border: `1px solid ${GREEN_DARK}` }}
+          onClick={() => session.end()}
+        >
+          [Q]uit
+        </button>
       </div>
     </div>
   );

package/dist/templates/link-digest/agent.eval.test.ts

@@ -152,7 +152,7 @@ describeWorkflowEval(agentDef, (test) => {
     expect(run.reported).toContain("Filing the digest.");
     // The one thing this harness cannot do, stated as an assertion rather than
     // left implied: the durable wait was ASKED FOR and not taken.
-    expect(run.slept).toEqual([{ duration: SETTLE_MS }]);
+    expect(run.slept).toEqual([{ label: "settle", duration: SETTLE_MS }]);
   });
 
   test("fails terminally on a page with no readable text", async ({ app, mode }) => {

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

@@ -10,26 +10,40 @@
  * rename here is a runtime 400 there), and the input schema (which is both the
  * call-site validation and the JSON Schema `GET /workflows` serves).
  *
- * The workflow BODY is not tested here: it is only durable once the Workflow
- * DevKit's build has transformed it, so a unit test of it would exercise a plain
- * async function and prove nothing about replay. Its STEPS are, and directly —
- * a step is an ordinary exported async function, so
- * async function, so its HTML handling, its JSON contract with the model and its
- * `FatalError` guards are all testable.
+ * The STEPS are exercised directly — a step is an ordinary exported async
+ * function, so its HTML handling, its JSON contract with the model and its
+ * `FatalError` guards are all testable without an engine.
+ *
+ * And so is the BODY, durably, which it was not: this file used to say the body
+ * "is only durable once the Workflow DevKit's build has transformed it, so a
+ * unit test of it would exercise a plain async function and prove nothing about
+ * replay". That stopped being true when the DevKit was replaced — the engine
+ * runs a run off the agent's own `workflows` declaration, in process, with no
+ * bundler in the path. `runWorkflow` from `@alexkroman1/aai-runtime/testing` is
+ * that engine, so the last block below asserts the thing this template exists to
+ * demonstrate: the run SUSPENDS on its settle window and resumes past it without
+ * fetching the page or paying the model again.
  */
 
-import { createWorkflowCtx, schemaInputIssues } from "@alexkroman1/aai/testing";
+import {
+  createWorkflowCtx,
+  schemaInputIssues,
+  stubGatewayRoute,
+  stubStepInfo,
+} from "@alexkroman1/aai/testing";
 import {
   installStubStepFetch,
   installStubGateway as stubGateway,
 } from "@alexkroman1/aai/testing/vitest";
-import { beforeEach, describe, expect, test, vi } from "vitest";
+import { runWorkflow } from "@alexkroman1/aai-runtime/testing";
+import { beforeEach, describe, expect, onTestFinished, test, vi } from "vitest";
 import agentDef, { digest } from "./agent.ts";
 import {
   digestFlow,
   extractText,
   extractTitle,
   fetchArticle,
+  SETTLE_MS,
   summarize,
 } from "./workflows/digest.ts";
 
@@ -214,6 +228,30 @@ describe("summarize", () => {
     await expect(summarize(ARTICLE)).rejects.toThrow(/ASSEMBLYAI_API_KEY/);
   });
 
+  test("asks for something simpler on the LAST attempt, not on the first", async () => {
+    // The branch the extra attempts exist for, and it is only reachable from a
+    // spec through `stubStepInfo`: outside a run `stepInfo()` answers
+    // `undefined`, which the step reads as the ordinary path. Five attempts of
+    // the same ask having failed, the sixth changes the ask.
+    onTestFinished(stubStepInfo({ attempt: 6, maxAttempts: 6 }).restore);
+    const calls = stubGateway('{"headline":"H","points":["a","b","c"]}');
+
+    await summarize(ARTICLE);
+
+    expect(calls[0]?.system).toContain("one short sentence");
+  });
+
+  test("asks the ordinary way when the attempt is not the last", async () => {
+    // The half that makes the case above mean something: a spec that only
+    // asserted the fallback would pass against a step that always degraded.
+    onTestFinished(stubStepInfo({ attempt: 1, maxAttempts: 6 }).restore);
+    const calls = stubGateway('{"headline":"H","points":["a","b","c"]}');
+
+    await summarize(ARTICLE);
+
+    expect(calls[0]?.system).not.toContain("one short sentence");
+  });
+
   test("is called with more attempts than the default, because a rate limit and a bad format both happen", async () => {
     // The retry policy is an argument to `ctx.step` now, not a `maxRetries`
     // property on the function — so the assertion is about the BODY's call,
@@ -232,3 +270,121 @@ describe("summarize", () => {
     expect(ctx.steps.map((step) => step.name)).toEqual(["fetchArticle", "summarize", "file"]);
   });
 });
+
+/**
+ * The run itself, against a real durable engine.
+ *
+ * `runWorkflow` starts the declared workflow on
+ * `createInProcessWorkflowEngine` over a memory journal — the same composition
+ * root `aai dev` uses — and supplies what a deployment's queue supplies: one
+ * delivery at a time, and a suspension recorded rather than waited out. So a
+ * `ctx.sleep` a deployed run would take ten seconds over (or six hours, which
+ * the body's own comment says is the interesting version) costs this file
+ * nothing, and what is asserted is the property the template is FOR.
+ *
+ * The steps are stubbed at the same two seams the blocks above use, which is
+ * what makes this affordable: the body is real, the engine is real, the journal
+ * is real, and only the page and the model are not.
+ */
+describe("the run is DURABLE", () => {
+  const PAGE = `<html><title>Otters</title><body><p>${"Otters use tools. ".repeat(20)}</p></body></html>`;
+  const REPLY = '{"headline":"Otters use tools","points":["They do."]}';
+
+  beforeEach(() => {
+    // The same fallback the `summarize` block above relies on: `stepEnv` reads
+    // the process env when no host has published one, which is what a spec is.
+    // A run whose step cannot read its credential fails FATALLY and the whole
+    // durability claim would be made about a run that never got past its first
+    // model call.
+    vi.stubEnv("ASSEMBLYAI_API_KEY", "sk-test");
+  });
+
+  /**
+   * The page and the model, behind ONE published `stepFetch`.
+   *
+   * The composition `stubGatewayRoute` exists for, and the reason it has to be
+   * this way here rather than `installStubGateway` beside a page stub: a step's
+   * HTTP — the model call included — goes through the published slot, so a page
+   * stub installed alongside answers the gateway request with HTML and the
+   * summarize step retries six times against it. The blocks above never hit
+   * that because each stubs one seam at a time.
+   *
+   * Both call logs come back, which is what makes a replay countable.
+   */
+  function stubWorld() {
+    const model = stubGatewayRoute(REPLY);
+    const page = vi.fn(() => ({
+      status: 200,
+      body: PAGE,
+      headers: { "Content-Type": "text/html" },
+    }));
+    installStubStepFetch((request) => model.route(request) ?? page());
+    return { page, model: model.calls };
+  }
+
+  test("suspends on the settle window instead of blocking, with its work already journaled", async () => {
+    stubWorld();
+    const started = Date.now();
+    const run = await runWorkflow(
+      digest,
+      { url: "https://example.com/otters" },
+      {
+        name: "digest",
+      },
+    );
+
+    // `running` is the PARKED state — the run is in progress, it is just not
+    // executing, which is what a page polling it sees.
+    expect(run.status).toBe("running");
+    expect(run.wakeAt).toBeGreaterThanOrEqual(started + SETTLE_MS);
+    // Everything BEFORE the wait is already durable, and `file` has not run.
+    expect(run.steps.map((step) => step.name)).toEqual(["fetchArticle", "summarize"]);
+  });
+
+  test("resumes past the wait without re-reading the page or paying the model again", async () => {
+    const { page, model } = stubWorld();
+    const run = await runWorkflow(
+      digest,
+      { url: "https://example.com/otters" },
+      {
+        name: "digest",
+      },
+    );
+    await run.advanceSleep();
+
+    expect(run.status).toBe("completed");
+    expect(run.output).toMatchObject({ headline: "Otters use tools", points: ["They do."] });
+    expect(run.output?.filedAt).toBeTruthy();
+    // Two walks of the body, one fetch and one completion. That is the whole
+    // durable-execution claim, and it is why the body splits the fetch from the
+    // model call: a resume replays a stranger's page out of the journal rather
+    // than requesting it again.
+    expect(run.deliveries).toBe(2);
+    expect(page).toHaveBeenCalledTimes(1);
+    expect(model).toHaveLength(1);
+  });
+
+  test("survives a worker that dies mid-run, and only re-runs what never settled", async () => {
+    const { page, model } = stubWorld();
+    // Killed on the way into `summarize`: the fetch is journaled, the model call
+    // is not. This is the failure a body cannot be written against without being
+    // able to produce it.
+    const run = await runWorkflow(
+      digest,
+      { url: "https://example.com/otters" },
+      {
+        name: "digest",
+        crashAt: "summarize",
+      },
+    );
+    expect(run.crashed).toBe(true);
+    expect(run.steps.map((step) => step.name)).toEqual(["fetchArticle"]);
+    expect(model).toHaveLength(0);
+
+    await run.restart();
+    await run.advanceSleep();
+    expect(run.status).toBe("completed");
+    expect(page).toHaveBeenCalledTimes(1);
+    expect(model).toHaveLength(1);
+  });
+});

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

@@ -25,9 +25,10 @@
  */
 
 import type { WorkflowCtx } from "@alexkroman1/aai";
-import { report } from "@alexkroman1/aai/step";
+import { htmlToText, pageMetadata } from "@alexkroman1/aai/html";
+import { report, stepInfo } from "@alexkroman1/aai/step";
 import { FatalError, stepFetchOk, stepGenerateJsonClassified } from "@alexkroman1/aai/step-errors";
-import { decodeHtmlEntities } from "@alexkroman1/aai/utils";
+import { omitUndefined } from "@alexkroman1/aai/utils";
 import { z } from "zod";
 
 /**
@@ -51,6 +52,21 @@ const MAX_ARTICLE_CHARS = 24_000;
 /** Points the digest reduces a page to. */
 const POINTS = 3;
 
+/**
+ * The model a LAST attempt falls back to.
+ *
+ * `summarize` is given six attempts because two different things go wrong here
+ * — a rate limit, and a model that answered with prose — and by the sixth the
+ * cheap explanation is that this model is not going to produce the shape asked
+ * for. A smaller model that returns three plain sentences beats a failed run, so
+ * the last try asks a different one rather than the same one again.
+ *
+ * Unset means the gateway default, which is the same model the agent's own
+ * pipeline resolves. Point this at a smaller id for a real deployment; the
+ * useful part of the pattern is `stepInfo()?.isLastAttempt`, not the id.
+ */
+const FALLBACK_MODEL: string | undefined = undefined;
+
 /** The page fetch's deadline. HTTP has none of its own, and a hung step never ends. */
 const FETCH_TIMEOUT_MS = 30_000;
 
@@ -104,7 +120,7 @@ export async function digestFlow(input: { url: string }, ctx: WorkflowCtx) {
   // resumes when it comes due. Nothing about the code changes if it is six
   // hours — which is the interesting version, and the one that makes an
   // overnight digest a digest rather than a slow request.
-  await ctx.sleep(SETTLE_MS);
+  await ctx.sleep("settle", SETTLE_MS);
 
   const filedAt = await ctx.step("file", () => file(digest));
   return { ...digest, filedAt };
@@ -166,7 +182,20 @@ export async function fetchArticle(url: string): Promise<Article> {
  * whole Node runtime is available here, unlike in the body.
  */
 export async function summarize(article: Article): Promise<Digest> {
-  await report("Pulling out the claims worth keeping.");
+  // Which attempt is this? `undefined` outside a run — which is what a spec
+  // calling this directly gets — and a spec MEANS the ordinary path, so the
+  // fallback is keyed on `=== true` rather than on truthiness.
+  const step = stepInfo();
+  const lastChance = step?.isLastAttempt === true;
+  // `undefined` on every attempt but the last, which is what lets the option be
+  // built with `omitUndefined` rather than a conditional spread — the guard is
+  // then the value, which is the case that primitive is for.
+  const model = lastChance ? FALLBACK_MODEL : undefined;
+  await report(
+    lastChance
+      ? `Last attempt (${step?.attempt} of ${step?.maxAttempts}): asking for something simpler.`
+      : "Pulling out the claims worth keeping.",
+  );
 
   // `stepGenerateJsonClassified` unwraps the fence a model puts around JSON,
   // parses it, and validates it against `DigestReply` — and throws PLAINLY when
@@ -180,7 +209,16 @@ export async function summarize(article: Article): Promise<Digest> {
       schema: DigestReply,
       system:
         `You digest articles. Reply with JSON only: {"headline": string, "points": string[]}. ` +
-        `Give exactly ${POINTS} points. No markdown fence, no preamble.`,
+        `Give exactly ${POINTS} points. No markdown fence, no preamble.` +
+        // The instruction is blunter on the last try for the same reason the
+        // model is different: whatever it has been doing for five attempts is
+        // not working.
+        (lastChance ? " Keep every point to one short sentence." : ""),
+      // Read `isLastAttempt`, never `attempt === 6`: the ceiling lives at the
+      // `ctx.step` call site in `digestFlow`, so a number written here degrades
+      // early on every run the moment somebody changes it there — silently,
+      // because the step still returns an answer.
+      ...omitUndefined({ model }),
     },
   );
 
@@ -217,29 +255,34 @@ export async function file(_digest: Digest): Promise<string> {
 
 // ---- Pure helpers -----------------------------------------------------------
 
-/** The document's `<title>`, when it has one. */
+/**
+ * The page's own name for itself.
+ *
+ * `pageMetadata` prefers `og:title` over the `<title>` element, which is what a
+ * digest wants: a `<title>` usually carries the site name and a separator
+ * ("Otters and tools | Nature Weekly") that a one-line summary does not.
+ */
 export function extractTitle(html: string): string | undefined {
-  const title = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(html)?.[1];
-  return title ? decodeHtmlEntities(title).replace(/\s+/g, " ").trim() || undefined : undefined;
+  return pageMetadata(html).title?.replace(/\s+/g, " ").trim() || undefined;
 }
 
 /**
  * Reduce HTML to the text a model should read.
  *
- * Deliberately crude, and the crudeness is the honest part: a real extractor is
- * a readability implementation and a dependency, where this is four `replace`
- * calls that get most of an article. What it MUST do is drop `<script>` and
- * `<style>` CONTENT — stripping tags alone leaves a page's JavaScript in the
- * prompt, which is both expensive and a way to smuggle instructions past the
- * reader.
+ * `htmlToText` is a real HTML parse (`@alexkroman1/aai/html`, over htmlparser2),
+ * which matters most for the thing this MUST do: drop `<script>` and `<style>`
+ * CONTENT, because a page's JavaScript in the prompt is both expensive and a way
+ * to smuggle instructions past the reader. This was four `replace` calls, and
+ * they had a hole exactly there — `<script[^>]*>[\s\S]*?<\/script>` needs the
+ * close tag, so a page truncated mid-script (a byte cap, a dropped connection)
+ * removed nothing and the tag strip put the whole script into the prompt.
+ *
+ * Whitespace is collapsed to single spaces afterwards because this text crosses
+ * a queue between two steps and the blank lines `htmlToText` uses for block
+ * structure are bytes the summary does not read.
  */
 export function extractText(html: string): string {
-  return decodeHtmlEntities(
-    html
-      .replace(/<(script|style|noscript|template)[^>]*>[\s\S]*?<\/\1>/gi, " ")
-      .replace(/<!--[\s\S]*?-->/g, " ")
-      .replace(/<[^>]+>/g, " "),
-  )
+  return htmlToText(html, { maxChars: MAX_ARTICLE_CHARS })
     .replace(/\s+/g, " ")
     .trim()
     .slice(0, MAX_ARTICLE_CHARS);

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

@@ -247,7 +247,10 @@ describeWorkflowEval(agentDef, (test) => {
     // a run that has delivered everything it owes should end rather than sleep
     // for two hours and then end.
     const interval = scheduleIntervalMs(2, "hours");
-    expect(run.slept).toEqual([{ duration: interval }, { duration: interval }]);
+    expect(run.slept).toEqual([
+      { label: "nextDigest", duration: interval },
+      { label: "nextDigest", duration: interval },
+    ]);
     expect(run.slept).toHaveLength(output.digestsScheduled - 1);
     // And no poll waits are mixed in: every job finished on its first poll, so
     // every recorded sleep above is a SCHEDULE sleep.
@@ -320,9 +323,9 @@ describeWorkflowEval(agentDef, (test) => {
     expect(world.calls.filter((call) => call.url.includes("/v2/transcript/"))).toHaveLength(5);
     // Three waits for four rounds — asked for, and recorded rather than taken.
     expect(run.slept).toEqual([
-      { duration: POLL_DELAY_MS },
-      { duration: POLL_DELAY_MS },
-      { duration: POLL_DELAY_MS },
+      { label: "poll", duration: POLL_DELAY_MS },
+      { label: "poll", duration: POLL_DELAY_MS },
+      { label: "poll", duration: POLL_DELAY_MS },
     ]);
 
     // And the digest is in PUBLICATION order, not completion order. The feed is