@a-t-h-i/bot-lobby 0.6.25 → 0.6.26

package/src/pi/plan-checklist.ts

@@ -89,6 +89,19 @@ function stepSection(lines: readonly string[]): string[] | undefined {
   return body;
 }
 
+/**
+ * The concise list a plan opens its steps with: a `Steps` section that comes
+ * before any `Step N` heading. The plan's detail then follows, often one
+ * `### Step N: …` section per step, and the list stays the checklist.
+ */
+function leadingStepList(lines: readonly string[]): string[] {
+  const section = lines.findIndex((line) => HEADER_LINE.test(line) && STEP_SECTION.test(line));
+  if (section < 0) return [];
+  const heading = lines.findIndex((line) => STEP_HEADING.test(line));
+  if (heading >= 0 && heading < section) return [];
+  return collectSteps(stepSection(lines) ?? [], sectionItem);
+}
+
 /** `Step N` headings, when the plan is structured as one heading per step. */
 function headingSteps(lines: readonly string[]): string[] {
   const found: string[] = [];
@@ -100,13 +113,17 @@ function headingSteps(lines: readonly string[]): string[] {
 }
 
 /**
- * Step texts from a free-form plan, capped. `Step N` headings win; then a
- * `sequence|steps|order` section; then numbered lines; when none exists,
- * top-level bullets are the last resort, so unrelated bullet lists under other
- * headers never leak into the checklist. Only the shallowest items count.
+ * Step texts from a free-form plan, capped. A steps list the plan opens with
+ * wins (its detail may follow under `Step N` headings); then `Step N`
+ * headings; then a `sequence|steps|order` section; then numbered lines; when
+ * none exists, top-level bullets are the last resort, so unrelated bullet
+ * lists under other headers never leak into the checklist. Only the
+ * shallowest items count.
  */
 export function planSteps(plan: string): string[] {
   const lines = plan.split("\n");
+  const leading = leadingStepList(lines);
+  if (leading.length > 0) return leading.slice(0, MAX_PLAN_STEPS);
   const headings = headingSteps(lines);
   if (headings.length > 0) return headings.slice(0, MAX_PLAN_STEPS);
   const section = stepSection(lines);
@@ -119,6 +136,26 @@ export function planSteps(plan: string): string[] {
   return collectSteps(lines, topBulletItem).slice(0, MAX_PLAN_STEPS);
 }
 
+/**
+ * The plan without the steps list it opens with, for reading after the
+ * checklist (which already shows those steps); undefined when the checklist
+ * does not come from such a list, so the plan is read whole.
+ */
+export function planDetails(plan: string): string | undefined {
+  const lines = plan.split("\n");
+  if (leadingStepList(lines).length === 0) return undefined;
+  const heading = lines.findIndex((line) => HEADER_LINE.test(line) && STEP_SECTION.test(line));
+  let to = lines.length;
+  for (let index = heading + 1; index < lines.length; index += 1) {
+    if (HEADER_LINE.test(lines[index]!)) {
+      to = index;
+      break;
+    }
+  }
+  const rest = [...lines.slice(0, heading), ...lines.slice(to)].join("\n").trim();
+  return rest || undefined;
+}
+
 /** Where a plan's steps section sits, and each of its top-level steps whole (its nested lines included). */
 export interface StepBlocks {
   /** The section's body: from this line up to (not including) `to`. */
@@ -239,15 +276,23 @@ function stepScore(step: string, instruction: InstructionIndex): number {
  * named, so "building on step 1, now do step 3" does not jump back to step 1.
  */
 export function explicitStepIndex(instruction: string, count: number): number {
+  return explicitStepRange(instruction, count)?.[1] ?? -1;
+}
+
+/** The 0-based steps an instruction labels itself with, first and last ("Steps 2-4: ..." is 1 to 3); undefined when none. */
+export function explicitStepRange(instruction: string, count: number): [number, number] | undefined {
   const refs = [...instruction.matchAll(STEP_REFERENCE)];
-  if (refs.length === 0) return -1;
+  if (refs.length === 0) return undefined;
   const first = refs[0]!;
   const leading = LEADING_LABEL.test(instruction.slice(0, first.index ?? 0)) ? first : undefined;
   const distinct = new Set(refs.map((ref) => ref[0].toLowerCase().replace(/\s+/g, "")));
   const chosen = leading ?? (distinct.size === 1 ? refs[0] : undefined);
-  if (!chosen) return -1;
-  const last = Math.max(Number(chosen[1]), Number(chosen[2] ?? chosen[1]));
-  return last >= 1 && last <= count ? last - 1 : -1;
+  if (!chosen) return undefined;
+  const a = Number(chosen[1]);
+  const b = Number(chosen[2] ?? chosen[1]);
+  const last = Math.max(a, b);
+  if (last < 1 || last > count) return undefined;
+  return [Math.max(1, Math.min(a, b)) - 1, last - 1];
 }
 
 /**
@@ -345,3 +390,48 @@ export function planChecklist(plan: string, runs: readonly AgentRun[]): PlanStep
   checklistMemo = { plan, runs, steps };
   return steps;
 }
+
+/* -------------------------------------------------------------------------
+ * Step work: how long the workers have worked on each step, and which steps
+ * they are on right now, for the checklist's `active · 1m 12s` marks.
+ * ---------------------------------------------------------------------- */
+
+export interface StepWork {
+  /** Worker time on the step so far, in ms (the running runs up to `now`). */
+  ms: number;
+  /** A worker is on it right now. */
+  active: boolean;
+}
+
+/** The steps a run works on: every step of a range it names, else the step it targets, else the next one still open. */
+function runSteps(steps: readonly string[], instruction: string | undefined, completed: ReadonlySet<number>): number[] {
+  const range = instruction ? explicitStepRange(instruction, steps.length) : undefined;
+  if (range) return Array.from({ length: range[1] - range[0] + 1 }, (_value, offset) => range[0] + offset);
+  const target = targetStep(steps, instruction, completed);
+  const step = target >= 0 ? target : nextOpenStep(steps, completed);
+  return step >= 0 ? [step] : [];
+}
+
+/**
+ * Each step's worker time and whether a worker is on it now, replaying the
+ * runs in start order as the checklist does. A run counts in full toward each
+ * step it works on (a `Steps 2-4` run toward all three), and its success
+ * completes them, so a later run that names no step goes to the next one.
+ */
+export function stepWork(steps: readonly string[], runs: readonly AgentRun[], now = Date.now()): StepWork[] {
+  const work = steps.map(() => ({ ms: 0, active: false }));
+  const completed = new Set<number>();
+  for (const run of byStart(runs)) {
+    if (run.role !== "worker") continue;
+    const covered = runSteps(steps, run.instruction, completed);
+    const start = Date.parse(run.startedAt);
+    const end = run.finishedAt ? Date.parse(run.finishedAt) : now;
+    const ms = Number.isFinite(start) && Number.isFinite(end) ? Math.max(0, end - start) : 0;
+    for (const index of covered) {
+      work[index]!.ms += ms;
+      if (run.status === "running") work[index]!.active = true;
+    }
+    if (run.status === "success" && covered.length > 0) markThrough(completed, covered[covered.length - 1]!);
+  }
+  return work;
+}

package/src/pi/route.ts

@@ -14,7 +14,6 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { Container, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import type { Domain } from "../schemas/agent.ts";
-import type { TaskTriage } from "../schemas/task.ts";
 import { chooseRoute, type RequestRoute } from "../workflow/track.ts";
 import { triageFor } from "../classifier/instance.ts";
 import { ownedTask } from "../state/persistence.ts";

package/src/pi/run-summary.ts

@@ -124,60 +124,3 @@ export function runFromLog(entry: RunLogEntry, taskId: string): AgentRun {
     ...(entry.error ? { error: entry.error } : {}),
   };
 }
-
-/** Silence after which a working agent reads as "quiet" in the scene. */
-export const QUIET_MS = 45_000;
-
-/** How long a running agent has produced nothing, or 0 when it is not running or has no clock yet. */
-export function quietFor(run: Pick<AgentRun, "status" | "lastEventAt" | "startedAt">, now: number): number {
-  if (run.status !== "running") return 0;
-  const last = run.lastEventAt ?? Date.parse(run.startedAt);
-  const quiet = now - last;
-  return Number.isFinite(quiet) && quiet > 0 ? quiet : 0;
-}
-
-export interface FeedLine {
-  text: string;
-  kind: "info" | "warning";
-}
-
-/** Ticks one working agent holds the feed before it rotates to the next (~3 s at the live clock). */
-export const FEED_ROTATE_TICKS = 12;
-
-/** What one working agent is doing right now, with a warning when something needs attention. */
-function liveFeed(run: AgentRun, now: number): FeedLine {
-  const name = agentName(run);
-  if (run.waitingFor) return { text: `⧗ ${name} waiting for ${run.waitingFor}${run.note ? ` · ${run.note}` : ""}`, kind: "warning" };
-  const quiet = quietFor(run, now);
-  if (quiet >= QUIET_MS) {
-    const doing = run.activity ? ` (last: ${run.activity}${run.detail ? ` ${run.detail}` : ""})` : "";
-    return { text: `! ${name} quiet for ${shortDuration(quiet)}${doing}`, kind: "warning" };
-  }
-  if (run.note && run.noteKind === "warning") return { text: `! ${name} ${run.note}`, kind: "warning" };
-  const parts = [`▸ ${name} ${run.activity ?? "working"}${run.detail ? ` ${run.detail}` : ""}`];
-  const turns = run.turns ?? run.usage?.turns;
-  if (turns) parts.push(`turn ${turns}`);
-  if (run.tools) parts.push(`${run.tools} tools`);
-  if (run.usage && run.usage.input + run.usage.output > 0) parts.push(`${tokens(run.usage.input + run.usage.output)} tok`);
-  if (run.note) parts.push(run.note);
-  return { text: parts.join(" · "), kind: "info" };
-}
-
-/**
- * The scene's feed row: a working agent that needs attention first, otherwise
- * the working agents in rotation, otherwise the most recent finished run.
- * Undefined before anything has run.
- */
-export function feedLine(runs: readonly AgentRun[], now: number, tick: number): FeedLine | undefined {
-  const running = runs.filter((run) => run.status === "running");
-  if (running.length > 0) {
-    const lines = running.map((run) => liveFeed(run, now));
-    const warning = lines.find((line) => line.kind === "warning");
-    if (warning) return warning;
-    const index = Math.floor(Math.max(0, tick) / FEED_ROTATE_TICKS) % lines.length;
-    return lines[index];
-  }
-  const last = [...runs].filter((run) => run.finishedAt).sort((a, b) => Date.parse(a.finishedAt!) - Date.parse(b.finishedAt!)).at(-1);
-  if (!last) return undefined;
-  return { text: describeRun(last, now), kind: last.status === "success" && !last.wrappedUp ? "info" : "warning" };
-}

package/src/schemas/agent.ts

@@ -33,7 +33,3 @@ export interface DomainSpec {
 export function isDomain(value: string): value is Domain {
   return (DOMAINS as readonly string[]).includes(value);
 }
-
-export function isRole(value: string): value is Role {
-  return (ROLES as readonly string[]).includes(value);
-}

package/src/schemas/configuration.ts

@@ -13,8 +13,6 @@ export type ThinkingLevelName = (typeof THINKING_LEVELS)[number];
  */
 const INHERIT = "inherit";
 export const INHERIT_MODEL = INHERIT;
-/** Legacy thinking sentinel; configs that still carry it migrate to `DEFAULT_THINKING`. */
-export const INHERIT_THINKING = INHERIT;
 /** Level used for a missing, legacy `inherit` or unknown thinking value. */
 export const DEFAULT_THINKING: ThinkingLevelName = "medium";
 /** Scouts are reconnaissance: always fast, never configurable. */

package/src/state/budget.ts

@@ -10,7 +10,7 @@
 import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { taskDirFor } from "./persistence.ts";
-import { readJsonCached } from "./file-cache.ts";
+import { clearStaleRuns, updateWork } from "./work-time.ts";
 
 /** What one delegation was given. */
 export interface Allotment {
@@ -74,18 +74,6 @@ function writeBudget(root: string, configDir: string, taskId: string, budget: Ta
   writeFileSync(path, `${JSON.stringify({ ...budget, allotments: budget.allotments.slice(-MAX_ALLOTMENTS) }, null, 2)}\n`, "utf8");
 }
 
-/** A task's budget as a display reads it every frame: parsed again only when the file changes. */
-export function peekBudget(root: string, configDir: string, taskId: string): TaskBudget | undefined {
-  const value = readJsonCached(budgetPath(root, configDir, taskId), isBudget);
-  return value ? { minutes: value.minutes, granted: value.granted ?? 0, usedMs: value.usedMs, allotments: Array.isArray(value.allotments) ? value.allotments : [] } : undefined;
-}
-
-/** Work time spent of the whole, for the lobby's status box; undefined without a budget. */
-export function budgetClock(root: string, configDir: string, taskId: string, now = Date.now()): { usedMs: number; totalMs: number } | undefined {
-  const budget = peekBudget(root, configDir, taskId);
-  return budget ? { usedMs: usedMs(taskId, budget, now), totalMs: (budget.minutes + budget.granted) * 60_000 } : undefined;
-}
-
 /** Change a task's budget in place (read afresh, written back); undefined when it has none. */
 export function updateBudget(root: string, configDir: string, taskId: string, change: (budget: TaskBudget) => void): TaskBudget | undefined {
   const budget = readBudget(root, configDir, taskId);
@@ -127,6 +115,11 @@ export function formatMinutes(ms: number): string {
 }
 
 /* ------------------------------------------------------------ work clock */
+/*
+ * Every task the session drives has a work clock, budget or not: it keeps the
+ * task's work time (work.json, what the lobby shows as "worked") and, when the
+ * task has a budget, the time spent of it.
+ */
 
 interface Clock {
   root: string;
@@ -141,41 +134,74 @@ interface Clock {
 
 /** Work clocks of the tasks this process drives. */
 const clocks = new Map<string, Clock>();
-/** How often a counting clock is saved, so other windows see time pass. */
+/** How often a running clock is saved, so other windows see time pass (and see it is still kept). */
 export const CLOCK_FLUSH_MS = 30_000;
 let flusher: ReturnType<typeof setInterval> | undefined;
+/** The oracle's turn is running in this process. */
+let turn = false;
 
-/** Fold the stretch that counted into the saved total, and start a new one if it still counts. */
+/** Fold the stretch that counted into the saved totals, and start a new one if it still counts. */
 function settle(taskId: string, clock: Clock, now = Date.now()): void {
+  let spent = 0;
   if (clock.since !== undefined) {
-    const spent = Math.max(0, now - clock.since);
+    spent = Math.max(0, now - clock.since);
     clock.since = undefined;
     if (spent > 0) updateBudget(clock.root, clock.configDir, taskId, (budget) => { budget.usedMs += spent; });
   }
   if (clock.running && clock.waits === 0) clock.since = now;
+  const since = clock.since;
+  updateWork(clock.root, clock.configDir, taskId, (work) => {
+    work.workedMs += spent;
+    if (since !== undefined) work.runningSince = new Date(since).toISOString();
+    else delete work.runningSince;
+  }, new Date(now));
 }
 
 function ensureFlusher(): void {
   if (flusher) return;
   flusher = setInterval(() => {
-    for (const [taskId, clock] of clocks) if (clock.since !== undefined) settle(taskId, clock);
+    for (const [taskId, clock] of clocks) if (clock.running) settle(taskId, clock);
   }, CLOCK_FLUSH_MS);
   flusher.unref();
 }
 
-/** The oracle started a turn on a task: its clock runs, if the task has a budget. */
+/** The oracle's turn started: a task it drives, or starts within the turn, is being worked on. */
+export function turnStarted(): void {
+  turn = true;
+}
+
+/** The oracle started a turn on a task (or took one up within it): its clock runs. */
 export function startClock(root: string, configDir: string, taskId: string): void {
-  if (!readBudget(root, configDir, taskId)) return;
-  const clock = clocks.get(taskId) ?? { root, configDir, running: false, waits: 0 };
-  clocks.set(taskId, clock);
+  let clock = clocks.get(taskId);
+  if (!clock) {
+    clock = { root, configDir, running: false, waits: 0 };
+    clocks.set(taskId, clock);
+    clearStaleRuns(root, configDir, taskId);
+  }
+  if (clock.running) return;
   clock.running = true;
   settle(taskId, clock);
   ensureFlusher();
 }
 
-/** The oracle's turn ended: the clock stops until the next one. */
+/**
+ * The task the session drives now, after a step that may have started, ended or taken over one: while
+ * a turn runs, its clock runs and any other task's stops.
+ */
+export function clockTask(root: string, configDir: string, taskId: string | undefined): void {
+  for (const [id, clock] of clocks) {
+    if (id === taskId || !clock.running) continue;
+    clock.running = false;
+    settle(id, clock);
+  }
+  if (taskId && turn) startClock(root, configDir, taskId);
+}
+
+/** The oracle's turn ended: the clocks stop until the next one. */
 export function stopClocks(): void {
+  turn = false;
   for (const [taskId, clock] of clocks) {
+    if (!clock.running && clock.since === undefined) continue;
     clock.running = false;
     settle(taskId, clock);
   }
@@ -215,6 +241,7 @@ export function usedMs(taskId: string, budget: TaskBudget, now = Date.now()): nu
 /** Forget the clocks (tests; a session that ends). */
 export function resetClocks(): void {
   clocks.clear();
+  turn = false;
   if (flusher) clearInterval(flusher);
   flusher = undefined;
 }

package/src/state/metrics.ts

@@ -356,7 +356,6 @@ export function aggregateMetrics(records: readonly MetricRecord[], by: GroupBy =
 }
 
 export type SortKey = "runs" | "avg" | "success" | "cost";
-export const SORT_KEYS: readonly SortKey[] = ["runs", "avg", "success", "cost"];
 
 export function sortGroups(groups: readonly MetricGroup[], key: SortKey): MetricGroup[] {
   const score = (group: MetricGroup): number => {

package/src/state/persistence.ts

@@ -270,8 +270,3 @@ export function removeTaskScratchpads(root: string, configDir: string, taskId: s
     if (file.startsWith("scout-")) rmSync(join(dir, file), { force: true });
   }
 }
-
-/** Delete the temporary task dir after knowledge has been distilled. */
-export function cleanupTaskDir(root: string, configDir: string, taskId: string): void {
-  rmSync(taskDir(dataRoot(root, configDir), taskId), { recursive: true, force: true });
-}

package/src/state/work-time.ts

@@ -0,0 +1,123 @@
+/**
+ * How long a task's agents have actually worked on it, and which worker runs
+ * are under way. Work time is the oracle's turns on the task — which include
+ * every agent it runs — and not the time it waits on the user (between turns,
+ * and while a dialog is open); the work clock in budget.ts measures it. The
+ * session that owns the task keeps it beside the task's state as work.json,
+ * refreshed while it works, so every window can show the time ticking and
+ * mark the steps being worked on. A file its owner stopped refreshing (the
+ * session ended or crashed) reads as stopped.
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { taskDirFor } from "./persistence.ts";
+
+/** A worker run under way: the step it works on is found from its instruction. */
+export interface ActiveRun {
+  runId: string;
+  instruction: string;
+  startedAt: string;
+}
+
+export interface WorkTime {
+  /** Work time folded in so far, in ms. */
+  workedMs: number;
+  /** While the agents work: since when the current stretch counts. */
+  runningSince?: string;
+  active: ActiveRun[];
+  /** When the owning session last wrote it. */
+  updatedAt: string;
+}
+
+/** The clock as a reader sees it at one moment. */
+export interface WorkProjection {
+  workedMs: number;
+  /** Still counting: the reader adds the time that passes. */
+  running: boolean;
+  active: ActiveRun[];
+}
+
+/** A file older than this is no longer being kept (the owner refreshes it every 30s while it works). */
+export const WORK_FRESH_MS = 75_000;
+
+export function workPath(root: string, configDir: string, taskId: string): string {
+  return join(taskDirFor(root, configDir, taskId), "work.json");
+}
+
+function isWork(value: unknown): value is WorkTime {
+  const work = value as Partial<WorkTime> | undefined;
+  return Boolean(work && typeof work.workedMs === "number" && typeof work.updatedAt === "string");
+}
+
+export function readWork(root: string, configDir: string, taskId: string): WorkTime | undefined {
+  try {
+    const value: unknown = JSON.parse(readFileSync(workPath(root, configDir, taskId), "utf8"));
+    if (!isWork(value)) return undefined;
+    return { workedMs: value.workedMs, ...(value.runningSince ? { runningSince: value.runningSince } : {}), active: Array.isArray(value.active) ? value.active : [], updatedAt: value.updatedAt };
+  } catch {
+    return undefined;
+  }
+}
+
+/** Change a task's work time in place (read afresh, written back atomically), starting it when there is none. */
+export function updateWork(root: string, configDir: string, taskId: string, change: (work: WorkTime) => void, now = new Date()): void {
+  const work = readWork(root, configDir, taskId) ?? { workedMs: 0, active: [], updatedAt: now.toISOString() };
+  change(work);
+  work.updatedAt = now.toISOString();
+  try {
+    const path = workPath(root, configDir, taskId);
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(work, null, 2)}\n`, "utf8");
+    renameSync(tmp, path);
+  } catch {
+    // A read-only tree must never fail the workflow; the time just stops being saved.
+  }
+}
+
+/** What a reader shows now: a stale file counts up to its last refresh and nothing in it is running. */
+export function projectWork(work: WorkTime | undefined, now = Date.now()): WorkProjection | undefined {
+  if (!work) return undefined;
+  const updated = Date.parse(work.updatedAt);
+  const fresh = Number.isFinite(updated) && now - updated <= WORK_FRESH_MS;
+  const since = work.runningSince ? Date.parse(work.runningSince) : Number.NaN;
+  const end = fresh ? now : updated;
+  const stretch = Number.isFinite(since) && Number.isFinite(end) ? Math.max(0, end - since) : 0;
+  return { workedMs: Math.max(0, work.workedMs) + stretch, running: fresh && Number.isFinite(since), active: fresh ? [...work.active] : [] };
+}
+
+/** A task's work time as a reader sees it now; undefined for a task with none (one from before it was kept). */
+export function taskWork(root: string, configDir: string, taskId: string, now = Date.now()): WorkProjection | undefined {
+  return projectWork(readWork(root, configDir, taskId), now);
+}
+
+/* ------------------------------------------------------ worker runs */
+
+/** Worker runs this process has written as under way, per task: the file changes only when a run starts or ends. */
+const noted = new Map<string, Set<string>>();
+
+/** A worker run of the task started or ended: the steps it works on read as active while it runs. */
+export function noteWorkerRun(root: string, configDir: string, taskId: string, run: { runId: string; instruction?: string; startedAt: string; status: string }): void {
+  const running = run.status === "running";
+  const ids = noted.get(taskId) ?? new Set<string>();
+  if (running === ids.has(run.runId)) return;
+  if (running) ids.add(run.runId);
+  else ids.delete(run.runId);
+  noted.set(taskId, ids);
+  updateWork(root, configDir, taskId, (work) => {
+    work.active = work.active.filter((entry) => entry.runId !== run.runId);
+    if (running) work.active.push({ runId: run.runId, instruction: run.instruction ?? "", startedAt: run.startedAt });
+  });
+}
+
+/** This process starts keeping a task's time: runs a crashed session left marked as under way are not. */
+export function clearStaleRuns(root: string, configDir: string, taskId: string): void {
+  if ((noted.get(taskId)?.size ?? 0) > 0) return;
+  const work = readWork(root, configDir, taskId);
+  if (work && work.active.length > 0) updateWork(root, configDir, taskId, (next) => { next.active = []; });
+}
+
+/** Forget the runs noted (tests). */
+export function resetNotedRuns(): void {
+  noted.clear();
+}

package/src/webui/api/index.ts

@@ -373,11 +373,6 @@ function buildRoutes(): Record<string, Route> {
 
 const ROUTES = buildRoutes();
 
-/** Whether the router knows a call (defined names only; never inherited ones). */
-export function isKnownCall(name: string): boolean {
-  return Object.hasOwn(ROUTES, name);
-}
-
 /**
  * Run `POST /api/<name>` with an already-parsed body. Throws `HttpError` for
  * refusals (unknown call, a body that is no object, a schema mismatch, or a

package/src/webui/api/lobby.ts

@@ -9,23 +9,30 @@ import type { Task } from "../../schemas/task.ts";
 import type { ApiContext } from "./index.ts";
 import { withAttachments } from "../uploads.ts";
 import { fail } from "./index.ts";
-import { taskSteps } from "./plan-facts.ts";
+import { stepViews } from "./plan-facts.ts";
+import { TERMINAL_STATES } from "../../schemas/task.ts";
+import type { WorkProjection } from "../../state/work-time.ts";
 import type { LobbySnapshot, SnapshotTask } from "../protocol.ts";
 
-/** Plan facts the header shows: step progress plus the step under way, if any. */
-function planFacts(task: Task): Pick<SnapshotTask, "progress" | "currentStep"> {
-  const steps = taskSteps(task);
-  if (steps.length === 0) return {};
+/** Plan facts the header shows: step progress, the steps a worker is on (with their time) or else the next one, and the work time. */
+function planFacts(task: Task, work: WorkProjection | undefined): Pick<SnapshotTask, "progress" | "currentStep" | "activeSteps" | "work"> {
+  const clock = work ? { work: { workedMs: Math.round(work.workedMs), running: work.running && !TERMINAL_STATES.includes(task.state) } } : {};
+  const steps = stepViews(task, work);
+  if (steps.length === 0) return clock;
+  const active = steps.filter((step) => step.active);
   const current = steps.find((step) => step.status === "current");
   return {
     progress: { done: steps.filter((step) => step.status === "done").length, total: steps.length },
     ...(current ? { currentStep: current.text } : {}),
+    ...(active.length > 0 ? { activeSteps: active.map((step) => ({ text: step.text, workedMs: step.workedMs })) } : {}),
+    ...clock,
   };
 }
 
 function taskOf(ctx: ApiContext): LobbySnapshot["task"] {
   const task = ctx.service.zen().task;
   if (!task) return undefined;
+  const work = ctx.service.work?.(task.id);
   return {
     id: task.id,
     title: task.title,
@@ -33,7 +40,7 @@ function taskOf(ctx: ApiContext): LobbySnapshot["task"] {
     ...(task.track ? { track: { path: task.track.path, size: task.track.size } } : {}),
     domains: [...(task.domains ?? [])],
     ...(task.git ? { git: { branch: task.git.branch, ...(task.git.from ? { from: task.git.from } : {}) } } : {}),
-    ...planFacts(task),
+    ...planFacts(task, work),
   };
 }
 

package/src/webui/api/plan-facts.ts

@@ -1,11 +1,13 @@
 /**
  * What the Lobby header and the Tasks calls both read of a task's plan: the
- * worker records as runs, and the plan's checklist. Kept here (not via
- * `persistedRuns`) so the server never loads the TUI.
+ * worker records as runs, the plan's checklist, the steps being worked on
+ * right now and the work time. Kept here (not via `persistedRuns`) so the
+ * server never loads the TUI.
  */
-import { planChecklist, type PlanStep } from "../../pi/plan-checklist.ts";
+import { planChecklist, planSteps, stepWork, type PlanStep } from "../../pi/plan-checklist.ts";
 import type { AgentRun } from "../../schemas/findings.ts";
 import type { Task } from "../../schemas/task.ts";
+import type { WorkProjection } from "../../state/work-time.ts";
 
 /** Worker records as runs, the same projection the terminal checklist reads. */
 export function persistedTaskRuns(task: Task): AgentRun[] {
@@ -23,7 +25,35 @@ export function persistedTaskRuns(task: Task): AgentRun[] {
   }));
 }
 
-/** The plan's steps with their state; none when the task has no plan. */
-export function taskSteps(task: Task): PlanStep[] {
-  return task.plan ? planChecklist(task.plan, persistedTaskRuns(task)) : [];
+/** The worker runs under way (from the owner's work file) that have not finished yet, as running runs. */
+function activeRuns(task: Task, work: WorkProjection | undefined): AgentRun[] {
+  const finished = new Set((task.workerRuns ?? []).map((record) => record.runId));
+  return (work?.active ?? [])
+    .filter((run) => !finished.has(run.runId))
+    .map((run) => ({ runId: run.runId, taskId: task.id, domain: "backend" as const, role: "worker" as const, status: "running" as const, instruction: run.instruction, output: "", attempts: 1, startedAt: run.startedAt }));
+}
+
+/** One step as the lobby shows it: its state, and while a worker is on it, how long they have worked on it. */
+export interface StepView {
+  text: string;
+  status: PlanStep["status"];
+  active: boolean;
+  /** Worker time on the step, in ms. */
+  workedMs: number;
+}
+
+/**
+ * The plan's steps with their state, which ones a worker is on right now and
+ * the worker time on each. A step being worked on is never done, so steps run
+ * side by side all read active.
+ */
+export function stepViews(task: Task, work: WorkProjection | undefined, now = Date.now()): StepView[] {
+  if (!task.plan) return [];
+  const runs = [...persistedTaskRuns(task), ...activeRuns(task, work)];
+  const checklist = planChecklist(task.plan, runs);
+  const times = stepWork(planSteps(task.plan), runs, now);
+  return checklist.map((step, index) => {
+    const time = times[index] ?? { ms: 0, active: false };
+    return { text: step.text, status: time.active ? "current" : step.status, active: time.active, workedMs: Math.round(time.ms) };
+  });
 }