@g3un/pi-orchestra 0.1.1 → 0.2.0

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);
 }
@@ -391,7 +360,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 +467,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 +514,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 +543,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 +555,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 +566,7 @@ function countWorkerResultStatuses(workerResults: WaitRunResult[]): Record<Agent
 function buildStageOutput(
   leaderRun: AgentRun,
   leaderRunId: string,
-  workerResults: WaitRunResult[],
+  workerResults: AgentRunResult[],
 ): WorkflowStageOutput {
   if (!leaderRun.result) {
     return {
@@ -619,7 +587,7 @@ function buildStageOutput(
   return output;
 }
 
-function toWorkflowRunResult(result: WaitRunResult) {
+function toWorkflowRunResult(result: AgentRunResult) {
   const output = {
     runId: result.runId,
     name: result.name,
@@ -635,49 +603,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 +625,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 +640,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 = {