@a-t-h-i/bot-lobby 0.6.32 → 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/index.ts

@@ -271,8 +271,8 @@ function buildRoutes(): Record<string, Route> {
     run: (body, ctx) => quickfixMovedToTask(body as { id: string }, ctx),
   };
   routes["metrics.get"] = {
-    schema: Type.Object({ groupBy: Type.Union([Type.Literal("model"), Type.Literal("model-kind")]), query: Type.Optional(Type.String({ maxLength: 500 })) }, { additionalProperties: false }),
-    run: (body, ctx) => metricsGet(body as { groupBy: "model" | "model-kind"; query?: string }, ctx),
+    schema: Type.Object({ groupBy: Type.Union([Type.Literal("model"), Type.Literal("model-kind")]), query: Type.Optional(Type.String({ maxLength: 500 })), from: Type.Optional(Type.String({ pattern: "^\\d{4}-\\d{2}-\\d{2}$" })), to: Type.Optional(Type.String({ pattern: "^\\d{4}-\\d{2}-\\d{2}$" })), timeZone: Type.Optional(Type.String({ maxLength: 100 })) }, { additionalProperties: false }),
+    run: (body, ctx) => metricsGet(body as Parameters<typeof metricsGet>[0], ctx),
   };
   routes["knowledge.files"] = { schema: Empty, run: (_body, ctx) => knowledgeFiles(ctx) };
   routes["knowledge.ask"] = {

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/metrics.ts

@@ -3,10 +3,10 @@
  * time goes, and what the classifier did — the same figures the terminal
  * tab draws, as data. Search narrows runs exactly like the tab's `/`.
  */
-import { aggregateMetrics, collectMetrics, sortGroups, summarizeClassifier, taskStats, taskTimesByModel, type GroupBy, type MetricRecord } from "../../state/metrics.ts";
+import { aggregateMetrics, collectMetrics, sortGroups, summarizeClassifier, taskStats, taskTimesByModel, type MetricRecord } from "../../state/metrics.ts";
 import { filterRecords } from "../../lobby/models/metrics.ts";
-import type { MetricsData } from "../protocol.ts";
-import type { ApiContext } from "./index.ts";
+import type { Api, MetricsData } from "../protocol.ts";
+import { fail, type ApiContext } from "./index.ts";
 
 function timed(records: readonly MetricRecord[]): MetricRecord[] {
   return records.filter((record) => record.status !== "cancelled" && record.durationMs > 0);
@@ -49,15 +49,48 @@ function shareOf(records: readonly MetricRecord[]): MetricsData["timeShare"]["by
 }
 
 /** The dashboard figures for one grouping and search. */
-export function metricsGet(body: { groupBy: GroupBy; query?: string }, ctx: ApiContext): MetricsData {
-  const tasks = ctx.service.tasks();
-  const records = filterRecords(collectMetrics(ctx.service.metrics(), tasks), body.query);
+export function metricsGet(body: Api["metrics.get"]["request"], ctx: ApiContext): MetricsData {
+  const { from, to } = body;
+  const validDate = (value: string) => /^\d{4}-\d{2}-\d{2}$/.test(value) && Number.isFinite(Date.parse(value)) && new Date(value).toISOString().slice(0, 10) === value;
+  if ((from === undefined) !== (to === undefined) || (from !== undefined && (!validDate(from) || !validDate(to!) || from > to!))) {
+    fail(400, "bad_request", "Choose a valid start and end date, with the start on or before the end.");
+  }
+  let formatter: Intl.DateTimeFormat;
+  try {
+    formatter = new Intl.DateTimeFormat("en", { timeZone: body.timeZone ?? "UTC", year: "numeric", month: "2-digit", day: "2-digit" });
+  } catch {
+    fail(400, "bad_request", "Choose a valid time zone.");
+  }
+  const dayOf = (timestamp: string) => {
+    const date = new Date(timestamp);
+    if (!Number.isFinite(date.getTime())) return "";
+    const parts = formatter.formatToParts(date);
+    return ["year", "month", "day"].map((part) => parts.find((item) => item.type === part)!.value).join("-");
+  };
+  const inRange = (timestamp: string) => !from || (dayOf(timestamp) >= from && dayOf(timestamp) <= to!);
+  const allTasks = ctx.service.tasks();
+  const tasks = allTasks.filter((task) => inRange(task.state === "completed" ? task.updatedAt : task.createdAt));
+  const allRecords = filterRecords(collectMetrics(ctx.service.metrics(), allTasks), body.query);
+  const records = allRecords.filter((record) => inRange(record.startedAt));
   const stats = taskStats(tasks);
-  const classifier = summarizeClassifier(ctx.service.classifierMetrics?.() ?? [], records);
+  const classifier = summarizeClassifier((ctx.service.classifierMetrics?.() ?? []).filter((record) => inRange(record.startedAt)), records);
+  const daily = new Map<string, MetricsData["daily"][number]>();
+  for (const record of records) {
+    const date = dayOf(record.startedAt);
+    if (!date) continue;
+    const entry = daily.get(date) ?? { date, runs: 0, successes: 0, cost: 0 };
+    entry.runs += 1;
+    entry.successes += Number(record.status === "success");
+    entry.cost += record.cost ?? 0;
+    daily.set(date, entry);
+  }
+  // Include range edges without allocating an entry for every empty day.
+  for (const date of [from, to]) if (date && !daily.has(date)) daily.set(date, { date, runs: 0, successes: 0, cost: 0 });
   return {
     tiles: tilesOf(records, stats),
+    daily: [...daily.values()].sort((a, b) => a.date.localeCompare(b.date)),
     groups: sortGroups(aggregateMetrics(records, body.groupBy), "runs"),
-    timeShare: { byAgent: shareOf(records), taskTimes: taskTimesByModel(tasks, records) },
+    timeShare: { byAgent: shareOf(records), taskTimes: taskTimesByModel(tasks, allRecords) },
     ...(classifier ? { classifier } : {}),
   };
 }

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;
 }
@@ -335,6 +335,7 @@ export interface MetricsClassifier {
 export interface MetricsData {
   tiles: MetricsTiles;
   groups: MetricGroupInfo[];
+  daily: Array<{ date: string; runs: number; successes: number; cost: number }>;
   timeShare: { byAgent: MetricsAgentShare[]; taskTimes: MetricsTaskTime[] };
   classifier?: MetricsClassifier;
 }
@@ -419,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[];
@@ -634,7 +635,7 @@ export interface Api {
   "quickfix.cancel": { request: { id: string }; result: { notice: string } };
   "quickfix.runAnyway": { request: { id: string }; result: { notice: string } };
   "quickfix.movedToTask": { request: { id: string }; result: { notice: string; key?: string } };
-  "metrics.get": { request: { groupBy: "model" | "model-kind"; query?: string }; result: MetricsData };
+  "metrics.get": { request: { groupBy: "model" | "model-kind"; query?: string; from?: string; to?: string; timeZone?: string }; result: MetricsData };
   "projects.browse": { request: { path?: string }; result: FolderListing };
   "projects.open": { request: { path: string }; result: { project: ProjectInfo } };
   "knowledge.files": { request: Record<string, never>; result: { files: KnowledgeFileInfo[]; models?: Partial<Record<KnowledgeAgentName, 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);