@llm4ts/flow 2.35.1 → 2.35.3

package/src/Review.ts

@@ -28,7 +28,9 @@ import {
   passedCountIn
 } from "./OracleGuard.ts"
 import { cachedReview, fingerprintOf } from "./ReviewCache.ts"
+import { withCallPurpose } from "./Timing.ts"
 import {
+  Began,
   ReviewFindingDemoted,
   Info,
   JudgmentObserved,
@@ -493,6 +495,8 @@ export const lintCommand = Effect.fn("@llm4ts/flow/Review.lintCommand")(function
   }
   const label = command.join(" ")
   const started = yield* Clock.currentTimeMillis
+  // A gate or a setup can run for many minutes: say it started, not only when it ends.
+  yield* events.publish(Began.make({ kind: "gate", label }))
   const run = guarded(
     Capabilities.Exec(executable),
     `lint: ${label}`,
@@ -526,6 +530,13 @@ export const lintCommand = Effect.fn("@llm4ts/flow/Review.lintCommand")(function
         ran === undefined ? Effect.void : Effect.annotateCurrentSpan(attr.gateExit, ran.exitCode)
       )
     )
+  ).pipe(
+    // A command that could not run still ends what its `Began` started.
+    Effect.tapError(() =>
+      Effect.flatMap(Clock.currentTimeMillis, (now) =>
+        events.publish(Timed.make({ kind: "gate", label, ms: now - started, failed: true }))
+      )
+    )
   )
   const failed = result === undefined || result.exitCode !== 0
   yield* events.publish(
@@ -895,14 +906,21 @@ export const reviewAndFixLoop = Effect.fn("@llm4ts/flow/Review.reviewAndFixLoop"
       const chosen = screened.reviewers
       const cache = options.cache
       const votes = Math.max(1, options.votes ?? 1)
+      // Each lens is its own call; the roster's lease says which, so four
+      // parallel reviewer leases read as four questions, not one repeated.
+      const lensCall = (lens: Reviewer, vote: number): Effect.Effect<ReviewResult, FlowError> =>
+        withCallPurpose(
+          `${lens.name} lens${votes > 1 && lens.name === adversarialReviewer.name ? ` · vote ${vote + 1} of ${votes}` : ""}`,
+          reviewWith(options.reviewerService, options.events, lens, options.taskTitle, diff)
+        )
       const reviewVote = (lens: Reviewer, vote: number): Effect.Effect<ReviewResult, FlowError> =>
         cache === undefined
-          ? reviewWith(options.reviewerService, options.events, lens, options.taskTitle, diff)
+          ? lensCall(lens, vote)
           : cachedReview(
               cache.files,
               join(cache.dir, `${fileSlug(lens.name)}${vote === 0 ? "" : `-vote${vote}`}.json`),
               fingerprintOf([lens.name, lensPrompt(lens), String(vote), options.taskTitle, diff]),
-              reviewWith(options.reviewerService, options.events, lens, options.taskTitle, diff)
+              lensCall(lens, vote)
             )
       // Votes multiply only the adversarial lens: its recall is what independent
       // eyes improve; the concern lenses are cheap scoped questions.
@@ -925,6 +943,21 @@ export const reviewAndFixLoop = Effect.fn("@llm4ts/flow/Review.reviewAndFixLoop"
           }))
         )
       const parallelism = options.parallelism ?? 0
+      if (chosen.length > 1) {
+        yield* options.events.publish(
+          Info.make({
+            message: `review round ${round} of "${options.taskTitle}": ${chosen.length} lenses ${
+              parallelism === 1 ? "one at a time" : "in parallel"
+            } (${chosen
+              .map((lens) =>
+                lens.name === adversarialReviewer.name && votes > 1
+                  ? `${lens.name} ×${votes}`
+                  : lens.name
+              )
+              .join(", ")})`
+          })
+        )
+      }
       const results =
         parallelism > 0
           ? yield* Effect.forEach(chosen, run, { concurrency: parallelism })

package/src/Roster.ts

@@ -15,6 +15,7 @@ import * as Semaphore from "effect/Semaphore"
 import type { LlmError } from "@llm4ts/core/Errors"
 import { RosterExhausted, type FlowError } from "./FlowError.ts"
 import {
+  Began,
   ExecutorExcluded,
   ExecutorLeased,
   ExecutorReleased,
@@ -406,6 +407,8 @@ export interface LeaseOptions {
   readonly prefer?: string
   /** Who is asking, for the events (a story's worktree). */
   readonly label?: string
+  /** What the call is for beyond its role (a review lens), for the events. */
+  readonly purpose?: string
   /**
    * The executor holding this context's coder, taken when independence
    * cannot be had now: no executor outside `avoid` can ever take the role,
@@ -515,6 +518,9 @@ export const makeRoster = Effect.fn("@llm4ts/flow/Roster.make")(function* (
     }
   }
 
+  const purposeOf = (who: LeaseOptions): { readonly purpose?: string } =>
+    who.purpose === undefined ? {} : { purpose: who.purpose }
+
   const say = (message: string): Effect.Effect<void> =>
     events.publish(Info.make({ message: `roster: ${message}` }))
 
@@ -598,13 +604,15 @@ export const makeRoster = Effect.fn("@llm4ts/flow/Roster.make")(function* (
   const leaseOf = (
     spec: ExecutorSpec,
     role: Role,
-    label: string | undefined,
+    who: LeaseOptions,
     because?: "nobody" | "held" | "out"
   ): Effect.Effect<Lease, never, Scope.Scope> =>
     Effect.gen(function* () {
-      const labelled = label === undefined ? {} : { label }
+      const labelled = who.label === undefined ? {} : { label: who.label }
       const own = because === undefined ? {} : { because }
-      yield* events.publish(ExecutorLeased.make({ executor: spec.id, role, ...labelled, ...own }))
+      yield* events.publish(
+        ExecutorLeased.make({ executor: spec.id, role, ...labelled, ...purposeOf(who), ...own })
+      )
       const done = yield* Ref.make(false)
       const free = Effect.flatMap(Ref.getAndSet(done, true), (was) =>
         was
@@ -622,13 +630,20 @@ export const makeRoster = Effect.fn("@llm4ts/flow/Roster.make")(function* (
   const borrowedLease = (
     spec: ExecutorSpec,
     role: Role,
-    label: string | undefined,
+    who: LeaseOptions,
     because: "nobody" | "held" | "out"
   ): Effect.Effect<Lease, never, Scope.Scope> =>
     Effect.gen(function* () {
-      const labelled = label === undefined ? {} : { label }
+      const labelled = who.label === undefined ? {} : { label: who.label }
       yield* events.publish(
-        ExecutorLeased.make({ executor: spec.id, role, ...labelled, borrowed: true, because })
+        ExecutorLeased.make({
+          executor: spec.id,
+          role,
+          ...labelled,
+          ...purposeOf(who),
+          borrowed: true,
+          because
+        })
       )
       const done = yield* Ref.make(false)
       const free = Effect.flatMap(Ref.getAndSet(done, true), (was) =>
@@ -841,11 +856,11 @@ export const makeRoster = Effect.fn("@llm4ts/flow/Roster.make")(function* (
           })
           yield* waited
           return own !== undefined && own.id === borrow.id
-            ? yield* leaseOf(own, role, leaseOptions.label, because)
+            ? yield* leaseOf(own, role, leaseOptions, because)
             : own !== undefined
               ? // Someone came back between the check and the pick: independent after all.
-                yield* leaseOf(own, role, leaseOptions.label)
-              : yield* borrowedLease(borrow, role, leaseOptions.label, because)
+                yield* leaseOf(own, role, leaseOptions)
+              : yield* borrowedLease(borrow, role, leaseOptions, because)
         })
       let announced = false
       const asked = yield* Clock.currentTimeMillis
@@ -866,7 +881,7 @@ export const makeRoster = Effect.fn("@llm4ts/flow/Roster.make")(function* (
         const spec = yield* attempt(role, leaseOptions)
         if (spec !== undefined) {
           yield* waited
-          return yield* leaseOf(spec, role, leaseOptions.label)
+          return yield* leaseOf(spec, role, leaseOptions)
         }
         if (!(yield* canEverServe(role, avoid))) {
           const own = yield* takeOwn("nobody")
@@ -897,15 +912,22 @@ export const makeRoster = Effect.fn("@llm4ts/flow/Roster.make")(function* (
         }
         if (!announced) {
           announced = true
+          yield* events.publish(
+            Began.make({
+              kind: "wait",
+              label: `roster ${role}`,
+              ...(leaseOptions.label === undefined ? {} : { lane: leaseOptions.label })
+            })
+          )
           yield* say(
-            `waiting for an executor to take ${role}${leaseOptions.label === undefined ? "" : ` for ${leaseOptions.label}`}: ${yield* waitingReport(role, avoid)}`
+            `waiting for an executor to take ${role}${leaseOptions.label === undefined ? "" : ` for ${leaseOptions.label}`}${leaseOptions.purpose === undefined ? "" : ` (${leaseOptions.purpose})`}: ${yield* waitingReport(role, avoid)}`
           )
         }
         yield* probeDue
         const recovered = yield* attempt(role, leaseOptions)
         if (recovered !== undefined) {
           yield* waited
-          return yield* leaseOf(recovered, role, leaseOptions.label)
+          return yield* leaseOf(recovered, role, leaseOptions)
         }
         yield* waitOrProbe(role)
       }
@@ -916,7 +938,7 @@ export const makeRoster = Effect.fn("@llm4ts/flow/Roster.make")(function* (
     leaseOptions: LeaseOptions = {}
   ): Effect.Effect<Lease | undefined, never, Scope.Scope> =>
     Effect.flatMap(attempt(role, leaseOptions), (spec) =>
-      spec === undefined ? Effect.succeed(undefined) : leaseOf(spec, role, leaseOptions.label)
+      spec === undefined ? Effect.succeed(undefined) : leaseOf(spec, role, leaseOptions)
     )
 
   const exclude = (exclusion: Exclusion): Effect.Effect<void> =>

package/src/RosterSeats.ts

@@ -13,6 +13,7 @@ import type { LlmServiceShape } from "@llm4ts/core/LlmService"
 import { Message, type ConnectorCapabilities, type LlmChunk } from "@llm4ts/core/Models"
 import { describeFlowError, type FlowError } from "./FlowError.ts"
 import { ExecutorHandedOver, type FlowEventsShape } from "./FlowEvents.ts"
+import { callPurpose } from "./Timing.ts"
 import {
   describeExclusion,
   hasRole,
@@ -141,10 +142,12 @@ export const rosterSeat = (
       // The roster decides who serves: an independent executor, or, when
       // none can ever serve or every one is held by a coder, the context's own.
       const borrow = options.borrow === undefined ? undefined : yield* options.borrow
+      const purpose = yield* callPurpose
       const lease = yield* roster
         .lease(role, {
           avoid,
           ...(options.label === undefined ? {} : { label: options.label }),
+          ...(purpose === undefined ? {} : { purpose }),
           ...(borrow === undefined ? {} : { borrow })
         })
         .pipe(Effect.mapError(asLlmError))

package/src/Stories.ts

@@ -42,6 +42,7 @@ import {
   type FlowError
 } from "./FlowError.ts"
 import {
+  Began,
   EvidenceChecked,
   Info,
   JudgedDimension,
@@ -781,6 +782,55 @@ export const setupRecoveryPrompt = (command: string): string =>
 const failed = (story: Story, reason: string): StoryFailed =>
   StoryFailed.make({ story: story.id, reason })
 
+/** What the story scheduler can say about stories it is not starting. */
+export interface LaunchPicture {
+  readonly epicId: string
+  readonly running: number
+  readonly concurrency: number
+  /** The roster's coder capacity; absent without a roster. */
+  readonly capacity?: number
+  /** Ready stories left for a coder slot to free. */
+  readonly readyWaiting: number
+  /** Stories whose dependencies are not merged yet, with the ones they wait for. */
+  readonly blocked: ReadonlyArray<{ readonly id: string; readonly on: ReadonlyArray<string> }>
+}
+
+const shownBlocked = 3
+
+/**
+ * One line on why fewer stories run than the cap allows, or `undefined`
+ * when nothing waits: dependencies first (the common case), then capacity.
+ */
+export const launchSummary = (picture: LaunchPicture): string | undefined => {
+  if (picture.blocked.length === 0 && picture.readyWaiting === 0) {
+    return undefined
+  }
+  const cap =
+    picture.capacity === undefined
+      ? `concurrency ${picture.concurrency}`
+      : `concurrency ${picture.concurrency}, ${picture.capacity} coder slot(s)`
+  const blocked =
+    picture.blocked.length === 0
+      ? []
+      : [
+          `${picture.blocked.length} waiting on dependencies: ${picture.blocked
+            .slice(0, shownBlocked)
+            .map((story) => `${story.id} ← ${story.on.join(", ")}`)
+            .join("; ")}${
+            picture.blocked.length > shownBlocked
+              ? ` (+${picture.blocked.length - shownBlocked} more)`
+              : ""
+          }`
+        ]
+  const starved =
+    picture.readyWaiting === 0 ? [] : [`${picture.readyWaiting} ready, waiting for a coder slot`]
+  return [
+    `epic ${picture.epicId}: ${picture.running} running (${cap})`,
+    ...blocked,
+    ...starved
+  ].join(" · ")
+}
+
 // ---- The executor -------------------------------------------------------------
 
 export const implementStoriesFlow = Effect.fn("@llm4ts/flow/Stories.implement")(function* (
@@ -934,52 +984,56 @@ export const implementStoriesFlow = Effect.fn("@llm4ts/flow/Stories.implement")(
   /** Merge the story branch into the epic branch and re-gate the epic head, one story at a time. */
   const integrate = (story: Story, branch: string): Effect.Effect<void, FlowError> =>
     Effect.flatMap(Clock.currentTimeMillis, (requested) =>
-      mergeLock.withPermit(
-        Effect.gen(function* () {
-          const lane = laneOf(story)
-          // Merges are one at a time: how long this story queued for its turn.
-          const turn = yield* Clock.currentTimeMillis
-          yield* lane.publish(
-            Timed.make({ kind: "wait", label: "merge lock", ms: turn - requested })
-          )
-          yield* epicCheckoutClean(story)
-          const checkpoint = yield* context.git.checkpoint
-          yield* timeEffect(
-            lane,
-            context.git.merge(branch, `${plan.epicId}: merge story ${story.id}`),
-            (ms, failed) =>
-              Timed.make({ kind: "merge", label: "merge", ms, ...(failed ? { failed } : {}) })
-          )
-          const gate = yield* options.gates(context.workDir, lane)
-          // Charged only with what the merge added: the head before it had
-          // a baseline (run start or the previous merge).
-          const before = yield* ensureBaseline(
-            checkpoint,
-            Effect.succeed(ReviewResult.make({ issues: [] })),
-            context.workDir
-          )
-          const verdict = triageGates(gate, before, rootsOf(context.workDir))
-          if (!verdict.blocking.isClean) {
-            // Never leave a red epic head for the next story to inherit.
-            yield* context.git.rollback(checkpoint)
-            return yield* failed(
-              story,
-              `epic gates failed after merging; merge undone:\n${issueLines(verdict.blocking)}`
+      Effect.andThen(
+        laneOf(story).publish(Began.make({ kind: "wait", label: "merge lock" })),
+        mergeLock.withPermit(
+          Effect.gen(function* () {
+            const lane = laneOf(story)
+            // Merges are one at a time: how long this story queued for its turn.
+            const turn = yield* Clock.currentTimeMillis
+            yield* lane.publish(
+              Timed.make({ kind: "wait", label: "merge lock", ms: turn - requested })
             )
-          }
-          if (gateCommands !== undefined) {
-            const mergedHead = yield* context.git.checkpoint
-            yield* writeBaseline(
-              files,
-              options.stateDir,
-              keyFor(mergedHead),
-              yield* baselineOf(mergedHead, gate, context.workDir)
+            yield* epicCheckoutClean(story)
+            const checkpoint = yield* context.git.checkpoint
+            yield* timeEffect(
+              lane,
+              context.git.merge(branch, `${plan.epicId}: merge story ${story.id}`),
+              (ms, failed) =>
+                Timed.make({ kind: "merge", label: "merge", ms, ...(failed ? { failed } : {}) }),
+              () => Began.make({ kind: "merge", label: "merge" })
             )
-          }
-          yield* laneOf(story).publish(
-            Info.make({ message: `story ${story.id}: merged into ${epicBranch}` })
-          )
-        })
+            const gate = yield* options.gates(context.workDir, lane)
+            // Charged only with what the merge added: the head before it had
+            // a baseline (run start or the previous merge).
+            const before = yield* ensureBaseline(
+              checkpoint,
+              Effect.succeed(ReviewResult.make({ issues: [] })),
+              context.workDir
+            )
+            const verdict = triageGates(gate, before, rootsOf(context.workDir))
+            if (!verdict.blocking.isClean) {
+              // Never leave a red epic head for the next story to inherit.
+              yield* context.git.rollback(checkpoint)
+              return yield* failed(
+                story,
+                `epic gates failed after merging; merge undone:\n${issueLines(verdict.blocking)}`
+              )
+            }
+            if (gateCommands !== undefined) {
+              const mergedHead = yield* context.git.checkpoint
+              yield* writeBaseline(
+                files,
+                options.stateDir,
+                keyFor(mergedHead),
+                yield* baselineOf(mergedHead, gate, context.workDir)
+              )
+            }
+            yield* laneOf(story).publish(
+              Info.make({ message: `story ${story.id}: merged into ${epicBranch}` })
+            )
+          })
+        )
       )
     )
 
@@ -1278,7 +1332,13 @@ export const implementStoriesFlow = Effect.fn("@llm4ts/flow/Stories.implement")(
         : { rerunTest: options.testGate(state.worktree, laneOf(story)) })
     }
     if (gateCommands !== undefined) {
-      const inherited = (yield* storyBaseline)?.failingLines ?? []
+      // Recorded here, before the first task, so the lane says what the time goes to.
+      const baseline = yield* stage(
+        laneOf(story),
+        `story ${story.id}: baseline gates`,
+        storyBaseline
+      )
+      const inherited = baseline?.failingLines ?? []
       if (inherited.length > 0) {
         inheritedByStory.set(story.id, inherited)
         yield* appendFindings(
@@ -1424,7 +1484,12 @@ export const implementStoriesFlow = Effect.fn("@llm4ts/flow/Stories.implement")(
       plan: planWithinPerimeter(
         plan,
         story,
-        (text) => planTasks(watchedSeats, story, text),
+        (text) =>
+          stage(
+            laneOf(story),
+            `story ${story.id}: plan tasks`,
+            planTasks(watchedSeats, story, text)
+          ),
         prompt,
         laneOf(story)
       ),
@@ -1816,6 +1881,8 @@ export const implementStoriesFlow = Effect.fn("@llm4ts/flow/Stories.implement")(
 
   /** Why no further story may start in this run; stories already running finish. */
   let halted: string | undefined
+  /** The last launch summary said, so a picture is told once, when it changes. */
+  let toldLaunch: string | undefined
   /** Stories retried once after the serving engine recovered. */
   const recovered = new Set<string>()
 
@@ -1856,6 +1923,34 @@ export const implementStoriesFlow = Effect.fn("@llm4ts/flow/Stories.implement")(
           ) {
             starvedAt = capacity
           }
+          // Say why fewer stories run than the cap allows: a plan that
+          // chains its stories looks exactly like a scheduler that stalled.
+          const started = new Set([...current.running, ...launching.map((story) => story.id)])
+          const said = launchSummary({
+            epicId: plan.epicId,
+            running: started.size,
+            concurrency,
+            ...(context.roster === undefined ? {} : { capacity }),
+            readyWaiting: ready.length - launching.length,
+            blocked: plan.stories.flatMap((story) =>
+              current.done.has(story.id) ||
+              current.failed.has(story.id) ||
+              current.waiting.has(story.id) ||
+              started.has(story.id) ||
+              ready.includes(story)
+                ? []
+                : [
+                    {
+                      id: story.id,
+                      on: story.dependsOn.filter((dependency) => !current.done.has(dependency))
+                    }
+                  ]
+            )
+          })
+          if (said !== undefined && said !== toldLaunch) {
+            yield* events.publish(Info.make({ message: said }))
+          }
+          toldLaunch = said
         }
         if ((yield* Ref.get(running)).size === 0) {
           break

package/src/Timing.ts

@@ -13,7 +13,7 @@ import { Message, type LlmChunk, type TokenUsage } from "@llm4ts/core/Models"
 import { redactText } from "@llm4ts/core/observability/Redaction"
 import { toolCategory } from "./Activity.ts"
 import { estimateUsage, estimatedModelLabel, type EstimatedUsageOptions } from "./EstimatedUsage.ts"
-import { Timed, type FlowEventsShape } from "./FlowEvents.ts"
+import { Began, Timed, type FlowEventsShape } from "./FlowEvents.ts"
 import {
   attr,
   currentKindSpan,
@@ -178,6 +178,22 @@ const TimedRole = Context.Reference<string | undefined>("@llm4ts/flow/Timing/Tim
   defaultValue: () => undefined
 })
 
+/**
+ * What a call is for, beyond its role: a review lens, a vote. A roster
+ * lease names it (`topolino takes reviewer for home · adversarial lens`),
+ * so parallel calls of one role read as the different questions they are.
+ */
+const CallPurpose = Context.Reference<string | undefined>("@llm4ts/flow/Timing/CallPurpose", {
+  defaultValue: () => undefined
+})
+
+/** The purpose the current call is made for, when its caller named one. */
+export const callPurpose: Effect.Effect<string | undefined> = CallPurpose
+
+/** Runs `effect`'s calls under `purpose`, for the roster's lease events. */
+export const withCallPurpose = <A, E, R>(purpose: string, effect: Effect.Effect<A, E, R>) =>
+  Effect.provideService(effect, CallPurpose, purpose)
+
 /** The role the current call is made for: the caller's, or else `label`. */
 export const roleOr = (label: string): Effect.Effect<string> =>
   Effect.map(TimedRole, (role) => role ?? label)
@@ -192,16 +208,24 @@ const reportedMs = (chunk: LlmChunk, key: string): number | undefined => {
   return Number.isFinite(value) ? value : undefined
 }
 
-/** Times `effect`, publishing what `timed` makes of its duration whether it succeeds or fails. */
+/**
+ * Times `effect`, publishing what `timed` makes of its duration whether it
+ * succeeds or fails; with `began`, also what it makes of the start, when the
+ * effect starts, so a screen shows the work while it runs.
+ */
 export const timeEffect = <A, E, R>(
   events: FlowEventsShape,
   effect: Effect.Effect<A, E, R>,
-  timed: (ms: number, failed: boolean, role: string | undefined) => Timed
+  timed: (ms: number, failed: boolean, role: string | undefined) => Timed,
+  began?: (role: string | undefined) => Began
 ): Effect.Effect<A, E, R> =>
   Effect.flatMap(Effect.all([Clock.currentTimeMillis, TimedRole]), ([start, role]) =>
-    Effect.onExit(effect, (exit) =>
-      Effect.flatMap(Clock.currentTimeMillis, (end) =>
-        events.publish(timed(end - start, Exit.isFailure(exit), role))
+    Effect.andThen(
+      began === undefined ? Effect.void : events.publish(began(role)),
+      Effect.onExit(effect, (exit) =>
+        Effect.flatMap(Clock.currentTimeMillis, (end) =>
+          events.publish(timed(end - start, Exit.isFailure(exit), role))
+        )
       )
     )
   )
@@ -239,7 +263,7 @@ const tracedEffect = <A, E, R>(
           ...promptContent(content, [Message.make({ role: "User", content: prompt })])
         }
       },
-      timeEffect(events, effect, timed).pipe(
+      timeEffect(events, effect, timed, () => Began.make({ kind: "model", label: role })).pipe(
         Effect.onExit((exit) => {
           const known = Exit.isSuccess(exit)
             ? usageOf(exit.value)
@@ -282,6 +306,7 @@ const timedStream = <E>(
       // The call's LLM span (ADR 0026), parented to the nearest kind span and
       // ended when the stream does; each harness tool call is a TOOL child,
       // opened on `tool_use` and closed on `tool_result`.
+      yield* events.publish(Began.make({ kind: "model", label: role }))
       const parent = yield* currentKindSpan
       const span = yield* Effect.makeSpan(role, {
         kind: "client",
@@ -488,12 +513,16 @@ export const timedSeat = (
 export const timedJudgment = (judgment: JudgmentShape, events: FlowEventsShape): JudgmentShape => ({
   ...judgment,
   judge: (input) =>
-    timeEffect(events, judgment.judge(input), (ms, failed, role) =>
-      Timed.make({
-        kind: "model",
-        label: role ?? "judgment",
-        ms,
-        ...(failed ? { failed: true } : {})
-      })
+    timeEffect(
+      events,
+      judgment.judge(input),
+      (ms, failed, role) =>
+        Timed.make({
+          kind: "model",
+          label: role ?? "judgment",
+          ms,
+          ...(failed ? { failed: true } : {})
+        }),
+      (role) => Began.make({ kind: "model", label: role ?? "judgment" })
     )
 })