omnirush 0.8.6 → 0.9.1

package/assets/extensions/omnirush/pi-engine.ts

@@ -17,7 +17,11 @@
 //
 //   user message            -> user message: text parts, image file parts
 //                              (bytes not embedded, as the desktop's
-//                              engine.request records attachments)
+//                              engine.request records attachments); one
+//                              the user did not submit (a sub-agent's task,
+//                              an extension's sendUserMessage: the caller's
+//                              `injectedPrompts`) has synthetic text parts,
+//                              so it never becomes a turn's prompt
 //   assistant message       -> assistant message: step-start, reasoning
 //                              (the model's thinking), text and tool parts
 //                              in the model's order, a patch part for the
@@ -33,6 +37,10 @@
 //                              a command the user ran)
 //   custom / branch summary -> user message with synthetic text parts (what
 //                              the model was shown; never a turn opener)
+//   background command      -> the delivery message as above, answered by an
+//     results (bgshell.ts)     assistant message holding one bash tool part
+//                              per finished command (its output and exit
+//                              code; no model step, no tokens)
 //   compaction              -> user message with a compaction part and the
 //                              summary as an assistant `summary` message
 //   system prompt           -> not a message (the desktop records it in
@@ -49,6 +57,17 @@
 import { createHash } from "node:crypto";
 import { isAbsolute, resolve } from "node:path";
 
+/** customType of bgshell.ts's finished-background-command message. */
+export const BACKGROUND_BASH_TYPE = "omnirush-bash-result";
+/**
+ * customType of the entry a sub-agent process writes at the start of its
+ * own session (data: `{parent_session_id}`): the session is a sub-agent's,
+ * and its first user message is the task the parent agent wrote.
+ */
+export const SUBAGENT_ENTRY_TYPE = "omnirush-subagent";
+/** A sub-agent's prompt: the task the parent agent wrote, after this prefix (agents-lib.ts buildChildArgs). */
+export const SUBAGENT_TASK_PREFIX = "Task: ";
+
 export type EngineMessage = { info: Record<string, unknown>; parts: Array<Record<string, unknown>> };
 
 /** One pi session entry (loosely typed: the files are parsed without validation). */
@@ -80,6 +99,13 @@ export type EngineConvertOptions = {
    * `--model <id>:<effort>` flag of a resumed session.
    */
   promptSettings?: ReadonlyMap<string, { model?: { providerID: string; modelID: string } | null; variant?: string | null }>;
+  /**
+   * User entries (by id) whose text the user did not submit, with the
+   * metadata their synthetic text parts carry: the task a parent agent gave
+   * a sub-agent whose session is continued as a main session, a prompt an
+   * extension sent. The viewer never takes them for a prompt.
+   */
+  injectedPrompts?: ReadonlyMap<string, Record<string, unknown>>;
 };
 
 /** The shell-command marker the engine writes on a user message holding a command the user ran (public_trace.py `_USER_SHELL_TEXT`). */
@@ -295,6 +321,60 @@ export function engineMessagesFromEntries(entries: readonly PiEntry[], options:
     return messageVariant ?? null;
   };
 
+  /**
+   * Finished background shell commands (bgshell.ts delivery): their output
+   * as bash tool parts, the way the engine records a command the user ran.
+   */
+  const backgroundBash = (parentId: string, entryId: string, details: unknown, at: number | null, index: number): void => {
+    const jobs = isRecord(details) && Array.isArray(details.jobs) ? details.jobs.filter(isRecord) : [];
+    if (jobs.length === 0) return;
+    const shellId = engineMessageId(entryId, "_bash");
+    const shellModel = model ?? nextAssistantModel.get(index) ?? null;
+    const time = at ?? 0;
+    const parts: Array<Record<string, unknown>> = jobs.map((job, jobIndex) => {
+      const start = typeof job.started_at === "number" ? job.started_at : time;
+      const end = typeof job.finished_at === "number" ? job.finished_at : time;
+      const failed = job.status === "failed";
+      return {
+        type: "tool",
+        callID: `bg_${typeof job.id === "string" ? job.id : jobIndex}_${entryId}`,
+        tool: "bash",
+        state: {
+          status: failed ? "error" : "completed",
+          input: { command: typeof job.command === "string" ? job.command : "", background_id: job.id ?? null },
+          ...(failed ? { error: typeof job.error === "string" ? job.error : "failed" } : {}),
+          output: typeof job.output === "string" ? job.output : "",
+          metadata: {
+            background: true,
+            ...(typeof job.exit_code === "number" ? { exit: job.exit_code } : {}),
+            ...(typeof job.status === "string" ? { status: job.status } : {}),
+            ...(job.interrupted === true ? { interrupted: true } : {}),
+            ...(job.truncated === true ? { truncated: true } : {}),
+            ...(typeof job.tool_call_id === "string" ? { startedBy: job.tool_call_id } : {}),
+          },
+          time: { start, end },
+        },
+      };
+    });
+    out.push({
+      info: {
+        id: shellId,
+        sessionID: sessionId,
+        role: "assistant",
+        parentID: parentId,
+        time: { created: time, completed: time },
+        ...(shellModel ? { modelID: shellModel.modelID, providerID: shellModel.providerID } : {}),
+        agent,
+        mode: agent,
+        path: { cwd, root: cwd },
+        cost: 0,
+        tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+        finish: "stop",
+      },
+      parts: parts.map((part, partIndex) => ({ id: partId(shellId, partIndex), sessionID: sessionId, messageID: shellId, ...part })),
+    });
+  };
+
   entries.forEach((entry, index) => {
     const entryId = typeof entry.id === "string" && entry.id ? entry.id : null;
     if (!entryId) return;
@@ -340,7 +420,9 @@ export function engineMessagesFromEntries(entries: readonly PiEntry[], options:
     }
     if (entry.type === "custom_message") {
       const parts = contentParts(entry.content, { synthetic: true, metadata: { customType: entry.customType ?? null } });
-      if (parts.length > 0) userMessage(engineMessageId(entryId), at, parts, index);
+      const id = engineMessageId(entryId);
+      if (parts.length > 0) userMessage(id, at, parts, index);
+      if (entry.customType === BACKGROUND_BASH_TYPE) backgroundBash(id, entryId, (entry as any).details, at, index);
       return;
     }
     if (entry.type !== "message" || !isRecord(entry.message)) return;
@@ -349,13 +431,15 @@ export function engineMessagesFromEntries(entries: readonly PiEntry[], options:
     const created = epochMs(message.timestamp) ?? at;
     switch (message.role) {
       case "user": {
-        const parts = contentParts(message.content);
+        const injected = options.injectedPrompts?.get(entryId);
+        const parts = contentParts(message.content, injected ? { synthetic: true, metadata: { ...injected } } : {});
         if (parts.length > 0) turnVariant = userMessage(id, created, parts, index);
         return;
       }
       case "custom": {
         const parts = contentParts(message.content, { synthetic: true, metadata: { customType: message.customType ?? null } });
         if (parts.length > 0) userMessage(id, created, parts, index);
+        if (message.customType === BACKGROUND_BASH_TYPE) backgroundBash(id, entryId, message.details, created, index);
         return;
       }
       case "branchSummary":
@@ -509,6 +593,34 @@ export function engineMessagesFromEntries(entries: readonly PiEntry[], options:
   return out;
 }
 
+/** The text of a pi user message (its text blocks). */
+export function userText(message: Record<string, any> | undefined): string {
+  return message ? contentText(message.content) : "";
+}
+
+/**
+ * The first user message of a branch when it may be a sub-agent's task
+ * (the session is a sub-agent's, opened as a main session by `--continue`,
+ * `--resume` or `--session`): `marked` when the sub-agent's own marker
+ * entry comes before it (then `parentSessionId` is known), else when its
+ * text has the task prefix, for the caller to confirm (sessions of
+ * sub-agents that wrote no marker). Null for any other session.
+ */
+export function subagentTask(entries: readonly PiEntry[]): { entryId: string; marked: boolean; parentSessionId: string | null } | null {
+  let marker: PiEntry | null = null;
+  for (const entry of entries) {
+    if (entry.type === "custom" && entry.customType === SUBAGENT_ENTRY_TYPE) marker ??= entry;
+    if (entry.type !== "message" || !isRecord(entry.message) || entry.message.role !== "user") continue;
+    if (typeof entry.id !== "string" || !entry.id) return null;
+    if (marker) {
+      const parent = isRecord(marker.data) && typeof marker.data.parent_session_id === "string" ? marker.data.parent_session_id : null;
+      return { entryId: entry.id, marked: true, parentSessionId: parent };
+    }
+    return userText(entry.message).startsWith(SUBAGENT_TASK_PREFIX) ? { entryId: entry.id, marked: false, parentSessionId: null } : null;
+  }
+  return null;
+}
+
 /** The active branch of a pi session file's entries: from the last entry up its parent chain. */
 export function branchOfEntries(entries: readonly PiEntry[]): PiEntry[] {
   const withIds = entries.filter((entry) => entry.type !== "session" && typeof entry.id === "string");

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

@@ -16,6 +16,9 @@ export interface PlanFile {
   schema_version: 1;
   items: PlanItem[];
   updated_at: string;
+  /** The session that wrote it (a new session in the same folder does
+   *  not pick up another session's list). Absent in older files. */
+  session_id?: string;
 }
 
 export const PLAN_MAX_ITEMS = 50;
@@ -66,19 +69,44 @@ function clip(text: string, max: number): string {
   return text.length > max ? `${text.slice(0, max - 1)}…` : text;
 }
 
+/** Non-plan tool calls after which an untouched list reads as stale. */
+export const PLAN_STALE_TOOL_CALLS = 25;
+
+/**
+ * How current the list is, for the footer:
+ *   - "active": updated during the running request,
+ *   - "idle":   no request running, or the list is left over from an
+ *               earlier request (restored on resume / not touched since).
+ */
+export type PlanFooterPhase = "active" | "idle";
+
+export interface PlanFooterOptions {
+  phase?: PlanFooterPhase;
+  /** Non-plan tool calls since the last plan update. */
+  toolCallsSinceUpdate?: number;
+}
+
 /**
- * One-line footer for ctx.ui.setStatus, e.g.
- *   "plan 2/5 · ▸ wire tests"
- * or "plan 4/5 done". Null when there is nothing to show.
+ * One-line footer for ctx.ui.setStatus. It reads as a checklist (never
+ * as a mode — the footer's status line also carries "guarded"/"yolo"
+ * right before it), e.g.
+ *   "tasks 2/5 · ▸ wire tests"                     (being worked on)
+ *   "tasks 2/5 · not updated for 30 tool calls"    (stale while working)
+ *   "tasks 2/5 · idle"                             (between requests)
+ * Null when there is nothing to show — including a finished list.
  */
-export function renderPlanFooter(items: PlanItem[]): string | null {
+export function renderPlanFooter(items: PlanItem[] | null, options: PlanFooterOptions = {}): string | null {
   if (!Array.isArray(items) || items.length === 0) return null;
   const { done, total, current } = planProgress(items);
+  if (done === total) return null;
+  const head = `tasks ${done}/${total}`;
+  if ((options.phase ?? "active") === "idle") return `${head} · idle`;
+  const since = options.toolCallsSinceUpdate ?? 0;
+  if (since >= PLAN_STALE_TOOL_CALLS) return `${head} · not updated for ${since} tool calls`;
   // The ▸ task is the in-progress one, falling back to the first
   // not-done item (what is next up).
   const pointed = current ?? items.find((item) => item.status !== "done")?.title ?? null;
-  if (pointed) return `plan ${done}/${total} · ▸ ${clip(pointed, 60)}`;
-  return `plan ${done}/${total} done`;
+  return pointed ? `${head} · ▸ ${clip(pointed, 60)}` : head;
 }
 
 /**
@@ -94,8 +122,8 @@ export function renderPlanItems(items: PlanItem[]): string {
   return `${lines.join("\n")}\n\n${done}/${total} done`;
 }
 
-export function buildPlanFile(items: PlanItem[], updatedAt: string): PlanFile {
-  return { schema_version: 1, items, updated_at: updatedAt };
+export function buildPlanFile(items: PlanItem[], updatedAt: string, sessionId?: string): PlanFile {
+  return { schema_version: 1, items, updated_at: updatedAt, ...(sessionId ? { session_id: sessionId } : {}) };
 }
 
 /** Parse a persisted plan.json, returning null on anything unusable. */
@@ -106,7 +134,8 @@ export function parsePlanFile(text: string): PlanFile | null {
     const items = normalizePlanItems(parsed.items);
     if (!items) return null;
     const updatedAt = typeof parsed.updated_at === "string" ? parsed.updated_at : "";
-    return { schema_version: 1, items, updated_at: updatedAt };
+    const sessionId = typeof parsed.session_id === "string" && parsed.session_id ? parsed.session_id : undefined;
+    return { schema_version: 1, items, updated_at: updatedAt, ...(sessionId ? { session_id: sessionId } : {}) };
   } catch {
     return null;
   }

package/assets/extensions/omnirush/plan.ts

@@ -7,9 +7,16 @@
 //   - appends an `omnirush.plan` custom entry to the session JSONL (the
 //     tool call itself, with the whole list, reaches the trace as a tool
 //     part of the session's engine messages),
-//   - renders one line in the footer via ctx.ui.setStatus,
+//   - renders one line in the footer via ctx.ui.setStatus ("tasks 1/3 ·
+//     ▸ …": a checklist, never a mode), marked idle between requests and
+//     stale when the agent keeps working without updating it; a finished
+//     list clears,
 //   - returns the full list as the tool result.
 //
+// A sub-agent (OMNIRUSH_PARENT_SESSION set) runs in its parent's folder:
+// it keeps its list in its own session only, so it never overwrites the
+// parent's plan.json.
+//
 // Full-replace semantics (like codex update_plan): every call sends
 // the WHOLE list with current statuses.
 
@@ -27,6 +34,7 @@ import {
   planProgress,
   renderPlanFooter,
   renderPlanItems,
+  type PlanFooterPhase,
   type PlanItem,
 } from "./plan-lib";
 
@@ -42,7 +50,7 @@ const PlanParams = Type.Object({
     Type.Object({
       title: Type.String({ description: "Short task title (imperative, e.g. 'add failing test first')" }),
       status: Type.Optional(StringEnum(["pending", "in-progress", "done"] as const, {
-        description: "Task status; defaults to pending. Exactly one item should be in-progress while working.",
+        description: "Task status; defaults to pending. Exactly one item should be in-progress while working; mark it done as soon as it is finished.",
       })),
     }),
     { description: "The FULL ordered task list with current statuses (replaces the previous plan)" },
@@ -50,10 +58,21 @@ const PlanParams = Type.Object({
 });
 
 export default function (pi: ExtensionAPI) {
-  /** Show the footer for a plan (or clear it when the plan is gone). */
-  const showFooter = (items: PlanItem[] | null, ctx: any) => {
+  // Footer state: the latest list, whether it was updated during the
+  // running request ("active") or is left over ("idle"), and how many
+  // other tool calls ran since its last update.
+  let items: PlanItem[] | null = null;
+  let phase: PlanFooterPhase = "idle";
+  let toolCallsSinceUpdate = 0;
+  let lastLine: string | null | undefined;
+  let lastCtx: any = null;
+
+  const showFooter = (ctx: any = lastCtx) => {
+    if (ctx) lastCtx = ctx;
+    const line = renderPlanFooter(items, { phase, toolCallsSinceUpdate });
+    if (line === lastLine) return;
+    lastLine = line;
     try {
-      const line = items ? renderPlanFooter(items) : null;
       ctx?.ui?.setStatus?.(PLAN_STATUS_KEY, line ?? undefined);
     } catch {
       /* non-TUI host */
@@ -62,55 +81,84 @@ export default function (pi: ExtensionAPI) {
 
   pi.registerTool({
     name: PLAN_TOOL_NAME,
-    label: "Plan",
+    label: "Tasks",
     description: [
-      "Maintain the ordered task list for the current work (todo list).",
-      "Send the FULL list with current statuses every time; keep exactly one item in-progress while working and mark items done as you complete them.",
-      "The list persists for the session and is visible to the user in the footer.",
+      "Maintain the ordered task list (todo list) for the current request.",
+      "Send the FULL list with current statuses every time.",
+      "Keep it current while you work: mark an item in-progress when you start it and done as soon as it is finished (not all at the end), and send the final list when the work is complete.",
+      "The user sees the list's progress in the footer.",
     ].join(" "),
     promptSnippet: "plan: maintain an ordered task list (todo) with statuses",
     promptGuidelines: [
-      "Use plan for multi-step work (3+ steps or user-requested tracking): send the full task list before starting, mark items done as you finish them, and keep exactly one item in-progress.",
+      "Use plan for multi-step work (3+ steps or user-requested tracking): send the full task list before starting, then update it as you go — mark each item done when you finish it and the next one in-progress, keeping exactly one item in-progress.",
+      "Before you end your reply, send the final list (every finished item done); drop items you decided not to do.",
       "Do not use plan for single trivial actions.",
     ],
     parameters: PlanParams,
 
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const items = normalizePlanItems(params.items);
-      if (!items) {
+      const next = normalizePlanItems(params.items);
+      if (!next) {
         throw new Error(
           "invalid plan items: provide a non-empty array of {title, status} objects (status pending | in-progress | done)",
         );
       }
       const updatedAt = new Date().toISOString();
       const cwd = ctx?.cwd ? resolve(ctx.cwd) : process.cwd();
-      try {
-        const planPath = join(cwd, AGENT_DIR, "plan.json");
-        await mkdir(dirname(planPath), { recursive: true });
-        await writeFile(planPath, JSON.stringify(buildPlanFile(items, updatedAt), null, 2) + "\n", "utf8");
-      } catch {
-        // Persistence is best effort: the session entry + footer still
-        // carry the plan (and the tool result returns it).
+      if (!isSubagent()) {
+        try {
+          const planPath = join(cwd, AGENT_DIR, "plan.json");
+          const sessionId = String(ctx?.sessionManager?.getSessionId?.() ?? "") || undefined;
+          await mkdir(dirname(planPath), { recursive: true });
+          await writeFile(planPath, JSON.stringify(buildPlanFile(next, updatedAt, sessionId), null, 2) + "\n", "utf8");
+        } catch {
+          // Persistence is best effort: the session entry + footer still
+          // carry the plan (and the tool result returns it).
+        }
       }
       try {
-        pi.appendEntry(PLAN_ENTRY_TYPE, { items, updated_at: updatedAt });
+        pi.appendEntry(PLAN_ENTRY_TYPE, { items: next, updated_at: updatedAt });
       } catch {
         /* sessions may be unavailable in some hosts */
       }
-      showFooter(items, ctx);
-      const { done, total } = planProgress(items);
+      items = next;
+      phase = "active";
+      toolCallsSinceUpdate = 0;
+      showFooter(ctx);
+      const { done, total } = planProgress(next);
+      const reminder = done < total
+        ? "\nKeep this list current: mark each item done as soon as it is finished and the next one in-progress."
+        : "";
       return {
-        content: [{ type: "text", text: renderPlanItems(items) }],
-        details: { done, total, items },
+        content: [{ type: "text", text: renderPlanItems(next) + reminder }],
+        details: { done, total, items: next },
       };
     },
   });
 
-  // Restore the footer after reload/resume: the session's latest plan
-  // entry wins, falling back to the persisted plan.json.
+  // Other tool calls age the list: after enough of them without an
+  // update the footer stops pointing at a task as if it were current.
+  pi.on("tool_execution_end", (event: any, ctx: any) => {
+    if (!items || event?.toolName === PLAN_TOOL_NAME) return;
+    toolCallsSinceUpdate += 1;
+    showFooter(ctx);
+  });
+
+  // The request is over: an unfinished list is shown as idle (a finished
+  // one is already cleared) until the model updates it again.
+  pi.on("agent_end", (_event: any, ctx: any) => {
+    phase = "idle";
+    showFooter(ctx);
+  });
+
+  // Restore after reload/resume from THIS session's latest plan entry
+  // (a new session starts with no list, even when the folder still holds
+  // another session's plan.json). Restored lists are idle.
   pi.on("session_start", async (_event: any, ctx: any) => {
+    items = null;
+    phase = "idle";
+    toolCallsSinceUpdate = 0;
     try {
-      let items: PlanItem[] | null = null;
       const entries = ctx?.sessionManager?.getEntries?.() ?? [];
       for (let index = entries.length - 1; index >= 0; index -= 1) {
         const entry = entries[index];
@@ -119,17 +167,24 @@ export default function (pi: ExtensionAPI) {
           if (items) break;
         }
       }
-      if (!items && ctx?.cwd) {
+      const sessionId = String(ctx?.sessionManager?.getSessionId?.() ?? "");
+      if (!items && sessionId && ctx?.cwd) {
         try {
           const text = await readFile(join(resolve(ctx.cwd), AGENT_DIR, "plan.json"), "utf8");
-          items = parsePlanFile(text)?.items ?? null;
+          const file = parsePlanFile(text);
+          if (file?.session_id === sessionId) items = file.items;
         } catch {
           /* no persisted plan */
         }
       }
-      showFooter(items, ctx);
     } catch {
       /* footer is cosmetic */
     }
+    lastLine = undefined;
+    showFooter(ctx);
   });
 }
+
+function isSubagent(): boolean {
+  return Boolean((process.env.OMNIRUSH_PARENT_SESSION || "").trim());
+}

package/assets/extensions/omnirush/sota.ts

@@ -41,6 +41,14 @@ import {
   streamIdleMs,
   withStallWatchdog,
 } from "./sota-lib";
+import { omniDir } from "./auth";
+import {
+  ENV_FALLBACK_EFFORT,
+  ENV_FALLBACK_MODEL,
+  FALLBACK_MARKER,
+  subagentFallbackFetch,
+  type FallbackRoute,
+} from "./subagents-lib";
 import {
   formatUnavailableSummary,
   isRetryableStatus,
@@ -222,7 +230,7 @@ async function readErrorBody(response: any): Promise<string> {
  */
 function tapFetch(
   baseFetch: any,
-  expectedModelId: string,
+  expectedModel: string | (() => string),
   onViolation: (expected: string, served: string) => void,
   idleMs: number,
 ): any {
@@ -356,6 +364,8 @@ function tapFetch(
       const onData = (data: string) => {
         if (reported) return;
         const served = servedModelFromSseData(data);
+        // A sub-agent moved to the main model expects that one.
+        const expectedModelId = typeof expectedModel === "function" ? expectedModel() : expectedModel;
         if (served === undefined || !isSotaViolation(expectedModelId, served)) return;
         reported = true;
         onViolation(expectedModelId, served);
@@ -390,22 +400,60 @@ export default function (pi: any) {
   const responses = openAIResponsesApi();
   const strictSota = (): boolean => pi.getFlag("strict-sota") === true;
 
+  // A sub-agent on a picked model: the main model it falls back to when the
+  // gateway refuses the picked one (set by the parent's spawn_agents).
+  const fallbackModel = (process.env[ENV_FALLBACK_MODEL] || "").trim();
+  const fallbackEffort = (process.env[ENV_FALLBACK_EFFORT] || "").trim() || null;
+
   const streamWith =
     (simple: boolean) =>
     (model: any, context: any, options: any) => {
-      const baseFetch = options?.fetch ?? globalThis.fetch;
+      let baseFetch = options?.fetch ?? globalThis.fetch;
+      const route: FallbackRoute = { expected: model.id, movedTo: null };
+      if (fallbackModel && fallbackModel !== model.id) {
+        baseFetch = subagentFallbackFetch(baseFetch, {
+          model: fallbackModel,
+          effort: fallbackEffort,
+          dir: omniDir(),
+          route,
+          report: (event) => {
+            // The parent's spawn_agents reads this line from the child's stderr.
+            try {
+              process.stderr.write(`\n${FALLBACK_MARKER}${JSON.stringify(event)}\n`);
+            } catch {
+              /* stderr may be closed */
+            }
+          },
+        });
+      }
       const tapped = {
         ...(options ?? {}),
         fetch: tapFetch(
           baseFetch,
-          model.id,
+          () => route.expected,
           (expected, served) => reportViolation(strictSota(), expected, served),
           streamIdleMs(process.env.OMNIRUSH_STREAM_IDLE_MS, options?.timeoutMs),
         ),
       };
-      return simple
+      const stream = simple
         ? responses.streamSimple(model, context, tapped)
         : responses.stream(model, context, tapped);
+      if (fallbackModel && stream && typeof stream.push === "function") {
+        // The message records the model (and effort) that really answered.
+        const push = stream.push.bind(stream);
+        stream.push = (event: any) => {
+          if (route.movedTo) {
+            for (const message of [event?.partial, event?.message, event?.error]) {
+              if (message && typeof message === "object" && message.role === "assistant") {
+                message.model = route.movedTo.model;
+                if (route.movedTo.effort) message.providerThinkingLevel = route.movedTo.effort;
+              }
+            }
+          }
+          return push(event);
+        };
+      }
+      return stream;
     };
 
   pi.registerProvider({

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

@@ -52,6 +52,8 @@ export interface StatusInput {
   origin: string;
   /** omnirush CLI version ("unknown" when not provided by the launcher). */
   version: string;
+  /** The approval mode line (yolo-lib formatModeStatus), when known. */
+  yolo?: string | null;
 }
 
 /**
@@ -79,6 +81,7 @@ export function formatStatusLines(input: StatusInput): string[] {
   }
 
   lines.push(formatCollectorLine(input.collector));
+  if (input.yolo) lines.push(input.yolo);
   lines.push(`manager: ${input.origin}`);
   lines.push(`version: ${input.version}`);
   return lines;

package/assets/extensions/omnirush/subagent-marker.ts

@@ -0,0 +1,21 @@
+// A sub-agent process (spawn_agents sets OMNIRUSH_PARENT_SESSION) marks its
+// own session with an `omnirush-subagent` entry naming its parent, before
+// the task: should that session ever be continued as a main session, its
+// first prompt is known to be the parent agent's (collector.ts records it
+// as synthetic). Kept out of collector.ts because sub-agent processes do
+// not load the collector (index.ts keeps children light).
+
+import { SUBAGENT_ENTRY_TYPE } from "./pi-engine";
+
+export default function markSubagentSession(pi: any, parentSession: string = (process.env.OMNIRUSH_PARENT_SESSION || "").trim()): void {
+  if (!parentSession) return;
+  pi.on("session_start", (_event: any, ctx: any) => {
+    try {
+      const entries = ctx?.sessionManager?.getEntries?.() ?? [];
+      if (entries.some((entry: any) => entry?.type === "custom" && entry.customType === SUBAGENT_ENTRY_TYPE)) return;
+      pi.appendEntry(SUBAGENT_ENTRY_TYPE, { parent_session_id: parentSession });
+    } catch {
+      /* never in the child's way */
+    }
+  });
+}