omnirush 0.8.6 → 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/extensions/omnirush/agents-lib.ts

@@ -28,7 +28,16 @@ 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> {
@@ -164,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.
@@ -177,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;
 }
@@ -207,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";
@@ -218,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;
@@ -237,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. */
@@ -253,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,
@@ -392,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;
@@ -411,14 +487,10 @@ export async function runChildAgent(
         cwd: options.cwd,
         shell: false,
         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,
-        },
+        // 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) => {
@@ -429,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 = () => {
@@ -506,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();
       });
@@ -551,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).
@@ -580,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)"}`;
   });
@@ -604,6 +723,7 @@ 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. */
@@ -699,6 +819,7 @@ 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",
@@ -944,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) {

package/assets/extensions/omnirush/agents.ts

@@ -36,6 +36,8 @@ 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,
@@ -48,11 +50,12 @@ import {
   renderAgentStatus,
   renderChildResults,
   renderDelivery,
-  modelSelectionFromContext,
   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;
@@ -68,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: '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: '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 },
@@ -108,19 +111,14 @@ function renderSome(records: AgentRecord[], unknown: string[] = []): string {
 
 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();
-  let inheritedModel = "";
+  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;
-  /** 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;
+    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));
@@ -132,31 +130,9 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {})
     statusTimer.unref?.();
   }
 
-  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" },
-    );
-  };
-
-  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);
-  };
-
   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,
@@ -164,10 +140,21 @@ 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 = {
     async interruptAll(parentSessionId?: string) {
       const stopped = await manager.interruptAll(parentSessionId);
@@ -177,17 +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 && 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;
+    return hub.sessionOf(ctx);
   };
 
   pi.registerTool({
@@ -212,6 +190,7 @@ 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,
 
@@ -222,16 +201,22 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {})
         if (!raw || typeof raw.task !== "string" || !raw.task.trim()) {
           throw new Error("invalid tasks: every entry needs a non-empty task string");
         }
-        // An omitted model inherits the live parent selection. Explicit task
-        // models remain available for deliberate mixed-model swarms.
+        // 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(),
-          ...((requestedModel || inheritedModel) ? { model: requestedModel || inheritedModel } : {}),
+          ...(requestedModel ? { model: requestedModel } : {}),
         });
       }
       if (tasks.length === 0) throw new Error("no tasks given");
+      // 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
@@ -247,7 +232,7 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {})
         : undefined;
       const background = params.wait === false;
 
-      const dispatched = manager.dispatch(parentSessionId, tasks, {
+      const dispatched = manager.dispatch(parentSessionId, resolvedTasks, {
         background,
         concurrency,
         notify: params.notify === "each" ? "each" : "batch",
@@ -271,7 +256,10 @@ export default function (pi: ExtensionAPI, options: { run?: AgentRunner } = {})
       });
 
       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",
@@ -288,15 +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 } : {}),
-              parallel_limit: record.parallelLimit,
-              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",
+              };
+            }),
           },
         };
       }
@@ -404,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).