@g3un/pi-orchestra 0.1.1 → 0.2.1

package/src/extension/workflow-monitor.ts

@@ -2,17 +2,33 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { AgentRun } from "../core/subagent.ts";
 import type { AgentStore } from "../core/store.ts";
 import type { WorkflowRun, WorkflowStageRun } from "../core/workflow.ts";
-import { formatNamedEntityLabel, isTerminalAgentState } from "../utils.ts";
+import { isTerminalAgentState } from "../utils.ts";
 
 const WIDGET_KEY = "pi-orchestra.workflow-monitor";
 const MAX_MONITORED_WORKFLOWS = 2;
 const MAX_WIDGET_LINES = 10;
+const DEFAULT_TICK_MS = 1_000;
+
+export interface WorkflowMonitorControllerOptions {
+  now?: () => number;
+  /** Defaults to 1000 ms. Use 0 to disable uptime ticks in tests. */
+  tickMs?: number;
+}
 
 export class WorkflowMonitorController {
+  private readonly now: () => number;
+  private readonly tickMs: number;
   private unsubscribe?: () => void;
+  private tickTimer?: ReturnType<typeof setInterval>;
   private ctx?: ExtensionContext;
 
-  constructor(private readonly store: AgentStore) {}
+  constructor(
+    private readonly store: AgentStore,
+    options: WorkflowMonitorControllerOptions = {},
+  ) {
+    this.now = options.now ?? Date.now;
+    this.tickMs = options.tickMs ?? DEFAULT_TICK_MS;
+  }
 
   hasActiveWorkflows(): boolean {
     return listActiveWorkflows(this.store).length > 0;
@@ -30,6 +46,7 @@ export class WorkflowMonitorController {
         unsubscribeWorkflows();
       };
     }
+    this.startTicking();
 
     return this.render();
   }
@@ -37,6 +54,7 @@ export class WorkflowMonitorController {
   dispose(): void {
     this.unsubscribe?.();
     this.unsubscribe = undefined;
+    this.stopTicking();
 
     if (this.ctx?.hasUI) {
       this.ctx.ui.setWidget(WIDGET_KEY, undefined);
@@ -48,7 +66,7 @@ export class WorkflowMonitorController {
     const ctx = this.ctx;
     if (!ctx?.hasUI) return false;
 
-    const lines = buildWorkflowMonitorLines(this.store);
+    const lines = buildWorkflowMonitorLines(this.store, this.now());
     if (lines.length === 0) {
       this.dispose();
       return false;
@@ -57,15 +75,28 @@ export class WorkflowMonitorController {
     ctx.ui.setWidget(WIDGET_KEY, lines, { placement: "belowEditor" });
     return true;
   }
+
+  private startTicking(): void {
+    if (this.tickMs <= 0 || this.tickTimer) return;
+    const timer = setInterval(() => this.render(), this.tickMs);
+    (timer as typeof timer & { unref?: () => void }).unref?.();
+    this.tickTimer = timer;
+  }
+
+  private stopTicking(): void {
+    if (!this.tickTimer) return;
+    clearInterval(this.tickTimer);
+    this.tickTimer = undefined;
+  }
 }
 
-export function buildWorkflowMonitorLines(store: AgentStore): string[] {
+export function buildWorkflowMonitorLines(store: AgentStore, nowMs = Date.now()): string[] {
   const workflows = listActiveWorkflows(store);
   if (workflows.length === 0) return [];
 
   const lines: string[] = [];
   for (const workflow of workflows.slice(0, MAX_MONITORED_WORKFLOWS)) {
-    appendWorkflowLines(lines, store, workflow);
+    appendWorkflowLines(lines, store, workflow, nowMs);
     if (lines.length >= MAX_WIDGET_LINES) break;
   }
 
@@ -77,12 +108,14 @@ export function buildWorkflowMonitorLines(store: AgentStore): string[] {
   return lines.slice(0, MAX_WIDGET_LINES);
 }
 
-function appendWorkflowLines(lines: string[], store: AgentStore, workflow: WorkflowRun): void {
+function appendWorkflowLines(lines: string[], store: AgentStore, workflow: WorkflowRun, nowMs: number): void {
   if (lines.length >= MAX_WIDGET_LINES) return;
 
   const stage = getCurrentStage(workflow);
-  const stageLabel = stage ? formatStageLabel(store, workflow, stage) : "none · agents 0/0";
-  lines.push(`${formatNamedEntityLabel(workflow)} | ${stageLabel}`);
+  const stageLabel = stage
+    ? formatStageLabel(store, workflow, stage)
+    : `none (0/${workflow.stages.length}) | agents (0/0)`;
+  lines.push(`${workflow.name} | ${stageLabel} | ${formatWorkflowUptime(workflow, nowMs)}`);
 }
 
 function listActiveWorkflows(store: AgentStore): WorkflowRun[] {
@@ -98,7 +131,7 @@ function getCurrentStage(workflow: WorkflowRun): WorkflowStageRun | undefined {
 function formatStageLabel(store: AgentStore, workflow: WorkflowRun, stage: WorkflowStageRun): string {
   const stageIndex = workflow.stages.indexOf(stage);
   const stagePosition = stageIndex >= 0 ? `${stageIndex + 1}/${workflow.stages.length}` : `?/${workflow.stages.length}`;
-  return `${stage.name} · step ${stagePosition} · agents ${formatStageProgress(store, stage)}`;
+  return `${stage.name} (${stagePosition}) | agents (${formatStageProgress(store, stage)})`;
 }
 
 function formatStageProgress(store: AgentStore, stage: WorkflowStageRun): string {
@@ -106,6 +139,22 @@ function formatStageProgress(store: AgentStore, stage: WorkflowStageRun): string
   return `${progress.completed}/${progress.total}`;
 }
 
+function formatWorkflowUptime(workflow: WorkflowRun, nowMs: number): string {
+  const elapsedSeconds = Math.max(0, Math.floor((nowMs - workflow.startedAtMs) / 1_000));
+  const seconds = elapsedSeconds % 60;
+  const totalMinutes = Math.floor(elapsedSeconds / 60);
+  const minutes = totalMinutes % 60;
+  const hours = Math.floor(totalMinutes / 60);
+
+  if (hours > 0) return `${hours}h ${pad2(minutes)}m`;
+  if (totalMinutes > 0) return `${totalMinutes}m ${pad2(seconds)}s`;
+  return `${seconds}s`;
+}
+
+function pad2(value: number): string {
+  return value.toString().padStart(2, "0");
+}
+
 function calculateStageProgress(store: AgentStore, stage: WorkflowStageRun): { completed: number; total: number } {
   const runs = collectStageRuns(store, stage);
   const completed = runs.filter((run) => isTerminalAgentState(run.state)).length;

package/src/tools/bus.ts

@@ -1,8 +1,7 @@
 import { defineTool, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import type { AgentRun } from "../core/subagent.ts";
 import type { Bus, BusMessage } from "../core/bus.ts";
-import type { OrchestraApi, WaitBusSettledResult, WaitNextRunResult, WaitRunResult } from "../core/orchestra.ts";
+import type { OrchestraApi } from "../core/orchestra.ts";
 import { formatNamedEntityLabel } from "../utils.ts";
 
 export type BusInput =
@@ -19,31 +18,11 @@ export type BusInput =
       id: string;
       message: string;
       from?: string;
-    }
-  | {
-      action: "wait_settled";
-      id: string;
-      /** Defaults to 10 minutes. Use null to wait indefinitely. */
-      timeoutMs?: number | null;
-    }
-  | {
-      action: "wait_next";
-      id: string;
-      /** Run ids or names to ignore. */
-      excludeRunIds?: string[];
-      /** Defaults to 10 minutes. Use null to wait indefinitely. */
-      timeoutMs?: number | null;
     };
 
 export interface BusOutput {
   bus?: Bus;
   busMessage?: BusMessage;
-  run?: AgentRun;
-  runResult?: WaitRunResult;
-  runs?: AgentRun[];
-  runResults?: WaitRunResult[];
-  timedOut?: boolean;
-  pendingRunIds?: string[];
   message: string;
 }
 
@@ -57,8 +36,8 @@ export interface BusToolDeps {
 }
 
 const BusActionParams = Type.String({
-  enum: ["create", "status", "publish", "wait_settled", "wait_next"],
-  description: "create/status/publish; wait_settled waits all attached runs; wait_next waits the next terminal run.",
+  enum: ["create", "status", "publish"],
+  description: "create/status/publish shared context buses; completion is delivered through pi-orchestra events.",
 });
 
 const BusToolParams = Type.Object(
@@ -79,24 +58,6 @@ const BusToolParams = Type.Object(
         description: "Required for action=publish. Shared context for attached agents.",
       }),
     ),
-    excludeRunIds: Type.Optional(
-      Type.Array(Type.String(), {
-        description: "Optional for action=wait_next. Already handled run ids/names.",
-      }),
-    ),
-    timeoutMs: Type.Optional(
-      Type.Union(
-        [
-          Type.Number({
-            exclusiveMinimum: 0,
-          }),
-          Type.Null(),
-        ],
-        {
-          description: "Optional for wait actions. Positive ms; default 10 min; null waits indefinitely.",
-        },
-      ),
-    ),
   },
   { additionalProperties: false },
 );
@@ -118,35 +79,6 @@ export function createBusTool({ orchestra }: BusToolDeps): BusTool {
         return { bus, message: formatBusStatus(bus) };
       }
 
-      if (input.action === "wait_settled") {
-        const output = await orchestra.waitBusSettled(bus.id, { timeoutMs: input.timeoutMs });
-        return {
-          bus: output.bus,
-          runs: output.runs,
-          runResults: output.runResults,
-          timedOut: output.timedOut,
-          pendingRunIds: output.pendingRunIds,
-          message: formatWaitBusSettledMessage(output),
-        };
-      }
-
-      if (input.action === "wait_next") {
-        const output = await orchestra.waitNextRun(bus.id, {
-          excludeRunIds: input.excludeRunIds,
-          timeoutMs: input.timeoutMs,
-        });
-        return {
-          bus: output.bus,
-          run: output.run,
-          runResult: output.runResult,
-          runs: output.runs,
-          runResults: output.runResults,
-          timedOut: output.timedOut,
-          pendingRunIds: output.pendingRunIds,
-          message: formatWaitNextRunMessage(output),
-        };
-      }
-
       const published = await orchestra.publishBus(input.id, input.message, input.from ?? "main");
       return {
         bus: published.bus,
@@ -161,13 +93,12 @@ export function defineBusPiTool(resolveTool: (ctx: ExtensionContext) => BusTool)
   return defineTool({
     name: "bus",
     label: "Bus",
-    description: "Create, inspect, publish to, and wait on work buses.",
-    promptSnippet:
-      "Use one bus per delegated work item; spawn related subagents on it and collect results with wait actions.",
+    description: "Create, inspect, and publish to work buses.",
+    promptSnippet: "Use one bus per delegated work item; spawn related subagents or workgroups on it.",
     promptGuidelines: [
-      "Create a bus before spawning related subagents; reuse it for that work item.",
-      "publish sends shared context to attached agents; status shows published messages.",
-      "wait_next handles results as they arrive; wait_settled waits for full fan-in.",
+      "Use bus create before spawning related subagents or workgroups; reuse it for that work item.",
+      "Use bus publish to send shared context to attached agents; bus status shows published messages.",
+      "Do not wait on buses; pi-orchestra delivers subagent and workgroup finish events automatically.",
     ],
     parameters: BusToolParams,
     executionMode: "sequential",
@@ -190,21 +121,6 @@ function toBusInput(params: RawBusParams): BusInput {
     return { action: "status", id: params.id };
   }
 
-  if (params.action === "wait_settled") {
-    if (!params.id) throw new Error("bus action=wait_settled requires id.");
-    return { action: "wait_settled", id: params.id, timeoutMs: params.timeoutMs };
-  }
-
-  if (params.action === "wait_next") {
-    if (!params.id) throw new Error("bus action=wait_next requires id.");
-    return {
-      action: "wait_next",
-      id: params.id,
-      excludeRunIds: params.excludeRunIds,
-      timeoutMs: params.timeoutMs,
-    };
-  }
-
   if (!params.id) throw new Error("bus action=publish requires id.");
   if (!params.message) throw new Error("bus action=publish requires message.");
   return { action: "publish", id: params.id, message: params.message };
@@ -227,49 +143,9 @@ function formatBusMessage(message: BusMessage): string {
   return [`- ${message.id} from ${message.from}:`, message.message].join("\n");
 }
 
-function formatWaitBusSettledMessage(result: WaitBusSettledResult): string {
-  const busLabel = formatNamedEntityLabel(result.bus);
-  const headline = result.timedOut
-    ? `Timed out waiting for bus ${busLabel} to settle; ${result.pendingRunIds.length} run(s) still pending.`
-    : `All ${result.runs.length} run(s) attached to bus ${busLabel} reached terminal state.`;
-  if (result.runs.length === 0) return headline;
-
-  return [headline, "", "Runs:", ...result.runs.map(formatRunSummary)].join("\n");
-}
-
-function formatRunSummary(run: AgentRun): string {
-  const runLabel = formatNamedEntityLabel(run);
-  if (!run.result) return `- ${runLabel}: ${run.state}`;
-  return `- ${runLabel}: ${run.state} result=${run.result.status} summary=${run.result.summary}`;
-}
-
-function formatWaitNextRunMessage(result: WaitNextRunResult): string {
-  const busLabel = formatNamedEntityLabel(result.bus);
-  if (result.run) {
-    return [
-      `Next terminal run on bus ${busLabel}: ${formatNamedEntityLabel(result.run)} is ${result.run.state}.`,
-      "",
-      formatRunResult(result.run),
-    ].join("\n");
-  }
-
-  if (result.timedOut) {
-    return `Timed out waiting for the next run on bus ${busLabel}; ${result.pendingRunIds.length} run(s) still pending.`;
-  }
-
-  return `No unhandled current runs remain on bus ${busLabel}.`;
-}
-
-function formatRunResult(run: AgentRun): string {
-  if (!run.result) return "No result payload recorded.";
-  return [`Result: ${run.result.status}`, run.result.summary].join("\n");
-}
-
 type RawBusParams = {
-  action: "create" | "status" | "publish" | "wait_settled" | "wait_next";
+  action: "create" | "status" | "publish";
   name?: string;
   id?: string;
   message?: string;
-  excludeRunIds?: string[];
-  timeoutMs?: number | null;
 };

package/src/tools/workflow.ts

@@ -1,7 +1,7 @@
 import { defineTool, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import type { AgentResultStatus, AgentRun } from "../core/subagent.ts";
-import type { OrchestraApi, WaitRunResult } from "../core/orchestra.ts";
+import type { AgentResultStatus, AgentRun, AgentRunResult } from "../core/subagent.ts";
+import type { OrchestraApi } from "../core/orchestra.ts";
 import type { AgentStore } from "../core/store.ts";
 import type { WorkflowRun, WorkflowStageOutput, WorkflowStageRun, WorkflowStageSpec } from "../core/workflow.ts";
 import { WORKGROUP_STRATEGY_VALUES, type WorkgroupMember, type WorkgroupStrategy } from "../core/workgroup.ts";
@@ -15,7 +15,6 @@ import {
   isTerminalAgentState,
   normalizeEntityName,
   requireWorkflow,
-  resolveWaitTimeoutMs,
 } from "../utils.ts";
 import {
   createWorkgroupTool,
@@ -41,17 +40,10 @@ export type WorkflowInput =
   | {
       action: "cancel";
       id: string;
-    }
-  | {
-      action: "wait";
-      id: string;
-      /** Defaults to 10 minutes. Use null to wait indefinitely. */
-      timeoutMs?: number | null;
     };
 
 export interface WorkflowOutput {
   workflow?: WorkflowRun;
-  timedOut?: boolean;
   message: string;
 }
 
@@ -92,8 +84,8 @@ const WorkflowStageParams = Type.Object(
 );
 
 const WorkflowActionParams = Type.String({
-  enum: ["start", "status", "cancel", "wait"],
-  description: "start launches; status inspects; cancel closes active runs; wait awaits terminal workflow state.",
+  enum: ["start", "status", "cancel"],
+  description: "start launches; status inspects progress or results; cancel closes active runs.",
 });
 
 const WorkflowToolParams = Type.Object(
@@ -106,7 +98,7 @@ const WorkflowToolParams = Type.Object(
     ),
     id: Type.Optional(
       Type.String({
-        description: "Required for status/cancel/wait. Workflow id/name.",
+        description: "Required for status/cancel. Workflow id/name.",
       }),
     ),
     goal: Type.Optional(
@@ -120,19 +112,6 @@ const WorkflowToolParams = Type.Object(
         minItems: 1,
       }),
     ),
-    timeoutMs: Type.Optional(
-      Type.Union(
-        [
-          Type.Number({
-            exclusiveMinimum: 0,
-          }),
-          Type.Null(),
-        ],
-        {
-          description: "Optional for action=wait. Positive ms; default 10 min; null waits indefinitely.",
-        },
-      ),
-    ),
   },
   { additionalProperties: false },
 );
@@ -161,24 +140,9 @@ export function createWorkflowTool({ orchestra, store }: WorkflowToolDeps): Work
       }
 
       const workflow = findWorkflow(store, input.id);
-      if (!workflow) {
-        return input.action === "wait"
-          ? { timedOut: false, message: formatWorkflowNotFound(input.id) }
-          : { message: formatWorkflowNotFound(input.id) };
-      }
+      if (!workflow) return { message: formatWorkflowNotFound(input.id) };
 
-      if (input.action === "status") {
-        return { workflow, message: formatWorkflowMessage(workflow) };
-      }
-
-      if (input.action === "wait") {
-        const result = await waitWorkflow(store, workflow.id, input.timeoutMs);
-        return {
-          workflow: result.workflow,
-          timedOut: result.timedOut,
-          message: formatWaitWorkflowMessage(result.workflow, result.timedOut, input.id),
-        };
-      }
+      if (input.action === "status") return { workflow, message: formatWorkflowMessage(workflow) };
 
       const closedWorkflow = await closeWorkflow(orchestra, store, workflow);
       return { workflow: closedWorkflow, message: formatWorkflowMessage(closedWorkflow, "Workflow cancelled.") };
@@ -194,12 +158,12 @@ export function defineWorkflowPiTool(
     name: "workflow",
     label: "Workflow",
     description: "Run linear workgroup stages with automatic restricted stage leaders.",
-    promptSnippet: "Launch a multi-stage workflow, then use workflow wait/status for progress and final output.",
+    promptSnippet: "Launch a multi-stage workflow; completion is delivered automatically as a pi-orchestra event.",
     promptGuidelines: [
       "Use workflow for ordered multi-stage work; not branching/DAG plans.",
       "Each stage gets its own bus and automatic leader; previous outputs feed the next stage.",
       "Use compete when one worker success is enough; use synthesize when findings must be combined.",
-      "Use status for progress, wait for terminal success/blocked/failed/closed.",
+      "Use workflow status for progress; workflow.finished events deliver terminal success/blocked/failed/closed results.",
     ],
     parameters: WorkflowToolParams,
     executionMode: "sequential",
@@ -272,7 +236,13 @@ async function runStage(workflowId: string, stageIndex: number, deps: WorkflowRu
     workerRunIds: workgroupOutput.runs.map((run) => run.id),
   });
 
-  const settledWorkgroup = await settleWorkgroupRuns(deps.orchestra, bus.id, stage.strategy);
+  const settledWorkgroup = await settleWorkgroupRuns(
+    deps.orchestra,
+    deps.store,
+    bus.id,
+    workgroupOutput.runs.map((run) => run.id),
+    stage.strategy,
+  );
   if (isWorkflowClosed(deps.store, workflowId)) return;
 
   if (stage.strategy === "compete" && !settledWorkgroup.winner) {
@@ -288,7 +258,7 @@ async function runStageLeader(
   workflowId: string,
   stageIndex: number,
   busId: string,
-  workerResults: WaitRunResult[],
+  workerResults: AgentRunResult[],
   deps: WorkflowRunnerDeps,
 ): Promise<void> {
   const workflow = requireWorkflow(deps.store, workflowId);
@@ -310,10 +280,9 @@ async function runStageLeader(
     leaderRunId: leaderRun.id,
   });
 
-  const leaderSettled = await deps.orchestra.waitBusSettled(busId, { timeoutMs: null });
+  const latestLeaderRun = await terminalRunEvent(deps.store, leaderRun.id);
   if (isWorkflowClosed(deps.store, workflowId)) return;
 
-  const latestLeaderRun = leaderSettled.runs.find((run) => run.id === leaderRun.id) ?? leaderRun;
   const output = buildStageOutput(latestLeaderRun, leaderRun.id, workerResults);
   finishStage(deps.store, requireWorkflow(deps.store, workflowId), stageIndex, output);
 }
@@ -343,6 +312,7 @@ function createWorkflowRun(
   return {
     ...identity,
     goal: input.goal,
+    startedAtMs: Date.now(),
     state: "idle",
     currentStageIndex: 0,
     stages: input.stages.map((stage) => {
@@ -391,7 +361,6 @@ function toWorkflowInput(params: RawWorkflowParams): WorkflowInput {
   }
 
   if (!params.id) throw new Error(`workflow action=${params.action} requires id.`);
-  if (params.action === "wait") return { action: "wait", id: params.id, timeoutMs: params.timeoutMs };
   return { action: params.action, id: params.id };
 }
 
@@ -499,7 +468,7 @@ function buildStageWorkerGoal(workflow: WorkflowRun, stageIndex: number): string
   return parts.join("\n");
 }
 
-function buildLeaderTask(workflow: WorkflowRun, stageIndex: number, workerResults: WaitRunResult[]): string {
+function buildLeaderTask(workflow: WorkflowRun, stageIndex: number, workerResults: AgentRunResult[]): string {
   const stage = workflow.stages[stageIndex];
   const strategyInstructions =
     stage.strategy === "compete"
@@ -546,12 +515,12 @@ function formatPreviousStageOutput(stageName: string, output: WorkflowStageOutpu
   return [`<stage_output name="${stageName}">`, formatStageOutputForPrompt(output), "</stage_output>"].join("\n");
 }
 
-function formatWorkerResults(workerResults: WaitRunResult[]): string {
+function formatWorkerResults(workerResults: AgentRunResult[]): string {
   if (workerResults.length === 0) return "None.";
   return workerResults.map(formatWorkerResult).join("\n\n");
 }
 
-function formatWorkerResult(result: WaitRunResult): string {
+function formatWorkerResult(result: AgentRunResult): string {
   const lines = [
     `<worker_result run_id="${result.runId}" name="${result.name}" profile="${result.profile}" state="${result.state}">`,
   ];
@@ -575,7 +544,7 @@ function formatJsonData(data: unknown): string {
   return JSON.stringify(data, null, 2) ?? String(data);
 }
 
-function buildCompeteNoWinnerOutput(workerResults: WaitRunResult[]): WorkflowStageOutput {
+function buildCompeteNoWinnerOutput(workerResults: AgentRunResult[]): WorkflowStageOutput {
   const status = workerResults.some((worker) => worker.result?.status === "blocked") ? "blocked" : "failed";
   const counts = countWorkerResultStatuses(workerResults);
   const workflowRunResults = workerResults.map(toWorkflowRunResult);
@@ -587,7 +556,7 @@ function buildCompeteNoWinnerOutput(workerResults: WaitRunResult[]): WorkflowSta
   };
 }
 
-function countWorkerResultStatuses(workerResults: WaitRunResult[]): Record<AgentResultStatus, number> {
+function countWorkerResultStatuses(workerResults: AgentRunResult[]): Record<AgentResultStatus, number> {
   const counts: Record<AgentResultStatus, number> = { success: 0, blocked: 0, failed: 0 };
   for (const worker of workerResults) {
     if (worker.result) counts[worker.result.status]++;
@@ -598,7 +567,7 @@ function countWorkerResultStatuses(workerResults: WaitRunResult[]): Record<Agent
 function buildStageOutput(
   leaderRun: AgentRun,
   leaderRunId: string,
-  workerResults: WaitRunResult[],
+  workerResults: AgentRunResult[],
 ): WorkflowStageOutput {
   if (!leaderRun.result) {
     return {
@@ -619,7 +588,7 @@ function buildStageOutput(
   return output;
 }
 
-function toWorkflowRunResult(result: WaitRunResult) {
+function toWorkflowRunResult(result: AgentRunResult) {
   const output = {
     runId: result.runId,
     name: result.name,
@@ -635,49 +604,21 @@ function formatStageOutput(output: WorkflowStageOutput): string {
   return parts.join("\n");
 }
 
-function waitWorkflow(
-  store: AgentStore,
-  workflowId: string,
-  timeoutMs: number | null | undefined,
-): Promise<{ workflow: WorkflowRun; timedOut: boolean }> {
-  const resolvedTimeoutMs = resolveWaitTimeoutMs("workflow wait", timeoutMs);
-  const initialWorkflow = requireWorkflow(store, workflowId);
-  if (isTerminalAgentState(initialWorkflow.state)) {
-    return Promise.resolve({ workflow: initialWorkflow, timedOut: false });
-  }
+function terminalRunEvent(store: AgentStore, runId: string): Promise<AgentRun> {
+  const initialRun = store.getRun(runId);
+  if (initialRun && isTerminalAgentState(initialRun.state)) return Promise.resolve(initialRun);
 
   return new Promise((resolve) => {
-    let settled = false;
-    let latestWorkflow = initialWorkflow;
-    let timeout: ReturnType<typeof setTimeout> | undefined;
-
-    const cleanup = () => {
-      if (timeout) clearTimeout(timeout);
-      unsubscribe();
-    };
-
-    const unsubscribe = store.subscribeWorkflows(
-      (workflow) => {
-        if (settled) return;
-        latestWorkflow = workflow;
-        if (!isTerminalAgentState(workflow.state)) return;
+    let unsubscribe: () => void = () => undefined;
+    unsubscribe = store.subscribeRuns(
+      (run) => {
+        if (!isTerminalAgentState(run.state)) return;
 
-        settled = true;
-        cleanup();
-        resolve({ workflow, timedOut: false });
+        unsubscribe();
+        resolve(run);
       },
-      (workflow) => workflow.id === workflowId,
+      (run) => run.id === runId,
     );
-
-    if (resolvedTimeoutMs !== null) {
-      timeout = setTimeout(() => {
-        if (settled) return;
-
-        settled = true;
-        cleanup();
-        resolve({ workflow: latestWorkflow, timedOut: true });
-      }, resolvedTimeoutMs);
-    }
   });
 }
 
@@ -685,14 +626,6 @@ function formatWorkflowNotFound(id: string): string {
   return `Workflow ${id} not found.`;
 }
 
-function formatWaitWorkflowMessage(workflow: WorkflowRun | undefined, timedOut: boolean, requestedId?: string): string {
-  if (!workflow) return formatWorkflowNotFound(requestedId ?? "");
-  const label = requestedId === workflow.id ? workflow.id : formatNamedEntityLabel(workflow);
-  const prefix = timedOut ? "Timed out waiting for" : "Workflow reached terminal state:";
-  const result = workflow.result ? ` result=${workflow.result.status}` : "";
-  return `${prefix} ${label}; state=${workflow.state}${result}.`;
-}
-
 function formatWorkflowMessage(
   workflow: WorkflowRun,
   headline = `Workflow ${formatNamedEntityLabel(workflow)} is ${workflow.state}.`,
@@ -708,12 +641,11 @@ function formatWorkflowMessage(
 }
 
 type RawWorkflowParams = {
-  action: "start" | "status" | "cancel" | "wait";
+  action: "start" | "status" | "cancel";
   name?: string;
   id?: string;
   goal?: string;
   stages?: RawWorkflowStageParams[];
-  timeoutMs?: number | null;
 };
 
 type RawWorkflowStageParams = {