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

package/src/pi/start-task.ts

@@ -7,7 +7,8 @@ import { existsSync } from "node:fs";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { createTask, taskRequest, type Task, type TaskTrack, type TaskTriage, type TrackPath } from "../schemas/task.ts";
 import type { Domain } from "../schemas/agent.ts";
-import { chooseTrack, trackLine, trackSummary } from "../workflow/track.ts";
+import { chooseTrack, qaRequired, rosterWords, trackLine, trackSummary } from "../workflow/track.ts";
+import { startFromAgreedPlan } from "../workflow/workflow.ts";
 import { lobbyFeed } from "../lobby/feed.ts";
 import { createTaskDir, ensureProjectStructure, loadTask, nextTaskId, ownedTask, saveTask, taskDirFor } from "../state/persistence.ts";
 import { detectProjectRoot, loadConfig } from "../state/project.ts";
@@ -43,7 +44,7 @@ function fastSteps(track: TaskTrack): string[] {
   const steps = [
     ...(track.roster.includes("researcher") ? ["First summon the researcher for the outside facts it needs: orchestrate action=research with a domain and the question."] : []),
     `Delegate now with orchestrate action=implement: ${builders}; open each task with "Step 1:" (the engine keeps the plan).`,
-    ...(track.roster.includes("qa") && building.length > 0 ? ["QA takes part (tests): once the change is in, give qa the tests as the last step (action=implement domain=qa), or run action=qa."] : []),
+    ...(track.roster.includes("qa") && building.length > 0 ? ["QA takes part: once the change is in, run orchestrate action=qa. Jev reads the change and sizes QA to its risk; one with nothing that runs passes on the engine's checks."] : []),
     "Check `git diff --stat` and the report, then orchestrate action=complete with a one-line summary.",
   ];
   return [
@@ -54,6 +55,25 @@ function fastSteps(track: TaskTrack): string[] {
   ].filter(Boolean);
 }
 
+/** A task from an agreed plan: straight to building its steps; QA only when it took part in the panel. */
+function plannedSteps(task: Task): string[] {
+  const qa = qaRequired(task);
+  const steps = [
+    'Delegate the plan\'s steps now with orchestrate action=implement, opening each task with "Step N:" and briefing it in full from the plan. Give one domain its consecutive steps in one call, and run independent domains together with assignments.',
+    "After each report, check `git diff --stat` and the report, then delegate the next step.",
+    qa
+      ? "Once every step is done, run orchestrate action=qa (Jev sizes it to the change), then action=complete with a one-line summary."
+      : "Once every step is done, call orchestrate action=complete with a one-line summary. QA sat out the planning panel, so there is no QA gate.",
+  ];
+  const out = task.track?.satOut ?? [];
+  return [
+    `Planned task: the user agreed this plan in the planning panel (${task.approvedPlan}), and it is already the task's plan. The panel asked the questions and read the code, so there is no clarifying, scouting, proposal or plan to write: start building.`,
+    out.length > 0 ? `Only the members who sat on the panel work on it (${rosterWords(task.track?.roster ?? [])}). ${rosterWords(out)} sat out, so give ${out.length === 1 ? "it" : "them"} nothing; if a step truly needs one, ask the user with orchestrate action=track (the roster with it, and why).` : "",
+    ...steps.map((step, index) => `${index + 1}. ${step}`),
+    "If the code contradicts the plan, amend it with action=plan (the plan with the change made) and tell the user in one line, rather than starting over.",
+  ].filter(Boolean);
+}
+
 export function kickoff(task: Task, budgetMinutes = 0, options: { fastTrack?: boolean; routed?: boolean } = {}): string {
   const track = task.track;
   const head = [
@@ -68,6 +88,7 @@ export function kickoff(task: Task, budgetMinutes = 0, options: { fastTrack?: bo
     "",
   ];
   if (track?.path === "fast") return [...head, ...fastSteps(track)].join("\n");
+  if (task.approvedPlan && task.plan && task.state === "planning") return [...head, ...plannedSteps(task)].join("\n");
   const fastAllowed = Boolean(track) && options.fastTrack !== false && track?.userChoice !== "full" && track?.source !== "plan";
   return [
     ...head,
@@ -105,6 +126,10 @@ async function giveWorkspace(ctx: ExtensionContext, root: string, configDir: str
 export interface StartOptions {
   /** The planned task (PLAN-…) this task starts from: the user agreed its plan, so its proposal needs no approval. */
   approvedPlan?: string;
+  /** That plan: it becomes the task's plan, and the task starts at delegating its steps. */
+  plan?: string;
+  /** The panel seats that took part in that plan; one that sat it out (QA) is not part of the task. */
+  panel?: readonly string[];
   /** Start in auto mode: the oracle drives it to completion without asking. */
   auto?: boolean;
   /** The task's short title (a planned task's own title); derived from the request otherwise. */
@@ -140,8 +165,10 @@ export async function startTask(pi: ExtensionAPI, ctx: ExtensionContext, configD
   if (triage) task.triage = triage;
   // How serious the request reads: who takes part, and whether it takes the fast track or the full workflow.
   const config = loadConfig();
-  task.track = chooseTrack(request, triage, { fastTrack: config.workflow.fastTrack, ...(options.track ? { forced: options.track } : {}), ...(options.approvedPlan ? { approvedPlan: true } : {}) });
+  task.track = chooseTrack(request, triage, { fastTrack: config.workflow.fastTrack, ...(options.track ? { forced: options.track } : {}), ...(options.approvedPlan ? { approvedPlan: true } : {}), ...(options.panel ? { planPanel: options.panel } : {}) });
   lobbyFeed.log("LOBBY", trackLine(task.track), "info");
+  // An agreed plan is the task's plan: it goes straight to delegating its steps.
+  if (options.approvedPlan && options.plan) startFromAgreedPlan(task, options.plan, taskDirFor(root, configDir, task.id));
   await giveWorkspace(ctx, root, configDir, task, options.isolation ?? config.workflow.gitIsolation);
   saveTask(root, configDir, task);
   const budgetMinutes = options.budget ?? config.workflow.taskBudgetMinutes;
@@ -192,7 +219,7 @@ export async function startPlannedTask(pi: ExtensionAPI, ctx: ExtensionContext,
   if (!plan) return `no planned task ${planId}`;
   if (plan.status !== "pending") return `${planId} was already started${plan.startedTaskId ? ` as ${plan.startedTaskId}` : ""}`;
   const waiting = unfinishedBefore(root, configDir, plan);
-  const task = await startTask(pi, ctx, configDir, plannedTaskRequest(plan), { approvedPlan: plan.id, title: plan.title, ...(options.auto ? { auto: true } : {}) });
+  const task = await startTask(pi, ctx, configDir, plannedTaskRequest(plan), { approvedPlan: plan.id, plan: plan.brief, ...(plan.panel ? { panel: plan.panel } : {}), title: plan.title, ...(options.auto ? { auto: true } : {}) });
   if (!task) return `this session already drives a task; finish or cancel it first`;
   markPlannedTaskStarted(root, configDir, plan.id, task.id);
   if (waiting.length > 0) {

package/src/pi/tools.ts

@@ -16,6 +16,7 @@ import { isQuiet } from "./quiet.ts";
 import { checkThinking, createProfileResolver, modelRef, type ModelLookup } from "./model-support.ts";
 import { agentName, describeRun } from "./run-summary.ts";
 import { lintFeed } from "../workflow/lint.ts";
+import { qaRiskLine } from "../classifier/qa-risk.ts";
 import { lobbyFeed } from "../lobby/feed.ts";
 import {
   ORCHESTRATE_ACTIONS,
@@ -140,6 +141,8 @@ export function workflowDeps(
       const line = lintFeed(taskId, report);
       lobbyFeed.log("LINT", line.text, line.kind);
     },
+    // Jev's QA risk read of each task's change, as the QA gate starts.
+    onQaRisk: (taskId, assessment) => lobbyFeed.log("CLASSIFIER", `${taskId} ${qaRiskLine(assessment)}`, "info"),
   };
 }
 

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. */
@@ -172,7 +170,7 @@ export interface LobbyConfig {
 }
 
 /** Decisions the classifier can make, each switched on or off on its own. */
-export const CLASSIFIER_FEATURES = ["seats", "answers", "files", "triage", "effort", "review", "knowledge"] as const;
+export const CLASSIFIER_FEATURES = ["seats", "answers", "files", "triage", "effort", "review", "knowledge", "qa"] as const;
 export type ClassifierFeature = (typeof CLASSIFIER_FEATURES)[number];
 
 /** Hosts that serve Jev behind the same System One API; `auto` takes OpenCode's free Jev when pi holds an OpenCode key, else TypeSafe. */
@@ -293,7 +291,7 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
     model: "",
     baseUrl: "",
     timeoutMs: 4000,
-    features: { seats: true, answers: true, files: true, triage: true, effort: true, review: true, knowledge: true },
+    features: { seats: true, answers: true, files: true, triage: true, effort: true, review: true, knowledge: true, qa: true },
     thresholds: {
       seatAt: 0.35,
       reseatReadyAt: 0.6,

package/src/schemas/task.ts

@@ -55,6 +55,8 @@ export interface ReviewRecord {
   findings: { severity: Severity; text: string }[];
   requiredChanges: string[];
   createdAt: string;
+  /** The engine's deterministic checks decided the round: no QA agent ran (a change with nothing that runs). */
+  checksOnly?: boolean;
 }
 /**
  * One finished worker delegation, kept on the task so the plan checklist can be
@@ -118,6 +120,32 @@ export interface TaskTriage {
   at: string;
 }
 
+/** How much verification a finished change warrants, lowest first. */
+export const QA_RISKS = ["none", "low", "medium", "high"] as const;
+export type QaRisk = (typeof QA_RISKS)[number];
+
+/**
+ * What the change a task built warrants of QA, read from its diff once the
+ * implementation is done: the QA gate's verification budget. The test budget
+ * is a ceiling, never a quota.
+ */
+export interface QaRiskAssessment {
+  risk: QaRisk;
+  /** Whether an LLM QA pass is needed at all: without one, the engine's deterministic checks decide. */
+  qaRequired: boolean;
+  /** New behavioural tests that may be worth writing, at most `max`. */
+  testBudget: { min: number; max: number };
+  /** What QA should verify first, as words. */
+  focusAreas: string[];
+  /** The evidence behind the level: what the diff touches, with paths. */
+  riskFactors: string[];
+  existingTestsLikelySufficient: boolean;
+  reasoning: string;
+  /** Jev's read of the diff, or the engine's rules alone when Jev is off, failed or had nothing to read. */
+  source: "classifier" | "rules";
+  at: string;
+}
+
 /** How much process a task gets: the fast track for a small, clear, low-risk change, the full workflow for the rest. */
 export type TrackPath = "fast" | "full";
 
@@ -142,6 +170,8 @@ export interface TaskTrack {
   userChoice?: TrackPath;
   /** The engine keeps the plan (fast track): each delegation adds its step. */
   autoPlan?: boolean;
+  /** Members who sat out the planning panel that agreed the plan: they do not work on the task (no QA gate without QA) unless the user lets one join. */
+  satOut?: TrackMember[];
   at: string;
 }
 
@@ -227,6 +257,8 @@ export interface Task {
   git?: TaskGit;
   /** The lint gate's last report on the files this task's agents touched. */
   lint?: LintReport;
+  /** The last read of what the built change warrants of QA, taken as the QA gate starts. */
+  qaRisk?: QaRiskAssessment;
   /** Set only by the user: the work is accepted with the lint errors it has, so the task may complete. */
   lintWaiver?: { at: string };
 }

package/src/state/backlog.ts

@@ -11,6 +11,7 @@ import { writeFileEnsured } from "../knowledge/store.ts";
 import { forgetCachedUnder, readJsonCached } from "./file-cache.ts";
 import { dataRoot } from "./project.ts";
 import { taskSlug } from "./persistence.ts";
+import type { PanelMember } from "../schemas/configuration.ts";
 
 export interface IssueRef {
   number: number;
@@ -44,6 +45,8 @@ export interface PlannedTask {
   startedTaskId?: string;
   /** Set when the plan was split into several tasks and this is one of them. */
   split?: SplitInfo;
+  /** The panel seats that took part in planning it (sat a round and were not unseated); absent on plans saved before this was kept. */
+  panel?: PanelMember[];
 }
 
 export function backlogDir(root: string, configDir: string): string {
@@ -63,7 +66,7 @@ function isPlannedTask(value: unknown): value is PlannedTask {
 export function savePlannedTask(
   root: string,
   configDir: string,
-  input: { title: string; brief: string; issue?: IssueRef; split?: SplitInfo },
+  input: { title: string; brief: string; issue?: IssueRef; split?: SplitInfo; panel?: readonly PanelMember[] },
   now = new Date(),
 ): PlannedTask {
   const title = input.title.trim() || "planned task";
@@ -73,7 +76,7 @@ export function savePlannedTask(
   let id = base;
   for (let n = 2; existsSync(entryPath(root, configDir, id)); n++) id = `${base}-${n}`;
   const at = now.toISOString();
-  const entry: PlannedTask = { id, title, brief, createdAt: at, updatedAt: at, status: "pending", ...(input.issue ? { issue: input.issue } : {}), ...(input.split ? { split: input.split } : {}) };
+  const entry: PlannedTask = { id, title, brief, createdAt: at, updatedAt: at, status: "pending", ...(input.issue ? { issue: input.issue } : {}), ...(input.split ? { split: input.split } : {}), ...(input.panel ? { panel: [...input.panel] } : {}) };
   writeFileEnsured(entryPath(root, configDir, id), JSON.stringify(entry, null, 2));
   return entry;
 }
@@ -131,9 +134,22 @@ export function splitLine(split: SplitInfo): string {
   return `This is part ${split.part} of ${split.of} of one plan that was split into separate tasks: ${others}.${before} Do only this part; the others are their own tasks.`;
 }
 
+/** Where a planned task's request moves on from what it is to the plan itself. */
+const AGREED_PLAN = "\n\nAgreed plan (from the planning session):\n";
+
 /** The request a started task carries: the agreed plan, plus the issue it came from, plus where it sits in a split plan. */
 export function plannedTaskRequest(entry: PlannedTask): string {
   const source = entry.issue ? `\n\nFrom GitHub issue #${entry.issue.number}: ${entry.issue.title}${entry.issue.url ? ` (${entry.issue.url})` : ""}` : "";
   const part = entry.split ? `\n\n${splitLine(entry.split)}` : "";
-  return `${entry.title}${part}\n\nAgreed plan (from the planning session):\n${entry.brief}${source}`;
+  return `${entry.title}${part}${AGREED_PLAN}${entry.brief}${source}`;
+}
+
+/**
+ * A planned task's request without the plan in it (its title, and where it
+ * sits in a split plan), for prompts that carry the plan on its own: the plan
+ * is not sent twice. Any other request is returned whole.
+ */
+export function requestBesidePlan(request: string): string {
+  const at = request.indexOf(AGREED_PLAN);
+  return at < 0 ? request : `${request.slice(0, at)}\n\n(The agreed plan is the task's plan.)`;
 }

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) };
+  });
 }