omnirush 0.8.5 → 0.9.0

package/assets/extensions/omnirush/agents.ts

@@ -36,10 +36,13 @@ import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 
+import { deliveryHub } from "./deliveries";
+import { subagentTasks } from "./subagents";
 import {
   AGENT_ROLES,
   AGENTS_HOOK,
   AgentManager,
+  agentStatusSummary,
   type AgentRunner,
   type AgentsHook,
   type AgentRecord,
@@ -48,9 +51,11 @@ import {
   renderChildResults,
   renderDelivery,
   runChildAgent,
+  childModelFallback,
   type ChildResult,
   type ChildTask,
 } from "./agents-lib";
+import { SWARM_GUIDELINE } from "./swarm-lib";
 
 /** A timeout_minutes below this is taken for a placeholder, not a limit. */
 const MIN_TIMEOUT_MINUTES = 1;
@@ -66,7 +71,7 @@ const SpawnAgentsParams = Type.Object({
       }),
       task: Type.String({ description: "Self-contained task description for the child agent (it sees ONLY this, not your conversation)" }),
       model: Type.Optional(Type.String({
-        description: 'Cross-model child: gateway model id for THIS task (e.g. "muse-spark-1.3", "muse-spark-1.2-contributor" for cheap swarm workers, "meta-muse-spark", "muse-spark-1.1", "gpt-6-astra", "gpt-6-sol", "gpt-5.6-sol"). Omit (or leave empty) to inherit this session\'s model',
+        description: 'Optional model[:effort] for THIS task (e.g. "muse-spark-1.3", "muse-spark-1.2-contributor" for cheap swarm workers, "meta-muse-spark", "muse-spark-1.1:low", "gpt-6-astra", "gpt-6-sol:high", "gpt-5.6-sol"). Omit (or leave empty) for the sub-agent model the user picked with /subagents, else the parent session\'s current model and effort',
       })),
     }),
     { description: "Tasks to delegate; they all run in parallel", minItems: 1 },
@@ -99,45 +104,35 @@ function renderSome(records: AgentRecord[], unknown: string[] = []): string {
   const open = records.filter((record) => !record.result);
   const parts: string[] = [];
   if (finished.length > 0) parts.push(renderChildResults(finished.map((record) => record.result as ChildResult), finished.map((record) => record.id)));
-  if (open.length > 0) parts.push(`Still running:\n${renderAgentStatus(open)}`);
+  if (open.length > 0) parts.push(`Open sub-agents:\n${renderAgentStatus(open)}`);
   if (unknown.length > 0) parts.push(`Unknown agent ids: ${unknown.join(", ")}`);
   return parts.join("\n\n") || "No matching sub-agents.";
 }
 
 export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {}) {
   const watchdogMinutes = Math.round(childInactivityMs() / 60_000);
-  /** The session this runtime is on (deliveries go to it). */
-  let currentSession = "";
-  let cwd = process.cwd();
-  /** An agent run is under way (one-shot runs deliver through the settle loop otherwise). */
-  let busy = false;
-  let oneShot = false;
+  const hub = deliveryHub(pi);
+  /** The last context seen (the TUI status bar for running agents). */
+  let lastContext: any = null;
+  let statusTimer: ReturnType<typeof setTimeout> | null = null;
 
-  const send = (records: AgentRecord[]) => {
-    pi.sendMessage(
-      {
-        customType: DELIVERY_TYPE,
-        content: renderDelivery(records),
-        display: true,
-        details: { results: records.map(resultOf) },
-      },
-      // Busy: into the running turn at its next step. Idle: a new turn.
-      { triggerTurn: true, deliverAs: "steer" },
-    );
-  };
+  function publishStatus(): void {
+    statusTimer = null;
+    const session = hub.currentSession;
+    if (!session || !lastContext?.ui?.setStatus) return;
+    const records = manager.list(session);
+    if (records.length > 0) lastContext.ui.setStatus("omnirush-agents", agentStatusSummary(records));
+  }
 
-  const deliver = () => {
-    if (!currentSession) return;
-    // One-shot and between runs: the agent_settled loop delivers.
-    if (oneShot && !busy) {
-      return;
-    }
-    for (const group of manager.takeDeliverable(currentSession)) send(group.records);
-  };
+  function scheduleStatus(): void {
+    if (statusTimer) return;
+    statusTimer = setTimeout(publishStatus, 250);
+    statusTimer.unref?.();
+  }
 
   const manager = new AgentManager({
     run: options.run ?? ((task, options) => runChildAgent(task, {
-      cwd: options.cwd ?? cwd,
+      cwd: options.cwd ?? hub.cwd,
       parentSessionId: options.parentSessionId,
       sessionId: options.sessionId,
       signal: options.signal,
@@ -145,7 +140,19 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {})
       ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),
     })),
     // After the settle's own bookkeeping (waiters took theirs).
-    onDeliverable: () => queueMicrotask(deliver),
+    onDeliverable: () => hub.notify(),
+    onChanged: scheduleStatus,
+  });
+
+  hub.addSource({
+    hasPending: (session) => manager.hasPending(session),
+    // One message per finished batch (or per child with notify "each").
+    take: (session) => manager.takeDeliverable(session).map(({ records }) => ({
+      customType: DELIVERY_TYPE,
+      content: renderDelivery(records),
+      details: { results: records.map(resultOf) },
+    })),
+    changed: () => manager.changed(),
   });
 
   const hook: AgentsHook = {
@@ -157,11 +164,8 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {})
   (globalThis as any)[AGENTS_HOOK] = hook;
 
   const sessionOf = (ctx: any): string => {
-    const id = String(ctx?.sessionManager?.getSessionId?.() ?? "");
-    if (id) currentSession = id;
-    if (ctx?.cwd) cwd = String(ctx.cwd);
-    if (ctx?.mode === "print" || ctx?.mode === "json") oneShot = true;
-    return id;
+    lastContext = ctx ?? lastContext;
+    return hub.sessionOf(ctx);
   };
 
   pi.registerTool({
@@ -186,25 +190,33 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {})
       "Short fan-outs whose results you need right away (quick searches, lookups): the default blocking call.",
       "Long work (implementation chunks, builds, test suites, long research — anything that may take many minutes) while you have other things to do: spawn_agents with wait:false, then keep working; the results arrive on their own as a message, so do not poll agents_status in a loop. Call agents_wait only when you have nothing else to do and need the results before going on.",
       "Do not use spawn_agents for a single quick action — doing it yourself is cheaper.",
+      SWARM_GUIDELINE,
     ],
     parameters: SpawnAgentsParams,
 
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      const parentSessionId = sessionOf(ctx);
       const tasks: ChildTask[] = [];
       for (const raw of params.tasks ?? []) {
         if (!raw || typeof raw.task !== "string" || !raw.task.trim()) {
           throw new Error("invalid tasks: every entry needs a non-empty task string");
         }
-        // An empty model (models fill optional fields) inherits the session's.
-        const model = typeof raw.model === "string" ? raw.model.trim() : "";
+        // A task's own model[:effort] wins; an omitted (or empty) one takes
+        // the /subagents pick, else the parent session's current model and
+        // effort (resolved below by subagentTasks).
+        const requestedModel = typeof raw.model === "string" ? raw.model.trim() : "";
         tasks.push({
           role: raw.role,
           task: raw.task.trim(),
-          ...(model ? { model } : {}),
+          ...(requestedModel ? { model: requestedModel } : {}),
         });
       }
       if (tasks.length === 0) throw new Error("no tasks given");
-      const parentSessionId = sessionOf(ctx);
+      // The model and effort each child runs on (subagents.ts): the task's
+      // own model[:effort], else the /subagents pick, else the parent
+      // session's current model and effort; the main model when a pick is
+      // unavailable.
+      const resolvedTasks = subagentTasks(pi, ctx, tasks);
       if (!parentSessionId) throw new Error("no parent session id — subagents cannot be traced");
       const workdir = ctx?.cwd ? String(ctx.cwd) : process.cwd();
       // Only a deliberate limit counts: models fill optional numbers with
@@ -212,32 +224,42 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {})
       const timeoutMs = typeof params.timeout_minutes === "number" && params.timeout_minutes >= MIN_TIMEOUT_MINUTES
         ? params.timeout_minutes * 60_000
         : undefined;
-      // No cap: every task runs at once unless the caller throttles.
-      const concurrency = typeof params.max_parallel === "number" && params.max_parallel >= 1
+      // No cap: every task runs at once unless the caller deliberately
+      // supplies max_parallel.
+      const hasParallelLimit = typeof params.max_parallel === "number" && params.max_parallel >= 1;
+      const concurrency = hasParallelLimit
         ? Math.floor(params.max_parallel)
-        : tasks.length;
+        : undefined;
       const background = params.wait === false;
 
-      let settledCount = 0;
-      const dispatched = manager.dispatch(parentSessionId, tasks, {
+      const dispatched = manager.dispatch(parentSessionId, resolvedTasks, {
         background,
         concurrency,
         notify: params.notify === "each" ? "each" : "batch",
         ...(background ? {} : { signal }),
         onSettled: (record) => {
-          settledCount += 1;
           if (background) return;
           onUpdate?.({
-            content: [{ type: "text", text: `spawn_agents: ${settledCount}/${tasks.length} settled (latest: ${record.id} ${record.role})` }],
+            content: [{ type: "text", text: `${agentStatusSummary(dispatched.records)} (latest: ${record.id} ${record.role})` }],
             details: { results: dispatched.records.filter((candidate) => candidate.result).map(resultOf) },
           });
         },
+        onChanged: () => {
+          if (background) return;
+          onUpdate?.({
+            content: [{ type: "text", text: agentStatusSummary(manager.list(parentSessionId)) }],
+            details: { results: manager.list(parentSessionId).filter((candidate) => candidate.result).map(resultOf) },
+          });
+        },
         ...(timeoutMs !== undefined ? { timeoutMs } : {}),
         cwd: workdir,
       });
 
       if (background) {
-        const lines = dispatched.records.map((record) => `- ${record.id}: ${record.role}${record.model ? ` [${record.model}]` : ""} — ${record.task.length > 100 ? `${record.task.slice(0, 99)}…` : record.task}`);
+        const lines = dispatched.records.map((record, index) => {
+          const note = childModelFallback(resolvedTasks[index])?.note;
+          return `- ${record.id}: ${record.role}${record.model ? ` [${record.model}${record.effort ? ` · ${record.effort}` : ""}]` : ""} — ${record.task.length > 100 ? `${record.task.slice(0, 99)}…` : record.task}${note ? ` (${note})` : ""}`;
+        });
         return {
           content: [{
             type: "text",
@@ -254,14 +276,20 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {})
           details: {
             background: true,
             batch: dispatched.batch,
-            results: dispatched.records.map((record) => ({
-              agent_id: record.id,
-              role: record.role,
-              task: record.task,
-              session_id: record.sessionId,
-              ...(record.model ? { model: record.model } : {}),
-              status: "running",
-            })),
+            results: dispatched.records.map((record, index) => {
+              const modelFallback = childModelFallback(resolvedTasks[index]);
+              return {
+                agent_id: record.id,
+                role: record.role,
+                task: record.task,
+                session_id: record.sessionId,
+                ...(record.model ? { model: record.model } : {}),
+                ...(record.effort ? { effort: record.effort } : {}),
+                ...(modelFallback ? { model_fallback: modelFallback } : {}),
+                parallel_limit: record.parallelLimit,
+                status: "running",
+              };
+            }),
           },
         };
       }
@@ -286,7 +314,20 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {})
       const text = renderAgentStatus(records) + (unknown.length ? `\nUnknown agent ids: ${unknown.join(", ")}` : "");
       return {
         content: [{ type: "text", text }],
-        details: { agents: records.map((record) => ({ agent_id: record.id, status: record.status, role: record.role, session_id: record.sessionId })) },
+        details: {
+          agents: records.map((record) => ({
+            agent_id: record.id,
+            status: record.status,
+            role: record.role,
+            task: record.task,
+            session_id: record.sessionId,
+            ...(record.model ? { model: record.model } : {}),
+            parallel_limit: record.parallelLimit,
+            turns: record.turns,
+            tools_running: record.toolsRunning,
+            last_activity_at: record.lastActivityAt,
+          })),
+        },
       };
     },
   });
@@ -356,55 +397,6 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {})
     },
   });
 
-  pi.on("session_start", (_event: any, ctx: any) => {
-    sessionOf(ctx);
-  });
-
-  pi.on("agent_start", (_event: any, ctx: any) => {
-    sessionOf(ctx);
-    busy = true;
-  });
-
-  /**
-   * One-shot runs (print/json mode) end when the agent settles: background
-   * children still out would be lost. The run waits for them here and
-   * continues with their results (a new run nested in this settle, whose
-   * own settle resumes this one when everything is done).
-   */
-  let resumeOuter: (() => void) | null = null;
-  pi.on("agent_settled", async (_event: any, ctx: any) => {
-    busy = false;
-    const session = sessionOf(ctx);
-    if (!oneShot) {
-      // Anything that finished right as the run ended.
-      deliver();
-      return;
-    }
-    const outer = resumeOuter;
-    resumeOuter = null;
-    try {
-      for (;;) {
-        if (typeof ctx?.isIdle === "function" && !ctx.isIdle()) {
-          // A run started (a delivery): its settle resumes this one.
-          await new Promise<void>((resolve) => { resumeOuter = resolve; });
-          break;
-        }
-        if (!session || !manager.hasPending(session)) break;
-        const groups = manager.takeDeliverable(session);
-        if (groups.length === 0) {
-          await manager.changed();
-          continue;
-        }
-        busy = true;
-        const records = groups.flatMap((group) => group.records);
-        send(records);
-        if (typeof ctx?.isIdle === "function" && ctx.isIdle()) busy = false;
-      }
-    } finally {
-      outer?.();
-    }
-  });
-
   pi.on("session_shutdown", async () => {
     // Children the session ends under are stopped (the collector, when it
     // runs, already did this before its last capture).