@a-t-h-i/bot-lobby 0.6.4 → 0.6.6

package/src/pi/activity.ts

@@ -1,8 +1,6 @@
 /**
  * One-word descriptions of the tool an agent is running: subagents show it as
- * `[spinner] word - elapsed`, and the oracle names the master's `orchestrate`
- * action. Pure lookup:
- * no clock, environment or I/O reads.
+ * `[spinner] word - elapsed`. Pure lookup: no clock, environment or I/O reads.
  */
 const ACTIVITY_WORDS: Record<string, string> = {
   read: "reading",
@@ -22,46 +20,16 @@ const ACTIVITY_WORDS: Record<string, string> = {
 
 const FALLBACK_WORD = "working";
 
-/** What the oracle says between its own tool calls while a master turn runs. */
-export const ORACLE_THINKING = "thinking";
-
 export function activityWord(toolName: string): string {
   return ACTIVITY_WORDS[toolName.trim().toLowerCase()] ?? FALLBACK_WORD;
 }
 
-/** Master `orchestrate` actions -> the word the oracle shows instead of the generic "orchestrating". */
-const ORACLE_ACTION_WORDS: Record<string, string> = {
-  clarify: "asking",
-  scout: "scouting",
-  research: "researching",
-  propose: "proposing",
-  plan: "planning",
-  implement: "delegating",
-  qa: "reviewing",
-  knowledge: "recording",
-  compact: "recording",
-  decide: "deciding",
-  resolve_approval: "deciding",
-  complete: "wrapping up",
-  status: "checking",
-  block: "blocking",
-  resume: "resuming",
-  cancel: "cancelling",
-};
-
 function orchestrateAction(args: unknown): string | undefined {
   if (!args || typeof args !== "object" || !("action" in args)) return undefined;
   const action = (args as { action?: unknown }).action;
   return typeof action === "string" ? action.trim().toLowerCase() : undefined;
 }
 
-/** One word for what the oracle (master) is doing; `orchestrate` maps by its action. */
-export function oracleActivityWord(toolName: string, args?: unknown): string {
-  if (toolName.trim().toLowerCase() !== "orchestrate") return activityWord(toolName);
-  const action = orchestrateAction(args);
-  return (action && ORACLE_ACTION_WORDS[action]) || FALLBACK_WORD;
-}
-
 const DETAIL_CHARS = 28;
 
 function clip(text: string): string {

package/src/pi/commands.ts

@@ -21,19 +21,22 @@ import { applyApprovalChoice, describeTask, describeOversizedKnowledge, lastQaAs
 import { applyStatus, registerRevealShortcut, setMinimized } from "./ui.ts";
 import { classifierSummary, openSettings } from "./settings-ui.ts";
 import { keyStatus } from "../classifier/instance.ts";
-import { kickoff, startPlannedTask, startTask } from "./start-task.ts";
+import { kickoff, startPlannedTask } from "./start-task.ts";
+import { startRequest } from "./route.ts";
 import { setAuto, toggleOwnAuto } from "./owner.ts";
 import { autoOpenLobby, showLobby } from "../lobby/runtime.ts";
 import { modelRef, thinkingMismatches } from "./model-support.ts";
 import { describeRun, runFromLog } from "./run-summary.ts";
 import { modelLookup } from "./tools.ts";
 import { budgetLine, budgetState, parseMinutes, readBudget, setBudget, startClock } from "../state/budget.ts";
+import { qaStillDue } from "../workflow/track.ts";
 
 const HELP = [
   "/bot-lobby                  Open the lobby: tasks, plan, quick fix, metrics (alt+l)",
-  "/bot-lobby <request>        Start a task through the workflow",
-  "/bot-lobby --task [--auto] <request>   Start a task even when the request begins with a subcommand word",
+  "/bot-lobby <request>        Start a request: a quick fix when one agent can do it alone (the oracle confirms), else a task",
+  "/bot-lobby --task [--auto] <request>   Always a task (also when the request begins with a subcommand word)",
   "/bot-lobby --budget 90m <request>   Start a task with a time budget the oracle divides between its agents",
+  "/bot-lobby --fast|--full <request>   Start a task on the fast track (straight to the agents it needs) or the full workflow, whatever it reads as",
   "/bot-lobby budget [90m|off]  Show or set this session's task time budget",
   "/bot-lobby status [taskId]  Show the active task",
   "/bot-lobby tasks            List tasks",
@@ -60,8 +63,8 @@ function isTaskId(value: string | undefined): boolean {
   return Boolean(value && /^TASK-/.test(value));
 }
 
-/** A task start's leading flags: `--task` (always a task), `--auto`, `--budget <time>` (or `--budget=<time>`). */
-const START_FLAG = /^--(task|auto)(?=\s|$)\s*|^--budget(?:=|\s+)(\S+)\s*/;
+/** A task start's leading flags: `--task` (always a task), `--auto`, `--fast`, `--full`, `--budget <time>` (or `--budget=<time>`). */
+const START_FLAG = /^--(task|auto|fast|full)(?=\s|$)\s*|^--budget(?:=|\s+)(\S+)\s*/;
 
 export interface ParsedCommand {
   sub: string | undefined;
@@ -72,6 +75,10 @@ export interface ParsedCommand {
   budget?: number;
   /** `--budget` with something that is not a time. */
   budgetError?: string;
+  /** `--fast` or `--full`: the task's path, whatever its request reads as. */
+  track?: "fast" | "full";
+  /** `--task`: a task, never routed to the quick-fix agent. */
+  task?: boolean;
 }
 
 export function parseCommand(args: string): ParsedCommand {
@@ -79,10 +86,12 @@ export function parseCommand(args: string): ParsedCommand {
   // Leading flags start a task: what follows is its request, even when it begins with a subcommand word
   // (a background session started from the lobby sends `--task [--auto] <request>`).
   let flagged = false;
-  const extras: Pick<ParsedCommand, "auto" | "budget" | "budgetError"> = {};
+  const extras: Pick<ParsedCommand, "auto" | "budget" | "budgetError" | "track" | "task"> = {};
   for (let match = START_FLAG.exec(trimmed); match; match = START_FLAG.exec(trimmed)) {
     flagged = true;
     if (match[1] === "auto") extras.auto = true;
+    else if (match[1] === "task") extras.task = true;
+    else if (match[1] === "fast" || match[1] === "full") extras.track = match[1];
     else if (match[2] !== undefined) {
       const minutes = parseMinutes(match[2]);
       if (minutes) extras.budget = minutes;
@@ -119,7 +128,7 @@ function showStatus(ctx: ExtensionCommandContext, configDir: string, taskId?: st
   ].filter(Boolean).join("\n");
   const footer = knowledge ? `\n${knowledge}` : "";
   const budget = task ? readBudget(root, configDir, task.id) : undefined;
-  const time = task && budget ? `\n${budgetLine(budget, budgetState(task.id, budget, task.qaVerdict === "pass"))}` : "";
+  const time = task && budget ? `\n${budgetLine(budget, budgetState(task.id, budget, !qaStillDue(task)))}` : "";
   ctx.ui.notify(task ? `${describeTask(task)}${time}${footer}` : `No bot-lobby task found in ${root}.${footer}`, task ? "info" : "warning");
 }
 
@@ -243,7 +252,7 @@ function budgetCommand(ctx: ExtensionCommandContext, configDir: string, value: s
   if (!task) return ctx.ui.notify("bot-lobby: no active task in this session — a time budget applies to a task (start one with /bot-lobby --budget 90m <request>)", "warning");
   if (!value) {
     const budget = readBudget(root, configDir, task.id);
-    return ctx.ui.notify(budget ? `${task.id} — ${budgetLine(budget, budgetState(task.id, budget, task.qaVerdict === "pass"))}` : `${task.id} has no time budget. Set one with /bot-lobby budget 90m.`, "info");
+    return ctx.ui.notify(budget ? `${task.id} — ${budgetLine(budget, budgetState(task.id, budget, !qaStillDue(task)))}` : `${task.id} has no time budget. Set one with /bot-lobby budget 90m.`, "info");
   }
   const minutes = /^off$/i.test(value) ? 0 : parseMinutes(value);
   if (minutes === undefined) return ctx.ui.notify(`bot-lobby: "${value}" is not a time budget (try 90m, 1h or 1h30m)`, "warning");
@@ -251,7 +260,7 @@ function budgetCommand(ctx: ExtensionCommandContext, configDir: string, value: s
   // Set while the oracle works: its clock runs from now, not from its next turn.
   if (budget && !ctx.isIdle()) startClock(root, configDir, task.id);
   applyStatus(ctx, root, configDir);
-  ctx.ui.notify(budget ? `bot-lobby: ${task.id} — ${budgetLine(budget, budgetState(task.id, budget, task.qaVerdict === "pass"))}` : `bot-lobby: ${task.id} has no time budget now.`, "info");
+  ctx.ui.notify(budget ? `bot-lobby: ${task.id} — ${budgetLine(budget, budgetState(task.id, budget, !qaStillDue(task)))}` : `bot-lobby: ${task.id} has no time budget now.`, "info");
 }
 
 function showKnowledge(ctx: ExtensionCommandContext, configDir: string): void {
@@ -315,14 +324,16 @@ export function registerCommands(pi: ExtensionAPI, configDir: string): void {
       return filtered.length > 0 ? filtered : null;
     },
     handler: async (args, ctx) => {
-      const { sub, rest, restText, auto, budget, budgetError } = parseCommand(args ?? "");
+      const { sub, rest, restText, auto, budget, budgetError, track, task } = parseCommand(args ?? "");
       if (budgetError) return ctx.ui.notify(`bot-lobby: ${budgetError}`, "warning");
       if (!sub) {
         if (!restText) {
           if (!showLobby()) ctx.ui.notify(HELP, "info");
           return;
         }
-        if (await startTask(pi, ctx, configDir, restText, { ...(auto ? { auto } : {}), ...(budget ? { budget } : {}) })) autoOpenLobby();
+        // A request one agent can do alone may go to the quick-fix agent once the oracle confirms; the rest start as tasks.
+        const started = await startRequest(pi, ctx, configDir, restText, { ...(auto ? { auto } : {}), ...(budget ? { budget } : {}), ...(track ? { track } : {}), ...(task ? { task } : {}) });
+        if (started === "task") autoOpenLobby();
         return;
       }
       switch (sub) {

package/src/pi/events.ts

@@ -7,14 +7,14 @@ import { selectKnowledge } from "../knowledge/selector.ts";
 import { cancelAllRuns } from "../execution/agent-runner.ts";
 import { describeTask } from "../workflow/workflow.ts";
 import { truncate } from "../text.ts";
-import { applyStatus, clearStatus, isMinimized, setMinimized, setOracleActivity } from "./ui.ts";
-import { ORACLE_THINKING, oracleActivityWord } from "./activity.ts";
+import { applyStatus, clearStatus, isMinimized, setMinimized } from "./ui.ts";
 import { isSubagentProcess, webToolsFor } from "./quiet.ts";
 import { registerQuietTools } from "./tool-renderers.ts";
 import { taskRequest, type Task, type TaskState } from "../schemas/task.ts";
 import { pendingComments, readPlanComments, type PlanComment } from "../state/comments.ts";
 import { isAutoMode } from "../state/auto.ts";
 import { triageContext } from "../classifier/triage.ts";
+import { qaStillDue } from "../workflow/track.ts";
 import { previousTaskNote } from "./fresh-context.ts";
 import { budgetLine, budgetState, pauseClocks, readBudget, resumeClocks, startClock, stopClocks } from "../state/budget.ts";
 
@@ -33,7 +33,7 @@ export function masterWorkflowContext(task: Task, time = ""): string {
 export function budgetContext(root: string, configDir: string, task: Task): string {
   const budget = readBudget(root, configDir, task.id);
   if (!budget) return "";
-  const state = budgetState(task.id, budget, task.qaVerdict === "pass");
+  const state = budgetState(task.id, budget, !qaStillDue(task));
   const running = budget.allotments.filter((entry) => !entry.endedAt).map((entry) => `${entry.who} (${entry.minutes}m)`);
   return [
     budgetLine(budget, state),
@@ -75,26 +75,16 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
   });
 
 
-  // The oracle's speech bubble mirrors the master's own turn: thinking between
-  // tool calls, the tool's word during one, and silent (your turn) once it ends.
-  // Subagents report into runs instead.
-  // Parallel tool calls: the newest still-running call keeps the word.
-  const inFlight = new Map<string, string>();
-  const showOracle = () => setOracleActivity([...inFlight.values()].at(-1) ?? ORACLE_THINKING);
   // A task's time budget counts while the oracle works on it, not while it waits on the user.
   const asking = new Set<string>();
   pi.on("agent_start", (_event, ctx) => {
     if (isSubagentProcess()) return;
-    inFlight.clear();
-    showOracle();
     const root = detectProjectRoot(ctx.cwd, configDir);
     const task = activeTask(root, configDir, ctx.sessionManager.getSessionId());
     if (task) startClock(root, configDir, task.id);
   });
   pi.on("tool_execution_start", (event) => {
     if (isSubagentProcess()) return;
-    inFlight.set(event.toolCallId, oracleActivityWord(event.toolName, event.args));
-    showOracle();
     if (ASKING_TOOLS.has(event.toolName) && !asking.has(event.toolCallId)) {
       asking.add(event.toolCallId);
       pauseClocks();
@@ -102,14 +92,10 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
   });
   pi.on("tool_execution_end", (event) => {
     if (isSubagentProcess()) return;
-    inFlight.delete(event.toolCallId);
-    showOracle();
     if (asking.delete(event.toolCallId)) resumeClocks();
   });
   pi.on("agent_end", () => {
     if (isSubagentProcess()) return;
-    inFlight.clear();
-    setOracleActivity(undefined);
     for (const _call of asking) resumeClocks();
     asking.clear();
     stopClocks();

package/src/pi/plan-checklist.ts

@@ -0,0 +1,305 @@
+/**
+ * The plan as a checklist: its steps parsed from the plan text, and each one
+ * done, current or pending from the worker runs so far. Pure.
+ */
+import type { AgentRun } from "../schemas/findings.ts";
+
+/** Upper bound on parsed plan steps so the checklist stays bounded. */
+export const MAX_PLAN_STEPS = 50;
+
+const PREFIX_CHARS = 32;
+const MIN_PREFIX = 8;
+const HEADER_LINE = /^\s*(?:#{1,6}\s+\S.*|\*\*[^*]+\*\*)\s*$/;
+const STEP_SECTION = /sequence|steps|order/i;
+const NUMBERED_STEP_LINE = /^(\s*)(\d+[.)])\s+(.*\S)\s*$/;
+const BULLET_LINE = /^(\s*)([*-])\s+(.*\S)\s*$/;
+const TOP_LEVEL_BULLET = /^()([*-])\s+(.*\S)\s*$/;
+/** `### Step 2: Wire the API`, `**Step 2 — Wire the API**`, `Phase 3) Tests`: one plan step per heading. */
+const STEP_HEADING = /^\s*(?:#{1,6}\s+)?(?:\*\*)?\s*(?:step|phase|stage)\s+#?\d+\s*(?:\*\*)?\s*[:.)\u2014\u2013-]\s*(?:\*\*)?\s*(.*?)\s*(?:\*\*)?\s*$/i;
+const MIN_STEP_HEADINGS = 2;
+
+export type PlanStepStatus = "done" | "current" | "pending";
+
+export interface PlanStep {
+  text: string;
+  status: PlanStepStatus;
+}
+
+interface ListItem {
+  indent: number;
+  /** Column where the item's text starts; deeper items are nested under it. */
+  content: number;
+  text: string;
+}
+
+type ItemMatcher = (line: string) => ListItem | undefined;
+
+function indentOf(line: string): number {
+  return /^\s*/.exec(line)![0].replace(/\t/g, "    ").length;
+}
+
+function itemMatcher(pattern: RegExp): ItemMatcher {
+  return (line) => {
+    const match = pattern.exec(line);
+    if (!match) return undefined;
+    const indent = indentOf(match[1]!);
+    return { indent, content: indent + match[2]!.length + 1, text: match[3]! };
+  };
+}
+
+const numberedItem = itemMatcher(NUMBERED_STEP_LINE);
+const bulletItem = itemMatcher(BULLET_LINE);
+const topBulletItem = itemMatcher(TOP_LEVEL_BULLET);
+
+/** Numbered `1.`/`1)` text, or a bullet inside a step section; undefined otherwise. */
+function sectionItem(line: string): ListItem | undefined {
+  return numberedItem(line) ?? bulletItem(line);
+}
+
+/**
+ * Top-level list items only. As in CommonMark, an item indented to its parent's
+ * text column is a sub-point of that step, so nested bullets or a nested `1.`
+ * list never inflate the checklist. Prose at a shallower indent ends the parent.
+ */
+function collectSteps(lines: readonly string[], accept: ItemMatcher): string[] {
+  const found: string[] = [];
+  let parent: number | undefined;
+  for (const line of lines) {
+    const item = accept(line);
+    if (!item) {
+      if (parent !== undefined && line.trim() && indentOf(line) < parent) parent = undefined;
+      continue;
+    }
+    if (parent !== undefined && item.indent >= parent) continue;
+    found.push(item.text);
+    parent = item.content;
+  }
+  return found;
+}
+
+/** Body of the first `sequence|steps|order` header, up to the next header; undefined when absent. */
+function stepSection(lines: readonly string[]): string[] | undefined {
+  const start = lines.findIndex((line) => HEADER_LINE.test(line) && STEP_SECTION.test(line));
+  if (start < 0) return undefined;
+  const body: string[] = [];
+  for (const line of lines.slice(start + 1)) {
+    if (HEADER_LINE.test(line)) break;
+    body.push(line);
+  }
+  return body;
+}
+
+/** `Step N` headings, when the plan is structured as one heading per step. */
+function headingSteps(lines: readonly string[]): string[] {
+  const found: string[] = [];
+  for (const line of lines) {
+    const match = STEP_HEADING.exec(line);
+    if (match) found.push(match[1] || line.replace(/[#*]/g, "").trim());
+  }
+  return found.length >= MIN_STEP_HEADINGS ? found : [];
+}
+
+/**
+ * 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.
+ */
+export function planSteps(plan: string): string[] {
+  const lines = plan.split("\n");
+  const headings = headingSteps(lines);
+  if (headings.length > 0) return headings.slice(0, MAX_PLAN_STEPS);
+  const section = stepSection(lines);
+  if (section) {
+    const sectioned = collectSteps(section, sectionItem);
+    if (sectioned.length > 0) return sectioned.slice(0, MAX_PLAN_STEPS);
+  }
+  const numbered = collectSteps(lines, numberedItem);
+  if (numbered.length > 0) return numbered.slice(0, MAX_PLAN_STEPS);
+  return collectSteps(lines, topBulletItem).slice(0, MAX_PLAN_STEPS);
+}
+
+/* -------------------------------------------------------------------------
+ * Step matching. A worker instruction names its step explicitly ("Step 3: ...")
+ * or is scored against every step by shared paths, a shared opening phrase and
+ * word overlap. Plans reuse file paths across steps, so near-ties go to the
+ * earliest step still open instead of the first step that ever mentioned the
+ * path -- otherwise every later instruction re-matches step 1 and the tracker
+ * never moves.
+ * ---------------------------------------------------------------------- */
+
+const STEP_REFERENCE = /\bsteps?\s*#?\s*(\d+)(?:\s*(?:-|\u2013|\u2014|to|through|thru|and|&)\s*#?\s*(\d+))?/gi;
+/** Text allowed before a step reference that labels the instruction itself ("Now implement step 3:"). */
+const LEADING_LABEL = /^[\s\W]*(?:(?:now|next|then|please|implement|do|complete|execute|start|begin|finish|work on|continue with|proceed with|plan)\s+)*(?:the\s+)?$/i;
+const MIN_SCORE = 0.5;
+const NEAR_TIE = 0.35;
+const PATH_WEIGHT = 0.75;
+const PREFIX_WEIGHT = 1;
+const WORD = /[a-z0-9_][a-z0-9_./-]*[a-z0-9_]/g;
+const MIN_WORD = 3;
+const STOP_WORDS = new Set([
+  "the", "and", "for", "with", "that", "this", "from", "into", "then", "when", "each", "use", "make",
+  "sure", "new", "all", "any", "its", "are", "not", "but", "now", "via", "per", "our", "your", "you",
+  "has", "have", "will", "should", "must", "also", "only", "step", "steps", "plan", "approved",
+  "implement", "please", "add", "update", "change", "changes", "file", "files", "code",
+]);
+
+function normalize(text: string): string {
+  return text.replace(/[`*_]/g, "").replace(/\s+/g, " ").trim().toLowerCase();
+}
+
+function significantWords(text: string): Set<string> {
+  const words = new Set<string>();
+  for (const word of normalize(text).match(WORD) ?? []) {
+    if (word.length >= MIN_WORD && !STOP_WORDS.has(word)) words.add(word);
+  }
+  return words;
+}
+
+/** Scoring context for one instruction, built once per run and reused for every step. */
+interface InstructionIndex {
+  text: string;
+  words: Set<string>;
+}
+
+function indexInstruction(instruction: string): InstructionIndex {
+  return { text: normalize(instruction), words: significantWords(instruction) };
+}
+
+function prefixMatches(step: string, hay: string): boolean {
+  const tail = normalize(step.replace(/`[^`]+`/g, " ").replace(/^[\s:;,.\u2014\u2013-]+/, ""));
+  return tail.length >= MIN_PREFIX && hay.includes(tail.slice(0, PREFIX_CHARS));
+}
+
+function pathShare(step: string, hay: string): number {
+  const paths = [...step.matchAll(/`([^`]+)`/g)].map((match) => normalize(match[1]!)).filter((path) => path.length > 0);
+  if (paths.length === 0) return 0;
+  return paths.filter((path) => hay.includes(path)).length / paths.length;
+}
+
+function wordShare(step: string, words: ReadonlySet<string>): number {
+  const own = significantWords(step);
+  if (own.size === 0) return 0;
+  let shared = 0;
+  for (const word of own) if (words.has(word)) shared += 1;
+  return shared / own.size;
+}
+
+/** How strongly an instruction targets one step; 0 when it shares nothing. */
+function stepScore(step: string, instruction: InstructionIndex): number {
+  const prefix = prefixMatches(step, instruction.text) ? PREFIX_WEIGHT : 0;
+  return prefix + PATH_WEIGHT * pathShare(step, instruction.text) + wordShare(step, instruction.words);
+}
+
+/**
+ * Highest 0-based step an instruction labels itself with ("Step 3: ...", "steps 2-4"),
+ * or -1. A reference counts when it opens the instruction or is the only one
+ * 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 {
+  const refs = [...instruction.matchAll(STEP_REFERENCE)];
+  if (refs.length === 0) return -1;
+  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;
+}
+
+/**
+ * The step an instruction targets, given the steps already completed; -1 when
+ * nothing matches. Among near-tied candidates the earliest open step wins.
+ */
+export function targetStep(steps: readonly string[], instruction: string | undefined, completed: ReadonlySet<number> = new Set()): number {
+  if (!instruction || steps.length === 0) return -1;
+  const explicit = explicitStepIndex(instruction, steps.length);
+  if (explicit >= 0) return explicit;
+  const index = indexInstruction(instruction);
+  const scores = steps.map((step) => stepScore(step, index));
+  const best = Math.max(...scores);
+  if (best < MIN_SCORE) return -1;
+  const near = scores.findIndex((score, at) => score >= best - NEAR_TIE && score >= MIN_SCORE && !completed.has(at));
+  return near >= 0 ? near : scores.indexOf(best);
+}
+
+/** The latest worker run carrying an instruction; its step is the current one. */
+export function latestWorkerRun(runs: readonly AgentRun[]): AgentRun | undefined {
+  let latest: AgentRun | undefined;
+  for (const run of runs) {
+    if (run.role !== "worker" || !run.instruction) continue;
+    if (!latest || Date.parse(run.startedAt) >= Date.parse(latest.startedAt)) latest = run;
+  }
+  return latest;
+}
+
+function stepStatus(index: number, current: number): PlanStepStatus {
+  if (current < 0) return index === 0 ? "current" : "pending";
+  if (index < current) return "done";
+  return index === current ? "current" : "pending";
+}
+
+/** Lowest index not yet in `completed`, or -1 when every step is. */
+function nextOpenStep(steps: readonly string[], completed: ReadonlySet<number>): number {
+  return steps.findIndex((_text, index) => !completed.has(index));
+}
+
+/** Marks every step up to and including `index` as completed. */
+function markThrough(completed: Set<number>, index: number): void {
+  for (let step = 0; step <= index; step += 1) completed.add(step);
+}
+
+function byStart(runs: readonly AgentRun[]): AgentRun[] {
+  const time = (run: AgentRun) => {
+    const at = Date.parse(run.startedAt);
+    return Number.isFinite(at) ? at : 0;
+  };
+  return runs
+    .map((run, order) => ({ run, order }))
+    .sort((a, b) => time(a.run) - time(b.run) || a.order - b.order)
+    .map((entry) => entry.run);
+}
+
+/**
+ * Replays worker runs in start order. A successful run completes everything up
+ * to its target step; a run that matches nothing -- the common case for a
+ * reworded instruction -- completes the next still-open step, so the count only
+ * grows and a failure can never tick one off. The latest worker run's own target
+ * is reported separately so a running or failed step reads current.
+ */
+function replaySteps(steps: readonly string[], runs: readonly AgentRun[]): { completed: number; latest: number } {
+  const completed = new Set<number>();
+  const latestRun = latestWorkerRun(runs);
+  let latest = -1;
+  for (const run of byStart(runs)) {
+    if (run.role !== "worker") continue;
+    const matched = targetStep(steps, run.instruction, completed);
+    if (run === latestRun) latest = matched >= 0 && run.status === "success" ? matched + 1 : matched;
+    if (run.status !== "success") continue;
+    const target = matched >= 0 ? matched : nextOpenStep(steps, completed);
+    if (target >= 0) markThrough(completed, target);
+  }
+  return { completed: completed.size, latest };
+}
+
+/** One-entry memo: the panel asks for the same checklist several times per frame. */
+let checklistMemo: { plan: string; runs: readonly AgentRun[]; steps: PlanStep[] } | undefined;
+
+/**
+ * Done/current/pending per plan step. A succeeded run completes its step, so the
+ * next step becomes current (and the last step reads done); running, failed,
+ * cancelled and timeout runs keep it current. Progress is monotonic: steps
+ * already completed by successful worker runs stay done, and a later call that
+ * names an earlier step can never tick it back. Memoized on the exact plan text
+ * and runs array, so callers must not mutate either.
+ */
+export function planChecklist(plan: string, runs: readonly AgentRun[]): PlanStep[] {
+  if (checklistMemo && checklistMemo.plan === plan && checklistMemo.runs === runs) return checklistMemo.steps;
+  const texts = planSteps(plan);
+  const replay = replaySteps(texts, runs);
+  const current = Math.max(replay.completed, replay.latest);
+  const steps = texts.map((text, index) => ({ text, status: stepStatus(index, current) }));
+  checklistMemo = { plan, runs, steps };
+  return steps;
+}