@g3un/pi-orchestra 0.2.1 → 0.9.2

package/src/tools/workgroup.ts

@@ -1,6 +1,6 @@
 import { defineTool, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import type { AgentProfile, AgentResultStatus, AgentRun, AgentRunResult } from "../core/subagent.ts";
+import type { AgentResultStatus, AgentRun, AgentRunResult } from "../core/subagent.ts";
 import type { Bus } from "../core/bus.ts";
 import type { OrchestraApi } from "../core/orchestra.ts";
 import type { AgentStore } from "../core/store.ts";
@@ -9,7 +9,8 @@ import {
   closeAgentRuns,
   formatError,
   formatNamedEntityLabel,
-  isTerminalAgentState,
+  isAgentRunActive,
+  isAgentRunFinished,
   normalizeEntityName,
   slugify,
   toAgentRunResult,
@@ -18,6 +19,8 @@ import {
   AgentProfileParams,
   spawnSubagent,
   SubagentRunNameParam,
+  toAgentProfile,
+  type RawAgentProfileParams,
   type SubagentSpawnInput,
   withDefaultProfileModel,
 } from "./subagent.ts";
@@ -44,7 +47,7 @@ export interface WorkgroupSettlement {
   workerResults: AgentRunResult[];
   /** Every terminal result observed while settling this workgroup. */
   completedResults: AgentRunResult[];
-  winner?: AgentRunResult;
+  winner: AgentRunResult | undefined;
   pendingRunIds: string[];
 }
 
@@ -69,9 +72,9 @@ export interface WorkgroupLaunchFailedEvent extends WorkgroupLaunchEvent {
 
 export interface WorkgroupToolDeps {
   orchestra: OrchestraApi;
-  onWorkgroupLaunching?: (event: WorkgroupLaunchEvent) => void;
-  onWorkgroupLaunched?: (event: WorkgroupLaunchedEvent) => void;
-  onWorkgroupLaunchFailed?: (event: WorkgroupLaunchFailedEvent) => void;
+  onWorkgroupLaunching: ((event: WorkgroupLaunchEvent) => void) | undefined;
+  onWorkgroupLaunched: ((event: WorkgroupLaunchedEvent) => void) | undefined;
+  onWorkgroupLaunchFailed: ((event: WorkgroupLaunchFailedEvent) => void) | undefined;
 }
 
 export const WorkgroupMemberParams = Type.Object(
@@ -144,7 +147,7 @@ export function createWorkgroupTool({
       try {
         const preparedInput: PreparedWorkgroupInput = {
           ...input,
-          members: prepareMembers(input.members, orchestra.listRuns()),
+          members: prepareMembers(input.members, orchestra.listRuns({ busId: undefined })),
         };
         const spawnResults = await Promise.allSettled(
           preparedInput.members.map(async (member): Promise<SpawnSuccess> => {
@@ -157,7 +160,7 @@ export function createWorkgroupTool({
         const failures = collectSpawnFailures(preparedInput.members, spawnResults);
         if (failures.length > 0) {
           const cleanupResults = await Promise.allSettled(
-            successes.map((success) => orchestra.closeAgent(success.run.id)),
+            successes.map((success) => orchestra.closeAgent(success.run.id, { busId: undefined })),
           );
           throw new Error(formatLaunchFailure(failures, successes, cleanupResults));
         }
@@ -275,12 +278,13 @@ class WorkgroupSettlementCollector {
           status: resolveWorkgroupStatus(this.completedResults),
           workerResults: this.completedResults,
           completedResults: this.completedResults,
+          winner: undefined,
           pendingRunIds: this.getPendingRunIds(),
         });
       };
 
       const observeRun = (run: AgentRun) => {
-        if (settled || !this.runIds.has(run.id) || !isTerminalAgentState(run.state)) return;
+        if (settled || !this.runIds.has(run.id) || !isAgentRunFinished(run)) return;
         this.recordTerminalRun(run);
         finishFromCurrentState();
       };
@@ -294,6 +298,7 @@ class WorkgroupSettlementCollector {
           status: "failed",
           workerResults: [],
           completedResults: [],
+          winner: undefined,
           pendingRunIds: [],
         });
       }
@@ -308,7 +313,7 @@ class WorkgroupSettlementCollector {
   }
 
   private recordTerminalRun(run: AgentRun): void {
-    if (!isTerminalAgentState(run.state) || this.completedRunIds.has(run.id)) return;
+    if (!isAgentRunFinished(run) || this.completedRunIds.has(run.id)) return;
 
     this.completedRunIds.add(run.id);
     this.completedResults.push(toAgentRunResult(run));
@@ -317,12 +322,15 @@ class WorkgroupSettlementCollector {
   private isSettled(): boolean {
     return [...this.runIds].every((runId) => {
       const run = this.store.getRun(runId);
-      return run !== undefined && isTerminalAgentState(run.state);
+      return run !== undefined && isAgentRunFinished(run);
     });
   }
 
   private getPendingRunIds(): string[] {
-    return [...this.runIds].filter((runId) => this.store.getRun(runId)?.state === "idle");
+    return [...this.runIds].filter((runId) => {
+      const run = this.store.getRun(runId);
+      return run !== undefined && isAgentRunActive(run);
+    });
   }
 }
 
@@ -353,7 +361,7 @@ function toWorkgroupInput(params: RawWorkgroupParams): WorkgroupInput {
 
 export function toWorkgroupMember(member: RawWorkgroupMemberParams, label: string): WorkgroupMember {
   if (!member.profile) throw new Error(`${label} requires profile.`);
-  return { profile: member.profile, name: member.name, assignment: member.assignment };
+  return { profile: toAgentProfile(member.profile), name: member.name, assignment: member.assignment };
 }
 
 function withDefaultModelsForWorkgroup(input: WorkgroupInput, ctx: ExtensionContext): WorkgroupInput {
@@ -531,7 +539,7 @@ type RawWorkgroupParams = {
 };
 
 export type RawWorkgroupMemberParams = {
-  profile?: AgentProfile;
+  profile?: RawAgentProfileParams;
   name?: string;
   assignment?: string;
 };

package/src/utils.ts

@@ -61,7 +61,15 @@ export function requireWorkflow(store: AgentStore, id: string): WorkflowRun {
 }
 
 export function isTerminalAgentState(state: AgentState): boolean {
-  return state !== "idle";
+  return state === "success" || state === "blocked" || state === "failed" || state === "closed";
+}
+
+export function isAgentRunActive(run: AgentRun): boolean {
+  return run.state === "running" && run.result === undefined;
+}
+
+export function isAgentRunFinished(run: AgentRun): boolean {
+  return isTerminalAgentState(run.state) || run.result !== undefined;
 }
 
 export function indent(text: string, prefix = "  "): string {
@@ -87,5 +95,7 @@ export function toAgentRunResult(run: AgentRun): AgentRunResult {
 }
 
 export async function closeAgentRuns(orchestra: OrchestraApi, runIds: string[]): Promise<void> {
-  await Promise.allSettled([...new Set(runIds)].map(async (runId) => await orchestra.closeAgent(runId)));
+  await Promise.allSettled(
+    [...new Set(runIds)].map(async (runId) => await orchestra.closeAgent(runId, { busId: undefined })),
+  );
 }

package/src/profiles/stage-leader.ts

@@ -1,20 +0,0 @@
-import type { AgentProfile } from "../core/subagent.ts";
-
-export interface StageLeaderProfileOptions {
-  name?: string;
-  model?: string;
-}
-
-export function createStageLeaderProfile(options: StageLeaderProfileOptions = {}): AgentProfile {
-  return {
-    name: options.name ?? "stage-leader",
-    systemPrompt: [
-      "You are a workflow stage leader: produce concise canonical output for the next stage.",
-      "Use only supplied context (workflow/stage goals, previous outputs, worker results, bus context); do not research, inspect files, run commands, or request external info.",
-      "Deduplicate and reconcile findings; note conflicts/gaps; prefer finish results over bus context.",
-      "Prefer status=success if useful output exists; use blocked if context is insufficient, failed if synthesis fails.",
-    ].join("\n"),
-    tools: [],
-    model: options.model,
-  };
-}