omnirush 0.8.6 → 0.9.1

package/assets/extensions/omnirush/collector.ts

@@ -32,10 +32,20 @@
 // session reaches the parent's trace as session.child events, like the
 // desktop's task sub-agents.
 //
+// A turn's prompt is only what the user submitted. A sub-agent process
+// marks its own session (an `omnirush-subagent` entry naming its parent),
+// so when that session is later opened as a main session (`--continue`,
+// `--resume`, `--session`) its first user message, the task the parent
+// agent wrote, is recorded as synthetic; for sub-agents that wrote no
+// marker, the parent session file naming it in a spawn result confirms
+// it. A prompt an extension sends (pi's input event, source "extension")
+// is synthetic too.
+//
 // Silent no-op without device credentials: collection only runs for
 // signed-in omnirush identities.
 
 import { createHash } from "node:crypto";
+import markSubagentSession from "./subagent-marker";
 import { createReadStream, readdirSync, readFileSync, rmSync } from "node:fs";
 import { readdir, stat } from "node:fs/promises";
 import os from "node:os";
@@ -51,13 +61,17 @@ import {
   engineMessagesFromEntries,
   MAX_TURN_MESSAGE_BYTES,
   messageParts,
+  subagentTask,
+  SUBAGENT_ENTRY_TYPE,
   turnHistory,
   turnModelFromMessages,
+  userText,
   type EngineMessage,
   type PiEntry,
 } from "./pi-engine";
 import { sharedRefresher } from "./refresh";
-import { AGENTS_HOOK, type AgentsHook } from "./agents-lib";
+import { AGENTS_HOOK, SUBAGENT_SESSIONS_DIR, type AgentsHook } from "./agents-lib";
+import { BGSHELL_HOOK, type BgShellHook } from "./bgshell-lib";
 
 /** info.agent of the root session's messages (a sub-agent's is its role). */
 export const ROOT_AGENT = "omnirush-cli";
@@ -83,11 +97,12 @@ const SWITCH_BUDGET_MS = 30_000;
  */
 const PRINT_EXIT_GRACE_MS = 2_000;
 
-/** The pi agent config dir: session files live under <dir>/sessions. */
+/** The agent data dir: session files live under <dir>/sessions (the launcher always sets it). */
 function piAgentDir(): string {
-  const override = process.env.PI_CODING_AGENT_DIR || process.env.OMNIRUSH_CODING_AGENT_DIR || "";
+  const override = process.env.OMNIRUSH_CODING_AGENT_DIR || process.env.PI_CODING_AGENT_DIR || "";
   if (override.trim()) return path.resolve(override.trim());
-  return path.join(os.homedir(), ".pi", "agent");
+  const stateDir = (process.env.OMNIRUSH_DIR || "").trim();
+  return path.join(stateDir ? path.resolve(stateDir) : path.join(os.homedir(), ".omnirush"), "agent");
 }
 
 /** pi session ids are UUIDs; the collector refuses anything outside its id alphabet. */
@@ -124,26 +139,68 @@ function removeLegacyJournals(stateDir: string): void {
   }
 }
 
-/** Sub-agents a session started: its spawn_agents results (session id, role, task). */
-export function spawnedChildren(entries: readonly PiEntry[]): Array<{ id: string; role: string | null; task: string | null }> {
-  const children: Array<{ id: string; role: string | null; task: string | null }> = [];
+/** A sub-agent that ran on the main model instead of the picked one (spawn_agents' model_fallback). */
+export type ChildModelFallback = { requested: string; used: string; effort: string | null; reason: string; kind: string; note: string };
+
+/** Tools and messages that report sub-agent results after spawn_agents named them. */
+const CHILD_RESULT_TOOLS = new Set(["agents_wait", "agents_result", "agents_cancel"]);
+const CHILD_RESULT_MESSAGE = "omnirush-agents-result";
+
+function modelFallbackOf(result: any): ChildModelFallback | null {
+  const fallback = result && typeof result.model_fallback === "object" ? result.model_fallback : null;
+  if (!fallback || typeof fallback.requested !== "string" || typeof fallback.used !== "string") return null;
+  return {
+    requested: fallback.requested,
+    used: fallback.used,
+    effort: typeof fallback.effort === "string" ? fallback.effort : null,
+    reason: typeof fallback.reason === "string" ? fallback.reason : "refused",
+    kind: typeof fallback.kind === "string" ? fallback.kind : "selection",
+    note: typeof fallback.note === "string" ? fallback.note : `ran on ${fallback.used}`,
+  };
+}
+
+/**
+ * Sub-agents a session started: its spawn_agents results (session id, role,
+ * task), with the model fallback a later result reported (a background
+ * child's delivery, agents_wait / agents_result) when there is one.
+ */
+export function spawnedChildren(entries: readonly PiEntry[]): Array<{ id: string; role: string | null; task: string | null; modelFallback?: ChildModelFallback }> {
+  const children: Array<{ id: string; role: string | null; task: string | null; modelFallback?: ChildModelFallback }> = [];
   for (const entry of entries) {
     const message = entry.type === "message" ? entry.message : null;
-    if (!message || message.role !== "toolResult" || message.toolName !== "spawn_agents") continue;
-    const results = message.details && Array.isArray(message.details.results) ? message.details.results : [];
+    const spawned = Boolean(message && message.role === "toolResult" && message.toolName === "spawn_agents");
+    const details = spawned
+      ? message!.details
+      : message && message.role === "toolResult" && CHILD_RESULT_TOOLS.has(message.toolName)
+        ? message.details
+        : entry.type === "custom_message" && (entry as any).customType === CHILD_RESULT_MESSAGE
+          ? (entry as any).details
+          : null;
+    const results = details && Array.isArray(details.results) ? details.results : [];
     for (const result of results) {
       const id = result && typeof result.session_id === "string" ? result.session_id : "";
-      if (!sanitizeSessionId(id) || children.some((child) => child.id === id)) continue;
+      if (!sanitizeSessionId(id)) continue;
+      const known = children.find((child) => child.id === id);
+      const modelFallback = modelFallbackOf(result);
+      if (known) {
+        if (modelFallback) known.modelFallback = modelFallback;
+        continue;
+      }
+      if (!spawned) continue;
       children.push({
         id,
         role: typeof result.role === "string" ? result.role : null,
         task: typeof result.task === "string" ? result.task : null,
+        ...(modelFallback ? { modelFallback } : {}),
       });
     }
   }
   return children;
 }
 
+/** Fallbacks already recorded as trace events (root session : child session). */
+const recordedFallbacks = new Set<string>();
+
 /** The session file of `sessionId`: `<ts>_<id>.jsonl` in one of the session dirs. */
 async function findSessionFile(sessionId: string, dirs: readonly string[]): Promise<string | null> {
   for (const dir of dirs) {
@@ -159,6 +216,71 @@ async function findSessionFile(sessionId: string, dirs: readonly string[]): Prom
   return null;
 }
 
+/** Session files read at most when looking for a sub-agent's parent, and for how long. */
+const MAX_PARENT_SCAN_FILES = 64;
+const PARENT_SCAN_BUDGET_MS = 3_000;
+
+/** Whether `file` contains `needle` (streamed in chunks, never held whole). */
+async function fileContains(file: string, needle: string, deadline: number): Promise<boolean> {
+  const input = createReadStream(file, { encoding: "utf8", highWaterMark: 256 * 1024 });
+  let tail = "";
+  try {
+    for await (const chunk of input) {
+      const text = tail + (chunk as string);
+      if (text.includes(needle)) return true;
+      if (Date.now() > deadline) return false;
+      tail = text.slice(-needle.length);
+    }
+  } catch {
+    /* unreadable: not the parent */
+  } finally {
+    input.destroy();
+  }
+  return false;
+}
+
+/**
+ * The session that started sub-agent `childId`: the session file in `dir`
+ * whose spawn_agents (or agents_*) results name it, among the files
+ * written since the sub-agent started (`since`, epoch ms; the newest
+ * first, at most MAX_PARENT_SCAN_FILES, within PARENT_SCAN_BUDGET_MS).
+ */
+export async function findSpawningSession(childId: string, dir: string, since: number): Promise<string | null> {
+  const deadline = Date.now() + PARENT_SCAN_BUDGET_MS;
+  const found = await findSpawningSessionIn(childId, dir, since, deadline);
+  if (found) return found;
+  // A sub-agent session moved into <session dir>/subagents/ (src/sessions.js,
+  // or written there by a newer parent): its parent sits one level up.
+  if (path.basename(dir) === SUBAGENT_SESSIONS_DIR) {
+    return findSpawningSessionIn(childId, path.dirname(dir), since, deadline);
+  }
+  return null;
+}
+
+async function findSpawningSessionIn(childId: string, dir: string, since: number, deadline: number): Promise<string | null> {
+  let names: string[];
+  try {
+    names = await readdir(dir);
+  } catch {
+    return null;
+  }
+  const candidates: Array<{ file: string; id: string; mtime: number }> = [];
+  for (const name of names) {
+    const match = /_([A-Za-z0-9._:-]{8,128})\.jsonl$/.exec(name);
+    if (!match || match[1] === childId) continue;
+    const file = path.join(dir, name);
+    const stats = await stat(file).catch(() => null);
+    if (stats && stats.mtimeMs >= since) candidates.push({ file, id: match[1]!, mtime: stats.mtimeMs });
+  }
+  candidates.sort((a, b) => b.mtime - a.mtime);
+  const needle = `"session_id":${JSON.stringify(childId)}`;
+  for (const candidate of candidates.slice(0, MAX_PARENT_SCAN_FILES)) {
+    if (Date.now() > deadline) break;
+    if (await fileContains(candidate.file, needle, deadline)) return candidate.id;
+  }
+  return null;
+}
+
 /** Parse a session JSONL file without buffering the raw transcript or its line array. */
 export async function parseSessionFileStream(file: string): Promise<{ header: PiEntry | null; entries: PiEntry[] }> {
   let header: PiEntry | null = null;
@@ -209,7 +331,8 @@ export async function captureChildSessions(input: {
   visited: Set<string>;
   /** Unchanged session files are not read again in this process. */
   seenFiles: Map<string, string>;
-  beforeRecord: (bytes: number) => void;
+  /** Before each event is recorded (may wait: the caller flushes and drains the upload queue). */
+  beforeRecord: (bytes: number) => void | Promise<void>;
 }): Promise<void> {
   if (input.depth > MAX_CHILD_DEPTH) return;
   for (const child of spawnedChildren(input.parentEntries).slice(0, MAX_CHILDREN)) {
@@ -233,13 +356,26 @@ export async function captureChildSessions(input: {
     if (history.omitted > 0) {
       input.collector.recordTrace(input.rootSessionId, "session.messages_omitted", { child_session_id: child.id, count: history.omitted });
     }
+    const fallbackKey = `${input.rootSessionId}:${child.id}`;
+    if (child.modelFallback && !recordedFallbacks.has(fallbackKey)) {
+      // As the desktop: the sub-agent ran on the main model, and why.
+      recordedFallbacks.add(fallbackKey);
+      input.collector.recordTrace(input.rootSessionId, "subagent.model_fallback", {
+        child_session_id: child.id,
+        requested: child.modelFallback.requested,
+        used: child.modelFallback.used,
+        effort: child.modelFallback.effort,
+        reason: child.modelFallback.reason,
+        kind: child.modelFallback.kind,
+      });
+    }
     if (history.delta.length > 0 || !input.known.has(child.id)) {
-      input.beforeRecord(history.sizes.reduce((total, bytes) => total + bytes, 0));
+      await input.beforeRecord(history.sizes.reduce((total, bytes) => total + bytes, 0));
       input.collector.recordChildSession(input.rootSessionId, {
         childSessionId: child.id,
         parentSessionId: input.parentSessionId,
         depth: input.depth,
-        title: child.task,
+        title: child.task && child.modelFallback ? `${child.task} (${child.modelFallback.note})` : child.task,
         agent: turnModelFromMessages(messages)?.agent ?? agent,
         messages: history.delta,
         lastMessageId: typeof messages.at(-1)?.info.id === "string" ? (messages.at(-1)!.info.id as string) : null,
@@ -252,7 +388,13 @@ export async function captureChildSessions(input: {
 
 export default function (pi: any) {
   // A sub-agent: the parent session captures it (session.child events).
-  if ((process.env.OMNIRUSH_PARENT_SESSION || "").trim()) return;
+  const parentSession = (process.env.OMNIRUSH_PARENT_SESSION || "").trim();
+  if (parentSession) {
+    // Its session says so (subagent-marker.ts; index.ts loads it for
+    // sub-agent processes, which do not load the collector).
+    markSubagentSession(pi, parentSession);
+    return;
+  }
   const origin = resolveOrigin(process.env);
   const gatewayUrl = process.env.OMNIRUSH_GATEWAY_URL || gatewayUrlForOrigin(origin);
   // The shared auth file is the source of truth (another process may have
@@ -319,7 +461,7 @@ export default function (pi: any) {
     // value is a bare release number); client_version / client_platform are
     // the backend's optional envelope metadata.
     appVersion: version ? `omnirush-cli/${version}` : "omnirush-cli",
-    ...(engineVersion ? { engineVersion: `pi/${engineVersion}` } : {}),
+    ...(engineVersion ? { engineVersion: `omnirush-core/${engineVersion}` } : {}),
     envelopeMetadata: {
       ...(version ? { client_version: version } : {}),
       client_platform: `${process.platform}/${process.arch}`,
@@ -372,21 +514,34 @@ export default function (pi: any) {
     pendingPrompts: Array<{ at: number; model: { providerID: string; modelID: string } | null; variant: string | null }>;
     /** User entry id -> what its prompt was sent with (pi-engine promptSettings). */
     promptSettings: Map<string, { model: { providerID: string; modelID: string } | null; variant: string | null }>;
+    /** Prompts an extension sent (pi's input event, source "extension"), until their user entry is found. */
+    extensionInputs: Array<{ at: number; text: string }>;
+    /** User entries the user did not submit -> their parts' metadata (pi-engine injectedPrompts). */
+    injectedPrompts: Map<string, Record<string, unknown>>;
+    /** Whether the session is a sub-agent's (its first prompt the parent agent's task), once looked up. */
+    origin: Promise<void> | null;
   } | null = null;
   let settling: Promise<void> = Promise.resolve();
 
+  // Where sub-agent session files are looked up: the session's own
+  // subagents/ folder first (where spawn_agents puts them, and where the
+  // launcher moves older releases' children), then the session dirs
+  // themselves (children of releases up to 0.9.0 not moved yet), then
+  // every project's.
   const sessionDirs = (ctx: any): string[] => {
     const dirs: string[] = [];
+    const add = (dir: unknown) => {
+      if (typeof dir !== "string" || !dir) return;
+      for (const candidate of [path.join(dir, SUBAGENT_SESSIONS_DIR), dir]) {
+        if (!dirs.includes(candidate)) dirs.push(candidate);
+      }
+    };
     const file = ctx?.sessionManager?.getSessionFile?.();
-    if (typeof file === "string" && file) dirs.push(path.dirname(file));
-    const sessionDir = ctx?.sessionManager?.getSessionDir?.();
-    if (typeof sessionDir === "string" && sessionDir && !dirs.includes(sessionDir)) dirs.push(sessionDir);
+    if (typeof file === "string" && file) add(path.dirname(file));
+    add(ctx?.sessionManager?.getSessionDir?.());
     try {
       const root = path.join(agentDir, "sessions");
-      for (const name of readdirSync(root)) {
-        const dir = path.join(root, name);
-        if (!dirs.includes(dir)) dirs.push(dir);
-      }
+      for (const name of readdirSync(root)) add(path.join(root, name));
     } catch {
       /* no sessions yet */
     }
@@ -406,7 +561,23 @@ export default function (pi: any) {
       // never wrote a user entry (handled by an extension) is let go.
       else if (pending.at > Date.now() - 60_000) state.pendingPrompts.push(pending);
     }
-    return engineMessagesFromEntries(entries, { sessionId: state.id, agent: ROOT_AGENT, cwd: state.root, toolStarts: state.toolStarts, promptSettings: state.promptSettings });
+    // An extension's prompt is the first user entry with its text written at or after it went out.
+    for (const input of state.extensionInputs.splice(0)) {
+      const entry = entries.find((candidate: any) =>
+        candidate?.type === "message" && candidate.message?.role === "user" && typeof candidate.id === "string"
+        && !state.injectedPrompts.has(candidate.id) && userText(candidate.message) === input.text
+        && Number(candidate.message.timestamp ?? Date.parse(candidate.timestamp)) >= input.at - 1_000);
+      if (entry) state.injectedPrompts.set(entry.id, { source: "extension" });
+      else if (input.at > Date.now() - 60_000) state.extensionInputs.push(input);
+    }
+    return engineMessagesFromEntries(entries, {
+      sessionId: state.id,
+      agent: ROOT_AGENT,
+      cwd: state.root,
+      toolStarts: state.toolStarts,
+      promptSettings: state.promptSettings,
+      injectedPrompts: state.injectedPrompts,
+    });
   };
 
   /**
@@ -419,7 +590,21 @@ export default function (pi: any) {
     if (!id) return null;
     if (session?.id !== id) {
       const root = ctx?.cwd || process.cwd();
-      session = { id, root, ctx, started: false, running: false, lastMessageId: undefined, toolStarts: new Map(), seenFiles: new Map(), pendingPrompts: [], promptSettings: new Map() };
+      session = {
+        id,
+        root,
+        ctx,
+        started: false,
+        running: false,
+        lastMessageId: undefined,
+        toolStarts: new Map(),
+        seenFiles: new Map(),
+        pendingPrompts: [],
+        promptSettings: new Map(),
+        extensionInputs: [],
+        injectedPrompts: new Map(),
+        origin: null,
+      };
     }
     session.ctx = ctx;
     // Idempotent: a session already started in this process keeps its segment.
@@ -435,7 +620,7 @@ export default function (pi: any) {
    * sub-agents keep running past the turn that started them: each later
    * settle (and the session's end) records what they did since.
    */
-  const captureChildren = async (state: NonNullable<typeof session>, room: (bytes: number) => void): Promise<void> => {
+  const captureChildren = async (state: NonNullable<typeof session>, room: (bytes: number) => void | Promise<void>): Promise<void> => {
     const { id } = state;
     try {
       await captureChildSessions({
@@ -456,6 +641,26 @@ export default function (pi: any) {
     }
   };
 
+  /**
+   * Room for the next sub-agent event: once the recorded messages would pass
+   * one flush (MAX_TURN_MESSAGE_BYTES), they flush, and the next child is
+   * read only after that upload went out. A turn with many sub-agents (20
+   * children, MiBs each) used to read and queue all of them at once, holding
+   * every child's messages, their trace documents and envelopes in memory
+   * together.
+   */
+  const childRoom = (id: string) => {
+    let pending = 0;
+    return async (bytes: number): Promise<void> => {
+      if (pending > 0 && pending + bytes > MAX_TURN_MESSAGE_BYTES) {
+        collector.flushTrace(id);
+        pending = 0;
+        await collector.drained(id);
+      }
+      pending += bytes;
+    };
+  };
+
   /**
    * Everything a settled run records, in the desktop observer's order:
    * messages, sub-agents, the idle event, the snapshot, the trace and the
@@ -483,22 +688,17 @@ export default function (pi: any) {
       for (const [index, part] of parts.slice(0, -1).entries()) {
         collector.recordTrace(id, "turn.messages", { messages: part.messages, part: index + 1, parts: parts.length });
         collector.flushTrace(id);
+        // One part waits in memory at a time (a resumed session's backlog is up to 32 MiB).
+        await collector.drained(id);
       }
     } catch (error) {
       collector.recordTrace(id, "session.messages_failed", { error: error instanceof Error ? error.message : "unknown" });
     }
     const newest = parts.at(-1)!;
     // Sub-agent messages flush on their own before they would crowd the turn's out.
-    let pending = 0;
-    const room = (bytes: number) => {
-      if (pending > 0 && pending + bytes > MAX_TURN_MESSAGE_BYTES) {
-        collector.flushTrace(id);
-        pending = 0;
-      }
-      pending += bytes;
-    };
+    const room = childRoom(id);
     await captureChildren(state, room);
-    room(newest.bytes);
+    await room(newest.bytes);
     collector.recordTrace(id, "session.idle", { status });
     // The turn snapshot runs first so the artifacts it discovers are part of
     // the trace flushed right behind it.
@@ -527,6 +727,10 @@ export default function (pi: any) {
     const hook = (globalThis as any)[AGENTS_HOOK] as AgentsHook | undefined;
     const followed = session;
     const interrupted = followed?.started && hook ? await hook.interruptAll(followed.id).catch(() => []) : [];
+    // Background shell commands still running are stopped too; their output
+    // is added to the session as a message, so the last capture keeps it.
+    const shell = (globalThis as any)[BGSHELL_HOOK] as BgShellHook | undefined;
+    if (followed?.started && shell) await shell.stopAll(followed.id).catch(() => []);
     await settleRunning("interrupted");
     const state = session;
     if (!state?.started) return;
@@ -537,14 +741,7 @@ export default function (pi: any) {
     if (typeof lastId !== "string" || lastId === state.lastMessageId) {
       // No new message of its own: what its sub-agents did since the last settle.
       settling = settling.then(async () => {
-        let pending = 0;
-        await captureChildren(state, (bytes) => {
-          if (pending > 0 && pending + bytes > MAX_TURN_MESSAGE_BYTES) {
-            collector.flushTrace(state.id);
-            pending = 0;
-          }
-          pending += bytes;
-        });
+        await captureChildren(state, childRoom(state.id));
         collector.flushTrace(state.id);
       }).catch(() => undefined);
       await settling;
@@ -588,11 +785,45 @@ export default function (pi: any) {
     clearTimeout(budget);
   };
 
+  /**
+   * A session opened as a main session that is a sub-agent's own (its file
+   * sits with the main sessions, so `--continue` or the resume picker can
+   * reopen it): its first prompt is the task the parent agent wrote, not
+   * something the user typed. Looked up once, before the first prompt of
+   * this process is written (every user entry then on the branch came
+   * before this process).
+   */
+  const lookUpOrigin = (state: NonNullable<typeof session>): Promise<void> =>
+    (state.origin ??= (async () => {
+      const entries: PiEntry[] = state.ctx?.sessionManager?.getBranch?.() ?? [];
+      const task = subagentTask(entries);
+      if (!task) return;
+      let parent = task.parentSessionId;
+      if (!task.marked) {
+        // Sub-agents that wrote no marker: the parent session names it.
+        const file = state.ctx?.sessionManager?.getSessionFile?.();
+        const started = Date.parse(String(state.ctx?.sessionManager?.getHeader?.()?.timestamp ?? entries[0]?.timestamp ?? ""));
+        parent = typeof file === "string" && file
+          ? await findSpawningSession(state.id, path.dirname(file), Number.isFinite(started) ? started - 10 * 60_000 : 0).catch(() => null)
+          : null;
+        if (!parent) return;
+      }
+      state.injectedPrompts.set(task.entryId, { subagentTask: true, ...(parent ? { parentSessionID: parent } : {}) });
+    })().catch(() => undefined));
+
   pi.on("session_start", (_event: any, ctx: any) => {
     follow(ctx, false);
   });
 
-  pi.on("before_agent_start", (event: any, ctx: any) => {
+  // What the user submits comes as input; an extension's prompt
+  // (pi.sendUserMessage) is marked so it never reads as the user's.
+  pi.on("input", (event: any, ctx: any) => {
+    if (event?.source !== "extension" || typeof event?.text !== "string") return;
+    const state = follow(ctx, false);
+    state?.extensionInputs.push({ at: Date.now(), text: event.text });
+  });
+
+  pi.on("before_agent_start", async (event: any, ctx: any) => {
     const state = follow(ctx, true);
     if (!state) return;
     state.running = true;
@@ -649,6 +880,7 @@ export default function (pi: any) {
       },
     });
     archive.turnFollowed(state.id);
+    await lookUpOrigin(state);
   });
 
   // A run that no prompt started (a background sub-agent's results

package/assets/extensions/omnirush/commands.ts

@@ -21,6 +21,7 @@ import { readSessionLedger, SESSION_LEDGER_FILE } from "./capture/workspace-coll
 import { deviceMe, omniDir, resolveOrigin, sessionEndedMessage } from "./auth";
 import { sharedRefresher } from "./refresh";
 import { formatCollectorLine, formatStatusLines } from "./status-lib";
+import { formatModeStatus } from "./yolo-lib";
 import {
   formatDeviceLines,
   formatGrantLines,
@@ -153,6 +154,7 @@ export default function (pi: ExtensionAPI) {
         collector: { sessionId, record },
         origin: resolveOrigin(process.env),
         version: CLI_VERSION,
+        yolo: formatModeStatus(),
       });
       notify(ctx, ["Omnirush status:", ...statusLines.map((line) => `  ${line}`)].join("\n"));
     },

package/assets/extensions/omnirush/deliveries.ts

@@ -0,0 +1,145 @@
+// deliveries — brings results of background work back into the conversation.
+//
+// Background sub-agents (agents.ts) and background shell commands
+// (bgshell.ts) finish while the main agent works on, waits for the user, or
+// is about to end a one-shot run. Each registers as a source here; one hub
+// per extension instance delivers what they have:
+//
+//   - the agent is busy: the result is steered into the running turn (the
+//     model sees it before its next step);
+//   - the agent is idle: the result starts a new turn;
+//   - one-shot runs (print/json mode) end when the agent settles, so the hub
+//     holds the run open while a source still has work out, delivers each
+//     result as it comes (a new run nested in this settle, whose own settle
+//     resumes this one), and gives each source one last word (`beforeEnd`)
+//     before the run is allowed to end.
+
+export interface DeliveryItem {
+  customType: string;
+  content: string;
+  details?: unknown;
+}
+
+export interface DeliverySource {
+  /** Work of this session whose result the run should still wait for (running, or finished and unread). */
+  hasPending(session: string): boolean;
+  /** Finished results ready now (each becomes one message); marked delivered. */
+  take(session: string): DeliveryItem[];
+  /** Resolves at the next change (something finished). */
+  changed(): Promise<void>;
+  /** One-shot runs with nothing pending: a last message before the run ends, or null. */
+  beforeEnd?(session: string): DeliveryItem | null;
+}
+
+export class DeliveryHub {
+  private readonly pi: any;
+  private readonly sources: DeliverySource[] = [];
+  /** The session this runtime is on (deliveries go to it). */
+  currentSession = "";
+  cwd = process.cwd();
+  /** An agent run is under way (one-shot runs deliver through the settle loop otherwise). */
+  private busy = false;
+  private oneShot = false;
+  private resumeOuter: (() => void) | null = null;
+
+  constructor(pi: any) {
+    this.pi = pi;
+    pi.on("session_start", (_event: any, ctx: any) => {
+      this.sessionOf(ctx);
+    });
+    pi.on("agent_start", (_event: any, ctx: any) => {
+      this.sessionOf(ctx);
+      this.busy = true;
+    });
+    pi.on("agent_settled", (_event: any, ctx: any) => this.settled(ctx));
+  }
+
+  addSource(source: DeliverySource): void {
+    this.sources.push(source);
+  }
+
+  /** A source has something to deliver (called after its own bookkeeping). */
+  notify(): void {
+    queueMicrotask(() => this.deliver());
+  }
+
+  /** The session of a tool or event context (and what the hub learns from it). */
+  sessionOf(ctx: any): string {
+    const id = String(ctx?.sessionManager?.getSessionId?.() ?? "");
+    if (id) this.currentSession = id;
+    if (ctx?.cwd) this.cwd = String(ctx.cwd);
+    if (ctx?.mode === "print" || ctx?.mode === "json") this.oneShot = true;
+    return id;
+  }
+
+  get isOneShot(): boolean {
+    return this.oneShot;
+  }
+
+  private send(item: DeliveryItem): void {
+    this.pi.sendMessage(
+      { customType: item.customType, content: item.content, display: true, ...(item.details !== undefined ? { details: item.details } : {}) },
+      // Busy: into the running turn at its next step. Idle: a new turn.
+      { triggerTurn: true, deliverAs: "steer" },
+    );
+  }
+
+  private deliver(): void {
+    if (!this.currentSession) return;
+    // One-shot and between runs: the agent_settled loop delivers.
+    if (this.oneShot && !this.busy) return;
+    for (const source of this.sources) {
+      for (const item of source.take(this.currentSession)) this.send(item);
+    }
+  }
+
+  private async settled(ctx: any): Promise<void> {
+    this.busy = false;
+    const session = this.sessionOf(ctx);
+    if (!this.oneShot) {
+      // Anything that finished right as the run ended.
+      this.deliver();
+      return;
+    }
+    const outer = this.resumeOuter;
+    this.resumeOuter = null;
+    const idle = () => typeof ctx?.isIdle !== "function" || ctx.isIdle();
+    try {
+      for (;;) {
+        if (!idle()) {
+          // A run started (a delivery): its settle resumes this one.
+          await new Promise<void>((resolve) => { this.resumeOuter = resolve; });
+          break;
+        }
+        if (!session) break;
+        const items = this.sources.flatMap((source) => source.take(session));
+        if (items.length === 0 && this.sources.some((source) => source.hasPending(session))) {
+          await Promise.race(this.sources.map((source) => source.changed()));
+          continue;
+        }
+        if (items.length === 0) {
+          const last = this.sources.map((source) => source.beforeEnd?.(session) ?? null).find((item) => item !== null);
+          if (!last) break;
+          items.push(last);
+        }
+        this.busy = true;
+        for (const item of items) this.send(item);
+        if (idle()) this.busy = false;
+      }
+    } finally {
+      outer?.();
+    }
+  }
+}
+
+const hubs = new WeakMap<object, DeliveryHub>();
+
+/** The hub of this extension instance (created, with its handlers, on first use). */
+export function deliveryHub(pi: any): DeliveryHub {
+  let hub = hubs.get(pi);
+  if (!hub) {
+    hub = new DeliveryHub(pi);
+    hubs.set(pi, hub);
+  }
+  return hub;
+}

package/assets/extensions/omnirush/guard/UPSTREAM

@@ -0,0 +1,2 @@
+Vendored from omnirush-gui apps/server/src/git-command-policy.ts at 51ee01f (origin/main).
+Keep it byte-identical to upstream; CLI-specific logic lives in ../guard-lib.ts.