@a-t-h-i/bot-lobby 0.6.33 → 0.6.34

package/src/schemas/task.ts

@@ -77,6 +77,10 @@ export const MAX_WORKER_RECORDS = 64;
 /** One finished subagent run of any role, kept for `/bot-lobby runs`. */
 export interface RunLogEntry {
   runId: string;
+  parentRunId?: string;
+  depth?: number;
+  instruction?: string;
+  stepInstruction?: string;
   domain: Domain;
   role: Role;
   status: "running" | "success" | "failed" | "cancelled" | "timeout";

package/src/state/work-time.ts

@@ -15,6 +15,8 @@ import { taskDirFor } from "./persistence.ts";
 /** A worker run under way: the step it works on is found from its instruction. */
 export interface ActiveRun {
   runId: string;
+  parentRunId?: string;
+  stepInstruction?: string;
   instruction: string;
   startedAt: string;
 }
@@ -97,7 +99,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; 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; 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;
@@ -106,7 +108,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 });
+    if (running) work.active.push({ runId: run.runId, instruction: run.instruction ?? "", startedAt: run.startedAt, ...(run.parentRunId ? { parentRunId: run.parentRunId } : {}), ...(run.stepInstruction ? { stepInstruction: run.stepInstruction } : {}) });
   });
 }
 

package/src/webui/api/lobby.ts

@@ -24,7 +24,7 @@ function planFacts(task: Task, work: WorkProjection | undefined): Pick<SnapshotT
   return {
     progress: { done: steps.filter((step) => step.status === "done").length, total: steps.length },
     ...(current ? { currentStep: current.text } : {}),
-    ...(active.length > 0 ? { activeSteps: active.map((step) => ({ text: step.text, workedMs: step.workedMs })) } : {}),
+    ...(active.length > 0 ? { activeSteps: active.map((step) => ({ text: step.text, workedMs: step.workedMs, activeAgentCount: step.activeAgentCount })) } : {}),
     ...clock,
   };
 }

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, 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: "backend" as const, role: "worker" as const, status: "running" as const, instruction: run.instruction, output: "", attempts: 1, startedAt: run.startedAt }));
 }
 
 /** One step as the lobby shows it: its state, and while a worker is on it, how long they have worked on it. */
@@ -38,6 +38,7 @@ export interface StepView {
   text: string;
   status: PlanStep["status"];
   active: boolean;
+  activeAgentCount: number;
   /** Worker time on the step, in ms. */
   workedMs: number;
 }
@@ -53,7 +54,7 @@ export function stepViews(task: Task, work: WorkProjection | undefined, now = Da
   const checklist = planChecklist(task.plan, runs);
   const times = stepWork(planSteps(task.plan), runs, now);
   return checklist.map((step, index) => {
-    const time = times[index] ?? { ms: 0, active: false };
-    return { text: step.text, status: time.active ? "current" : step.status, active: time.active, workedMs: Math.round(time.ms) };
+    const time = times[index] ?? { ms: 0, active: false, activeAgentCount: 0 };
+    return { text: step.text, status: time.active ? "current" : step.status, active: time.active, activeAgentCount: time.activeAgentCount, 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 } : {}),
+      ...(step.active ? { active: true, workedMs: step.workedMs, activeAgentCount: step.activeAgentCount } : {}),
     })),
     amendments: [...found.amendments],
     waiting: waitingOf(found),

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

@@ -478,7 +478,7 @@ export function createFixtureService(name: string, feed = new LobbyFeed()): Lobb
       const work = fixture.mockWork?.[taskId];
       if (!work) return undefined;
       const now = Date.now();
-      return { workedMs: work.workedMs, running: work.running, active: (work.active ?? []).map((run) => ({ runId: run.runId, instruction: run.instruction, startedAt: new Date(now - run.startedAgoMs).toISOString() })) };
+      return { workedMs: work.workedMs, running: work.running, active: (work.active ?? []).map((run) => ({ runId: run.runId, parentRunId: run.parentRunId, stepInstruction: run.stepInstruction, instruction: run.instruction, startedAt: new Date(now - run.startedAgoMs).toISOString() })) };
     },
     plans: () => [...plans],
     metrics: () => metrics.map((record) => ({ ...record })),

package/src/webui/dev/fixtures.ts

@@ -65,7 +65,7 @@ export interface ScenarioFixture {
   /** Tasks backing `tasks.list` (absent means none). */
   mockTasks?: Array<Record<string, unknown>>;
   /** Work clocks by task id (`work.json` as the owner keeps it); a run's start is given as how long ago, so it reads live. */
-  mockWork?: Record<string, { workedMs: number; running: boolean; active?: Array<{ runId: string; instruction: string; startedAgoMs: number }> }>;
+  mockWork?: Record<string, { workedMs: number; running: boolean; active?: Array<{ runId: string; parentRunId?: string; stepInstruction?: string; instruction: string; startedAgoMs: number }> }>;
   /** Saved plans backing `plans.start`/`plans.discard` and the pending rows. */
   mockPlans?: Array<{ id: string; title: string; brief: string }>;
   /** Archived tasks backing `tasks.archived`. */

package/src/webui/protocol.ts

@@ -131,7 +131,7 @@ export interface SnapshotTask {
   progress?: { done: number; total: number };
   currentStep?: string;
   /** The steps a worker is on right now, with the worker time on each (ms, as of the snapshot). */
-  activeSteps?: Array<{ text: string; workedMs: number }>;
+  activeSteps?: Array<{ text: string; workedMs: number; activeAgentCount?: number }>;
   /** How long the task's agents have worked on it, idle time left out. */
   work?: WorkClock;
 }
@@ -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 }>;
+  steps: Array<{ text: string; status: "done" | "current" | "open"; active?: boolean; workedMs?: number; activeAgentCount?: number }>;
   /** 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[];

package/src/workflow/workflow.ts

@@ -2012,7 +2012,10 @@ export async function runWorkflowAction(params: OrchestrateParams, deps: Workflo
     // Every agent, diff and desk of a task with its own worktree works there.
     cwd: taskCwd(task, deps.cwd),
     onUpdate: (run) => {
-      if (run.status !== "running") finished.set(run.runId, run);
+      if (run.status !== "running") {
+        finished.set(run.runId, run);
+        if (run.parentRunId) writeFileEnsured(join(taskDirFor(deps.root, deps.configDir, task.id), "children", `${run.runId}.json`), `${JSON.stringify(run)}\n`);
+      }
       // Every window marks the steps a worker is on while it runs.
       if (run.role === "worker") {
         if (run.status === "running") working.add(run.runId);