@llm4ts/flow 2.9.0 → 2.9.2

package/src/RosterSeats.ts

@@ -125,49 +125,103 @@ export const rosterSeat = (
   workDir: string,
   options: RosterSeatOptions
 ): LlmServiceShape => {
-  const acquire: Effect.Effect<ExecutorSpec, LlmError, Scope.Scope> = Effect.gen(function* () {
-    const avoid = options.avoid === undefined ? [] : yield* options.avoid
-    if (avoid.length > 0 && !(yield* roster.canEverServe(role, avoid))) {
-      const borrowed = options.borrow === undefined ? undefined : yield* options.borrow
-      if (borrowed !== undefined && hasRole(borrowed, role)) {
+  const acquire = (
+    alsoAvoid: ReadonlyArray<string>
+  ): Effect.Effect<ExecutorSpec, LlmError, Scope.Scope> =>
+    Effect.gen(function* () {
+      const avoid = [...(options.avoid === undefined ? [] : yield* options.avoid), ...alsoAvoid]
+      if (avoid.length > 0 && !(yield* roster.canEverServe(role, avoid))) {
+        const borrowed = options.borrow === undefined ? undefined : yield* options.borrow
+        if (borrowed !== undefined && hasRole(borrowed, role)) {
+          yield* say(
+            options.events,
+            `${borrowed.id} takes ${role}${options.label === undefined ? "" : ` for ${options.label}`} on its own coder's slot — not independent (no other executor can take ${role})`
+          )
+          return borrowed
+        }
+      }
+      const lease = yield* roster
+        .lease(role, { avoid, ...(options.label === undefined ? {} : { label: options.label }) })
+        .pipe(Effect.mapError(asLlmError))
+      return lease.executor
+    })
+
+  const seatOf = (executor: ExecutorSpec): Effect.Effect<RosterSeat, LlmError> =>
+    source.seatFor(executor, role, workDir).pipe(Effect.mapError(asLlmError))
+
+  /**
+   * After a failure that took `executor` out of the round, whether another
+   * executor can still take the call: the call moves once, never twice — a
+   * second failure is the call's own, not the executor's.
+   */
+  const retryElsewhere = (
+    executor: ExecutorSpec,
+    error: LlmError,
+    tried: ReadonlyArray<string>
+  ): Effect.Effect<boolean> =>
+    Effect.gen(function* () {
+      const exclusion = yield* roster.report(executor.id, error)
+      if (exclusion === undefined || tried.length > 0) {
+        return false
+      }
+      const avoid = options.avoid === undefined ? [] : yield* options.avoid
+      const other = yield* roster.canEverServe(role, [...avoid, executor.id])
+      if (other) {
         yield* say(
           options.events,
-          `${borrowed.id} takes ${role}${options.label === undefined ? "" : ` for ${options.label}`} on its own coder's slot — not independent (no other executor can take ${role})`
+          `${role}${options.label === undefined ? "" : ` for ${options.label}`} moves off ${executor.id} (${describeExclusion(exclusion)})`
         )
-        return borrowed
       }
-    }
-    const lease = yield* roster
-      .lease(role, { avoid, ...(options.label === undefined ? {} : { label: options.label }) })
-      .pipe(Effect.mapError(asLlmError))
-    return lease.executor
-  })
+      return other
+    })
 
-  const seatOf = (executor: ExecutorSpec): Effect.Effect<RosterSeat, LlmError> =>
-    source.seatFor(executor, role, workDir).pipe(Effect.mapError(asLlmError))
+  const runOn = <A, R>(
+    use: (seat: RosterSeat, note: string | undefined) => Effect.Effect<A, LlmError, R>,
+    tried: ReadonlyArray<string>
+  ): Effect.Effect<A, LlmError, R> =>
+    // The slot is held for the call and released before any retry.
+    Effect.scoped(
+      Effect.gen(function* () {
+        const executor = yield* acquire(tried)
+        const seat = yield* seatOf(executor)
+        const outcome = yield* Effect.result(use(seat, undefined))
+        return { executor, outcome }
+      })
+    ).pipe(
+      Effect.flatMap(({ executor, outcome }) =>
+        outcome._tag === "Success"
+          ? Effect.succeed(outcome.success)
+          : Effect.flatMap(retryElsewhere(executor, outcome.failure, tried), (again) =>
+              again ? runOn(use, [...tried, executor.id]) : Effect.fail(outcome.failure)
+            )
+      )
+    )
 
-  const reportOn =
-    (executor: ExecutorSpec) =>
-    (error: LlmError): Effect.Effect<void> =>
-      Effect.asVoid(roster.report(executor.id, error))
+  const streamOn = (
+    use: (seat: RosterSeat, note: string | undefined) => Stream.Stream<LlmChunk, LlmError>,
+    tried: ReadonlyArray<string>
+  ): Stream.Stream<LlmChunk, LlmError> =>
+    Stream.unwrap(
+      Effect.gen(function* () {
+        const executor = yield* acquire(tried)
+        const seat = yield* seatOf(executor)
+        return use(seat, undefined).pipe(
+          Stream.catchIf(
+            () => true,
+            (error) =>
+              Stream.unwrap(
+                Effect.map(retryElsewhere(executor, error, tried), (again) =>
+                  again ? streamOn(use, [...tried, executor.id]) : Stream.fail(error)
+                )
+              )
+          )
+        )
+      })
+    )
 
   return serviceOver({
-    run: (use) =>
-      Effect.scoped(
-        Effect.gen(function* () {
-          const executor = yield* acquire
-          const seat = yield* seatOf(executor)
-          return yield* use(seat, undefined).pipe(Effect.tapError(reportOn(executor)))
-        })
-      ),
-    stream: (use) =>
-      Stream.unwrap(
-        Effect.gen(function* () {
-          const executor = yield* acquire
-          const seat = yield* seatOf(executor)
-          return use(seat, undefined).pipe(Stream.tapError(reportOn(executor)))
-        })
-      ),
+    run: (use) => runOn(use, []),
+    stream: (use) => streamOn(use, []),
     isAvailable: roster.canEverServe(role)
   })
 }

package/src/Stories.ts

@@ -28,7 +28,7 @@ import {
   StoryFailed,
   type FlowError
 } from "./FlowError.ts"
-import { Info } from "./FlowEvents.ts"
+import { Info, withLane, type FlowEventsShape } from "./FlowEvents.ts"
 import { statusPaths, type GitToolShape } from "./GitTool.ts"
 import {
   checkPerimeter,
@@ -562,6 +562,18 @@ export const implementStoriesFlow = Effect.fn("@llm4ts/flow/Stories.implement")(
       }
     })
 
+  /** A story's own events say so (a lane), so concurrent stories stay apart on screen. */
+  const lanes = new Map<string, FlowEventsShape>()
+  const laneOf = (story: Story): FlowEventsShape => {
+    const known = lanes.get(story.id)
+    if (known !== undefined) {
+      return known
+    }
+    const lane = withLane(events, { lane: story.id })
+    lanes.set(story.id, lane)
+    return lane
+  }
+
   yield* epicCheckoutClean()
   yield* stage(events, "epic branch", context.git.checkoutOrCreate(epicBranch))
 
@@ -600,7 +612,7 @@ export const implementStoriesFlow = Effect.fn("@llm4ts/flow/Stories.implement")(
             `epic gates failed after merging; merge undone:\n${issueLines(gate)}`
           )
         }
-        yield* events.publish(
+        yield* laneOf(story).publish(
           Info.make({ message: `story ${story.id}: merged into ${epicBranch}` })
         )
       })
@@ -616,7 +628,7 @@ export const implementStoriesFlow = Effect.fn("@llm4ts/flow/Stories.implement")(
     const path = statePath(story)
     let stored = yield* loadVersioned(files, path, StoryStateVersion, StoryState)
     if (stored !== undefined && stored.hash !== hash) {
-      yield* events.publish(
+      yield* laneOf(story).publish(
         Info.make({
           message: `story ${story.id}: plan entry changed since its branch was created; starting over`
         })
@@ -627,7 +639,9 @@ export const implementStoriesFlow = Effect.fn("@llm4ts/flow/Stories.implement")(
         .removeWorktree(stored.worktree, true)
         .pipe(
           Effect.catch((error) =>
-            events.publish(Info.make({ message: `story ${story.id}: ${describeFlowError(error)}` }))
+            laneOf(story).publish(
+              Info.make({ message: `story ${story.id}: ${describeFlowError(error)}` })
+            )
           )
         )
       if (yield* context.git.branchExists(stored.branch)) {
@@ -655,7 +669,7 @@ export const implementStoriesFlow = Effect.fn("@llm4ts/flow/Stories.implement")(
     if (stored.worktree !== worktree) {
       if ((yield* files.read(join(stored.worktree, ".git"))) !== undefined) {
         yield* context.git.moveWorktree(stored.worktree, worktree)
-        yield* events.publish(
+        yield* laneOf(story).publish(
           Info.make({ message: `story ${story.id}: moved its worktree to ${worktree}` })
         )
       }
@@ -666,7 +680,9 @@ export const implementStoriesFlow = Effect.fn("@llm4ts/flow/Stories.implement")(
     if (marker === undefined) {
       yield* context.git.addWorktree(state.worktree, state.branch)
     }
-    yield* events.publish(Info.make({ message: `story ${story.id}: resuming ${state.branch}` }))
+    yield* laneOf(story).publish(
+      Info.make({ message: `story ${story.id}: resuming ${state.branch}` })
+    )
     return { state, alreadyMerged: false }
   })
 
@@ -688,7 +704,7 @@ export const implementStoriesFlow = Effect.fn("@llm4ts/flow/Stories.implement")(
       yield* git.merge(epicBranch, `${story.id}: catch up with ${epicBranch}`, {
         preferIncoming: true
       })
-      yield* events.publish(
+      yield* laneOf(story).publish(
         Info.make({ message: `story ${story.id}: caught up with ${epicBranch}` })
       )
     })
@@ -718,7 +734,7 @@ export const implementStoriesFlow = Effect.fn("@llm4ts/flow/Stories.implement")(
     Scope.Scope
   > {
     const seats = yield* options.contextFor(state.worktree, {
-      label: `story ${story.id}`,
+      label: story.id,
       ...(state.executor === undefined ? {} : { prefer: state.executor })
     })
     const roster = seats.context.roster
@@ -752,7 +768,7 @@ export const implementStoriesFlow = Effect.fn("@llm4ts/flow/Stories.implement")(
     // Catch up before setup: the epic may have changed the manifest too.
     yield* catchUp(story, git)
     if (options.setup !== undefined) {
-      yield* stage(events, `story ${story.id}: setup`, options.setup(state.worktree))
+      yield* stage(laneOf(story), `story ${story.id}: setup`, options.setup(state.worktree))
     }
 
     // The target's gates plus the perimeter: a stray path is a gate failure
@@ -811,7 +827,7 @@ export const implementStoriesFlow = Effect.fn("@llm4ts/flow/Stories.implement")(
         }
         yield* Ref.set(blocked, undefined)
         yield* Ref.update(pushbacks, (count) => count + 1)
-        yield* events.publish(
+        yield* laneOf(story).publish(
           Info.make({ message: `story ${story.id}: BLOCKED_ON rejected — ${rebuttal}` })
         )
         yield* coderTurn(
@@ -864,7 +880,7 @@ export const implementStoriesFlow = Effect.fn("@llm4ts/flow/Stories.implement")(
       if (!isWithinPerimeter(second)) {
         const stray = [...second.sharedReadOnly, ...second.outside]
         yield* git.restorePaths(epicBranch, stray)
-        yield* events.publish(
+        yield* laneOf(story).publish(
           Info.make({
             message: `story ${story.id}: restored ${stray.length} path(s) outside its perimeter from ${epicBranch}: ${stray.join(", ")}`
           })
@@ -882,7 +898,7 @@ export const implementStoriesFlow = Effect.fn("@llm4ts/flow/Stories.implement")(
         story,
         (text) => planTasks(watchedSeats, story, text),
         prompt,
-        events
+        laneOf(story)
       ),
       system,
       chatPerTask: true,
@@ -956,7 +972,9 @@ export const implementStoriesFlow = Effect.fn("@llm4ts/flow/Stories.implement")(
     yield* board.start(story.id)
     const { state, alreadyMerged } = yield* prepareWorktree(story)
     if (alreadyMerged) {
-      yield* events.publish(Info.make({ message: `story ${story.id}: already merged; skipping` }))
+      yield* laneOf(story).publish(
+        Info.make({ message: `story ${story.id}: already merged; skipping` })
+      )
       return StoryOutcome.make({
         id: story.id,
         title: story.title,
@@ -993,7 +1011,7 @@ export const implementStoriesFlow = Effect.fn("@llm4ts/flow/Stories.implement")(
 
   /** A story's run as a completion — failures become outcomes, never fiber deaths. */
   const attempt = (story: Story): Effect.Effect<Completion> =>
-    stage(events, `story ${story.id}`, runStory(story)).pipe(
+    stage(laneOf(story), `story ${story.id}`, runStory(story)).pipe(
       Effect.map((outcome): Completion => ({ story, outcome })),
       Effect.catch((error) =>
         Effect.gen(function* () {
@@ -1117,7 +1135,7 @@ export const implementStoriesFlow = Effect.fn("@llm4ts/flow/Stories.implement")(
         if (completion.interruption === "outage" && halted === undefined) {
           if (options.awaitRecovery !== undefined && !recovered.has(completion.story.id)) {
             recovered.add(completion.story.id)
-            yield* events.publish(
+            yield* laneOf(completion.story).publish(
               Info.make({
                 message: `story ${completion.story.id}: the serving engine is down; waiting for it to recover, then retrying the story`
               })