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

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/changes.ts

@@ -142,6 +142,8 @@ export interface FileProvenance {
   notes: string[];
   /** The quick fixes that edited it. */
   quickFixes: string[];
+  /** This task's domains whose workers edited it. */
+  domains?: Domain[];
 }
 
 const DOMAIN_LABELS: Record<string, string> = { backend: "DEV", designer: "DESIGN", qa: "QA" };
@@ -180,6 +182,7 @@ export function explainChanges(task: Pick<Task, "id" | "baseline">, changed: rea
     const kinds: Provenance[] = [];
     const notes: string[] = [];
     const quickFixes: string[] = [];
+    const domains: Domain[] = [];
     const add = (kind: Provenance, note: string) => {
       if (!kinds.includes(kind)) kinds.push(kind);
       if (!notes.includes(note)) notes.push(note);
@@ -188,12 +191,15 @@ export function explainChanges(task: Pick<Task, "id" | "baseline">, changed: rea
       if (record.source === "quickfix") {
         add("quickfix", `quick fix ${record.id}${clock(record.finishedAt)}, asked by the user: "${clip(record.what)}"`);
         if (!quickFixes.includes(record.id)) quickFixes.push(record.id);
-      } else if (record.taskId === task.id) add("planned", `planned: ${DOMAIN_LABELS[record.domain ?? ""] ?? record.domain ?? "worker"} — ${clip(record.what)}`);
+      } else if (record.taskId === task.id) {
+        add("planned", `planned: ${DOMAIN_LABELS[record.domain ?? ""] ?? record.domain ?? "worker"} — ${clip(record.what)}`);
+        if (record.domain && !domains.includes(record.domain)) domains.push(record.domain);
+      }
       else add("other-task", `another task's worker (${record.taskId ?? "unknown task"}): ${clip(record.what)}`);
     }
     if (before.has(path)) add("pre-existing", "pre-existing: it already had uncommitted changes before this task's agents started");
     if (kinds.length === 0) add("unattributed", "unattributed: no bot-lobby agent recorded editing it");
-    return { path, kinds, notes, quickFixes };
+    return { path, kinds, notes, quickFixes, ...(domains.length ? { domains } : {}) };
   });
 }
 

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

@@ -23,7 +23,7 @@ import { plansDiscard, plansGet, plansStart } from "./plans.ts";
 import { gitCancelReview, gitJev, gitPull, gitPulls, gitReview } from "./git.ts";
 import { issuesCreate, issuesGet, issuesList } from "./issues.ts";
 import { sessionsAnswer, sessionsChat, sessionsList, sessionsMessage, sessionsStart, sessionsStop, sessionsSwitch } from "./sessions.ts";
-import { settingsGet, settingsSet } from "./settings.ts";
+import { settingsGet, settingsLinters, settingsSet } from "./settings.ts";
 import { noticeText, pushNotice } from "../notices.ts";
 
 /** What a handler reads besides the request body. */
@@ -367,16 +367,12 @@ function buildRoutes(): Record<string, Route> {
     schema: Type.Object({ patch: Type.Object({}, { additionalProperties: true }) }, { additionalProperties: false }),
     run: (body, ctx) => settingsSet(body as { patch: Record<string, unknown> }, ctx),
   };
+  routes["settings.linters"] = { schema: Empty, run: (_body, ctx) => settingsLinters(ctx) };
   return routes;
 }
 
 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/knowledge.ts

@@ -7,7 +7,9 @@
  */
 import type { KnowledgeAgent } from "../../knowledge/paths.ts";
 import type { EntryRef } from "../../lobby/knowledge.ts";
-import type { KnowledgeFileInfo, KnowledgeViewData } from "../protocol.ts";
+import type { KnowledgeAgentName, KnowledgeFileInfo, KnowledgeViewData } from "../protocol.ts";
+import { INHERIT_MODEL, type BotLobbyConfig } from "../../schemas/configuration.ts";
+import { loadConfig } from "../../state/project.ts";
 import type { ApiContext } from "./index.ts";
 import { fail } from "./index.ts";
 
@@ -31,8 +33,14 @@ interface RefBody extends FileBody {
 }
 
 /** Every agent's files with their size and note counts, in tab order. */
-export function knowledgeFiles(ctx: ApiContext): { files: KnowledgeFileInfo[] } {
-  return { files: ctx.service.knowledge.files() };
+export function knowledgeFiles(ctx: ApiContext): { files: KnowledgeFileInfo[]; models: Record<KnowledgeAgentName, string> } {
+  return { files: ctx.service.knowledge.files(), models: agentModels(ctx.service.config?.() ?? loadConfig()) };
+}
+
+/** The model each knowledge-keeping agent runs on, as the tree names it ("session model" when none is pinned). */
+export function agentModels(config: BotLobbyConfig): Record<KnowledgeAgentName, string> {
+  const named = (model: string) => (model === INHERIT_MODEL || !model.trim() ? "session model" : model);
+  return { master: named(config.master.model), designer: named(config.agents.designer.model), backend: named(config.agents.backend.model), qa: named(config.agents.qa.model) };
 }
 
 /** One file as entries with their notes. */

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

package/src/webui/api/settings.ts

@@ -10,7 +10,7 @@ import { lobbyTopics } from "../../lobby/topics.ts";
 import { prefillModels } from "../../pi/model-settings.ts";
 import { kindLabel } from "../../pi/model-support.ts";
 import { pushNotice } from "../notices.ts";
-import type { SettingsInfo } from "../protocol.ts";
+import type { SettingsInfo, SettingsLinter } from "../protocol.ts";
 import type { ApiContext } from "./index.ts";
 import { fail } from "./index.ts";
 
@@ -93,6 +93,11 @@ export function settingsGet(ctx: ApiContext): SettingsInfo {
   return { config: stripSecrets(config), models: ctx.service.models?.() ?? [] };
 }
 
+/** The linters the project configures (its top and a few folders below), and whether each is installed. */
+export function settingsLinters(ctx: ApiContext): { linters: SettingsLinter[] } {
+  return { linters: ctx.service.linters?.() ?? [] };
+}
+
 /** Merge, normalise and save the patch; the lobby rereads the config. */
 export function settingsSet(body: { patch: Record<string, unknown> }, ctx: ApiContext): { config: BotLobbyConfig } {
   checkPort(body.patch);

package/src/webui/api/tasks.ts

@@ -13,7 +13,9 @@ import type { TaskDetail } from "../protocol.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 { planDetails } from "../../pi/plan-checklist.ts";
+import type { WorkProjection } from "../../state/work-time.ts";
 import type { TaskSection } from "../../lobby/task-rows.ts";
 import { projectPhaseTiming } from "../../state/phase-timing.ts";
 import type { DeliveryRequest } from "../../delivery/operations.ts";
@@ -51,6 +53,7 @@ interface RowContext {
   names: ReadonlyMap<string, string>;
   auto: ReadonlySet<string>;
   live: ReadonlySet<string>;
+  work: (taskId: string) => WorkProjection | undefined;
 }
 
 function checkOf(task: Task): TaskRow["check"] {
@@ -59,12 +62,18 @@ function checkOf(task: Task): TaskRow["check"] {
   return "open";
 }
 
-function progressOf(task: Task): TaskRow["progress"] {
-  const steps = taskSteps(task);
+function progressOf(task: Task, work: WorkProjection | undefined, now: number): TaskRow["progress"] {
+  const steps = stepViews(task, work, now);
   if (steps.length === 0) return undefined;
   return { done: steps.filter((step) => step.status === "done").length, total: steps.length };
 }
 
+/** The work clock as the page shows it; a finished task's no longer counts. */
+function clockOf(task: Task, work: WorkProjection | undefined): TaskRow["work"] {
+  if (!work) return undefined;
+  return { workedMs: Math.round(work.workedMs), running: work.running && !TERMINAL_STATES.includes(task.state) };
+}
+
 /** How long ago, as `3h` (mirrors the lobby layout's `ago`). */
 function ago(ms: number): string {
   if (!Number.isFinite(ms) || ms < 5_000) return "now";
@@ -86,7 +95,9 @@ function ownerOf(task: Task, sessionId: string | undefined, ctx: RowContext): st
 }
 
 function rowOf(task: Task, section: TaskSection, ctx: RowContext, sessionId: string | undefined, now: number): TaskRow {
-  const progress = section === "recent" ? undefined : progressOf(task);
+  const work = ctx.work(task.id);
+  const progress = section === "recent" ? undefined : progressOf(task, work, now);
+  const clock = clockOf(task, work);
   return {
     kind: "task",
     id: task.id,
@@ -98,6 +109,7 @@ function rowOf(task: Task, section: TaskSection, ctx: RowContext, sessionId: str
     ...(task.paused && section !== "recent" ? { paused: true } : {}),
     check: checkOf(task),
     ...(progress ? { progress } : {}),
+    ...(clock ? { work: clock } : {}),
     ...(section === "others" ? { owner: ownerOf(task, sessionId, ctx) } : {}),
     ...(section === "recent" ? { age: ago(now - Date.parse(task.updatedAt)) } : {}),
     ...(section !== "recent" && ctx.auto.has(task.id) ? { auto: true } : {}),
@@ -141,7 +153,7 @@ function contextOf(ctx: ApiContext, tasks: readonly Task[]): RowContext {
     if (session.sessionId && session.alive) names.set(session.sessionId, session.name);
   }
   const auto = new Set(tasks.filter((task) => !TERMINAL_STATES.includes(task.state) && ctx.service.isAuto(task.id)).map((task) => task.id));
-  return { names, auto, live: new Set(ctx.service.liveSessions().map((session) => session.sessionId)) };
+  return { names, auto, live: new Set(ctx.service.liveSessions().map((session) => session.sessionId)), work: (taskId) => ctx.service.work?.(taskId) };
 }
 
 /** Every task, plan and recent row, oldest groups first like the terminal. */
@@ -255,13 +267,22 @@ export function tasksGet(body: { taskId: string }, ctx: ApiContext): TaskDetail
   const found = task as Task;
   const request = taskRequest(found);
   const now = Date.now();
+  const work = ctx.service.work?.(found.id);
+  const clock = clockOf(found, work);
+  const details = found.plan ? planDetails(found.plan) : undefined;
   return {
     timing: projectPhaseTiming(found, new Date(now).toISOString()),
+    ...(clock ? { work: clock } : {}),
     ...(found.delivery ? { delivery: found.delivery } : {}),
     ...(request !== found.title ? { request } : {}),
     ...(!found.plan && found.proposal ? { proposal: found.proposal } : {}),
     ...(found.plan ? { plan: found.plan } : {}),
-    steps: taskSteps(found).map((step) => ({ text: step.text, status: step.status === "pending" ? "open" : step.status })),
+    ...(details ? { planDetails: details } : {}),
+    steps: stepViews(found, work, now).map((step) => ({
+      text: step.text,
+      status: step.status === "pending" ? "open" : step.status,
+      ...(step.active ? { active: true, workedMs: step.workedMs } : {}),
+    })),
     amendments: [...found.amendments],
     waiting: waitingOf(found),
     blockers: found.blockers.map((blocker) => ({ reason: blocker.reason, need: blocker.need })),

package/src/webui/command.ts

@@ -119,6 +119,16 @@ function resetCommand(ctx: ExtensionCommandContext): void {
   ctx.ui.notify(`bot-lobby web: the link changed: ${link}`, "info");
 }
 
+/** Close the page's server when bot-lobby is turned off; quiet, and nothing when it is not running. */
+export async function stopWebServer(ctx: ExtensionContext): Promise<void> {
+  const running = currentWebServer();
+  if (!running) return;
+  await running.close();
+  latestLink = undefined;
+  heartbeat();
+  showAddress(ctx, undefined);
+}
+
 /** Run one `web` subcommand; a failure is a notice, never a throw. */
 export async function webCommand(ctx: ExtensionCommandContext, word: string | undefined, deps?: WebCommandDeps): Promise<void> {
   const action = webAction(word);
@@ -137,9 +147,10 @@ export async function webCommand(ctx: ExtensionCommandContext, word: string | un
 }
 
 /**
- * On `session_start`: follow the fresh lobby service, and start the server
- * (the first time) with the browser opening on it. The page is always on in
- * an interactive session; a subagent or a one-shot run serves nothing.
+ * On `session_start` (and when bot-lobby is turned on): follow the fresh
+ * lobby service, and start the server (the first time) with the browser
+ * opening on it. The page runs while bot-lobby is on in an interactive
+ * session; off, a subagent or a one-shot run serves nothing.
  */
 export function webSessionStarted(ctx: ExtensionContext, deps?: WebCommandDeps): void {
   if (isSubagentProcess() || !servesPage(ctx)) return;

package/src/webui/dev/fake-service.ts

@@ -447,6 +447,7 @@ export function createFixtureService(name: string, feed = new LobbyFeed()): Lobb
     sessionName: () => fixture.status.sessionName,
     masterBusy: () => fixture.status.busy,
     config: () => config,
+    linters: () => fixture.settings?.linters ?? [{ tool: "ESLint", folder: "", installed: true }, { tool: "Ruff", folder: "services/api", installed: false }],
     saveConfig: (next: BotLobbyConfig) => {
       config = next;
     },
@@ -467,6 +468,12 @@ export function createFixtureService(name: string, feed = new LobbyFeed()): Lobb
     },
     chatHistory: () => [...history],
     tasks: () => [...tasks],
+    work: (taskId: string) => {
+      const work = fixture.mockWork?.[taskId];
+      if (!work) return undefined;
+      const now = Date.now();
+      return { workedMs: work.workedMs, running: work.running, active: (work.active ?? []).map((run) => ({ runId: run.runId, instruction: run.instruction, startedAt: new Date(now - run.startedAgoMs).toISOString() })) };
+    },
     plans: () => [...plans],
     metrics: () => metrics.map((record) => ({ ...record })),
     classifierMetrics: () => classifierMetrics.map((record) => ({ ...record })),