omnirush 0.9.0 → 0.10.0

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/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/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 */
+    }
+  });
+}

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.0",
+  "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/scripts/smoke-packages.py

@@ -28,6 +28,7 @@ REQUIRED_PATHS = [
     "src/bin.js",
     "src/lib.js",
     "src/compat.js",
+    "src/sessions.js",
     "scripts/postinstall.js",
     "scripts/brand-engine.js",
     "assets/extensions/omnirush/index.ts",

package/src/bin.js

@@ -55,6 +55,7 @@ import {
 } from "./lib.js";
 import { installManagedTools } from "./tools.js";
 import { engineEnvAliases, migrateAgentDir, projectConfigDirName, resolveAgentDir } from "./compat.js";
+import { customSessionDir, moveLegacySubagentSessions } from "./sessions.js";
 import { ensureRuntime, managedBunPath } from "../scripts/postinstall.js";
 import {
   clearAuth,
@@ -159,7 +160,88 @@ 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 });
+  }
+}
+
+/**
+ * Sub-agent sessions older releases wrote next to the user's are moved to
+ * their session dir's subagents/ folder before the core picks a session,
+ * so /resume lists only the user's sessions and --continue resumes the
+ * user's last one (src/sessions.js). Not on a run that fell back to the
+ * pre-0.9 folder, which is left as it was.
+ */
+function tidySubagentSessions(args) {
+  if (AGENT.legacyDir && PI_AGENT_DIR === AGENT.legacyDir) return;
+  try {
+    const custom = customSessionDir(args, process.env, PI_SETTINGS_JSON, os.homedir());
+    moveLegacySubagentSessions({ agentDir: PI_AGENT_DIR, extraDirs: custom ? [custom] : [] });
+  } catch {
+    /* best effort */
+  }
 }
 
 // Product default effort (P2): xhigh. Fills an ABSENT
@@ -180,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 });
   }
 }
 
@@ -219,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 */
           }
@@ -245,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() {
@@ -274,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) {
@@ -543,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})`);
   }
@@ -589,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) {
@@ -886,6 +984,7 @@ async function cmdRun() {
   // flags win when present.
   // `omnirush run` takes no other arguments; only yolo's --approve passes.
   const yolo = launchYolo(process.argv.slice(3).filter((a) => a === "--yolo" || a === "--no-yolo"));
+  tidySubagentSessions([]);
   const piArgs = withModelDefaults(yolo.args, resolveModelDefaults(process.env));
   spawnAgent(cmd, [...args, ...piArgs], {
     stdio: "inherit",
@@ -950,7 +1049,8 @@ Session commands (inside the agent):
   /mcp     MCP server state (/mcp reconnect [server])
   /subagents  model and effort of the sub-agents (/subagents model <id|same>,
               /subagents effort <level|same>; saved for the next runs)
-  /agents  sub-agents of this session (/agents cancel <id|all>)
+  /agents  sub-agents of this session (/agents cancel <id|all>,
+           /agents memory: the memory they may use)
   /jobs    background shell commands (/jobs kill <id|all>)
   /voice   dictate prompts: hold Space to talk (/voice hold|tap|off|status)
   /mode    approval mode: guarded (asks before git writes and destructive
@@ -972,6 +1072,12 @@ Environment:
   OMNIRUSH_BASH_FOREGROUND_SECONDS
                          how long a shell command runs in the foreground before
                          it continues in the background (default 300)
+  OMNIRUSH_AGENT_MIN_FREE / OMNIRUSH_AGENT_MEMORY_BUDGET / OMNIRUSH_AGENT_CRITICAL_FREE
+                         sub-agents start while this much RAM stays free
+                         (default 20%), all agents stay under this budget
+                         (default 50% of RAM), and none start below this
+                         (default 10%); e.g. 25% or 6G. OMNIRUSH_AGENT_MEMORY=off
+                         starts them without checking memory
   OMNIRUSH_<SETTING>     the agent core's own settings (e.g. OMNIRUSH_CACHE_RETENTION;
                          the older PI_<SETTING> names still work)
 
@@ -1058,6 +1164,7 @@ async function runCore(args) {
   const { cmd: bin, args: runtimeArgs } = await runtimeFor(entry);
   const yolo = launchYolo(args);
   const piArgs = withModelDefaults(yolo.args, resolveModelDefaults(process.env));
+  tidySubagentSessions(piArgs);
   spawnAgent(bin, [...runtimeArgs, ...piArgs], {
     stdio: "inherit",
     env: { ...process.env, ...childEnv(auth), ...yolo.env },

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;