@llm4ts/runner 2.21.0 → 2.22.0

package/src/AgentTreeSurface.ts

@@ -38,18 +38,69 @@ export interface AgentTreeHost {
   readonly close: Effect.Effect<void>
 }
 
-const enterScreen = "\u001b[?1049h\u001b[?25l"
-const leaveScreen = "\u001b[?25h\u001b[?1049l"
-const home = "\u001b[H\u001b[2J"
+const beginUpdate = "\u001b[?2026h"
+const endUpdate = "\u001b[?2026l"
+const clearScreen = "\u001b[H\u001b[2J"
+const at = (row: number): string => `\u001b[${row};1H`
+
+/**
+ * What to send to turn the screen showing `previous` into `next`: the whole
+ * frame after a clear when there is no previous one (first paint, resize, a
+ * prompt in between), otherwise only the rows that changed — never a clear,
+ * which is what flickers under tmux and Windows terminals — and nothing at
+ * all when the frame is the same. Each paint is one synchronized update, which
+ * terminals that know it show at once and the rest ignore. Rows are drawn
+ * at full width, so an overwritten row leaves nothing behind.
+ */
+export const paintFrame = (
+  previous: ReadonlyArray<string> | undefined,
+  next: ReadonlyArray<string>
+): string => {
+  if (previous === undefined) {
+    return `${beginUpdate}${clearScreen}${next.map((line, row) => `${at(row + 1)}${line}`).join("")}${endUpdate}`
+  }
+  const changed = next.flatMap((line, row) =>
+    line === previous[row] ? [] : [`${at(row + 1)}${line}`]
+  )
+  const shorter = next.length < previous.length ? `${at(next.length + 1)}\u001b[J` : ""
+  return changed.length === 0 && shorter === ""
+    ? ""
+    : `${beginUpdate}${changed.join("")}${shorter}${endUpdate}`
+}
+
+/** A full-screen view's painter: remembers what is on screen, and at which size. */
+export interface ScreenPainter {
+  /** What to write to show `lines` at terminal size `size`; empty when nothing changed. */
+  readonly paint: (lines: ReadonlyArray<string>, size: string) => Effect.Effect<string>
+  /** The screen was cleared or covered: the next paint is a whole one. */
+  readonly reset: Effect.Effect<void>
+}
+
+export const makeScreenPainter: Effect.Effect<ScreenPainter> = Effect.map(
+  Ref.make<{ readonly lines: ReadonlyArray<string>; readonly size: string } | undefined>(undefined),
+  (shown) => ({
+    paint: (lines, size) =>
+      Ref.modify(shown, (previous) => [
+        paintFrame(previous?.size === size ? previous.lines : undefined, lines),
+        { lines, size }
+      ]),
+    reset: Ref.set(shown, undefined)
+  })
+)
+
+/** The alternate screen, cursor hidden, no auto-wrap: a full-width last row never scrolls. */
+export const enterScreen = "\u001b[?1049h\u001b[?25l\u001b[?7l"
+export const leaveScreen = "\u001b[?7h\u001b[?25h\u001b[?1049l"
 const redrawEvery = "100 millis"
 
 export const makeAgentTreeHost = Effect.fn("@llm4ts/runner/AgentTreeSurface.make")(function* (
   hub: FlowEventHub,
   classic: TerminalSurface,
   output: AgentTreeOutput,
-  keys: Stream.Stream<string>
+  keys: Stream.Stream<string>,
+  idleAfterMs?: number
 ): Effect.fn.Return<AgentTreeHost, never, Scope.Scope> {
-  const state = yield* Ref.make(emptyTree())
+  const state = yield* Ref.make(emptyTree(idleAfterMs === undefined ? {} : { idleAfterMs }))
   const view = yield* Ref.make<TreeView>(initialView)
   const active = yield* Ref.make(true)
   const consumed = yield* Ref.make(0)
@@ -65,19 +116,28 @@ export const makeAgentTreeHost = Effect.fn("@llm4ts/runner/AgentTreeSurface.make
     Effect.forkScoped
   )
 
-  const render = (rows: number | undefined): Effect.Effect<string> =>
+  const render = (rows: number | undefined): Effect.Effect<ReadonlyArray<string>> =>
     Effect.gen(function* () {
-      const lines = renderTree(yield* Ref.get(state), {
+      return renderTree(yield* Ref.get(state), {
         width: Math.max(90, output.columns() ?? 90),
         colour: output.colour,
         view: yield* Ref.get(view),
         ...(rows === undefined ? {} : { height: rows })
       })
-      return lines.join("\n")
     })
   /** The full screen fits the terminal; the last frame left behind is whole. */
-  const frame = render(undefined)
-  const screen = Effect.suspend(() => render(output.rows()))
+  const frame = Effect.map(render(undefined), (lines) => lines.join("\n"))
+  const painter = yield* makeScreenPainter
+  const repaint = Effect.gen(function* () {
+    // The clock moves between events: lane timers and the idle marker run.
+    const now = yield* Clock.currentTimeMillis
+    yield* Ref.update(state, (current) => reduceTree(current, { _tag: "Tick", at: now }))
+    const rows = output.rows()
+    const text = yield* painter.paint(yield* render(rows), `${output.columns()}x${rows}`)
+    if (text.length > 0) {
+      yield* output.write(text)
+    }
+  })
 
   /** Runs `effect` only while the tree has the screen, under the drawing lock. */
   const whileShown = (effect: Effect.Effect<void>): Effect.Effect<void> =>
@@ -93,12 +153,9 @@ export const makeAgentTreeHost = Effect.fn("@llm4ts/runner/AgentTreeSurface.make
 
   yield* output.write(enterScreen)
   yield* Effect.addFinalizer(() => leave(false))
-  yield* Effect.forever(
-    Effect.andThen(
-      Effect.sleep(redrawEvery),
-      whileShown(Effect.flatMap(screen, (text) => output.write(`${home}${text}`)))
-    )
-  ).pipe(Effect.forkScoped)
+  yield* Effect.forever(Effect.andThen(Effect.sleep(redrawEvery), whileShown(repaint))).pipe(
+    Effect.forkScoped
+  )
   yield* Stream.runForEach(keys, (key) =>
     Effect.gen(function* () {
       const next = onTreeKey(yield* Ref.get(view), key, yield* Ref.get(state))
@@ -123,7 +180,9 @@ export const makeAgentTreeHost = Effect.fn("@llm4ts/runner/AgentTreeSurface.make
               lock.withPermit(Effect.andThen(Ref.set(active, false), output.write(leaveScreen))),
               () => classic.suspend(effect),
               () =>
-                lock.withPermit(Effect.andThen(Ref.set(active, true), output.write(enterScreen)))
+                lock.withPermit(
+                  Effect.all([Ref.set(active, true), painter.reset, output.write(enterScreen)])
+                )
             )
           : classic.suspend(effect)
       )

package/src/FlowRunner.ts

@@ -58,6 +58,8 @@ import {
 } from "@llm4ts/flow/FlowEvents"
 import { FlowContext, type ContextOptions, type FlowContextShape } from "@llm4ts/flow/FlowContext"
 import { makeFlowRecorder, type RunOutcome } from "@llm4ts/flow/FlowRecorder"
+import { timedSeat } from "@llm4ts/flow/Timing"
+import { idleAfterFrom } from "./AgentTree.ts"
 import { makeAgentTreeHost, nodeTreeKeys } from "./AgentTreeSurface.ts"
 import { makeJudgmentLog, type JudgmentLogShape } from "@llm4ts/flow/JudgmentLog"
 import { makeGitHubTool } from "@llm4ts/flow/GitHubTool"
@@ -454,13 +456,14 @@ export const makeFlowRunnerContext = Effect.fn("@llm4ts/runner/FlowRunner.makeCo
     laneEvents: FlowEventsShape = events
   ): FlowContextShape =>
     FlowContext.of({
-      reasoning: seats.reasoning,
-      coder: seats.coder,
+      // Every call is timed on the lane's events, under its role.
+      reasoning: timedSeat(seats.reasoning, laneEvents, "reasoning"),
+      coder: { ...seats.coder, ...timedSeat(seats.coder, laneEvents, "coder") },
       judgment: seats.judgment,
       git: makeGitTool(dependencies.process, workDir, laneEvents),
       hosting: makeGitHubTool(dependencies.process, workDir, laneEvents),
       events: laneEvents,
-      reviewers: seats.reviewers,
+      reviewers: seats.reviewers.map((reviewer) => timedSeat(reviewer, laneEvents, "reviewer")),
       coderCapabilities: seats.coder.capabilities,
       userPrompt: options.userPrompt,
       workDir,
@@ -618,12 +621,16 @@ export const makeFlowRunnerContext = Effect.fn("@llm4ts/runner/FlowRunner.makeCo
       laneEvents: FlowEventsShape
     ): RosterView => ({
       forRole: (role) =>
-        rosterSeat(roster, source, role, workDir, {
-          events: laneEvents,
-          avoid: Effect.map(held.executor, (id) => (id === undefined ? [] : [id])),
-          borrow: held.lease,
-          label
-        }),
+        timedSeat(
+          rosterSeat(roster, source, role, workDir, {
+            events: laneEvents,
+            avoid: Effect.map(held.executor, (id) => (id === undefined ? [] : [id])),
+            borrow: held.lease,
+            label
+          }),
+          laneEvents,
+          role
+        ),
       available: roster.available,
       slots: roster.slots,
       executor: held.executor,
@@ -647,7 +654,7 @@ export const makeFlowRunnerContext = Effect.fn("@llm4ts/runner/FlowRunner.makeCo
         const judgment = yield* judgmentFor(judgmentSeat, judgmentConfig, runEnvironment)
         return FlowContext.of({
           reasoning: view.forRole(rebind ? "planner" : "reviewer"),
-          coder: held.service,
+          coder: timedSeat(held.service, laneEvents, "coder"),
           judgment,
           git: makeGitTool(dependencies.process, workDir, laneEvents),
           hosting: makeGitHubTool(dependencies.process, workDir, laneEvents),
@@ -765,7 +772,8 @@ export const runWithBundle = Effect.fn("@llm4ts/runner/FlowRunner.runWithBundle"
             rows: () => process.stdout.rows,
             colour: true
           },
-          nodeTreeKeys("interrupt")
+          nodeTreeKeys("interrupt"),
+          idleAfterFrom(environment)
         )
       : undefined
   const surface = tree?.surface ?? classic