@g3un/pi-orchestra 0.1.0 → 0.1.1

package/README.md

@@ -15,6 +15,9 @@ pi -e npm:@g3un/pi-orchestra
 ```
 
 Pi-Orchestra registers four tools: `bus`, `subagent`, `workgroup`, and `workflow`.
+Active workflows are also shown in a TUI progress widget with the current stage
+and agent completion counts. Use `/orchestra-workflows` to reopen the widget if
+needed.
 
 ## Core concepts
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@g3un/pi-orchestra",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Subagent orchestration tools for Pi.",
   "keywords": [
     "orchestration",

package/src/adapters/in-memory-store.ts

@@ -3,16 +3,21 @@ import type { Bus, BusMessage } from "../core/bus.ts";
 import type { AgentStore } from "../core/store.ts";
 import type { WorkflowRun } from "../core/workflow.ts";
 
+interface StoreSubscription<T> {
+  listener(value: T): void;
+  filter?: (value: T) => boolean;
+}
+
 export class InMemoryAgentStore implements AgentStore {
   private readonly runs = new Map<string, AgentRun>();
   private readonly buses = new Map<string, Bus>();
   private readonly workflows = new Map<string, WorkflowRun>();
-  private readonly runListeners = new Map<string, Set<(run: AgentRun) => void>>();
-  private readonly workflowListeners = new Map<string, Set<(workflow: WorkflowRun) => void>>();
+  private readonly runSubscriptions = new Set<StoreSubscription<AgentRun>>();
+  private readonly workflowSubscriptions = new Set<StoreSubscription<WorkflowRun>>();
 
   saveRun(run: AgentRun): void {
     this.runs.set(run.id, run);
-    for (const listener of this.runListeners.get(run.id) ?? []) listener(run);
+    notifySubscribers(this.runSubscriptions, run);
   }
 
   getRun(id: string): AgentRun | undefined {
@@ -23,15 +28,10 @@ export class InMemoryAgentStore implements AgentStore {
     return [...this.runs.values()];
   }
 
-  subscribeRun(id: string, listener: (run: AgentRun) => void): () => void {
-    const listeners = this.runListeners.get(id) ?? new Set<(run: AgentRun) => void>();
-    listeners.add(listener);
-    this.runListeners.set(id, listeners);
-
-    return () => {
-      listeners.delete(listener);
-      if (listeners.size === 0) this.runListeners.delete(id);
-    };
+  subscribeRuns(listener: (run: AgentRun) => void, filter?: (run: AgentRun) => boolean): () => void {
+    const subscription = { listener, filter };
+    this.runSubscriptions.add(subscription);
+    return () => this.runSubscriptions.delete(subscription);
   }
 
   saveBus(bus: Bus): void {
@@ -61,7 +61,7 @@ export class InMemoryAgentStore implements AgentStore {
 
   saveWorkflow(workflow: WorkflowRun): void {
     this.workflows.set(workflow.id, workflow);
-    for (const listener of this.workflowListeners.get(workflow.id) ?? []) listener(workflow);
+    notifySubscribers(this.workflowSubscriptions, workflow);
   }
 
   getWorkflow(id: string): WorkflowRun | undefined {
@@ -72,14 +72,18 @@ export class InMemoryAgentStore implements AgentStore {
     return [...this.workflows.values()];
   }
 
-  subscribeWorkflow(id: string, listener: (workflow: WorkflowRun) => void): () => void {
-    const listeners = this.workflowListeners.get(id) ?? new Set<(workflow: WorkflowRun) => void>();
-    listeners.add(listener);
-    this.workflowListeners.set(id, listeners);
+  subscribeWorkflows(
+    listener: (workflow: WorkflowRun) => void,
+    filter?: (workflow: WorkflowRun) => boolean,
+  ): () => void {
+    const subscription = { listener, filter };
+    this.workflowSubscriptions.add(subscription);
+    return () => this.workflowSubscriptions.delete(subscription);
+  }
+}
 
-    return () => {
-      listeners.delete(listener);
-      if (listeners.size === 0) this.workflowListeners.delete(id);
-    };
+function notifySubscribers<T>(subscriptions: Set<StoreSubscription<T>>, value: T): void {
+  for (const subscription of subscriptions) {
+    if (!subscription.filter || subscription.filter(value)) subscription.listener(value);
   }
 }

package/src/core/orchestra.ts

@@ -183,11 +183,14 @@ export class Orchestra implements OrchestraApi {
       for (const run of initialRuns) {
         if (isTerminalAgentState(run.state)) continue;
         unsubscribeAll.push(
-          this.store.subscribeRun(run.id, (updatedRun) => {
-            if (settled) return;
-            latestRuns.set(updatedRun.id, updatedRun);
-            resolveIfDone();
-          }),
+          this.store.subscribeRuns(
+            (updatedRun) => {
+              if (settled) return;
+              latestRuns.set(updatedRun.id, updatedRun);
+              resolveIfDone();
+            },
+            (updatedRun) => updatedRun.id === run.id,
+          ),
         );
       }
 
@@ -238,12 +241,15 @@ export class Orchestra implements OrchestraApi {
       for (const run of initialRuns) {
         if (isTerminalAgentState(run.state)) continue;
         unsubscribeAll.push(
-          this.store.subscribeRun(run.id, (updatedRun) => {
-            if (settled) return;
-            latestRuns.set(updatedRun.id, updatedRun);
-            if (!excludedRunIds.has(updatedRun.id) && isTerminalAgentState(updatedRun.state))
-              resolveWithRun(updatedRun);
-          }),
+          this.store.subscribeRuns(
+            (updatedRun) => {
+              if (settled) return;
+              latestRuns.set(updatedRun.id, updatedRun);
+              if (!excludedRunIds.has(updatedRun.id) && isTerminalAgentState(updatedRun.state))
+                resolveWithRun(updatedRun);
+            },
+            (updatedRun) => updatedRun.id === run.id,
+          ),
         );
       }
     });

package/src/core/store.ts

@@ -6,7 +6,7 @@ export interface AgentStore {
   saveRun(run: AgentRun): void;
   getRun(id: string): AgentRun | undefined;
   listRuns(): AgentRun[];
-  subscribeRun(id: string, listener: (run: AgentRun) => void): () => void;
+  subscribeRuns(listener: (run: AgentRun) => void, filter?: (run: AgentRun) => boolean): () => void;
 
   saveBus(bus: Bus): void;
   getBus(id: string): Bus | undefined;
@@ -17,5 +17,8 @@ export interface AgentStore {
   saveWorkflow(workflow: WorkflowRun): void;
   getWorkflow(id: string): WorkflowRun | undefined;
   listWorkflows(): WorkflowRun[];
-  subscribeWorkflow(id: string, listener: (workflow: WorkflowRun) => void): () => void;
+  subscribeWorkflows(
+    listener: (workflow: WorkflowRun) => void,
+    filter?: (workflow: WorkflowRun) => boolean,
+  ): () => void;
 }

package/src/extension/index.ts

@@ -6,12 +6,14 @@ import { createBusTool, defineBusPiTool, type BusTool } from "../tools/bus.ts";
 import { createSubagentTool, defineSubagentPiTool, type SubagentTool } from "../tools/subagent.ts";
 import { createWorkflowTool, defineWorkflowPiTool, type WorkflowTool } from "../tools/workflow.ts";
 import { createWorkgroupTool, defineWorkgroupPiTool, type WorkgroupTool } from "../tools/workgroup.ts";
+import { WorkflowMonitorController } from "./workflow-monitor.ts";
 
 interface ToolBundle {
   busTool: BusTool;
   subagentTool: SubagentTool;
   workgroupTool: WorkgroupTool;
   workflowTool: WorkflowTool;
+  workflowMonitor: WorkflowMonitorController;
 }
 
 export default function piOrchestraExtension(pi: ExtensionAPI): void {
@@ -21,7 +23,25 @@ export default function piOrchestraExtension(pi: ExtensionAPI): void {
   pi.registerTool(defineBusPiTool((ctx) => getToolBundle(ctx).busTool));
   pi.registerTool(defineSubagentPiTool((ctx) => getToolBundle(ctx).subagentTool));
   pi.registerTool(defineWorkgroupPiTool((ctx) => getToolBundle(ctx).workgroupTool));
-  pi.registerTool(defineWorkflowPiTool((ctx) => getToolBundle(ctx).workflowTool));
+  pi.registerTool(
+    defineWorkflowPiTool((ctx) => getToolBundle(ctx).workflowTool, {
+      onWorkflowInput: (ctx) => getToolBundle(ctx).workflowMonitor.show(ctx),
+      onWorkflowOutput: (ctx) => getToolBundle(ctx).workflowMonitor.show(ctx),
+    }),
+  );
+
+  pi.registerCommand("orchestra-workflows", {
+    description: "Show the active pi-orchestra workflow progress widget.",
+    handler: async (_args, ctx) => {
+      const monitor = getToolBundle(ctx).workflowMonitor;
+      if (monitor.show(ctx)) return;
+      ctx.ui.notify("No active pi-orchestra workflows.", "info");
+    },
+  });
+
+  pi.on("session_shutdown", (_event, ctx) => {
+    bundles.get(ctx.cwd)?.workflowMonitor.dispose();
+  });
 }
 
 function getBundle(bundles: Map<string, ToolBundle>, ctx: ExtensionContext): ToolBundle {
@@ -40,6 +60,7 @@ function getBundle(bundles: Map<string, ToolBundle>, ctx: ExtensionContext): Too
     subagentTool: createSubagentTool({ orchestra }),
     workgroupTool: createWorkgroupTool({ orchestra }),
     workflowTool: createWorkflowTool({ orchestra, store }),
+    workflowMonitor: new WorkflowMonitorController(store),
   };
   bundles.set(ctx.cwd, bundle);
   return bundle;

package/src/extension/workflow-monitor.ts

@@ -0,0 +1,143 @@
+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";
+
+const WIDGET_KEY = "pi-orchestra.workflow-monitor";
+const MAX_MONITORED_WORKFLOWS = 2;
+const MAX_WIDGET_LINES = 10;
+
+export class WorkflowMonitorController {
+  private unsubscribe?: () => void;
+  private ctx?: ExtensionContext;
+
+  constructor(private readonly store: AgentStore) {}
+
+  hasActiveWorkflows(): boolean {
+    return listActiveWorkflows(this.store).length > 0;
+  }
+
+  show(ctx: ExtensionContext): boolean {
+    if (!ctx.hasUI) return false;
+
+    this.ctx = ctx;
+    if (!this.unsubscribe) {
+      const unsubscribeRuns = this.store.subscribeRuns(() => this.render());
+      const unsubscribeWorkflows = this.store.subscribeWorkflows(() => this.render());
+      this.unsubscribe = () => {
+        unsubscribeRuns();
+        unsubscribeWorkflows();
+      };
+    }
+
+    return this.render();
+  }
+
+  dispose(): void {
+    this.unsubscribe?.();
+    this.unsubscribe = undefined;
+
+    if (this.ctx?.hasUI) {
+      this.ctx.ui.setWidget(WIDGET_KEY, undefined);
+    }
+    this.ctx = undefined;
+  }
+
+  private render(): boolean {
+    const ctx = this.ctx;
+    if (!ctx?.hasUI) return false;
+
+    const lines = buildWorkflowMonitorLines(this.store);
+    if (lines.length === 0) {
+      this.dispose();
+      return false;
+    }
+
+    ctx.ui.setWidget(WIDGET_KEY, lines, { placement: "belowEditor" });
+    return true;
+  }
+}
+
+export function buildWorkflowMonitorLines(store: AgentStore): 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);
+    if (lines.length >= MAX_WIDGET_LINES) break;
+  }
+
+  const hiddenWorkflowCount = workflows.length - MAX_MONITORED_WORKFLOWS;
+  if (hiddenWorkflowCount > 0 && lines.length < MAX_WIDGET_LINES) {
+    lines.push(`... +${hiddenWorkflowCount} more active ${pluralize("workflow", hiddenWorkflowCount)}`);
+  }
+
+  return lines.slice(0, MAX_WIDGET_LINES);
+}
+
+function appendWorkflowLines(lines: string[], store: AgentStore, workflow: WorkflowRun): 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}`);
+}
+
+function listActiveWorkflows(store: AgentStore): WorkflowRun[] {
+  return store.listWorkflows().filter((workflow) => !isTerminalAgentState(workflow.state));
+}
+
+function getCurrentStage(workflow: WorkflowRun): WorkflowStageRun | undefined {
+  return (
+    workflow.stages[workflow.currentStageIndex] ?? workflow.stages.find((stage) => !isTerminalAgentState(stage.state))
+  );
+}
+
+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)}`;
+}
+
+function formatStageProgress(store: AgentStore, stage: WorkflowStageRun): string {
+  const progress = calculateStageProgress(store, stage);
+  return `${progress.completed}/${progress.total}`;
+}
+
+function calculateStageProgress(store: AgentStore, stage: WorkflowStageRun): { completed: number; total: number } {
+  const runs = collectStageRuns(store, stage);
+  const completed = runs.filter((run) => isTerminalAgentState(run.state)).length;
+  const workerRunCount = runs.filter((run) => run.id !== stage.leaderRunId).length;
+  const workerTotal = Math.max(stage.members.length, stage.workerRunIds.length, workerRunCount);
+  const leaderTotal = stage.phase === "leader" || stage.leaderRunId !== undefined ? 1 : 0;
+  const total = Math.max(workerTotal + leaderTotal, runs.length);
+  return { completed: Math.min(completed, total), total };
+}
+
+function collectStageRuns(store: AgentStore, stage: WorkflowStageRun): AgentRun[] {
+  const runsById = new Map<string, AgentRun>();
+
+  for (const runId of stage.workerRunIds) {
+    const run = store.getRun(runId);
+    if (run) runsById.set(run.id, run);
+  }
+
+  if (stage.leaderRunId) {
+    const leaderRun = store.getRun(stage.leaderRunId);
+    if (leaderRun) runsById.set(leaderRun.id, leaderRun);
+  }
+
+  if (stage.busId) {
+    for (const run of store.listRuns().filter((current) => current.busId === stage.busId)) {
+      runsById.set(run.id, run);
+    }
+  }
+
+  return [...runsById.values()];
+}
+
+function pluralize(noun: string, count: number): string {
+  return count === 1 ? noun : `${noun}s`;
+}

package/src/tools/workflow.ts

@@ -65,6 +65,11 @@ export interface WorkflowToolDeps {
   store: AgentStore;
 }
 
+export interface WorkflowPiToolOptions {
+  onWorkflowInput?: (ctx: ExtensionContext, input: WorkflowInput) => void;
+  onWorkflowOutput?: (ctx: ExtensionContext, output: WorkflowOutput) => void;
+}
+
 const WorkflowStageParams = Type.Object(
   {
     name: Type.String({
@@ -181,7 +186,10 @@ export function createWorkflowTool({ orchestra, store }: WorkflowToolDeps): Work
   };
 }
 
-export function defineWorkflowPiTool(resolveTool: (ctx: ExtensionContext) => WorkflowTool) {
+export function defineWorkflowPiTool(
+  resolveTool: (ctx: ExtensionContext) => WorkflowTool,
+  options: WorkflowPiToolOptions = {},
+) {
   return defineTool({
     name: "workflow",
     label: "Workflow",
@@ -196,9 +204,11 @@ export function defineWorkflowPiTool(resolveTool: (ctx: ExtensionContext) => Wor
     parameters: WorkflowToolParams,
     executionMode: "sequential",
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const output = await resolveTool(ctx).execute(
-        withDefaultModels(toWorkflowInput(params as RawWorkflowParams), ctx),
-      );
+      const input = withDefaultModels(toWorkflowInput(params as RawWorkflowParams), ctx);
+      options.onWorkflowInput?.(ctx, input);
+
+      const output = await resolveTool(ctx).execute(input);
+      if (output.workflow) options.onWorkflowOutput?.(ctx, output);
 
       return {
         content: [{ type: "text", text: output.message }],
@@ -646,15 +656,18 @@ function waitWorkflow(
       unsubscribe();
     };
 
-    const unsubscribe = store.subscribeWorkflow(workflowId, (workflow) => {
-      if (settled) return;
-      latestWorkflow = workflow;
-      if (!isTerminalAgentState(workflow.state)) return;
+    const unsubscribe = store.subscribeWorkflows(
+      (workflow) => {
+        if (settled) return;
+        latestWorkflow = workflow;
+        if (!isTerminalAgentState(workflow.state)) return;
 
-      settled = true;
-      cleanup();
-      resolve({ workflow, timedOut: false });
-    });
+        settled = true;
+        cleanup();
+        resolve({ workflow, timedOut: false });
+      },
+      (workflow) => workflow.id === workflowId,
+    );
 
     if (resolvedTimeoutMs !== null) {
       timeout = setTimeout(() => {