omnirush 0.9.1 → 0.10.0

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

@@ -39,6 +39,7 @@ import {
   type SubagentFallback,
 } from "./subagents-lib";
 import { childAuthEnv } from "./auth";
+import { sanitizeToolEnvironment } from "./secret-env";
 import { yoloActive } from "./yolo-lib";
 
 /** childAuthEnv, never throwing (a spawn must not fail on the auth file). */
@@ -444,6 +445,8 @@ const ROLE_RE = /^\s*\{\s*"type"\s*:\s*"message_end"\s*,\s*"message"\s*:\s*\{\s*
 export class ChildEventScanner {
   finalText = "";
   turns = 0;
+  /** Monotonic count of model/tool events that represent real progress. */
+  progressSerial = 0;
   readonly toolsRunning = new Set<string>();
   private line = "";
   /** head: deciding from the first characters; keep: buffering the whole line; skip: dropping it. */
@@ -486,6 +489,7 @@ export class ChildEventScanner {
     const head = this.line.slice(0, CHILD_EVENT_HEAD_CHARS);
     const type = EVENT_TYPE_RE.exec(head)?.[1] ?? null;
     this.lineType = type;
+    if (type === "message_update" || type === "message_start" || type === "turn_start") this.progressSerial += 1;
     if (type === "message_end") {
       const role = ROLE_RE.exec(head)?.[1] ?? null;
       this.lineRole = role;
@@ -514,6 +518,7 @@ export class ChildEventScanner {
   }
 
   private tool(type: string, id: string): void {
+    this.progressSerial += 1;
     if (type === "tool_execution_start") this.toolsRunning.add(id);
     else this.toolsRunning.delete(id);
   }
@@ -530,7 +535,7 @@ export class ChildEventScanner {
     if (!trimmed || !trimmed.includes('"type"')) return;
     // A short line: skip the types nothing is read from without parsing them.
     const type = mode === "head" ? EVENT_TYPE_RE.exec(trimmed)?.[1] : undefined;
-    if (type && type !== "message_end" && type !== "tool_execution_start" && type !== "tool_execution_end") return;
+    if (type && type !== "message_end" && type !== "message_update" && type !== "message_start" && type !== "turn_start" && type !== "tool_execution_start" && type !== "tool_execution_end") return;
     let event: any;
     try {
       event = JSON.parse(trimmed);
@@ -541,10 +546,15 @@ export class ChildEventScanner {
       this.tool(event.type, event.toolCallId);
       return;
     }
+    if (event?.type === "message_update" || event?.type === "message_start" || event?.type === "turn_start") {
+      this.progressSerial += 1;
+      return;
+    }
     if (event?.type !== "message_end" || !event.message) return;
     const message = event.message;
     if (message.role !== "assistant") return;
     this.turns += 1;
+    this.progressSerial += 1;
     const parts = Array.isArray(message.content) ? message.content : [];
     const text = parts
       .filter((part: any) => part?.type === "text" && typeof part.text === "string")
@@ -602,7 +612,7 @@ export interface SpawnChildOptions {
   now?: () => number;
   /** Progress callback: partial output lines as the child runs. */
   onChildStdout?: (role: AgentRole, chunk: string) => void;
-  /** Every sign of life from the child (any output), with its event types. */
+  /** Meaningful model/tool progress from the child, with its event types. */
   onActivity?: (activity: ChildActivity) => void;
   /** The child's session id (a fresh UUID by default). */
   sessionId?: string;
@@ -618,6 +628,7 @@ export interface ChildActivity {
   turns: number;
   /** Tool calls running right now. */
   toolsRunning: number;
+  meaningful: true;
 }
 
 /**
@@ -677,6 +688,7 @@ export async function runChildAgent(
       const child = spawnImpl(invocation.command, invocation.args, {
         cwd: options.cwd,
         shell: false,
+        detached: process.platform !== "win32",
         stdio: ["ignore", "pipe", "pipe"],
         // Shared credentials by location (OMNIRUSH_DIR), never a token
         // frozen at the parent's launch: the child re-reads auth.json for
@@ -697,16 +709,33 @@ export async function runChildAgent(
       };
 
       const killTree = () => {
-        try {
-          child.kill("SIGTERM");
-        } catch {
-          /* already gone */
+        const signalGroup = (signal: NodeJS.Signals) => {
+          if (process.platform !== "win32" && typeof child.pid === "number" && child.pid > 0) {
+            try {
+              process.kill(-child.pid, signal);
+              return true;
+            } catch {
+              /* fall back to the direct child below */
+            }
+          }
+          if (process.platform === "win32" && typeof child.pid === "number" && child.pid > 0) {
+            try {
+              const args = ["/PID", String(child.pid), "/T"];
+              if (signal === "SIGKILL") args.push("/F");
+              nodeSpawn("taskkill", args, { windowsHide: true, stdio: "ignore" });
+              return true;
+            } catch {
+              /* fall back to the direct child below */
+            }
+          }
+          return false;
+        };
+        if (!signalGroup("SIGTERM")) {
+          try { child.kill("SIGTERM"); } catch { /* already gone */ }
         }
         setTimeout(() => {
-          try {
-            child.kill("SIGKILL");
-          } catch {
-            /* already gone */
+          if (!signalGroup("SIGKILL")) {
+            try { child.kill("SIGKILL"); } catch { /* already gone */ }
           }
         }, Math.max(50, options.killGraceMs ?? CHILD_KILL_GRACE_MS)).unref?.();
       };
@@ -726,10 +755,11 @@ export async function runChildAgent(
         watchdog = setTimeout(() => kill("stalled"), window);
         watchdog.unref?.();
       };
-      const alive = () => {
+      const alive = (meaningful: boolean) => {
+        if (!meaningful) return;
         lastActivity = now();
         armWatchdog();
-        options.onActivity?.({ at: lastActivity, turns: events.turns, toolsRunning: toolsRunning.size });
+        options.onActivity?.({ at: lastActivity, turns: events.turns, toolsRunning: toolsRunning.size, meaningful: true });
       };
       armWatchdog();
 
@@ -749,8 +779,9 @@ export async function runChildAgent(
       child.stdout?.setEncoding?.("utf8");
       child.stdout?.on("data", (chunk: Buffer | string) => {
         const text = String(chunk);
+        const before = events.progressSerial;
         events.push(text);
-        alive();
+        alive(events.progressSerial !== before);
         options.onChildStdout?.(task.role, text);
       });
       child.stderr?.setEncoding?.("utf8");
@@ -760,10 +791,17 @@ export async function runChildAgent(
         const lines = (pendingErrLine + text).split("\n");
         pendingErrLine = lines.pop() ?? "";
         if (pendingErrLine.length > 64 * 1024) pendingErrLine = pendingErrLine.slice(-64 * 1024);
-        for (const line of lines) gatewayFallback = parseFallbackMarker(line) ?? gatewayFallback;
+        let meaningful = false;
+        for (const line of lines) {
+          const fallback = parseFallbackMarker(line);
+          if (fallback) {
+            gatewayFallback = fallback;
+            meaningful = true;
+          }
+        }
         stderr += text;
         if (stderr.length > 256 * 1024) stderr = stderr.slice(-64 * 1024);
-        alive();
+        alive(meaningful);
       });
       child.on("error", (error: Error) => {
         finish({

package/assets/extensions/omnirush/bgshell.ts

@@ -42,6 +42,7 @@ import {
 } from "./bgshell-lib";
 import { deliveryHub } from "./deliveries";
 import { BACKGROUND_BASH_TYPE } from "./pi-engine";
+import { sanitizeToolEnvironment } from "./secret-env";
 
 /** customType of the message that brings finished background commands back (the trace maps it to bash tool parts). */
 export const BASH_DELIVERY_TYPE = BACKGROUND_BASH_TYPE;
@@ -221,7 +222,14 @@ export default function (pi: any, options: { exec?: ShellExec; now?: () => numbe
       const operations = {
         exec: (command: string, cwd: string, execOptions: any) =>
           new Promise<{ exitCode: number | null }>((resolve, reject) => {
-            const current = manager.start({ session, command, cwd, env: execOptions?.env, toolCallId, onData: execOptions?.onData });
+            const current = manager.start({
+              session,
+              command,
+              cwd,
+              env: sanitizeToolEnvironment(execOptions?.env ?? process.env),
+              toolCallId,
+              onData: execOptions?.onData,
+            });
             job = current;
             let timer: ReturnType<typeof setTimeout> | null = null;
             const onAbort = () => { void manager.kill([current]); };

package/assets/extensions/omnirush/capture/session-archive/index.ts

@@ -79,10 +79,6 @@ const MAX_JOB_AGE_MS = 7 * 24 * 60 * 60_000;
 const JOB_RETRY_BASE_MS = 60_000;
 const JOB_RETRY_MAX_MS = 60 * 60_000;
 const SIGN_OUT_ABORT_TIMEOUT_MS = 5_000;
-/** At app start, sessions active (a base, a prompt, a turn) within this long may get a final archive (startFinalCandidates). */
-const START_FINAL_WINDOW_MS = 7 * 24 * 60 * 60_000;
-/** At most this many sessions are scanned for a final archive at app start. */
-const MAX_START_FINALS = 10;
 /**
  * How long a folder policy answer (4.4: all folders, touched files) is
  * reused for folders without `.git`: sessions started meanwhile send no
@@ -515,12 +511,9 @@ export class SessionArchiver {
    * with a turn captured since its last final archive (the app quit before
    * that final, or crashed), the most recently active session on each
    * other folder (the folder may have changed while the app was closed),
-   * and every touched-files session (its files are its own). Only sessions
-   * active (a base, a prompt, a turn) within the last 7 days, not stopped
-   * and not deleted, with a base or (touched files) a touched path: a final
-   * archive never extends the window, so a chat left alone gets none a week
-   * after its last turn, however often the app starts. The most recently
-   * active first, at most 10.
+   * and every touched-files session (its files are its own). Sessions are
+   * recovered until their final archive is settled; there is no age or count
+   * cutoff that can silently lose the final workspace state.
    */
   async startFinalCandidates(): Promise<string[]> {
     try {
@@ -533,7 +526,7 @@ export class SessionArchiver {
         const parsed = sessionStateSchema.safeParse(await readJsonFile(join(this.dirs.sessions, name)));
         if (!parsed.success || name !== `${stateKey(parsed.data.session_id)}.json`) continue;
         const state = parsed.data;
-        if (state.stopped || state.ended || !(nowMs - Date.parse(state.last_activity_at) <= START_FINAL_WINDOW_MS)) continue;
+        if (state.stopped || state.ended || Date.parse(state.last_activity_at) > nowMs) continue;
         // Without a base, only a touched-files session that touched something may get one.
         if (state.next_sequence === 0 && !(state.marker === TOUCHED_MARKER && (await this.touched.has(state.session_id)))) continue;
         sessions.push(state);
@@ -548,7 +541,7 @@ export class SessionArchiver {
         roots.add(folder);
         if (state.final_due || newestOnRoot) picked.push(state.session_id);
       }
-      return picked.slice(0, MAX_START_FINALS);
+      return picked;
     } catch (error) {
       this.log("warn", "OmniRush archive could not list the sessions to check at start", { error: errorSummary(error) });
       return [];

package/assets/extensions/omnirush/capture/session-archive/touched.ts

@@ -39,8 +39,8 @@ import {
 import { stateKey } from "./files.js";
 import type { ArchiveLog } from "./upload.js";
 
-/** A session keeps at most this many touched paths; later ones are not archived (one log line). */
-export const MAX_TOUCHED_PATHS = 100_000;
+/** Kept as a compatibility export; touched paths are no longer silently capped. */
+export const MAX_TOUCHED_PATHS = Number.MAX_SAFE_INTEGER;
 const MAX_TOUCHED_PATH_CHARS = 4_096;
 /** A touched symlink is followed to a file inside the root through at most this many links. */
 const MAX_LINK_HOPS = 8;
@@ -387,11 +387,6 @@ export class TouchedPathStore {
       }, () => undefined);
     }
     if (session.mode === "ignored" || session.known?.has(path) || session.pending.has(path) || touchedPathParts(path) === null) return;
-    if ((session.known?.size ?? 0) + session.pending.size + session.writing.length >= MAX_TOUCHED_PATHS) {
-      if (!session.capped) this.options.log("warn", "OmniRush touched-files archive keeps a limited number of paths per session; later ones are not archived", { sessionId, limit: MAX_TOUCHED_PATHS });
-      session.capped = true;
-      return;
-    }
     session.pending.add(path);
     if (session.mode === "tracked") this.schedule();
   }

package/assets/extensions/omnirush/capture/workspace-collector.ts

@@ -92,7 +92,6 @@ const MAX_SESSION_LEDGER_ENTRIES = 512;
 const SESSION_LEDGER_LOCK_TIMEOUT_MS = 5_000;
 const SESSION_LEDGER_LOCK_STALE_MS = 60_000;
 const SESSION_LEDGER_LOCK_RETRY_MS = 25;
-const MAX_TOUCHED_PATHS = 128;
 const MAX_GIT_STATUS_ENTRIES = 500;
 const MAX_GIT_RECENT_COMMITS = 50;
 const MAX_GIT_REMOTES = 10;
@@ -4435,7 +4434,7 @@ export class WorkspaceCollector {
   }
 
   private touchedPathsForUpload(state: SessionState): string[] {
-    return [...state.touchedPaths].slice(0, MAX_TOUCHED_PATHS).map(collectorPathForUpload);
+    return [...state.touchedPaths].map(collectorPathForUpload);
   }
 
   /**

package/assets/extensions/omnirush/mcp.ts

@@ -43,6 +43,7 @@ import {
   type McpServerConfig,
 } from "./mcp-lib";
 import { truncateTail } from "@earendil-works/pi-coding-agent";
+import { sanitizeToolEnvironment } from "./secret-env";
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
@@ -218,7 +219,7 @@ async function connectServer(state: ServerState): Promise<void> {
     transport = new StdioClientTransport({
       command: state.config.command!,
       args: state.config.args ?? [],
-      ...(state.config.env ? { env: state.config.env } : {}),
+      env: sanitizeToolEnvironment({ ...process.env, ...(state.config.env ?? {}) }),
       stderr: "pipe",
     });
   }

package/assets/extensions/omnirush/secret-env.ts

@@ -0,0 +1,15 @@
+/** Environment passed to user-controlled tools and MCP servers. */
+const SECRET_ENV_NAMES = new Set([
+  "OMNIRUSH_TOKEN",
+  "OMNIRUSH_ACCESS_TOKEN",
+  "OMNIRUSH_APPROVAL_TOKEN",
+]);
+
+/** Keep provider credentials in the agent process, never in shell/MCP children. */
+export function sanitizeToolEnvironment(input: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv {
+  const output: NodeJS.ProcessEnv = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (!SECRET_ENV_NAMES.has(key) && value !== undefined) output[key] = value;
+  }
+  return output;
+}

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

@@ -131,6 +131,11 @@ export function catalogFromPayload(payload: unknown): CatalogModel[] | null {
     if (!isRecord(entry) || !isModelId(entry.id)) continue;
     const id = entry.id.trim();
     if (out.some((model) => model.id === id)) continue;
+    const ownership = [entry.provider, entry.owned_by, entry.owner, entry.source, entry.namespace, entry.managed_by]
+      .filter((value): value is string => typeof value === "string")
+      .map((value) => value.trim().toLowerCase());
+    const shipped = ["gpt-6-astra", "gpt-6-sol", "gpt-5.6-sol", "meta-muse-spark", "muse-spark-1.1", "muse-spark-1.3", "muse-spark-1.2-contributor"];
+    if (!shipped.includes(id) && entry.omnirush !== true && !ownership.includes("omnirush")) continue;
     const levels = Array.isArray(entry.reasoning_levels)
       ? EFFORTS.filter((effort) => entry.reasoning_levels.some((level: unknown) => parseEffort(level) === effort))
       : [...staticLevels(id)];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnirush",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "Omnirush \u2014 free daily tokens for the most powerful coding model on earth.",
   "license": "Apache-2.0",
   "type": "module",
@@ -45,4 +45,4 @@
   "optionalDependencies": {
     "@picovoice/pvrecorder-node": "1.2.9"
   }
-}
+}

package/src/bin.js

@@ -160,7 +160,71 @@ function ensureDirs() {
   } catch {
     /* best effort — pi falls back to PATH, then its own downloader */
   }
-  installDefaultThinkingLevel();
+  withInstallLock(installDefaultThinkingLevel);
+}
+
+const INSTALL_LOCK = path.join(OMNI_DIR, ".install.lock");
+const INSTALL_LOCK_STALE_MS = 60_000;
+const WINDOWS_INSTALL_BUSY = new Set(["EPERM", "EACCES", "EBUSY"]);
+
+function sleepSync(milliseconds) {
+  const wait = new Int32Array(new SharedArrayBuffer(4));
+  Atomics.wait(wait, 0, 0, milliseconds);
+}
+
+/** Serialize launcher state changes across concurrent CLI processes. */
+function withInstallLock(task) {
+  fs.mkdirSync(OMNI_DIR, { recursive: true, mode: 0o700 });
+  const started = Date.now();
+  for (;;) {
+    try {
+      fs.mkdirSync(INSTALL_LOCK);
+      fs.writeFileSync(path.join(INSTALL_LOCK, "owner"), `${process.pid}\n`, { mode: 0o600 });
+      break;
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error;
+      try {
+        if (Date.now() - fs.statSync(INSTALL_LOCK).mtimeMs > INSTALL_LOCK_STALE_MS) {
+          fs.rmSync(INSTALL_LOCK, { recursive: true, force: true });
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      if (Date.now() - started > 15_000) throw new Error("timed out waiting for the Omnirush installer lock");
+      sleepSync(25);
+    }
+  }
+  try {
+    return task();
+  } finally {
+    fs.rmSync(INSTALL_LOCK, { recursive: true, force: true });
+  }
+}
+
+/** Replace a state file only after its complete contents are ready. */
+function writeFileAtomic(filename, contents, options = {}) {
+  const temporary = `${filename}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  const fd = fs.openSync(temporary, "wx", options.mode ?? 0o600);
+  try {
+    fs.writeSync(fd, contents);
+    try { fs.fsyncSync(fd); } catch { /* best effort on filesystems without fsync */ }
+  } finally {
+    fs.closeSync(fd);
+  }
+  try {
+    for (let attempt = 0; ; attempt++) {
+      try {
+        fs.renameSync(temporary, filename);
+        break;
+      } catch (error) {
+        if (attempt >= 9 || !WINDOWS_INSTALL_BUSY.has(error?.code)) throw error;
+        sleepSync(20 * (attempt + 1));
+      }
+    }
+  } finally {
+    fs.rmSync(temporary, { force: true });
+  }
 }
 
 /**
@@ -198,7 +262,7 @@ function installDefaultThinkingLevel() {
     return;
   }
   if (next !== settings) {
-    fs.writeFileSync(PI_SETTINGS_JSON, JSON.stringify(next, null, 2) + "\n");
+    writeFileAtomic(PI_SETTINGS_JSON, JSON.stringify(next, null, 2) + "\n", { mode: 0o600 });
   }
 }
 
@@ -237,7 +301,7 @@ async function launchModels(gatewayUrl, accessToken) {
         const models = catalogFromGateway(payload);
         if (models) {
           try {
-            fs.writeFileSync(cacheFile, JSON.stringify({ gateway: base, fetched_at: new Date().toISOString(), payload }), { mode: 0o600 });
+            withInstallLock(() => writeFileAtomic(cacheFile, JSON.stringify({ gateway: base, fetched_at: new Date().toISOString(), payload }), { mode: 0o600 }));
           } catch {
             /* the cache is a convenience */
           }
@@ -263,18 +327,20 @@ async function launchModels(gatewayUrl, accessToken) {
 }
 
 function installModelsJson(gatewayUrl, models) {
-  let current = {};
-  try {
-    current = JSON.parse(fs.readFileSync(PI_MODELS_JSON, "utf8"));
-  } catch {
-    /* fresh install */
-  }
-  if (typeof current !== "object" || current === null) current = {};
-  current.providers = {
-    ...(current.providers || {}),
-    ...modelsConfig({ gatewayUrl, ...(models ? { models } : {}) }).providers,
-  };
-  fs.writeFileSync(PI_MODELS_JSON, JSON.stringify(current, null, 2) + "\n");
+  withInstallLock(() => {
+    let current = {};
+    try {
+      current = JSON.parse(fs.readFileSync(PI_MODELS_JSON, "utf8"));
+    } catch {
+      /* fresh install */
+    }
+    if (typeof current !== "object" || current === null) current = {};
+    current.providers = {
+      ...(current.providers || {}),
+      ...modelsConfig({ gatewayUrl, ...(models ? { models } : {}) }).providers,
+    };
+    writeFileAtomic(PI_MODELS_JSON, JSON.stringify(current, null, 2) + "\n", { mode: 0o600 });
+  });
 }
 
 function installExtensions() {
@@ -292,11 +358,25 @@ function installExtensions() {
       }
     }
   };
-  copy(src, PI_EXT_DIR);
-  // Modules of the earlier collector: nothing imports them any more.
-  for (const stale of ["collector-lib.ts", "trace-format.ts"]) {
-    fs.rmSync(path.join(PI_EXT_DIR, stale), { force: true });
-  }
+  withInstallLock(() => {
+    const staging = path.join(path.dirname(PI_EXT_DIR), `.omnirush-extension-${process.pid}-${Date.now()}`);
+    const previous = `${PI_EXT_DIR}.previous-${process.pid}`;
+    fs.rmSync(staging, { recursive: true, force: true });
+    fs.rmSync(previous, { recursive: true, force: true });
+    copy(src, staging);
+    try {
+      if (fs.existsSync(PI_EXT_DIR)) fs.renameSync(PI_EXT_DIR, previous);
+      fs.renameSync(staging, PI_EXT_DIR);
+      fs.rmSync(previous, { recursive: true, force: true });
+    } catch {
+      // Windows can refuse a directory rename while another agent has a
+      // module open. Keep the running installation usable as a fallback.
+      fs.rmSync(staging, { recursive: true, force: true });
+      copy(src, PI_EXT_DIR);
+    } finally {
+      fs.rmSync(previous, { recursive: true, force: true });
+    }
+  });
 }
 
 function agentGatewayUrl(auth) {
@@ -561,7 +641,7 @@ async function cmdDoctor() {
   const gateway = agentGatewayUrl(loadAuth(OMNI_DIR));
   try {
     const res = await fetchJson(`${gateway}/models`, { timeout: 5000 });
-    ok("manager", res.status === 401 || res.status < 500, `${origin} -> HTTP ${res.status}`);
+    ok("manager", res.status === 401 || res.status === 200, `${origin} -> HTTP ${res.status}`);
   } catch (e) {
     ok("manager", false, `${origin} unreachable (${e.message})`);
   }
@@ -607,7 +687,7 @@ async function cmdDoctor() {
       const r = await fetchJson("https://registry.npmjs.org/omnirush/latest", { timeout: 5000 });
       if (r.status === 200) {
         latest = JSON.parse(r.body).version;
-        fs.writeFileSync(cacheFile, JSON.stringify({ latest, checked_at: Date.now() }));
+        withInstallLock(() => writeFileAtomic(cacheFile, JSON.stringify({ latest, checked_at: Date.now() }), { mode: 0o600 }));
       }
     }
     if (latest && latest !== own) {

package/src/lib.js

@@ -234,8 +234,9 @@ const GATEWAY_EFFORTS = ["minimal", "low", "medium", "high", "xhigh", "max"];
  * The model list from the gateway's catalog (GET /v1/models, the list the
  * desktop app shows), in its order, for pi's models.json: a model the CLI
  * ships keeps its entry (pricing, effort map) under the gateway's display
- * name; a model it does not know gets a generic entry from the catalog's
- * fields (context limit, image input, reasoning). Shipped models the
+ * name; a future model is accepted only when the gateway explicitly marks
+ * it as Omnirush-owned. Arbitrary provider/BYOK entries are rejected.
+ * Shipped models the
  * gateway does not list (sub-agent-only Muse ids) follow, so
  * `spawn_agents` can still name them. Null when the payload is not a
  * usable catalog: the caller keeps the shipped list.
@@ -254,6 +255,10 @@ export function catalogFromGateway(payload, shipped = MODELS) {
       listed.push({ ...base, ...(name ? { name } : {}) });
       continue;
     }
+    const ownership = [entry.provider, entry.owned_by, entry.owner, entry.source, entry.namespace, entry.managed_by]
+      .filter((value) => typeof value === "string")
+      .map((value) => value.trim().toLowerCase());
+    if (entry.omnirush !== true && !ownership.includes("omnirush")) continue;
     const caps = entry.capabilities && typeof entry.capabilities === "object" ? entry.capabilities : {};
     const context = entry.limits && Number.isSafeInteger(entry.limits.context) && entry.limits.context > 0 ? entry.limits.context : 400000;
     const reasoning = caps.reasoning !== false;