@a-t-h-i/bot-lobby 0.6.37 → 0.6.39

package/src/prompts/compiler.ts

@@ -15,6 +15,8 @@ export interface CompileInput {
   standards?: string;
   knowledge?: string;
   decisions?: string;
+  /** The shared scripts that fit the step, or the library for the oracle. */
+  scripts?: string;
   workflowContext?: string;
 }
 
@@ -29,7 +31,7 @@ function section(title: string, body?: string): string {
 
 /**
  * Compose the layered prompt: global + domain + role + task context +
- * standards + knowledge + decisions + workflow context + output contract.
+ * standards + knowledge + decisions + scripts + workflow context + output contract.
  * Empty layers are dropped so agents never receive empty headings.
  */
 export function compilePrompt(input: CompileInput): string {
@@ -43,6 +45,7 @@ export function compilePrompt(input: CompileInput): string {
     section("Standards", input.standards),
     section("Knowledge", input.knowledge),
     section("Decisions", input.decisions),
+    section("Scripts", input.scripts),
     section("Workflow Context", input.workflowContext),
     spec?.contract ?? "",
   ];

package/src/roles/worker.ts

@@ -1,6 +1,6 @@
 import type { Domain, RoleSpec } from "../schemas/agent.ts";
 import type { Blocker } from "../schemas/task.ts";
-import type { FileChange, KnowledgeProposal, WorkerResult } from "../schemas/findings.ts";
+import type { FileChange, KnowledgeProposal, ScriptProposal, WorkerResult } from "../schemas/findings.ts";
 import { bullets, fieldValue, findSection, parseFileBullet, parsePushback, parseSections } from "./markdown.ts";
 
 /**
@@ -18,6 +18,7 @@ export const workerSpec: RoleSpec = {
     "Respond with exactly these sections and nothing else: `## Completed`, `## Files Changed`,",
     "`## Verification`, `## Brief Check` (one `- criterion — met|not met — evidence` line per \"Done when\" item of your brief), `## Notes`, `## Blockers`, `## Dependencies Needed`, `## Architecture Changes`,",
     "`## Knowledge Proposals` (`- knowledge: ...`, `- standard: ...`, or `- decision: ...`).",
+    "An optional `## Script Proposals` (`- \\`name.ext\\` — what it does — draft: \\`path\\``) proposes a script you wrote for a job that will come back, for the shared library.",
     "`## Files Changed` entries are `- \\`path\\` — change`.",
     "`## Verification` entries are `- command — result`.",
     "Blocked work uses `**Blocker:**`, `**Tried:**`, `**Need:**` under `## Blockers`.",
@@ -39,6 +40,18 @@ export function parseKnowledgeProposals(domain: Domain, text: string | undefined
   });
 }
 
+/** Parse `` - `name.ext` — purpose — draft: `path` `` proposals; one without a name is dropped. */
+export function parseScriptProposals(domain: Domain, text: string | undefined): ScriptProposal[] {
+  return bullets(text).flatMap((entry): ScriptProposal[] => {
+    const draftMatch = /\bdraft\s*:\s*`?([^`\s]+)`?/i.exec(entry);
+    const rest = (draftMatch ? entry.slice(0, draftMatch.index) : entry).replace(/[\s—–(-]+$/, "");
+    const named = /^`?([A-Za-z0-9_.-]+\.[A-Za-z0-9]+)`?\s*(?:[—–:-]+\s*)?(.*)$/.exec(rest.trim());
+    if (!named) return [];
+    const purpose = named[2]!.replace(/^[—–:-]+\s*/, "").trim();
+    return [{ domain, name: named[1]!, purpose, ...(draftMatch ? { draft: draftMatch[1]! } : {}) }];
+  });
+}
+
 function splitList(text: string | undefined): string[] {
   return (text ?? "")
     .split(/[;\n]|\s+then\s+/)
@@ -100,6 +113,7 @@ export function parseWorkerResult(domain: Domain, raw: string, now = new Date().
     notes: findSection(sections, "notes") ?? "",
     blockers: parseBlockers(sections, domain, now),
     knowledgeProposals: parseKnowledgeProposals(domain, findSection(sections, "knowledge proposals")),
+    scriptProposals: parseScriptProposals(domain, findSection(sections, "script proposals")),
     pushback: parsePushback(sections),
     dependencyNeeds: realAsks(bullets(findSection(sections, "dependencies needed"))),
     architectureChanges: realAsks(bullets(findSection(sections, "architecture changes"))),

package/src/schemas/configuration.ts

@@ -173,7 +173,7 @@ export interface LobbyConfig {
 }
 
 /** Decisions the classifier can make, each switched on or off on its own. */
-export const CLASSIFIER_FEATURES = ["seats", "answers", "files", "triage", "effort", "review", "knowledge", "qa"] as const;
+export const CLASSIFIER_FEATURES = ["seats", "answers", "files", "triage", "effort", "review", "knowledge", "scripts", "qa"] as const;
 export type ClassifierFeature = (typeof CLASSIFIER_FEATURES)[number];
 
 /** Hosts that serve Jev behind the same System One API; `auto` takes OpenCode's free Jev when pi holds an OpenCode key, else TypeSafe. */
@@ -194,6 +194,8 @@ export interface ClassifierThresholds {
   fileRelevantAt: number;
   /** A section of a knowledge file that is over the prompt budget stays in at this relevance. */
   knowledgeRelevantAt: number;
+  /** A shared script is suggested for a step at this probability that it does part of it. */
+  scriptRelevantAt: number;
   /** A step scored simple at this confidence runs one thinking level lower. */
   simpleAt: number;
   /** A step scored trivial at this confidence runs on the cheaper model. */
@@ -294,7 +296,7 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
     model: "",
     baseUrl: "",
     timeoutMs: 4000,
-    features: { seats: true, answers: true, files: true, triage: true, effort: true, review: true, knowledge: true, qa: true },
+    features: { seats: true, answers: true, files: true, triage: true, effort: true, review: true, knowledge: true, scripts: true, qa: true },
     thresholds: {
       seatAt: 0.35,
       reseatReadyAt: 0.6,
@@ -302,6 +304,7 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
       autoAnswerMargin: 0.5,
       fileRelevantAt: 0.5,
       knowledgeRelevantAt: 0.4,
+      scriptRelevantAt: 0.5,
       simpleAt: 0.7,
       trivialAt: 0.8,
       quickFixAt: 0.7,

package/src/schemas/findings.ts

@@ -24,6 +24,16 @@ export interface KnowledgeProposal {
   content: string;
 }
 
+/** A script a worker thinks the shared library should keep, for the oracle to save or ignore. */
+export interface ScriptProposal {
+  domain: Domain;
+  /** The file name it proposes: `seed_public_holidays.py`. */
+  name: string;
+  purpose: string;
+  /** Where the worker drafted it, when it did. */
+  draft?: string;
+}
+
 export interface ScoutResult {
   domain: Domain;
   role: "scout";
@@ -51,6 +61,8 @@ export interface WorkerResult {
   notes: string;
   blockers: Blocker[];
   knowledgeProposals: KnowledgeProposal[];
+  /** Scripts the worker proposes for the shared library. */
+  scriptProposals?: ScriptProposal[];
   dependencyNeeds: string[];
   architectureChanges: string[];
   pushback?: Pushback;

package/src/scripts/library.ts

@@ -0,0 +1,168 @@
+/**
+ * The scripts library: scripts every agent shares for jobs that come back
+ * (seeding data, regenerating fixtures, a set of checks, a migration), so a
+ * step done once is run the next time, not worked out again, which saves
+ * tokens and time. They live in `<data>/scripts/`, one file each, named for
+ * what they do in snake_case with the language's extension
+ * (`seed_public_holidays.py`, `run_changed_tests.sh`). The first lines of each
+ * file say what it is for and how to run it, and the library's index is read
+ * from them, so a script edited by hand stays listed. Only the oracle adds or
+ * replaces a script; workers propose one. A replaced script is kept under
+ * `archive/`.
+ */
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+/** The languages a script may be written in: how it is run and how its header lines are commented. */
+export const SCRIPT_LANGUAGES = {
+  py: { runner: "python3", comment: "#" },
+  sh: { runner: "bash", comment: "#" },
+  bash: { runner: "bash", comment: "#" },
+  js: { runner: "node", comment: "//" },
+  mjs: { runner: "node", comment: "//" },
+  cjs: { runner: "node", comment: "//" },
+  ts: { runner: "node", comment: "//" },
+  rb: { runner: "ruby", comment: "#" },
+  pl: { runner: "perl", comment: "#" },
+  ps1: { runner: "pwsh -File", comment: "#" },
+} as const;
+export type ScriptLanguage = keyof typeof SCRIPT_LANGUAGES;
+
+/** Longest name, extension included. */
+export const MAX_SCRIPT_NAME = 64;
+/** Largest script the library takes. */
+export const MAX_SCRIPT_BYTES = 64 * 1024;
+
+const NAME = new RegExp(`^[a-z][a-z0-9]*(?:_[a-z0-9]+)+\\.(${Object.keys(SCRIPT_LANGUAGES).join("|")})$`);
+/** How many lines from the top the header is looked for in. */
+const HEADER_LINES = 12;
+
+export interface ScriptEntry {
+  /** The file name: `seed_public_holidays.py`. */
+  name: string;
+  path: string;
+  language: ScriptLanguage;
+  /** What it is for, one line. */
+  purpose: string;
+  /** How to run it, with its arguments; the runner and path when the header gives none. */
+  usage: string;
+}
+
+export function scriptsDir(dataRoot: string): string {
+  return join(dataRoot, "scripts");
+}
+
+/** The words of a name (`seed_public_holidays.py` → `seed public holidays`), for matching it against a step. */
+export function nameWords(name: string): string {
+  return name.replace(/\.[a-z0-9]+$/, "").replace(/_/g, " ");
+}
+
+/**
+ * The library name for what was asked: lower-cased, spaces and hyphens as
+ * underscores (`Seed public-holidays.py` → `seed_public_holidays.py`). Throws
+ * with what is wrong when it still does not read `<what_it_does>.<ext>`.
+ */
+export function scriptName(asked: string): string {
+  const name = asked.trim().toLowerCase().replace(/[\s-]+/g, "_").replace(/_+/g, "_");
+  const languages = Object.keys(SCRIPT_LANGUAGES).map((ext) => `.${ext}`).join(", ");
+  if (!/\.[a-z0-9]+$/.test(name) || !(name.split(".").pop()! in SCRIPT_LANGUAGES)) {
+    throw new Error(`a script name ends in its language's extension (${languages}): "${asked}"`);
+  }
+  if (name.length > MAX_SCRIPT_NAME) throw new Error(`a script name is at most ${MAX_SCRIPT_NAME} characters: "${asked}"`);
+  if (!NAME.test(name)) {
+    throw new Error(`a script is named for what it does, in snake_case words (seed_public_holidays.py): "${asked}"`);
+  }
+  return name;
+}
+
+function language(name: string): ScriptLanguage {
+  return name.split(".").pop() as ScriptLanguage;
+}
+
+function headerValue(lines: readonly string[], key: string): string | undefined {
+  const line = lines.find((entry) => new RegExp(`^\\s*(?:#|//)\\s*${key}\\s*:`, "i").test(entry));
+  return line?.replace(new RegExp(`^\\s*(?:#|//)\\s*${key}\\s*:\\s*`, "i"), "").trim() || undefined;
+}
+
+/** The command that runs a script when its header gives none. */
+export function runCommand(entry: Pick<ScriptEntry, "path" | "language">): string {
+  return `${SCRIPT_LANGUAGES[entry.language].runner} ${entry.path}`;
+}
+
+function readEntry(dir: string, name: string): ScriptEntry | undefined {
+  const path = join(dir, name);
+  try {
+    if (!statSync(path).isFile()) return undefined;
+    const lines = readFileSync(path, "utf8").split("\n").slice(0, HEADER_LINES);
+    const entry = { name, path, language: language(name) };
+    return { ...entry, purpose: headerValue(lines, "purpose") ?? nameWords(name), usage: headerValue(lines, "usage") ?? runCommand(entry) };
+  } catch {
+    return undefined;
+  }
+}
+
+/** Every script in the library, by name; files not named like a script are left out. */
+export function listScripts(dataRoot: string): ScriptEntry[] {
+  const dir = scriptsDir(dataRoot);
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter((name) => NAME.test(name))
+    .sort()
+    .map((name) => readEntry(dir, name))
+    .filter((entry): entry is ScriptEntry => entry !== undefined);
+}
+
+/** The body with any header lines of its own taken out, and a shebang it starts with kept apart. */
+function splitBody(body: string): { shebang?: string; rest: string } {
+  const lines = body.replace(/\r\n/g, "\n").split("\n");
+  const shebang = lines[0]?.startsWith("#!") ? lines.shift() : undefined;
+  const rest = lines.filter((line, index) => index >= HEADER_LINES || !/^\s*(?:#|\/\/)\s*(?:purpose|usage)\s*:/i.test(line));
+  while (rest.length > 0 && rest[0]!.trim() === "") rest.shift();
+  return { ...(shebang ? { shebang } : {}), rest: rest.join("\n") };
+}
+
+export interface SaveScript {
+  dataRoot: string;
+  name: string;
+  purpose: string;
+  /** How to run it, with its arguments; the runner and path when absent. */
+  usage?: string;
+  body: string;
+}
+
+export interface SavedScript {
+  entry: ScriptEntry;
+  /** Where the version it replaced was kept, when there was one. */
+  archived?: string;
+}
+
+/**
+ * Add a script to the library, or replace the one of that name (the old one
+ * is kept under `archive/`). The engine writes its header: purpose and usage
+ * as comments after any shebang, so the index never depends on the agent
+ * having written one.
+ */
+export function saveScript(input: SaveScript, now = new Date()): SavedScript {
+  const name = scriptName(input.name);
+  const purpose = input.purpose.replace(/\s+/g, " ").trim();
+  if (!purpose) throw new Error("a script needs its purpose: one line on what it does");
+  const { shebang, rest } = splitBody(input.body);
+  if (!rest.trim()) throw new Error("the script is empty");
+  const dir = scriptsDir(input.dataRoot);
+  const path = join(dir, name);
+  const lang = language(name);
+  const usage = input.usage?.replace(/\s+/g, " ").trim() || runCommand({ path, language: lang });
+  const { comment } = SCRIPT_LANGUAGES[lang];
+  const text = [...(shebang ? [shebang] : []), `${comment} purpose: ${purpose}`, `${comment} usage: ${usage}`, "", rest.replace(/\s+$/, ""), ""].join("\n");
+  if (Buffer.byteLength(text) > MAX_SCRIPT_BYTES) throw new Error(`a script is at most ${MAX_SCRIPT_BYTES / 1024} KB`);
+  mkdirSync(dir, { recursive: true });
+  let archived: string | undefined;
+  if (existsSync(path)) {
+    if (readFileSync(path, "utf8") === text) return { entry: readEntry(dir, name)! };
+    mkdirSync(join(dir, "archive"), { recursive: true });
+    archived = join(dir, "archive", `${name}.${now.toISOString().replace(/[:.]/g, "-")}`);
+    copyFileSync(path, archived);
+  }
+  writeFileSync(path, text, { mode: 0o755 });
+  return { entry: readEntry(dir, name)!, ...(archived ? { archived } : {}) };
+}

package/src/scripts/pick.ts

@@ -0,0 +1,79 @@
+/**
+ * Which of the library's scripts fit a step, and how an agent's prompt shows
+ * them. Jev judges each script against the step when it is on (see
+ * `classifier/scripts.ts`); without it, or when it fails, a script fits when
+ * its name or purpose shares words with the step. Either way the prompt names
+ * the library, so an agent can look for itself.
+ */
+import { score, tokenize } from "../knowledge/selector.ts";
+import { listScripts, nameWords, scriptsDir, type ScriptEntry } from "./library.ts";
+
+/** Most scripts one prompt suggests. */
+export const MAX_SUGGESTED = 6;
+/** Most scripts the oracle's prompt lists. */
+export const MAX_LISTED = 40;
+
+/** The scripts whose name or purpose shares the most words with the step, best first. */
+export function keywordScripts(step: string, entries: readonly ScriptEntry[], limit = MAX_SUGGESTED): ScriptEntry[] {
+  const tokens = tokenize(step);
+  return entries
+    .map((entry, index) => ({ entry, index, hits: score(`${nameWords(entry.name)} ${entry.purpose}`, tokens) }))
+    .filter((scored) => scored.hits > 0)
+    .sort((a, b) => b.hits - a.hits || a.index - b.index)
+    .slice(0, limit)
+    .map((scored) => scored.entry);
+}
+
+/** Picks the scripts that fit a step. */
+export interface ScriptPicker {
+  pick(step: string, entries: readonly ScriptEntry[], options?: { signal?: AbortSignal }): Promise<ScriptEntry[]>;
+}
+
+/** The picker that goes by shared words alone. */
+export const keywordPicker: ScriptPicker = { pick: async (step, entries) => keywordScripts(step, entries) };
+
+function line(entry: ScriptEntry): string {
+  return `- \`${entry.name}\` — ${entry.purpose}\n  run: \`${entry.usage}\``;
+}
+
+/**
+ * The Scripts layer of a worker's, scout's or QA agent's prompt: the scripts
+ * that fit this step and how to run each, then where the rest are. "" while
+ * the library is empty.
+ */
+export function scriptsBlock(dataRoot: string, entries: readonly ScriptEntry[], picked: readonly ScriptEntry[]): string {
+  if (entries.length === 0) return "";
+  const where = `The shared scripts library (${entries.length} script${entries.length === 1 ? "" : "s"}) is \`${scriptsDir(dataRoot)}\`; each file's first lines say what it does and how to run it.`;
+  if (picked.length === 0) return `None of the shared scripts fits this step. ${where}`;
+  return [
+    "These shared scripts do part of this step: run one instead of doing its work by hand, and check its output as you would your own.",
+    ...picked.map(line),
+    where,
+  ].join("\n");
+}
+
+/** The oracle's view of the library: every script by name and purpose, so it can point a brief at one. */
+export function libraryBlock(dataRoot: string, entries: readonly ScriptEntry[] = listScripts(dataRoot)): string {
+  const dir = scriptsDir(dataRoot);
+  if (entries.length === 0) return `The shared scripts library (\`${dir}\`) is empty.`;
+  const shown = entries.slice(0, MAX_LISTED).map((entry) => `- \`${entry.name}\` — ${entry.purpose}`);
+  const more = entries.length > MAX_LISTED ? [`…and ${entries.length - MAX_LISTED} more in \`${dir}\`.`] : [];
+  return [`Shared scripts (\`${dir}\`):`, ...shown, ...more].join("\n");
+}
+
+/**
+ * The Scripts layer for one agent's step: the library read, the picker's
+ * choice (shared words when it fails), and the block. "" with no scripts.
+ */
+export async function scriptsFor(dataRoot: string | undefined, step: string, picker: ScriptPicker = keywordPicker, signal?: AbortSignal): Promise<string> {
+  if (!dataRoot) return "";
+  const entries = listScripts(dataRoot);
+  if (entries.length === 0) return "";
+  let picked: ScriptEntry[];
+  try {
+    picked = await picker.pick(step, entries, signal ? { signal } : {});
+  } catch {
+    picked = keywordScripts(step, entries);
+  }
+  return scriptsBlock(dataRoot, entries, picked.slice(0, MAX_SUGGESTED));
+}

package/src/state/work-time.ts

@@ -16,6 +16,8 @@ import { taskDirFor } from "./persistence.ts";
 export interface ActiveRun {
   runId: string;
   parentRunId?: string;
+  /** The worker's domain (`backend`, `designer`), for who is doing what. */
+  domain?: string;
   stepInstruction?: string;
   instruction: string;
   startedAt: string;
@@ -104,7 +106,7 @@ export function taskWork(root: string, configDir: string, taskId: string, now =
 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; parentRunId?: string; stepInstruction?: string; instruction?: string; startedAt: string; status: string }): void {
+export function noteWorkerRun(root: string, configDir: string, taskId: string, run: { runId: string; parentRunId?: string; stepInstruction?: string; instruction?: string; domain?: 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;
@@ -113,7 +115,7 @@ export function noteWorkerRun(root: string, configDir: string, taskId: string, r
   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, ...(run.parentRunId ? { parentRunId: run.parentRunId } : {}), ...(run.stepInstruction ? { stepInstruction: run.stepInstruction } : {}) });
+    if (running) work.active.push({ runId: run.runId, instruction: run.instruction ?? "", startedAt: run.startedAt, ...(run.parentRunId ? { parentRunId: run.parentRunId } : {}), ...(run.domain ? { domain: run.domain } : {}), ...(run.stepInstruction ? { stepInstruction: run.stepInstruction } : {}) });
   });
 }
 

package/src/webui/api/plan-facts.ts

@@ -30,7 +30,7 @@ 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, parentRunId: run.parentRunId, stepInstruction: run.stepInstruction, taskId: task.id, domain: "backend" as const, role: "worker" as const, status: "running" as const, instruction: run.instruction, output: "", attempts: 1, startedAt: run.startedAt }));
+    .map((run) => ({ runId: run.runId, parentRunId: run.parentRunId, stepInstruction: run.stepInstruction, taskId: task.id, domain: (run.domain === "designer" || run.domain === "qa" ? run.domain : "backend") as AgentRun["domain"], 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. */
@@ -40,10 +40,20 @@ export interface StepView {
   active: boolean;
   activeAgentCount: number;
   runIds: string[];
+  /** The agents on it right now: who, doing what, since when; a child names its parent. */
+  agents: StepAgent[];
   /** Worker time on the step, in ms. */
   workedMs: number;
 }
 
+export interface StepAgent {
+  runId: string;
+  parentRunId?: string;
+  domain: string;
+  instruction: string;
+  startedAt: string;
+}
+
 /**
  * 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
@@ -54,8 +64,13 @@ export function stepViews(task: Task, work: WorkProjection | undefined, now = Da
   const runs = [...persistedTaskRuns(task), ...activeRuns(task, work)];
   const checklist = planChecklist(task.plan, runs);
   const times = stepWork(planSteps(task.plan), runs, now);
+  const byId = new Map(runs.map((run) => [run.runId, run]));
   return checklist.map((step, index) => {
     const time = times[index] ?? { ms: 0, active: false, activeAgentCount: 0, runIds: [] };
-    return { text: step.text, status: time.active ? "current" : step.status, active: time.active, activeAgentCount: time.activeAgentCount, runIds: time.runIds, workedMs: Math.round(time.ms) };
+    const agents = time.runIds.flatMap((runId) => {
+      const run = byId.get(runId);
+      return run ? [{ runId, ...(run.parentRunId ? { parentRunId: run.parentRunId } : {}), domain: run.domain, instruction: (run.instruction ?? "").split("\n")[0]!.trim(), startedAt: run.startedAt }] : [];
+    });
+    return { text: step.text, status: time.active ? "current" : step.status, active: time.active, activeAgentCount: time.activeAgentCount, runIds: time.runIds, agents, workedMs: Math.round(time.ms) };
   });
 }

package/src/webui/api/tasks.ts

@@ -311,7 +311,7 @@ export function tasksGet(body: { taskId: string }, ctx: ApiContext): TaskDetail
     steps: stepViews(found, work, now).map((step) => ({
       text: step.text,
       status: step.status === "pending" ? "open" : step.status,
-      ...(step.active ? { active: true, workedMs: step.workedMs, activeAgentCount: step.activeAgentCount } : {}),
+      ...(step.active ? { active: true, workedMs: step.workedMs, activeAgentCount: step.activeAgentCount, agents: step.agents } : {}),
     })),
     amendments: [...found.amendments],
     waiting: waitingOf(found),

package/src/webui/protocol.ts

@@ -420,7 +420,7 @@ export interface TaskDetail {
    * The plan as a checklist, in order; `current` is the step under way, `active` the steps a worker is on right now,
    * each with its worker time (ms, as of the reply).
    */
-  steps: Array<{ text: string; status: "done" | "current" | "open"; active?: boolean; workedMs?: number; activeAgentCount?: number }>;
+  steps: Array<{ text: string; status: "done" | "current" | "open"; active?: boolean; workedMs?: number; activeAgentCount?: number; agents?: StepAgentInfo[] }>;
   /** How long the task's agents have worked on it, idle time left out (ms, as of the reply); `running` while they work. */
   work?: WorkClock;
   amendments: string[];
@@ -676,3 +676,12 @@ export interface Api {
 }
 
 export type ApiName = keyof Api;
+
+/** An agent on a step right now: its domain, what it was told (first line), since when; a child names its parent. */
+export interface StepAgentInfo {
+  runId: string;
+  parentRunId?: string;
+  domain: string;
+  instruction: string;
+  startedAt: string;
+}