omnirush 0.8.5 → 0.8.6

package/assets/collect-once.ts

@@ -43,7 +43,9 @@ async function main() {
   const { dir, dryRun } = parseArgs(process.argv.slice(2));
   const sessionId = `manual-${randomBytes(6).toString("hex")}`;
   const workspaceId = `cli_${createHash("sha256").update(path.resolve(dir)).digest("hex").slice(0, 16)}`;
-  const accessToken = (process.env.OMNIRUSH_ACCESS_TOKEN || process.env.OMNIRUSH_TOKEN || "").trim();
+  const accessToken = (
+    sharedRefresher().accessToken() || process.env.OMNIRUSH_ACCESS_TOKEN || process.env.OMNIRUSH_TOKEN || ""
+  ).trim();
   if (!accessToken && !dryRun) {
     console.error("omnirush collect: no access token (run `omnirush login`)");
     process.exit(1);
@@ -57,10 +59,9 @@ async function main() {
     // A dry run keeps no state (nothing is spooled for a later run).
     ...(dryRun ? {} : { stateDir: omniDir() }),
     refreshAccessToken: async () => {
-      const refresher = sharedRefresher();
-      const refreshed = await refresher.refresh(current).catch(() => false);
-      const next = refresher.auth?.accessToken ?? null;
-      if (!refreshed || !next) return null;
+      const outcome = await sharedRefresher().recover(current).catch(() => null);
+      if (outcome?.status !== "ok") return null;
+      const next = outcome.accessToken;
       current = next;
       return next;
     },

package/assets/extensions/omnirush/agents-lib.ts

@@ -28,6 +28,17 @@ import { mkdtemp, writeFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 
+import { childAuthEnv } from "./auth";
+
+/** childAuthEnv, never throwing (a spawn must not fail on the auth file). */
+function childAuthEnvSafe(): Record<string, string> {
+  try {
+    return childAuthEnv(process.env);
+  } catch {
+    return {};
+  }
+}
+
 /**
  * Inactivity watchdog default: a child that prints nothing (no model
  * stream, no tool event) for this long is treated as hung and stopped.
@@ -55,6 +66,24 @@ export const CHILD_OUTPUT_CAP_BYTES = 50 * 1024;
 export const AGENT_ROLES = ["code-searcher", "researcher-web", "general-worker"] as const;
 export type AgentRole = (typeof AGENT_ROLES)[number];
 
+/**
+ * Resolve the model selected for the current parent session. Pi keeps the
+ * effort level separately from the model id, while the CLI accepts the
+ * canonical `model:effort` spelling for child argv.
+ */
+export function modelSelectionFromContext(ctx: any): string | undefined {
+  const model = ctx?.model;
+  const id = typeof model?.id === "string"
+    ? model.id.trim()
+    : typeof model?.modelID === "string"
+      ? model.modelID.trim()
+      : "";
+  if (!id) return undefined;
+  const effort = typeof ctx?.thinkingLevel === "string" ? ctx.thinkingLevel.trim() : "";
+  if (!effort || effort === "off" || id.includes(":")) return id;
+  return `${id}:${effort}`;
+}
+
 export interface RolePreset {
   role: AgentRole;
   label: string;
@@ -384,6 +413,10 @@ export async function runChildAgent(
         stdio: ["ignore", "pipe", "pipe"],
         env: {
           ...process.env,
+          // Shared credentials by location (OMNIRUSH_DIR), never a token
+          // frozen at the parent's launch: the child re-reads auth.json
+          // for every request and takes part in the refresh lock.
+          ...childAuthEnvSafe(),
           OMNIRUSH_PARENT_SESSION: options.parentSessionId,
         },
       });
@@ -573,6 +606,8 @@ export interface AgentRecord {
   model?: string;
   /** Dispatched with wait:false: its result comes back as a message. */
   background: boolean;
+  /** Null means the batch was intentionally uncapped; otherwise the batch limit. */
+  parallelLimit: number | null;
   /** Background delivery: one message per child, or one per batch. */
   notify: "each" | "batch";
   status: AgentState;
@@ -611,6 +646,8 @@ export interface DispatchOptions {
   signal?: AbortSignal;
   /** A child settled (progress updates). */
   onSettled?: (record: AgentRecord) => void;
+  /** A child was queued, started, updated, or settled. */
+  onChanged?: () => void;
   /** Explicit wall-clock limit per child (none by default). */
   timeoutMs?: number;
   /** Workspace the children run in. */
@@ -627,6 +664,7 @@ export class AgentManager {
   private readonly runner: AgentRunner;
   private readonly now: () => number;
   private readonly onDeliverable: () => void;
+  private readonly onChanged: () => void;
   private readonly bySession = new Map<string, AgentRecord[]>();
   private waiters: Array<{ records: AgentRecord[]; resolve: () => void }> = [];
   private changeWaiters: Array<() => void> = [];
@@ -634,10 +672,11 @@ export class AgentManager {
   private nextAgent = 1;
   private nextBatch = 1;
 
-  constructor(options: { run: AgentRunner; now?: () => number; onDeliverable?: () => void }) {
+  constructor(options: { run: AgentRunner; now?: () => number; onDeliverable?: () => void; onChanged?: () => void }) {
     this.runner = options.run;
     this.now = options.now ?? Date.now;
     this.onDeliverable = options.onDeliverable ?? (() => undefined);
+    this.onChanged = options.onChanged ?? (() => undefined);
   }
 
   dispatch(
@@ -661,6 +700,7 @@ export class AgentManager {
         task: task.task,
         ...(task.model ? { model: task.model } : {}),
         background: options.background,
+        parallelLimit: options.concurrency === undefined ? null : Math.max(1, Math.floor(options.concurrency)),
         notify: options.notify ?? "batch",
         status: "queued",
         queuedAt: at,
@@ -679,6 +719,8 @@ export class AgentManager {
       list.push(record);
       return record;
     });
+    this.onChanged();
+    options.onChanged?.();
     if (options.signal) {
       const abort = () => { void this.cancel(records); };
       if (options.signal.aborted) abort();
@@ -697,6 +739,8 @@ export class AgentManager {
     record.status = "running";
     record.startedAt = this.now();
     record.lastActivityAt = record.startedAt;
+    this.onChanged();
+    options.onChanged?.();
     let result: ChildResult;
     try {
       result = await this.runner(task, {
@@ -709,6 +753,8 @@ export class AgentManager {
           record.lastActivityAt = activity.at;
           record.turns = activity.turns;
           record.toolsRunning = activity.toolsRunning;
+          this.onChanged();
+          options.onChanged?.();
         },
       });
     } catch (error) {
@@ -730,6 +776,9 @@ export class AgentManager {
     record.finishedAt = this.now();
     record.turns = result.turns;
     record.toolsRunning = 0;
+    this.onChanged();
+    // The dispatch callback is not available here; settle callers also invoke
+    // their onSettled hook immediately after start() returns.
     this.resolvers.get(record)?.(result);
     this.resolvers.delete(record);
     // Waiters first: what they return is delivered through their tool result.
@@ -873,6 +922,21 @@ function minutesOf(ms: number): number {
   return Math.round((ms / 60_000) * 10) / 10;
 }
 
+/** Compact status used by both the tool stream and the TUI status bar. */
+export function agentStatusSummary(records: AgentRecord[]): string {
+  if (records.length === 0) return "No sub-agents in this session.";
+  const running = records.filter((record) => record.status === "running").length;
+  const queued = records.filter((record) => record.status === "queued").length;
+  const settled = records.filter((record) => Boolean(record.result)).length;
+  const limits = [...new Set(records.map((record) => record.parallelLimit))];
+  const parallel = limits.length === 1 && limits[0] === null
+    ? "unlimited"
+    : limits.length === 1
+      ? String(limits[0])
+      : "per-batch";
+  return `${records.length} sub-agents: ${running} running, ${queued} queued, ${settled} settled (parallel: ${parallel})`;
+}
+
 /** One status line per sub-agent (agents_status, /agents). */
 export function renderAgentStatus(records: AgentRecord[], now: number = Date.now()): string {
   if (records.length === 0) return "No sub-agents in this session.";
@@ -892,8 +956,7 @@ export function renderAgentStatus(records: AgentRecord[], now: number = Date.now
     const task = record.task.length > 80 ? `${record.task.slice(0, 79)}…` : record.task;
     return `- ${bits.join(" ")} (${detail.join(", ")}) — ${task}`;
   });
-  const running = records.filter((record) => !record.result).length;
-  return `${records.length} sub-agents, ${running} running:\n${lines.join("\n")}`;
+  return `${agentStatusSummary(records)}:\n${lines.join("\n")}`;
 }
 
 /** The message that brings finished background agents back to the parent. */

package/assets/extensions/omnirush/agents.ts

@@ -40,6 +40,7 @@ import {
   AGENT_ROLES,
   AGENTS_HOOK,
   AgentManager,
+  agentStatusSummary,
   type AgentRunner,
   type AgentsHook,
   type AgentRecord,
@@ -47,6 +48,7 @@ import {
   renderAgentStatus,
   renderChildResults,
   renderDelivery,
+  modelSelectionFromContext,
   runChildAgent,
   type ChildResult,
   type ChildTask,
@@ -66,7 +68,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", "gpt-6-sol:high"). Omit (or leave empty) to inherit the parent session\'s current model and effort',
       })),
     }),
     { description: "Tasks to delegate; they all run in parallel", minItems: 1 },
@@ -99,7 +101,7 @@ 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.";
 }
@@ -109,10 +111,27 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {})
   /** The session this runtime is on (deliveries go to it). */
   let currentSession = "";
   let cwd = process.cwd();
+  let inheritedModel = "";
+  let lastContext: any = null;
+  let statusTimer: ReturnType<typeof setTimeout> | null = null;
   /** An agent run is under way (one-shot runs deliver through the settle loop otherwise). */
   let busy = false;
   let oneShot = false;
 
+  function publishStatus(): void {
+    statusTimer = null;
+    const session = currentSession;
+    if (!session || !lastContext?.ui?.setStatus) return;
+    const records = manager.list(session);
+    if (records.length > 0) lastContext.ui.setStatus("omnirush-agents", agentStatusSummary(records));
+  }
+
+  function scheduleStatus(): void {
+    if (statusTimer) return;
+    statusTimer = setTimeout(publishStatus, 250);
+    statusTimer.unref?.();
+  }
+
   const send = (records: AgentRecord[]) => {
     pi.sendMessage(
       {
@@ -146,6 +165,7 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {})
     })),
     // After the settle's own bookkeeping (waiters took theirs).
     onDeliverable: () => queueMicrotask(deliver),
+    onChanged: scheduleStatus,
   });
 
   const hook: AgentsHook = {
@@ -158,7 +178,13 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {})
 
   const sessionOf = (ctx: any): string => {
     const id = String(ctx?.sessionManager?.getSessionId?.() ?? "");
-    if (id) currentSession = id;
+    if (id && id !== currentSession) {
+      currentSession = id;
+      inheritedModel = "";
+    }
+    lastContext = ctx ?? lastContext;
+    const selected = modelSelectionFromContext(ctx);
+    if (selected) inheritedModel = selected;
     if (ctx?.cwd) cwd = String(ctx.cwd);
     if (ctx?.mode === "print" || ctx?.mode === "json") oneShot = true;
     return id;
@@ -190,21 +216,22 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {})
     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() : "";
+        // An omitted model inherits the live parent selection. Explicit task
+        // models remain available for deliberate mixed-model swarms.
+        const requestedModel = typeof raw.model === "string" ? raw.model.trim() : "";
         tasks.push({
           role: raw.role,
           task: raw.task.trim(),
-          ...(model ? { model } : {}),
+          ...((requestedModel || inheritedModel) ? { model: requestedModel || inheritedModel } : {}),
         });
       }
       if (tasks.length === 0) throw new Error("no tasks given");
-      const parentSessionId = sessionOf(ctx);
       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,26 +239,33 @@ 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, {
         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,
       });
@@ -260,6 +294,7 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {})
               task: record.task,
               session_id: record.sessionId,
               ...(record.model ? { model: record.model } : {}),
+              parallel_limit: record.parallelLimit,
               status: "running",
             })),
           },
@@ -286,7 +321,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,
+          })),
+        },
       };
     },
   });