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

package/README.md

@@ -20,7 +20,9 @@ The questionnaire and web tools are built in, so don't also install extensions w
 1. In Pi, run `/bot-lobby add a login page`. Bot-lobby turns on and the lobby opens in your browser.
    A new pi session starts with bot-lobby off, as plain pi: `Ctrl+Shift+M` or `/bot-lobby on|off` switches it.
 2. Answer the oracle's questions and approve its plan, or agree one with the panel in **Plan** first.
-3. Follow the agents in **Lobby**. Models, effort and time limits are in **Settings**.
+   A plan opens with a short list of steps; the detail of each follows for whoever wants it.
+3. Follow the agents in **Lobby**: the step being worked on reads `active · 1m 12s`, and each task shows
+   how long its agents have worked on it (idle time left out). Models, effort and time limits are in **Settings**.
 
 Small changes go to **Quick fix**. `--task` forces a full task, `--fast` / `--full` picks the workflow,
 and `--branch` / `--worktree` isolates it in git. A finished isolated task pushes its branch and tries

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-t-h-i/bot-lobby",
-  "version": "0.6.25",
+  "version": "0.6.26",
   "description": "Structured multi-agent software engineering orchestrator for Pi",
   "type": "module",
   "license": "Apache-2.0",
@@ -58,7 +58,6 @@
     "@earendil-works/pi-tui": "0.87.0",
     "@fontsource-variable/inter": "5.3.0",
     "@playwright/test": "1.62.0",
-    "@shadcn/react": "0.3.1",
     "@tailwindcss/vite": "4.3.3",
     "@types/node": "^22.10.0",
     "@types/react": "19.3.0",
@@ -72,11 +71,8 @@
     "react": "19.3.0",
     "react-dom": "19.3.0",
     "react-markdown": "10.1.0",
-    "recharts": "3.10.1",
     "remark-gfm": "4.0.1",
-    "shiki": "4.5.0",
     "socket.io": "4.8.4",
-    "sonner": "2.0.8",
     "tailwind-merge": "3.7.0",
     "tailwindcss": "4.3.3",
     "tw-animate-css": "1.4.0",

package/prompts/master.md

@@ -169,10 +169,15 @@ integrations. One file has one owner: never split a file between domains, and
 never give DESIGN only the styling of something another domain built —
 whoever builds a visual thing owns how it looks.
 
-Write the plan's steps as a numbered list under a `## Steps` heading, and open
-each `implement` task with its step number (`Step 3: ...`, or `Steps 3-4: ...`
-when one delegation covers several) so the user's checklist tracks progress
-exactly.
+Write the plan for the user to skim first and read in full only if they want
+to. It opens with `## Steps`: a numbered list, one short plain line per step,
+in the order they happen — what gets done, in a few words (`Add the work timer
+to the task`), never how: no file paths, code, flags or jargon. That list is
+the user's checklist, so keep it to the steps themselves. The detail follows
+under `## Details`, one `### Step N: <the same words>` section per step, and
+then the rest of the plan (contracts, risks, notes). Open each `implement` task
+with its step number (`Step 3: ...`, or `Steps 3-4: ...` when one delegation
+covers several) so the checklist tracks progress exactly.
 
 ## Briefing the agents
 
@@ -228,9 +233,9 @@ Rules for the brief:
   a few actions. Split anything larger into consecutive steps in the same
   `implement` call rather than leaving the agent to sequence it. Prefer more
   explicit detail to fewer, larger chunks.
-- The plan's steps are written to the same standard: each step names its
-  files, its actions and its done criteria, so the brief is the step made
-  explicit, never a new decision.
+- Each step's detail section is written to the same standard: it names the
+  step's files, its actions and its done criteria, so the brief is the step
+  made explicit, never a new decision.
 - Scout and research instructions ask specific questions with the answer
   format you want (paths, names, versions, yes/no plus evidence), and say what
   you will do with the answer.

package/prompts/planner.md

@@ -106,6 +106,11 @@ or when you decided everything yourself.)
 ## Plan
 The current draft, in Markdown:
 
+### Steps
+1. …
+(first, so the user can skim the plan: one short plain line per step, in the
+order they happen — what gets done in a few words, never how: no file paths,
+code or jargon; the sections below carry the detail)
 ### Objective
 ### Scope and non-goals
 ### Acceptance criteria
@@ -115,6 +120,4 @@ The current draft, in Markdown:
 (what the user decided for DEV, DESIGN, QA and RESEARCH, one bullet each)
 ### Assumptions
 (what you decided without asking, each with its seat: "[QA] Test in evergreen browsers only")
-### Steps
-1. …
 ### Risks and open points

package/src/classifier/hosts.ts

@@ -40,11 +40,6 @@ export const JEV_HOST_TABLE: Readonly<Record<JevHostId, JevHost>> = Object.freez
 /** The hosts `auto` tries, in order: OpenCode's free Jev first. */
 export const AUTO_ORDER: readonly JevHostId[] = ["opencode", "typesafe"];
 
-/** How a host name reads in settings. */
-export function hostLabel(name: JevHostName): string {
-  return name === "auto" ? "Auto (OpenCode's free Jev, else TypeSafe)" : JEV_HOST_TABLE[name].label;
-}
-
 /** Resolves a pi provider's API key (stored credential, then its environment variable). */
 export type KeySource = (piProvider: string) => Promise<string | undefined>;
 
@@ -122,12 +117,6 @@ export function keyHint(config: Pick<ClassifierConfig, "provider">): string {
   return how(JEV_HOST_TABLE[config.provider]);
 }
 
-/** `ts_ab…cd`: enough to recognise which key is loaded, never the key. */
-export function maskKey(key: string): string {
-  if (key.length <= 8) return "*".repeat(key.length);
-  return `${key.slice(0, 4)}…${key.slice(-4)}`;
-}
-
 /** One line on where a host's key comes from, for settings and `/bot-lobby config`. */
 export function describeKey(host: JevHost, status: StatusSource | undefined, env: NodeJS.ProcessEnv = process.env): string {
   const found = configuredProvider(host, status);

package/src/classifier/instance.ts

@@ -76,11 +76,6 @@ export function keyStatus(piProvider: string): KeyStatus | undefined {
   return binding?.status(piProvider);
 }
 
-/** Tests: use this classifier for the process (undefined restores the default). */
-export function useClassifier(next: Classifier | undefined): void {
-  instance = next;
-}
-
 /** Register the `typesafe` login entry and bind the classifier to each session's key store. */
 export function registerClassifier(pi: ExtensionAPI, configDir: string): void {
   registerJevProvider(pi);

package/src/execution/agent-runner.ts

@@ -380,21 +380,3 @@ export async function mapConcurrent<TIn, TOut>(items: TIn[], limit: number, fn:
 export async function runParallel(requests: AgentRequest[], limit: number, run: ProcessRunner = spawnPiProcess): Promise<AgentRun[]> {
   return mapWithConcurrencyLimit(requests, limit, (request) => runAgent(request, run));
 }
-
-function lastOutput(results: AgentRun[]): string {
-  return results.length > 0 ? results[results.length - 1]!.output : "";
-}
-
-/** Run agents in order, substituting `{previous}` with the prior output. */
-export async function runSequential(requests: AgentRequest[], run: ProcessRunner = spawnPiProcess): Promise<AgentRun[]> {
-  const results: AgentRun[] = [];
-  for (const request of requests) {
-    const instruction = request.instruction.includes("{previous}")
-      ? request.instruction.replaceAll("{previous}", lastOutput(results))
-      : request.instruction;
-    const result = await runAgent({ ...request, instruction }, run);
-    results.push(result);
-    if (result.status !== "success") break;
-  }
-  return results;
-}

package/src/knowledge/compactor.ts

@@ -4,76 +4,6 @@ import type { KnowledgeAgent } from "./paths.ts";
 import { AGENT_DIR_NAMES, KNOWLEDGE_FILES, knowledgeDir } from "./paths.ts";
 import { readFirstExisting, readFileOr, writeFileEnsured } from "./store.ts";
 
-export interface KnowledgeAnalysis {
-  /** Lines that say the same thing twice. */
-  duplicates: string[];
-  /** Lines with hedging or unresolved wording. */
-  ambiguity: string[];
-  /** Different statements sharing a subject: candidates for conflict review. */
-  conflictCandidates: { subject: string; statements: string[] }[];
-}
-
-const AMBIGUITY = /\bmaybe|possibly|probably|tbd|todo|unclear|not sure|some kind|etc\.|approximately\b/i;
-const HEDGE_STOPWORDS = new Set(["this", "that", "with", "from", "into", "when", "they", "have", "will", "should", "must"]);
-
-function significantLines(content: string, minLength = 12): string[] {
-  return content
-    .split("\n")
-    .map((line) => line.replace(/^[-*#>\s]+/, "").trim())
-    .filter((line) => line.length >= minLength);
-}
-
-function normalize(line: string): string {
-  return line
-    .toLowerCase()
-    .replace(/[^\w\s]/g, "")
-    .replace(/\s+/g, " ")
-    .trim();
-}
-
-function subjectKey(line: string): string {
-  return normalize(line)
-    .split(" ")
-    .filter((word) => word.length > 3 && !HEDGE_STOPWORDS.has(word))
-    .slice(0, 2)
-    .join(" ");
-}
-
-function findDuplicates(lines: string[]): string[] {
-  const seen = new Map<string, string>();
-  const duplicates: string[] = [];
-  for (const line of lines) {
-    const key = normalize(line);
-    if (seen.has(key)) duplicates.push(line);
-    else seen.set(key, line);
-  }
-  return duplicates;
-}
-
-function findConflicts(lines: string[]): { subject: string; statements: string[] }[] {
-  const groups = new Map<string, Set<string>>();
-  for (const line of lines) {
-    const key = subjectKey(line);
-    if (key.split(" ").length < 2) continue;
-    const statements = groups.get(key) ?? new Set<string>();
-    statements.add(line);
-    groups.set(key, statements);
-  }
-  return [...groups.entries()]
-    .filter(([, statements]) => statements.size > 1)
-    .map(([subject, statements]) => ({ subject, statements: [...statements] }));
-}
-
-/** Mechanical candidates that help the Master decide what to compact (§24). */
-export function analyzeKnowledge(content: string): KnowledgeAnalysis {
-  const lines = significantLines(content);
-  return {
-    duplicates: findDuplicates(lines),
-    ambiguity: lines.filter((line) => AMBIGUITY.test(line)),
-    conflictCandidates: findConflicts(lines),
-  };
-}
-
 export interface OversizedFile {
   agent: KnowledgeAgent;
   file: string;

package/src/lobby/ask.ts

@@ -6,7 +6,6 @@
  * The panel's questions become questionnaires of at most four, and the
  * answers become the user's turn for the next round.
  */
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { PanelQuestion, SettledQuestion } from "./planner.ts";
 import { MAX_HEADER, MAX_LABEL, MAX_OPTIONS, MAX_QUESTIONS, MIN_OPTIONS, RESERVED, type AskAnswer, type AskOption, type AskQuestion, type AskResult, type Asker } from "../ask/types.ts";
 
@@ -122,17 +121,3 @@ export function answerMessage(questions: readonly PanelQuestion[], results: read
     ...(skipped.length > 0 ? ["", "Not answered this round:", ...skipped] : []),
   ].join("\n");
 }
-
-/**
- * Put every question to the user, one questionnaire after another. Stopping
- * a questionnaire (esc) stops the rest; what was answered before it is kept.
- */
-export async function askPanel(questions: readonly PanelQuestion[], ask: Asker, ctx: ExtensionContext): Promise<{ results: AskResult[]; stopped: boolean }> {
-  const results: AskResult[] = [];
-  for (const chunk of questionnaires(questions)) {
-    const result = await ask(chunk, ctx);
-    if (result.cancelled) return { results, stopped: true };
-    results.push(result);
-  }
-  return { results, stopped: false };
-}

package/src/lobby/host.ts

@@ -95,6 +95,8 @@ export interface LobbyService {
   feed: LobbyFeed;
   masterBusy(): boolean;
   tasks(): Task[];
+  /** How long a task's agents have worked on it, and the worker runs under way (`work.json`); undefined without one. */
+  work?(taskId: string): import("../state/work-time.ts").WorkProjection | undefined;
   deliveryDeliver?(taskId: string, request: import("../delivery/operations.ts").DeliveryRequest): Promise<import("../delivery/types.ts").Delivery>;
   deliveryReview?(taskId: string): Promise<import("../delivery/types.ts").Delivery>;
   deliveryDefer?(taskId: string, reviewId: string): import("../delivery/types.ts").Delivery;

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/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/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

@@ -17,7 +17,7 @@ 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";
+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"]);
@@ -77,10 +77,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 +93,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 {