@llm4ts/flow 2.40.1 → 2.42.0

package/src/Plan.ts

@@ -120,3 +120,74 @@ export const parsePlan = Effect.fn("@llm4ts/flow/Plan.parse")(function* (
     ...(brief === undefined ? {} : { brief })
   })
 })
+
+// ---- The task graph (ADR 0034) ------------------------------------------------
+
+/**
+ * The tasks a task waits for, from its description's `Depends on:` line
+ * (`1, 3`, or `none`). Without the line it waits for every earlier task, so
+ * a plan written before ADR 0034 runs in order. Only earlier tasks count: a
+ * forward or self reference is dropped, so the graph never has a cycle, and
+ * a line left naming none of them is read as no line.
+ */
+export const dependsOnOf = (description: string, index: number): ReadonlyArray<number> => {
+  const earlier = Array.from({ length: Math.max(0, index - 1) }, (_, position) => position + 1)
+  const match = /\bDepends on:\s*([^\n.]*)/iu.exec(description)
+  if (match === null) {
+    return earlier
+  }
+  const text = match[1] ?? ""
+  if (/^\s*none\b/iu.test(text)) {
+    return []
+  }
+  const named = [
+    ...new Set(
+      text
+        .split(/[^\d]+/u)
+        .filter((part) => part.length > 0)
+        .map((part) => Number.parseInt(part, 10))
+        .filter((number) => Number.isInteger(number) && number >= 1 && number < index)
+    )
+  ]
+  return named.length === 0 ? earlier : named
+}
+
+/**
+ * The paths a task says it changes, from its `Owns:` line; empty when it
+ * says none. The line ends at a newline, the next label, or a period that
+ * ends the sentence (the planner writes one-line JSON descriptions).
+ */
+export const ownsOf = (description: string): ReadonlyArray<string> => {
+  const match = /\bOwns:\s*(.*?)(?=\s+(?:Depends on|Satisfies):|\.\s|\.$|\n|$)/iu.exec(description)
+  return match === null
+    ? []
+    : (match[1] ?? "")
+        .split(/[,\s]+/u)
+        .map((path) =>
+          path
+            .trim()
+            .replace(/^`|`$/gu, "")
+            .replace(/[.;]+$/u, "")
+        )
+        .filter((path) => path.length > 0 && path.toLowerCase() !== "none")
+}
+
+/** One task of a plan as the scheduler sees it: its 1-based index and what it waits for. */
+export interface TaskNode {
+  readonly index: number
+  readonly task: Task
+  readonly dependsOn: ReadonlyArray<number>
+  readonly owns: ReadonlyArray<string>
+}
+
+export const taskGraph = (plan: Plan): ReadonlyArray<TaskNode> =>
+  plan.tasks.map((task, position) => ({
+    index: position + 1,
+    task,
+    dependsOn: dependsOnOf(task.description, position + 1),
+    owns: ownsOf(task.description)
+  }))
+
+/** Whether some task of the plan may start without the task right before it. */
+export const hasParallelTasks = (plan: Plan): boolean =>
+  taskGraph(plan).some((node) => node.index > 1 && !node.dependsOn.includes(node.index - 1))

package/src/PlanExecution.ts

@@ -1,8 +1,20 @@
 import * as Effect from "effect/Effect"
-import { StageCompleted, StageFailed, StageStarted, type FlowEventsShape } from "./FlowEvents.ts"
+import * as Exit from "effect/Exit"
+import * as Fiber from "effect/Fiber"
+import * as Queue from "effect/Queue"
+import * as Semaphore from "effect/Semaphore"
+import {
+  StageCompleted,
+  StageFailed,
+  StageStarted,
+  TaskCompleted,
+  TaskStarted,
+  TasksPlanned,
+  type FlowEventsShape
+} from "./FlowEvents.ts"
 import { withKindSpan, type SpanOptions } from "./Spans.ts"
-import { describeFlowError, type FlowError } from "./FlowError.ts"
-import type { Plan, Task } from "./Plan.ts"
+import { FlowAborted, describeFlowError, type FlowError } from "./FlowError.ts"
+import { taskGraph, type Plan, type Task, type TaskNode } from "./Plan.ts"
 import type { PlanStoreShape } from "./Persistence.ts"
 
 const errorMessage = describeFlowError
@@ -35,6 +47,26 @@ export const stage = <A, E, R>(
     )
   )
 
+/** The acceptance criteria a task's description names: `Satisfies: 1, 3` → `[1, 3]` (ADR 0033). */
+export const satisfiesOf = (description: string): ReadonlyArray<number> | undefined => {
+  // The planner writes JSON, so the line is usually the description's last sentence.
+  const match = /\bSatisfies:\s*([^\n]*)/iu.exec(description)
+  if (match === null) {
+    return undefined
+  }
+  const numbers = (match[1] ?? "")
+    .split(/[^\d]+/u)
+    .filter((part) => part.length > 0)
+    .map((part) => Number.parseInt(part, 10))
+    .filter((number) => Number.isInteger(number) && number > 0)
+  return numbers.length === 0 ? undefined : numbers
+}
+
+const withSatisfies = (description: string): { readonly satisfies?: ReadonlyArray<number> } => {
+  const satisfies = satisfiesOf(description)
+  return satisfies === undefined ? {} : { satisfies }
+}
+
 export const implementTaskLoop = Effect.fn("@llm4ts/flow/PlanExecution.implementTaskLoop")(
   function* <E, R>(
     store: PlanStoreShape,
@@ -44,11 +76,208 @@ export const implementTaskLoop = Effect.fn("@llm4ts/flow/PlanExecution.implement
     perTask: (task: Task, planSoFar: Plan) => Effect.Effect<void, E, R>
   ): Effect.fn.Return<Plan, E | FlowError, R> {
     let current = plan
-    for (const task of plan.tasks) {
+    const count = plan.tasks.length
+    yield* events.publish(
+      TasksPlanned.make({
+        tasks: plan.tasks.map((task) => ({
+          title: task.title,
+          completed: task.completed,
+          ...withSatisfies(task.description)
+        }))
+      })
+    )
+    for (const [position, task] of plan.tasks.entries()) {
       if (!task.completed) {
+        const index = position + 1
+        yield* events.publish(
+          TaskStarted.make({ index, count, title: task.title, ...withSatisfies(task.description) })
+        )
         yield* stage(events, task.title, perTask(task, current))
         current = current.complete(task.title)
         yield* store.save(planPath, current)
+        yield* events.publish(TaskCompleted.make({ index, count, title: task.title }))
+      }
+    }
+    return current
+  }
+)
+
+// ---- Tasks beside the held coder (ADR 0034) -----------------------------------
+
+/**
+ * How a task tried beside the held coder ended: `merged` into the story,
+ * `declined` (no free coder, or it could not finish there) or `conflict`
+ * (its merge back conflicted). The last two go back to the held coder; a
+ * conflicting task runs after the others, on the merged state.
+ */
+export type AsideOutcome = "merged" | "declined" | "conflict"
+
+export interface AsideRequest {
+  readonly node: TaskNode
+  /** The plan's size, for `task n/m`. */
+  readonly count: number
+  readonly planSoFar: Plan
+  /** Runs `effect` while no task runs at home: the merge back into the story. */
+  readonly exclusive: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  /** Says the task started, on the coder it got; call it once that coder is held. */
+  readonly announce: (coder: {
+    readonly executor?: string
+    readonly clone?: number
+  }) => Effect.Effect<void>
+}
+
+export interface ParallelTasks<E, R> {
+  /** Coders one story may hold at once, its own included; 1 runs every task at home. */
+  readonly concurrency: number
+  readonly aside: (request: AsideRequest) => Effect.Effect<AsideOutcome, E, R>
+}
+
+/** A task's run that ended: at home (`undefined`) or aside (its outcome). */
+interface Finished<E> {
+  readonly kind: "home" | "aside"
+  readonly node: TaskNode
+  readonly exit: Exit.Exit<AsideOutcome | undefined, E>
+}
+
+/**
+ * The task loop over the plan's graph (ADR 0034): the held coder runs one
+ * ready task at a time, in plan order, as `implementTaskLoop` does; up to
+ * `concurrency - 1` other ready tasks are offered to `aside`, which runs
+ * each on another coder and merges it back under `exclusive`. A task is
+ * ready when the tasks it depends on are complete; a plan whose every task
+ * depends on the one before runs exactly as `implementTaskLoop`.
+ */
+export const implementTaskGraph = Effect.fn("@llm4ts/flow/PlanExecution.implementTaskGraph")(
+  function* <E, R, E2, R2>(
+    store: PlanStoreShape,
+    events: FlowEventsShape,
+    planPath: string,
+    plan: Plan,
+    perTask: (task: Task, planSoFar: Plan) => Effect.Effect<void, E, R>,
+    parallel: ParallelTasks<E2, R2>
+  ): Effect.fn.Return<Plan, E | E2 | FlowError, R | R2> {
+    const graph = taskGraph(plan)
+    const count = graph.length
+    yield* events.publish(
+      TasksPlanned.make({
+        tasks: plan.tasks.map((task) => ({
+          title: task.title,
+          completed: task.completed,
+          ...withSatisfies(task.description)
+        }))
+      })
+    )
+    let current = plan
+    const done = new Set(graph.filter((node) => node.task.completed).map((node) => node.index))
+    /** Tasks that go to the held coder only, and those that wait for every other one. */
+    const homeOnly = new Set<number>()
+    const last = new Set<number>()
+    const running = new Map<number, "home" | "aside">()
+    const fibers: Array<Fiber.Fiber<unknown, unknown>> = []
+    const finished = yield* Queue.unbounded<Finished<E | E2>>()
+    const home = yield* Semaphore.make(1)
+    const exclusive = <A, EX, RX>(effect: Effect.Effect<A, EX, RX>) => home.withPermit(effect)
+
+    const started = (
+      node: TaskNode,
+      extra: Partial<Pick<TaskStarted, "parallel" | "executor" | "clone">> = {}
+    ) =>
+      events.publish(
+        TaskStarted.make({
+          index: node.index,
+          count,
+          title: node.task.title,
+          ...withSatisfies(node.task.description),
+          ...extra
+        })
+      )
+    const complete = (node: TaskNode) =>
+      Effect.gen(function* () {
+        current = current.complete(node.task.title)
+        yield* store.save(planPath, current)
+        done.add(node.index)
+        yield* events.publish(
+          TaskCompleted.make({ index: node.index, count, title: node.task.title })
+        )
+      })
+
+    while (done.size < count) {
+      const ready = graph.filter(
+        (node) =>
+          !done.has(node.index) &&
+          !running.has(node.index) &&
+          node.dependsOn.every((index) => done.has(index))
+      )
+      if (![...running.values()].includes("home")) {
+        const pick = ready.find((node) => !last.has(node.index)) ?? ready[0]
+        if (pick !== undefined) {
+          running.set(pick.index, "home")
+          const snapshot = current
+          fibers.push(
+            yield* Effect.forkChild(
+              exclusive(
+                Effect.andThen(
+                  started(pick),
+                  stage(events, pick.task.title, perTask(pick.task, snapshot))
+                )
+              ).pipe(
+                Effect.as(undefined),
+                Effect.exit,
+                Effect.flatMap((exit) => Queue.offer(finished, { kind: "home", node: pick, exit }))
+              )
+            )
+          )
+        }
+      }
+      for (const node of ready) {
+        if (running.size >= parallel.concurrency) {
+          break
+        }
+        if (running.has(node.index) || homeOnly.has(node.index)) {
+          continue
+        }
+        running.set(node.index, "aside")
+        const request: AsideRequest = {
+          node,
+          count,
+          planSoFar: current,
+          exclusive,
+          announce: (coder) =>
+            started(node, {
+              parallel: true,
+              ...(coder.executor === undefined ? {} : { executor: coder.executor }),
+              ...(coder.clone === undefined ? {} : { clone: coder.clone })
+            })
+        }
+        fibers.push(
+          yield* Effect.forkChild(
+            parallel.aside(request).pipe(
+              Effect.exit,
+              Effect.flatMap((exit) => Queue.offer(finished, { kind: "aside", node, exit }))
+            )
+          )
+        )
+      }
+      if (running.size === 0) {
+        return yield* FlowAborted.make({
+          message: `plan ${plan.epicId}: no task can start, though ${count - done.size} are not done`
+        })
+      }
+      const next = yield* Queue.take(finished)
+      running.delete(next.node.index)
+      if (Exit.isFailure(next.exit)) {
+        yield* Fiber.interruptAll(fibers)
+        return yield* Effect.failCause(next.exit.cause)
+      }
+      if (next.kind === "home") {
+        yield* complete(next.node)
+      } else if (next.exit.value === "merged") {
+        yield* complete(next.node)
+      } else {
+        homeOnly.add(next.node.index)
+        if (next.exit.value === "conflict") {
+          last.add(next.node.index)
+        }
       }
     }
     return current

package/src/Roster.ts

@@ -55,7 +55,7 @@ export class ExecutorSpec extends Schema.Class<ExecutorSpec>("ExecutorSpec")({
   baseUrl: Schema.optionalKey(Schema.String),
   roles: Schema.Array(Schema.String),
   slots: Schema.optionalKey(Schema.Number),
-  /** Slots coders may use; default `slots - 1` when the executor also reasons. */
+  /** Slots coders may use; default: every slot (ADR 0033). */
   coderSlots: Schema.optionalKey(Schema.Number),
   /** Lower first. A number for every role, or per role with a `default`. */
   priority: Schema.optionalKey(
@@ -105,8 +105,6 @@ export class RosterState extends Schema.Class<RosterState>("RosterState")({
 
 // ---- Pure helpers -------------------------------------------------------------
 
-const reasoningRoles: ReadonlyArray<Role> = ["planner", "reviewer", "judge", "verifier"]
-
 export const isRole = (value: string): value is Role => roles.some((role) => role === value)
 
 export const rolesOf = (spec: ExecutorSpec): ReadonlyArray<Role> => spec.roles.filter(isRole)
@@ -115,14 +113,12 @@ export const hasRole = (spec: ExecutorSpec, role: Role): boolean => rolesOf(spec
 
 export const slotsOf = (spec: ExecutorSpec): number => Math.max(1, Math.floor(spec.slots ?? 1))
 
-/** Slots coders may hold: one stays free for reasoning on an executor that does both. */
+/** Slots coders may hold: every clone, unless the roster sets `coderSlots` lower (ADR 0033). */
 export const coderSlotsOf = (spec: ExecutorSpec): number => {
   const slots = slotsOf(spec)
-  if (spec.coderSlots !== undefined) {
-    return Math.max(0, Math.min(slots, Math.floor(spec.coderSlots)))
-  }
-  const reasons = rolesOf(spec).some((role) => reasoningRoles.includes(role))
-  return hasRole(spec, "coder") && reasons && slots > 1 ? slots - 1 : slots
+  return spec.coderSlots === undefined
+    ? slots
+    : Math.max(0, Math.min(slots, Math.floor(spec.coderSlots)))
 }
 
 /** The effort a role runs at on this executor (ADR 0029); absent is the harness's default. */
@@ -419,6 +415,8 @@ export interface Lease {
   readonly role: Role
   /** Frees the slot; idempotent, and also run when the lease's scope closes. */
   readonly release: Effect.Effect<void>
+  /** Which of the executor's clones this is, from 1; absent on a borrowed lease (ADR 0033). */
+  readonly clone: number | undefined
   /** Took no slot: the context's own coder executor serves the call (see `LeaseOptions.borrow`). */
   readonly borrowed: boolean
   /** Set when the executor is the context's own coder (not independent), and why; see `ExecutorLeased.because`. */
@@ -522,6 +520,12 @@ interface Usage {
   busyCoders: number
 }
 
+/** A slot taken under the lock: the executor and which of its clones. */
+interface Taken {
+  readonly spec: ExecutorSpec
+  readonly clone: number
+}
+
 export const makeRoster = Effect.fn("@llm4ts/flow/Roster.make")(function* (
   options: RosterOptions
 ): Effect.fn.Return<RosterShape, FlowError> {
@@ -534,6 +538,21 @@ export const makeRoster = Effect.fn("@llm4ts/flow/Roster.make")(function* (
   const rateLimits = new Map<string, ReadonlyArray<number>>()
   const lastLeased = new Map<string, number>()
   let leases = 0
+  /** Clone numbers in use per executor; a lease takes the lowest free one (ADR 0033). */
+  const clones = new Map<string, Set<number>>(executors.map((spec) => [spec.id, new Set<number>()]))
+  const takeClone = (spec: ExecutorSpec): number => {
+    const used = clones.get(spec.id) ?? new Set<number>()
+    let clone = 1
+    while (used.has(clone)) {
+      clone += 1
+    }
+    used.add(clone)
+    clones.set(spec.id, used)
+    return clone
+  }
+  const freeClone = (spec: ExecutorSpec, clone: number): void => {
+    clones.get(spec.id)?.delete(clone)
+  }
   const changed = yield* Ref.make(yield* Deferred.make<void>())
   const known = new Set(executors.map((spec) => spec.id))
 
@@ -611,7 +630,7 @@ export const makeRoster = Effect.fn("@llm4ts/flow/Roster.make")(function* (
       : best
   }
 
-  const release = (spec: ExecutorSpec, role: Role): Effect.Effect<void> =>
+  const release = (spec: ExecutorSpec, role: Role, clone: number): Effect.Effect<void> =>
     lock
       .withPermit(
         Effect.sync(() => {
@@ -622,33 +641,42 @@ export const makeRoster = Effect.fn("@llm4ts/flow/Roster.make")(function* (
               used.busyCoders = Math.max(0, used.busyCoders - 1)
             }
           }
+          freeClone(spec, clone)
         })
       )
       .pipe(Effect.andThen(signal))
 
   const leaseOf = (
-    spec: ExecutorSpec,
+    taken: Taken,
     role: Role,
     who: LeaseOptions,
     because?: "nobody" | "held" | "out"
   ): Effect.Effect<Lease, never, Scope.Scope> =>
     Effect.gen(function* () {
+      const { spec, clone } = taken
       const labelled = who.label === undefined ? {} : { label: who.label }
       const own = because === undefined ? {} : { because }
       yield* events.publish(
-        ExecutorLeased.make({ executor: spec.id, role, ...labelled, ...purposeOf(who), ...own })
+        ExecutorLeased.make({
+          executor: spec.id,
+          role,
+          clone,
+          ...labelled,
+          ...purposeOf(who),
+          ...own
+        })
       )
       const done = yield* Ref.make(false)
       const free = Effect.flatMap(Ref.getAndSet(done, true), (was) =>
         was
           ? Effect.void
           : Effect.andThen(
-              release(spec, role),
-              events.publish(ExecutorReleased.make({ executor: spec.id, role, ...labelled }))
+              release(spec, role, clone),
+              events.publish(ExecutorReleased.make({ executor: spec.id, role, clone, ...labelled }))
             )
       )
       yield* Effect.addFinalizer(() => free)
-      return { executor: spec, role, release: free, borrowed: false, ...own }
+      return { executor: spec, role, clone, release: free, borrowed: false, ...own }
     })
 
   /** A lease over the context's own coder executor: no slot taken, none freed. */
@@ -677,32 +705,30 @@ export const makeRoster = Effect.fn("@llm4ts/flow/Roster.make")(function* (
           : events.publish(ExecutorReleased.make({ executor: spec.id, role, ...labelled }))
       )
       yield* Effect.addFinalizer(() => free)
-      return { executor: spec, role, release: free, borrowed: true, because }
+      return { executor: spec, role, clone: undefined, release: free, borrowed: true, because }
     })
 
-  /** One attempt: expire, pick, take the slot — all under the lock. */
-  const attempt = (
-    role: Role,
-    leaseOptions: LeaseOptions
-  ): Effect.Effect<ExecutorSpec | undefined> =>
+  /** One attempt: expire, pick, take the slot and its clone number — all under the lock. */
+  const attempt = (role: Role, leaseOptions: LeaseOptions): Effect.Effect<Taken | undefined> =>
     Effect.gen(function* () {
       const now = yield* Clock.currentTimeMillis
-      const { spec, back } = yield* lock.withPermit(
+      const { taken, back } = yield* lock.withPermit(
         Effect.sync(() => {
           const back = expire(now)
           const spec = pick(role, leaseOptions)
-          if (spec !== undefined) {
-            const used = usage.get(spec.id)
-            if (used !== undefined) {
-              used.busy += 1
-              if (role === "coder") {
-                used.busyCoders += 1
-              }
+          if (spec === undefined) {
+            return { taken: undefined, back }
+          }
+          const used = usage.get(spec.id)
+          if (used !== undefined) {
+            used.busy += 1
+            if (role === "coder") {
+              used.busyCoders += 1
             }
-            leases += 1
-            lastLeased.set(spec.id, leases)
           }
-          return { spec, back }
+          leases += 1
+          lastLeased.set(spec.id, leases)
+          return { taken: { spec, clone: takeClone(spec) }, back }
         })
       )
       if (back.length > 0) {
@@ -711,7 +737,7 @@ export const makeRoster = Effect.fn("@llm4ts/flow/Roster.make")(function* (
         )
         yield* persist
       }
-      return spec
+      return taken
     })
 
   const canEverServe = (role: Role, avoid: ReadonlyArray<string> = []): Effect.Effect<boolean> =>
@@ -880,7 +906,7 @@ export const makeRoster = Effect.fn("@llm4ts/flow/Roster.make")(function* (
             prefer: borrow.id
           })
           yield* waited
-          return own !== undefined && own.id === borrow.id
+          return own !== undefined && own.spec.id === borrow.id
             ? yield* leaseOf(own, role, leaseOptions, because)
             : own !== undefined
               ? // Someone came back between the check and the pick: independent after all.

package/src/RosterSeats.ts

@@ -11,7 +11,7 @@ import * as Stream from "effect/Stream"
 import { ConfigError, type LlmError } from "@llm4ts/core/Errors"
 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 { describeFlowError, type FlowError, RosterExhausted } from "./FlowError.ts"
 import { ExecutorHandedOver, type FlowEventsShape } from "./FlowEvents.ts"
 import { callPurpose } from "./Timing.ts"
 import {
@@ -48,6 +48,8 @@ export interface RosterView {
   readonly capacityChanged: (role: Role, from: number) => Effect.Effect<number>
   /** The executor holding this context's coder, once leased. */
   readonly executor: Effect.Effect<string | undefined>
+  /** Which clone of it (ADR 0033), once leased. */
+  readonly clone?: Effect.Effect<number | undefined>
   /** Every executor that held this context's coder, in order (handovers). */
   readonly history: Effect.Effect<ReadonlyArray<string>>
   /** The autonomy contract profile an executor's roster entry asks for (ADR 0027), when it does. */
@@ -253,11 +255,18 @@ export interface HeldCoderOptions {
   /** Handovers before a failure surfaces. Default 2. */
   readonly maxHandovers?: number
   readonly label?: string
+  /**
+   * Lease only a slot that is free now; none fails `RosterExhausted` at
+   * once instead of waiting (a task run aside, ADR 0034).
+   */
+  readonly ifFree?: boolean
 }
 
 export interface HeldCoder {
   readonly service: LlmServiceShape
   readonly executor: Effect.Effect<string | undefined>
+  /** The held coder's clone number, when it holds a slot (ADR 0033). */
+  readonly clone: Effect.Effect<number | undefined>
   readonly lease: Effect.Effect<ExecutorSpec | undefined>
   readonly history: Effect.Effect<ReadonlyArray<string>>
 }
@@ -303,12 +312,26 @@ export const makeHeldCoder = Effect.fn("@llm4ts/flow/RosterSeats.heldCoder")(fun
         return held
       }
       const preferred = yield* Ref.get(prefer)
-      const lease = yield* roster
-        .lease("coder", {
-          ...(preferred === undefined ? {} : { prefer: preferred }),
-          ...(options.label === undefined ? {} : { label: options.label })
-        })
-        .pipe(Scope.provide(scope))
+      const leaseOptions = {
+        ...(preferred === undefined ? {} : { prefer: preferred }),
+        ...(options.label === undefined ? {} : { label: options.label })
+      }
+      const lease =
+        options.ifFree === true
+          ? yield* roster.tryLease("coder", leaseOptions).pipe(
+              Scope.provide(scope),
+              Effect.flatMap((free) =>
+                free === undefined
+                  ? Effect.fail(
+                      RosterExhausted.make({
+                        role: "coder",
+                        reasons: ["no coder slot is free now"]
+                      })
+                    )
+                  : Effect.succeed(free)
+              )
+            )
+          : yield* roster.lease("coder", leaseOptions).pipe(Scope.provide(scope))
       const seat = yield* source.seatFor(lease.executor, "coder", workDir)
       const next = { lease, seat }
       yield* Ref.set(current, next)
@@ -375,6 +398,7 @@ export const makeHeldCoder = Effect.fn("@llm4ts/flow/RosterSeats.heldCoder")(fun
   return {
     service: serviceOver({ run, stream, isAvailable: roster.canEverServe("coder") }),
     executor: Effect.map(Ref.get(current), (held) => held?.lease.executor.id),
+    clone: Effect.map(Ref.get(current), (held) => held?.lease.clone),
     lease: Effect.map(Ref.get(current), (held) => held?.lease.executor),
     history: Ref.get(history)
   }