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

package/src/lobby/issues.ts

@@ -154,14 +154,6 @@ export async function createIssue(exec: Exec, cwd: string, title: string, body:
   return { url, ...(Number.isFinite(number) ? { number } : {}) };
 }
 
-/** The issue as text for the planner: body plus comments. */
-export function issueText(issue: IssueDetail): string {
-  const comments = issue.comments
-    .filter((comment) => comment.body.trim())
-    .map((comment) => `**${comment.author ?? "someone"}** commented:\n${comment.body.trim()}`);
-  return [issue.body.trim() || "(no description)", ...comments].join("\n\n");
-}
-
 /** Lobby state for the Issues tab: the list, the open issue, and what is loading. */
 export class IssuesState {
   issues: IssueSummary[] = [];

package/src/lobby/planner.ts

@@ -563,6 +563,8 @@ export class PlanningSession {
   satOut = new Map<PanelMember, number>();
   /** How each seat left the last round it sat. */
   private readonly lastStatus = new Map<PanelMember, "ready" | "open">();
+  /** Seats that answered in at least one round: who took part in the plan. */
+  private readonly sat = new Set<PanelMember>();
   /** The last round was started by the classifier settling every question; the next one waits for the user. */
   private autoContinued = false;
   private controller?: AbortController;
@@ -707,6 +709,15 @@ export class PlanningSession {
     this.controller?.abort();
   }
 
+  /**
+   * The seats that took part in the plan: each answered in a round and is
+   * still on the panel. One the classifier always left out, or the user
+   * unseated, sat the plan out, and the task it becomes runs without it.
+   */
+  get panel(): PanelMember[] {
+    return PANEL_MEMBERS.filter((member) => this.sat.has(member) && this.seats.has(member));
+  }
+
   /** Save the latest draft as a pending task. */
   save(now = new Date()): PlannedTask {
     const plan = this.reply?.plan;
@@ -715,6 +726,7 @@ export class PlanningSession {
       title: this.title ?? this.messages[0]?.text.split("\n")[0] ?? "planned task",
       brief: plan,
       ...(this.seed ? { issue: this.seed.issue } : {}),
+      panel: this.panel,
     }, now);
     this.deps.feed?.log(ORACLE_LABEL, `saved ${this.saved.id} to pending tasks`, "success");
     this.deps.onChange?.();
@@ -733,6 +745,7 @@ export class PlanningSession {
       brief: partBrief({ plan, steps, proposal, index }),
       ...(this.seed ? { issue: this.seed.issue } : {}),
       split: partInfo(proposal, index, group),
+      panel: this.panel,
     }, new Date(now.getTime() + (proposal.tasks.length - index))));
     this.savedParts = parts;
     this.saved = parts[0];
@@ -966,6 +979,7 @@ export class PlanningSession {
       const transcript = [plannerTranscript(this.messages, this.seed, this.reply?.plan, ""), likely].filter(Boolean).join("\n\n");
       const outcomes = await Promise.all(this.members.map((state) => this.runMember(state, transcript, controller.signal, effort)));
       if (controller.signal.aborted) throw new Error("stopped");
+      for (const outcome of outcomes) if (outcome.reply) this.sat.add(outcome.member);
       this.notes = PANEL_MEMBERS.flatMap((member) => (this.memberNotes.get(member) ?? []).map((text) => ({ from: MEMBER_LABELS[member], text })));
       this.step = "writing the plan";
       this.deps.onChange?.();

package/src/lobby/pulls.ts

@@ -4,7 +4,7 @@
  * Like issues, `gh` owns authentication and repository detection; every
  * failure becomes one readable line.
  */
-import { execCommand, gh, type Exec } from "./issues.ts";
+import { gh, type Exec } from "./issues.ts";
 
 export type ChecksState = "passing" | "failing" | "pending";
 
@@ -193,49 +193,6 @@ export async function pullDiff(exec: Exec, cwd: string, number: number, limit =
   return stdout.length > limit ? `${stdout.slice(0, limit)}\n[…the diff continues: ${stdout.length - limit} more characters]` : stdout;
 }
 
-/** A pull request opened for a completed task's branch. */
-export interface CreatedPull {
-  number: number;
-  url: string;
-}
-
-const PUSH_TIMEOUT_MS = 60_000;
-
-async function run(exec: Exec, cwd: string, command: string, args: string[]): Promise<string> {
-  let result: Awaited<ReturnType<Exec>>;
-  try {
-    result = await exec(command, args, { cwd, timeout: PUSH_TIMEOUT_MS });
-  } catch (error) {
-    throw new Error(`${command} could not run — ${(error as Error).message}`);
-  }
-  if (result.code !== 0) throw new Error(result.stderr.trim() || `${command} exited with code ${result.code}`);
-  return result.stdout;
-}
-
-/** `gh pr create` ends with the URL on its own last line; the number is its tail. */
-function parseCreated(stdout: string): CreatedPull {
-  const url = stdout.trim().split("\n").map((line) => line.trim()).filter((line) => /^https?:\/\/\S+$/.test(line)).pop();
-  if (!url) throw new Error("gh pr create printed no pull request URL");
-  const match = /\/pull\/([1-9]\d*)$/.exec(url);
-  const number = Number(match?.[1]);
-  if (!Number.isSafeInteger(number) || number <= 0) throw new Error(`gh pr create printed an unreadable URL: ${url}`);
-  return { number, url };
-}
-
-/**
- * Push a finished task's branch and open its pull request, so the work lands
- * in review without the oracle having to remember a second step.
- */
-export async function createPullRequest(options: { exec?: Exec; cwd: string; branch: string; base: string; title: string; body: string }): Promise<CreatedPull> {
-  for (const ref of [options.branch, options.base]) {
-    if (!ref || ref.startsWith("-") || /[\s~^:?*\[\\]|\.\.|@\{|\/\//.test(ref) || /[/.]$/.test(ref)) throw new Error("invalid pull request branch");
-  }
-  const exec = options.exec ?? execCommand;
-  await run(exec, options.cwd, "git", ["push", "-u", "origin", options.branch]);
-  const stdout = await gh(exec, options.cwd, ["pr", "create", "--base", options.base, "--head", options.branch, "--title", options.title, "--body", options.body.slice(0, 60_000)]);
-  return parseCreated(stdout);
-}
-
 /** Lobby state for the Git tab: the list, the open pull request, and what is loading. */
 export class PullsState {
   pulls: PullSummary[] = [];

package/src/lobby/runtime.ts

@@ -20,7 +20,7 @@ import type { Domain } from "../schemas/agent.ts";
 import { chatFromEntries, lobbyFeed, narrateEvent, type AgentEventLike } from "./feed.ts";
 import { classifier, effortFor, hintsFor } from "../classifier/instance.ts";
 import { checkThinking } from "../pi/model-support.ts";
-import { jobTitle, QuickFixQueue } from "./quickfix.ts";
+import { QuickFixQueue } from "./quickfix.ts";
 import type { Asker } from "../ask/types.ts";
 import type { PlanningSession } from "./planner.ts";
 import { execCommand, IssuesState } from "./issues.ts";

package/src/lobby/service.ts

@@ -10,6 +10,7 @@ import { randomUUID } from "node:crypto";
 import { realpathSync } from "node:fs";
 import { resolve } from "node:path";
 import { loadTask, ownedTask, peekTasks, saveTask } from "../state/persistence.ts";
+import { taskWork } from "../state/work-time.ts";
 import { refreshReview, deferReview } from "../delivery/review.ts";
 import { deliver, type DeliveryRequest, type DeliveryStore } from "../delivery/operations.ts";
 import type { LockIdentity } from "../delivery/lock.ts";
@@ -34,7 +35,7 @@ import { pendingRequest, startRequest } from "../pi/route.ts";
 import { deliverComments, setAuto } from "../pi/owner.ts";
 import { chatFromEntries, lobbyFeed, type ChatEntry } from "./feed.ts";
 import { classifier, effortFor, hintsFor } from "../classifier/instance.ts";
-import { launchPi, SessionRegistry, type BackgroundSession, type DialogAnswer, type SessionLauncher } from "./sessions.ts";
+import { launchPi, SessionRegistry, type BackgroundSession, type SessionLauncher } from "./sessions.ts";
 import { SessionChats } from "./session-files.ts";
 import { answerMessage, questionnaires, settledQuestions } from "./ask.ts";
 import { askUser } from "../ask/web.ts";
@@ -572,6 +573,7 @@ export function createLobbyService(state: Runtime): LobbyService {
     feed: lobbyFeed,
     masterBusy: () => !state.ctx.isIdle(),
     tasks: () => peekTasks(state.root, state.configDir),
+    work: (taskId) => taskWork(state.root, state.configDir, taskId),
     deliveryDeliver: (taskId, request: DeliveryRequest) => deliver(request, { cwd: state.root, exec: execCommand }, deliveryStore(state, taskId)),
     deliveryReview: async (taskId) => {
       const task = deliveryTask(state, taskId);

package/src/lobby/session-files.ts

@@ -7,51 +7,7 @@
  * parent, and the text of user and assistant messages (never tool output).
  */
 import { closeSync, openSync, readSync, statSync } from "node:fs";
-import { chatFromEntries, chatText, CLEARED_NOTE, isClearedMark, MAX_CHAT, textOf, type ChatEntry } from "./feed.ts";
-
-interface EntryLike {
-  type?: string;
-  id?: string;
-  parentId?: string | null;
-}
-
-/** The entries on the branch that ends at the newest entry, oldest first (a session file is a tree). */
-export function currentBranch(entries: readonly unknown[]): unknown[] {
-  const byId = new Map<string, EntryLike>();
-  let leaf: EntryLike | undefined;
-  for (const entry of entries) {
-    const record = entry as EntryLike;
-    if (!record || typeof record.id !== "string") continue;
-    byId.set(record.id, record);
-    leaf = record;
-  }
-  const branch: unknown[] = [];
-  const seen = new Set<string>();
-  for (let entry = leaf; entry?.id && !seen.has(entry.id); entry = entry.parentId ? byId.get(entry.parentId) : undefined) {
-    seen.add(entry.id);
-    branch.push(entry);
-  }
-  return branch.reverse();
-}
-
-/** Parse a session file's JSON lines, skipping torn ones. */
-export function parseEntries(text: string): unknown[] {
-  const entries: unknown[] = [];
-  for (const line of text.split("\n")) {
-    if (!line.trim()) continue;
-    try {
-      entries.push(JSON.parse(line));
-    } catch {
-      // A line being written right now; the next read has it.
-    }
-  }
-  return entries;
-}
-
-/** The conversation a session file holds, as the lobby's chat entries. */
-export function chatFromFile(text: string, max = MAX_CHAT): ChatEntry[] {
-  return chatFromEntries(currentBranch(parseEntries(text)), max).map((line, index) => ({ id: index + 1, at: line.at ?? 0, role: line.role, text: line.text }));
-}
+import { chatText, CLEARED_NOTE, isClearedMark, MAX_CHAT, textOf, type ChatEntry } from "./feed.ts";
 
 /** What a session log keeps of one entry: its parent, and its conversation lines if it is a message. */
 interface LogNode {

package/src/lobby/split.ts

@@ -202,7 +202,39 @@ function planWithSteps(plan: string, covers: readonly number[], stepCount: numbe
   const lines = plan.split("\n");
   const kept = covers.map((step, index) => found.blocks[step - 1]!.replace(/^(\s*)\d+([.)])/, (_all, indent: string, mark: string) => `${indent}${index + 1}${mark}`));
   const spacer = found.to > found.from && !(lines[found.to - 1] ?? "").trim() ? [""] : [];
-  return [...lines.slice(0, found.from), ...kept.flatMap((block) => block.split("\n")), ...spacer, ...lines.slice(found.to)].join("\n");
+  return [...lines.slice(0, found.from), ...kept.flatMap((block) => block.split("\n")), ...spacer, ...stepDetails(lines.slice(found.to), covers)].join("\n");
+}
+
+/** `### Step 3: …` (or `**Step 3 — …**`): the heading of one step's detail. */
+const DETAIL_HEADING = /^(\s*(?:#{1,6}\s+)?(?:\*\*)?\s*step\s+#?)(\d+)(?!\d)/i;
+const ANY_HEADING = /^\s*(?:(#{1,6})\s+\S.*|\*\*[^*]+\*\*.*)$/;
+
+/** A heading's depth: `#` is 1, a bold line deeper than any `#`. */
+const depth = (line: string): number => ANY_HEADING.exec(line)?.[1]?.length ?? 7;
+
+/**
+ * The lines after a plan's steps list with only the detail of the steps in `covers`, renumbered as
+ * the list was: a step's detail runs from its `Step N` heading to the next heading as deep or deeper.
+ */
+function stepDetails(lines: readonly string[], covers: readonly number[]): string[] {
+  const out: string[] = [];
+  let skipping: number | undefined;
+  for (const line of lines) {
+    const heading = ANY_HEADING.test(line) ? depth(line) : undefined;
+    if (skipping !== undefined && heading !== undefined && heading <= skipping) skipping = undefined;
+    const detail = heading !== undefined ? DETAIL_HEADING.exec(line) : null;
+    if (detail) {
+      const at = covers.indexOf(Number(detail[2]));
+      if (at < 0) {
+        skipping = heading;
+        continue;
+      }
+      out.push(line.replace(DETAIL_HEADING, (_all, lead: string) => `${lead}${at + 1}`));
+      continue;
+    }
+    if (skipping === undefined) out.push(line);
+  }
+  return out;
 }
 
 /** One part's brief: where it sits, what it delivers, then the plan as written with only its own steps. */

package/src/lobby/task-rows.ts

@@ -22,6 +22,8 @@ export interface TaskRow {
   check: CheckState;
   /** Plan steps done, once the task has a plan. */
   progress?: { done: number; total: number };
+  /** How long the task's agents have worked on it, idle time left out (ms, as of the reply). */
+  work?: { workedMs: number; running: boolean };
   /** Who drives it, for tasks other sessions own. */
   owner?: string;
   /** How long ago it finished (finished tasks), was saved (plans) or was archived, as `3h`. */

package/src/master/decisions.ts

@@ -7,14 +7,17 @@ import { builtSomething, onFastTrack, qaRequired, qaTookPart } from "../workflow
 /**
  * §19: everything the engine requires before completion may be declared. The
  * fast track asks for a finished worker step instead of a QA pass, and for
- * QA's part only when the change needs tests.
+ * QA's part only when the change needs tests; so does a planned task whose
+ * QA sat out the planning panel.
  */
 export function completionBlockers(task: Task, pendingCount: number): string[] {
   const blockers: string[] = [];
   if (!task.plan) blockers.push("no approved plan is recorded");
   if (onFastTrack(task)) {
     if (!builtSomething(task)) blockers.push("no worker step has finished yet");
-    if (qaRequired(task) && !qaTookPart(task) && !task.qaWaiver) blockers.push("QA has not taken part (give qa the tests as the last step, or run the QA gate)");
+    if (qaRequired(task) && !qaTookPart(task) && !task.qaWaiver) blockers.push("QA has not taken part (run the QA gate: action=qa)");
+  } else if (!qaRequired(task)) {
+    if (!builtSomething(task)) blockers.push("no worker step has finished yet");
   } else if (task.qaVerdict !== "pass" && !task.qaWaiver) blockers.push(`QA gate is ${task.qaVerdict ?? "not run"}`);
   if (pendingCount > 0) blockers.push(`${pendingCount} unresolved approval request(s)`);
   if (task.blockers.length > 0) blockers.push(`${task.blockers.length} unresolved blocker(s)`);

package/src/master/master.ts

@@ -238,6 +238,8 @@ export interface WorkerRequest {
   time?: AgentTime;
   /** The worker may ask the user (the designer): its questions are relayed, and its images saved in `previews`. */
   ask?: { onAsk: RelayAsk; previews: string };
+  /** A QA step's verification budget: Jev's QA risk read of the change so far. */
+  risk?: string;
 }
 
 /** What a worker that may ask the user is told about it. */
@@ -264,6 +266,7 @@ function workerWorkflowContext(request: WorkerRequest, likely = ""): string {
       ? `Scout findings for your domain:\n${summarizeOutcomes(own, 1500)}`
       : "No scout findings were collected for your domain; verify the repository yourself.",
     likely,
+    request.risk ?? "",
     request.time?.note ?? "",
     request.ask ? askGuidance(request.ask.previews) : "",
   ].filter(Boolean).join("\n\n");
@@ -344,6 +347,8 @@ export interface ReviewerRequest {
   previousRound?: string;
   /** The engine's lint result on the touched files and the suppressions the task added. */
   lint?: string;
+  /** Jev's QA risk read of the change: the gate's depth, test budget and focus. */
+  risk?: string;
   /** Under a task time budget: the gate's time. */
   time?: AgentTime;
   instruction?: string;
@@ -365,6 +370,7 @@ function reviewerContext(request: ReviewerRequest): string {
   return [
     `Task state: reviewing. Domain: ${request.domain}.`,
     "You may not modify implementation. Report required changes instead.",
+    request.risk ?? "",
     request.previousRound ?? "",
     request.workerSummary ? `Worker summary (each domain's newest entries):\n${truncate(request.workerSummary, 4800)}` : "No worker summary available.",
     owns.length > 0 ? `Scout findings:\n${summarizeOutcomes(owns, 1200)}` : "",

package/src/master/research.ts

@@ -1,4 +1,3 @@
-import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import type { Domain } from "../schemas/agent.ts";
 import { profileFor, type BotLobbyConfig, type ProfileResolver } from "../schemas/configuration.ts";
@@ -39,21 +38,6 @@ export function saveResearchResult(taskDir: string, outcome: ResearchOutcome): v
   writeFileEnsured(researchResultPath(taskDir, outcome.result.domain), JSON.stringify(outcome, null, 2));
 }
 
-/** Re-read persisted research reports for the given domains. */
-export function loadResearchResults(taskDir: string, domains: Domain[]): ResearchOutcome[] {
-  const outcomes: ResearchOutcome[] = [];
-  for (const domain of domains) {
-    const path = researchResultPath(taskDir, domain);
-    if (!existsSync(path)) continue;
-    try {
-      outcomes.push(JSON.parse(readFileSync(path, "utf8")) as ResearchOutcome);
-    } catch {
-      // Corrupted research artifact: skip it rather than failing the workflow.
-    }
-  }
-  return outcomes;
-}
-
 function researchContext(request: ResearchRequest): AgentRequest["context"] {
   return {
     task: request.instruction,

package/src/pi/events.ts

@@ -13,11 +13,12 @@ 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 { requestBesidePlan } from "../state/backlog.ts";
 import { isAutoMode } from "../state/auto.ts";
 import { triageContext } from "../classifier/triage.ts";
-import { qaStillDue } from "../workflow/track.ts";
+import { qaStillDue, rosterWords } from "../workflow/track.ts";
 import { previousTaskNote } from "./fresh-context.ts";
-import { budgetLine, budgetState, pauseClocks, readBudget, resumeClocks, startClock, stopClocks } from "../state/budget.ts";
+import { budgetLine, budgetState, clockTask, pauseClocks, readBudget, resumeClocks, startClock, stopClocks, turnStarted } from "../state/budget.ts";
 
 /** Tools that wait on the user: the task's clock waits with them. */
 const ASKING_TOOLS: ReadonlySet<string> = new Set(["ask_user_question"]);
@@ -47,12 +48,12 @@ export function masterTaskContext(task: Task, comments: readonly PlanComment[] =
   const open = pendingComments(comments);
   return [
     `Task ${task.id}: ${task.title}`,
-    `Request: ${truncate(taskRequest(task), 2000)}`,
+    `Request: ${truncate(task.approvedPlan && task.plan ? requestBesidePlan(taskRequest(task)) : taskRequest(task), 2000)}`,
     task.proposal ? `Current proposal:\n${truncate(task.proposal, 2000)}` : "",
     task.plan ? `Approved plan:\n${truncate(task.plan, 3000)}` : "",
     task.amendments.length > 0 ? `User amendments:\n${task.amendments.map((entry) => `- ${entry}`).join("\n")}` : "",
     open.length > 0 ? `Open plan comments (from the lobby):\n${open.map((comment) => `- ${truncate(comment.text, 600)}`).join("\n")}` : "",
-    task.approvedPlan ? `The user agreed this task's plan in the planning panel (${task.approvedPlan}): follow it, do not ask them to approve a proposal (propose is approved automatically), and answer open questions from the plan.` : "",
+    task.approvedPlan ? `The user agreed this task's plan in the planning panel (${task.approvedPlan}), and it is the task's plan: delegate its steps without clarifying, scouting or proposing, and answer open questions from the plan.${task.track?.satOut?.length ? ` ${rosterWords(task.track.satOut)} sat out the panel: do not give ${task.track.satOut.length === 1 ? "it" : "them"} work${task.track.satOut.includes("qa") ? ", and there is no QA gate (complete once every step is done)" : ""}.` : ""}` : "",
     auto ? "AUTO MODE is on: drive this task to completion without the user. Do not ask them anything (clarify and ask_user_question are not answered); decide yourself, record each decision, and keep calling the orchestrate tool until the task is complete or truly blocked." : "",
   ]
     .filter((line) => line.length > 0)
@@ -77,10 +78,11 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
   });
 
 
-  // A task's time budget counts while the oracle works on it, not while it waits on the user.
+  // A task's work time (and its 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;
+    turnStarted();
     const root = detectProjectRoot(ctx.cwd, configDir);
     const task = activeTask(root, configDir, ctx.sessionManager.getSessionId());
     if (task) startClock(root, configDir, task.id);
@@ -92,9 +94,14 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
       pauseClocks();
     }
   });
-  pi.on("tool_execution_end", (event) => {
+  pi.on("tool_execution_end", (event, ctx) => {
     if (isSubagentProcess()) return;
     if (asking.delete(event.toolCallId)) resumeClocks();
+    // A task started, finished or taken over within the turn: the clock follows the task the session drives now.
+    if (event.toolName === "orchestrate") {
+      const root = detectProjectRoot(ctx.cwd, configDir);
+      clockTask(root, configDir, activeTask(root, configDir, ctx.sessionManager.getSessionId())?.id);
+    }
   });
   pi.on("agent_end", () => {
     if (isSubagentProcess()) return;

package/src/pi/model-settings.ts

@@ -18,7 +18,6 @@ import { describeKey, jevEndpoint, type StatusSource } from "../classifier/hosts
 
 /** One settings entry: the master or a subagent profile. */
 export type SettingsKind = "master" | SubagentKind;
-export const SETTINGS_KINDS: readonly SettingsKind[] = ["master", ...SUBAGENT_KINDS];
 
 /** The editable fields of one entry; scouts have no thinking and no instructions of their own. */
 export interface EntryView {

package/src/pi/plan-checklist.ts

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

package/src/pi/route.ts

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

package/src/pi/run-summary.ts

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