omnirush 0.8.5 → 0.9.0

package/assets/CHANGELOG.md

@@ -0,0 +1,85 @@
+# Omnirush CLI release notes
+
+Shown by `/changelog` inside the agent and after an update. Newest first;
+keep entries free of links (the agent core rewrites relative links).
+
+## [0.9.0]
+
+### Added
+- Voice mode: `/voice` turns on dictation. Hold Space to talk and your words
+  are typed into the prompt at the cursor as you speak, ready to edit before
+  you send. Esc cancels and puts your draft back. `/voice tap` toggles with a
+  tap instead, `/voice key <key>` picks another key, `/voice auto-send on`
+  sends dictations of three words or more when you let go, and `/voice off`
+  turns it off. Audio is never saved to disk and never becomes part of your
+  session; only the text you send does.
+- Long shell commands no longer get killed. A command still running after
+  five minutes (or the time the agent asked for) keeps going in the
+  background and its output arrives when it finishes; servers, watchers and
+  long builds can start in the background right away. `/jobs` lists them and
+  `/jobs kill <id|all>` stops them. `OMNIRUSH_BASH_FOREGROUND_SECONDS`
+  changes the five minutes.
+- `/subagents` picks the model and effort sub-agents run on, as in the
+  desktop app: `/subagents model <id|same>`, `/subagents effort <level|same>`
+  and `/subagents reset`. The choice is remembered for the next runs;
+  `--subagent-model` / `--subagent-effort` (or `OMNIRUSH_SUBAGENT_MODEL` /
+  `OMNIRUSH_SUBAGENT_EFFORT`) set it for one run. If your account cannot use
+  the picked model, sub-agents run on your main model and say so. A task's
+  own `model:effort` still wins over the pick.
+- Swarms: when you ask for a big job split across three or more sub-agents
+  (or ask for a swarm), omnirush coordinates them on a shared board in
+  `.omnirush/swarm.md` and archives it to `.omnirush/swarms/` when the swarm
+  ends. Smaller requests never create a board, and the board is kept out of
+  git.
+- Guarded mode, on by default, as in the desktop app: before the agent
+  commits, pushes, rewrites git history, runs a destructive command
+  (`rm -rf`, `git reset --hard`, `git push --force` ...), uses `sudo`, reads
+  a `.env` file or touches files outside the project, omnirush shows you the
+  command and asks: allow once, allow for this session, or deny. Sub-agents
+  ask in the same place. Runs with `-p` cannot ask, so those calls are
+  blocked there with a note to rerun with `--yolo`.
+- Yolo mode: `omnirush --yolo`, `/yolo on` or `/mode yolo` (remembered), or
+  `OMNIRUSH_YOLO=1`. Nothing asks, every command is allowed and the project
+  folder is trusted. The footer, `/status` and `/mode` show which mode you
+  are in.
+
+### Changed
+- Omnirush everywhere: every screen, help page, message, file name and
+  update note now says omnirush.
+- Your agent data (sessions, settings, models.json, provider logins,
+  installed packages) now lives in `~/.omnirush/agent`. It is copied over
+  automatically the first time 0.9.0 starts; the previous folder is left
+  untouched, and `--continue` and `/resume` find your earlier sessions.
+- Project settings live in `<project>/.omnirush/`. A project that still has
+  its settings in the folder older versions used keeps working unchanged.
+- Environment variables: every agent setting can be set as `OMNIRUSH_<NAME>`
+  (for example `OMNIRUSH_CACHE_RETENTION`); the older names still work.
+  `OMNIRUSH_AGENT_DIR` moves the agent data folder.
+
+### Removed
+- `/bug` and `/share`: omnirush no longer sends reports, sessions, install
+  reports, analytics or version checks to the agent core's upstream service.
+
+## [0.8.6]
+
+### Added
+- Sub-agents run on your session's current model and effort, and a task can
+  name its own as `model:effort` (for example `gpt-6-sol:high`).
+- A footer line shows your sub-agents while they run: how many are running,
+  queued and finished.
+
+### Fixed
+- No more false "this device's session is no longer valid" after another
+  omnirush process refreshed the sign-in.
+
+## [0.8.1]
+
+### Added
+- GPT 6 Sol, and the model list now comes from the gateway's catalog, as in
+  the desktop app.
+
+## [0.8.0]
+
+### Added
+- Session capture in the desktop app's format, with sub-agents and project
+  archives.

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,26 @@ import { mkdtemp, writeFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 
+import {
+  ENV_FALLBACK_EFFORT,
+  ENV_FALLBACK_MODEL,
+  FALLBACK_MARKER,
+  fallbackNote,
+  piThinking,
+  type SubagentFallback,
+} from "./subagents-lib";
+import { childAuthEnv } from "./auth";
+import { yoloActive } from "./yolo-lib";
+
+/** 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 +75,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;
@@ -135,8 +173,15 @@ export function buildChildArgs(
   promptFilePath: string | null,
   model?: string,
   sessionId?: string,
+  effort?: string | null,
+  approve = false,
 ): string[] {
   const args: string[] = ["--mode", "json", "-p"];
+  if (approve) {
+    // Yolo mode: a headless child has no trust prompt, so without this it
+    // would ignore the project's settings the parent runs with.
+    args.push("--approve");
+  }
   if (sessionId) {
     // The child's session id, picked by the parent so its session file can
     // be found and captured as this session's sub-agent.
@@ -148,6 +193,11 @@ export function buildChildArgs(
   if (model && model.trim()) {
     args.push("--provider", "omnirush", "--model", model.trim());
   }
+  if (effort && effort.trim()) {
+    // The effort the sub-agent runs on (the picked one, or the main agent's
+    // mapped to the levels this model offers).
+    args.push("--thinking", piThinking(effort.trim()));
+  }
   args.push(`Task: ${task}`);
   return args;
 }
@@ -178,6 +228,25 @@ export interface ChildTask {
    *  (e.g. "muse-spark-1.3" for cheap swarm workers under an astra
    *  parent). Undefined = inherit the parent's model. */
   model?: string;
+  /** The effort the child runs on (gateway spelling); undefined = pi's default. */
+  effort?: string;
+  /** The picked sub-agent model could not be used: `model` is the main one. */
+  fallback?: SubagentFallback;
+  /** The main model the child's gateway guard moves to when the gateway refuses `model`. */
+  gatewayFallback?: { model: string; effort: string | null };
+  /** Extra environment for the child (the sub-agent setting and main model, for nested layers). */
+  env?: Record<string, string>;
+}
+
+/** A sub-agent that ran on the main model instead of the picked one. */
+export interface ChildModelFallback {
+  requested: string;
+  used: string;
+  effort?: string | null;
+  reason: string;
+  /** "selection": picked before it started; "gateway": the gateway refused the picked model mid-run. */
+  kind: "selection" | "gateway";
+  note: string;
 }
 
 export type ChildStatus = "completed" | "failed" | "timeout" | "stalled" | "cancelled" | "interrupted";
@@ -189,6 +258,10 @@ export interface ChildResult {
   session_id?: string;
   /** The gateway model the child ran on (cross-model children). */
   model?: string;
+  /** The effort it ran on. */
+  effort?: string;
+  /** It ran on the main model instead of the picked one (why, and since when). */
+  model_fallback?: ChildModelFallback;
   status: ChildStatus;
   /** Process exit code (null when killed by a signal or still unknown). */
   exitCode: number | null;
@@ -208,6 +281,33 @@ export interface ChildResultInput {
   turns: number;
   status?: ChildStatus;
   error?: string;
+  /** The gateway moved the child to the main model mid-run. */
+  gatewayFallback?: { requested: string; used: string; effort?: string | null; reason: string };
+}
+
+/** The selection or gateway fallback of a child, for its result. */
+export function childModelFallback(task: ChildTask, gateway?: ChildResultInput["gatewayFallback"]): ChildModelFallback | undefined {
+  if (task.fallback) {
+    return {
+      requested: task.fallback.requested,
+      used: task.fallback.used,
+      effort: task.effort ?? null,
+      reason: String(task.fallback.reason),
+      kind: "selection",
+      note: fallbackNote(task.fallback),
+    };
+  }
+  if (gateway) {
+    return {
+      requested: gateway.requested,
+      used: gateway.used,
+      effort: gateway.effort ?? null,
+      reason: gateway.reason,
+      kind: "gateway",
+      note: fallbackNote({ requested: gateway.requested, used: gateway.used, reason: gateway.reason }),
+    };
+  }
+  return undefined;
 }
 
 /** Final structured result for one child. */
@@ -224,11 +324,14 @@ export function buildChildResult(
     capped = output.slice(0, CHILD_OUTPUT_CAP_BYTES);
     while (Buffer.byteLength(capped, "utf8") > CHILD_OUTPUT_CAP_BYTES) capped = capped.slice(0, -1);
   }
+  const modelFallback = childModelFallback(task, input.gatewayFallback);
   return {
     role: task.role,
     task: task.task,
     ...(sessionId ? { session_id: sessionId } : {}),
     ...(task.model ? { model: task.model } : {}),
+    ...(task.effort ? { effort: task.effort } : {}),
+    ...(modelFallback ? { model_fallback: modelFallback } : {}),
     status: input.status ?? (input.exitCode === 0 ? "completed" : "failed"),
     exitCode: input.exitCode,
     output: capped,
@@ -363,13 +466,15 @@ export async function runChildAgent(
   const sessionId = options.sessionId ?? randomUUID();
 
   return withRolePromptFile(task.role, async (promptFile) => {
-    const args = buildChildArgs(task.task, promptFile, task.model, sessionId);
+    const args = buildChildArgs(task.task, promptFile, task.model, sessionId, task.effort, yoloActive());
     const invocation = childInvocation(args);
 
     return await new Promise<ChildResult>((resolvePromise) => {
       let stdout = "";
       let stderr = "";
       let pendingLine = "";
+      let pendingErrLine = "";
+      let gatewayFallback: ChildResultInput["gatewayFallback"];
       let settled = false;
       let killedFor: "timeout" | "stalled" | "cancelled" | "interrupted" | null = null;
       let turns = 0;
@@ -382,10 +487,10 @@ export async function runChildAgent(
         cwd: options.cwd,
         shell: false,
         stdio: ["ignore", "pipe", "pipe"],
-        env: {
-          ...process.env,
-          OMNIRUSH_PARENT_SESSION: options.parentSessionId,
-        },
+        // 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.
+        env: childEnvironment(task, options.parentSessionId, { ...process.env, ...childAuthEnvSafe() }),
       });
 
       const finish = (input: ChildResultInput) => {
@@ -396,7 +501,7 @@ export async function runChildAgent(
         if (options.signal && abortHandler) {
           options.signal.removeEventListener("abort", abortHandler);
         }
-        resolvePromise(buildChildResult(task, input, now() - startedAt, sessionId));
+        resolvePromise(buildChildResult(task, { ...input, ...(gatewayFallback ? { gatewayFallback } : {}) }, now() - startedAt, sessionId));
       };
 
       const killTree = () => {
@@ -473,7 +578,12 @@ export async function runChildAgent(
         options.onChildStdout?.(task.role, text);
       });
       child.stderr?.on("data", (chunk: Buffer | string) => {
-        stderr += String(chunk);
+        const text = String(chunk);
+        // The child's gateway guard reports a move to the main model here.
+        const lines = (pendingErrLine + text).split("\n");
+        pendingErrLine = lines.pop() ?? "";
+        for (const line of lines) gatewayFallback = parseFallbackMarker(line) ?? gatewayFallback;
+        stderr += text;
         if (stderr.length > 256 * 1024) stderr = stderr.slice(-64 * 1024);
         alive();
       });
@@ -518,6 +628,44 @@ function formatMinutes(ms: number): string {
   return `${Math.max(1, Math.round(ms / 1000))} s`;
 }
 
+/**
+ * A child's environment: the parent's, the parent session id (the child
+ * uploads nothing itself), the sub-agent setting and main model handed down
+ * to nested layers, and the main model its gateway guard falls back to (only
+ * for this child: a nested one gets its own or none).
+ */
+export function childEnvironment(task: ChildTask, parentSessionId: string, base: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv {
+  const env: NodeJS.ProcessEnv = { ...base, ...(task.env ?? {}), OMNIRUSH_PARENT_SESSION: parentSessionId };
+  // Guarded mode: the name the parent's approval prompt shows for this child.
+  const oneLine = task.task.replace(/\s+/g, " ").trim();
+  env.OMNIRUSH_SUBAGENT_LABEL = `${ROLE_PRESETS[task.role]?.label ?? task.role}: ${oneLine.length > 60 ? `${oneLine.slice(0, 59)}…` : oneLine}`;
+  delete env[ENV_FALLBACK_MODEL];
+  delete env[ENV_FALLBACK_EFFORT];
+  if (task.gatewayFallback?.model) {
+    env[ENV_FALLBACK_MODEL] = task.gatewayFallback.model;
+    if (task.gatewayFallback.effort) env[ENV_FALLBACK_EFFORT] = task.gatewayFallback.effort;
+  }
+  return env;
+}
+
+/** A child's stderr line reporting its gateway fallback (see sota.ts), or null. */
+export function parseFallbackMarker(line: string): ChildResultInput["gatewayFallback"] | null {
+  const at = line.indexOf(FALLBACK_MARKER);
+  if (at < 0) return null;
+  try {
+    const parsed = JSON.parse(line.slice(at + FALLBACK_MARKER.length));
+    if (typeof parsed?.requested !== "string" || typeof parsed?.used !== "string") return null;
+    return {
+      requested: parsed.requested,
+      used: parsed.used,
+      effort: typeof parsed.effort === "string" ? parsed.effort : null,
+      reason: typeof parsed.reason === "string" ? parsed.reason : "refused",
+    };
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Run tasks with a concurrency cap, preserving input order in the
  * results (ports the pi subagent example's mapWithConcurrencyLimit).
@@ -547,8 +695,12 @@ export function renderChildResults(results: ChildResult[], ids?: readonly string
   const succeeded = results.filter((result) => result.status === "completed").length;
   const sections = results.map((result, index) => {
     const minutes = Math.round((result.durationMs / 60_000) * 10) / 10;
-    const header = `### ${ids?.[index] ? `${ids[index]} ` : ""}${result.role}${result.model ? ` [${result.model}]` : ""} — ${result.status} (${minutes} min${result.outputTruncated ? ", output capped" : ""})`;
+    const ranOn = result.model_fallback?.kind === "gateway" ? result.model_fallback.used : result.model;
+    const effort = result.model_fallback?.kind === "gateway" ? result.model_fallback.effort ?? undefined : result.effort;
+    const label = ranOn ? ` [${ranOn}${effort ? ` · ${effort}` : ""}]` : "";
+    const header = `### ${ids?.[index] ? `${ids[index]} ` : ""}${result.role}${label} — ${result.status} (${minutes} min${result.outputTruncated ? ", output capped" : ""})`;
     const meta: string[] = [`task: ${result.task}`];
+    if (result.model_fallback) meta.push(`note: ${result.model_fallback.note}`);
     if (result.error) meta.push(`error: ${result.error}`);
     return `${header}\n${meta.join("\n")}\n\n${result.output || "(no output)"}`;
   });
@@ -571,8 +723,11 @@ export interface AgentRecord {
   role: AgentRole;
   task: string;
   model?: string;
+  effort?: 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 +766,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 +784,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 +792,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(
@@ -660,7 +819,9 @@ export class AgentManager {
         role: task.role,
         task: task.task,
         ...(task.model ? { model: task.model } : {}),
+        ...(task.effort ? { effort: task.effort } : {}),
         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 +840,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 +860,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 +874,8 @@ export class AgentManager {
           record.lastActivityAt = activity.at;
           record.turns = activity.turns;
           record.toolsRunning = activity.toolsRunning;
+          this.onChanged();
+          options.onChanged?.();
         },
       });
     } catch (error) {
@@ -730,6 +897,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 +1043,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.";
@@ -880,7 +1065,7 @@ export function renderAgentStatus(records: AgentRecord[], now: number = Date.now
     const since = record.startedAt ?? record.queuedAt;
     const elapsed = minutesOf((record.finishedAt ?? now) - since);
     const bits = [`${record.id}`, `[${record.status}]`, record.role];
-    if (record.model) bits.push(`[${record.model}]`);
+    if (record.model) bits.push(`[${record.model}${record.effort ? ` · ${record.effort}` : ""}]`);
     bits.push(record.background ? "background" : "blocking");
     const detail: string[] = [`${elapsed} min`];
     if (!record.result && record.startedAt) {
@@ -892,8 +1077,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. */