omnirush 0.6.0 → 0.7.0

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

@@ -25,8 +25,10 @@ export const CHILD_TIMEOUT_MS = 10 * 60_000;
 export const CHILD_KILL_GRACE_MS = 5_000;
 /** Default number of children running at once. */
 export const MAX_CONCURRENT_CHILDREN = 4;
+/** Upper bound on children running at once (swarms). */
+export const MAX_CONCURRENCY_CEILING = 12;
 /** Upper bound on tasks per spawn_agents call. */
-export const MAX_TASKS_PER_CALL = 8;
+export const MAX_TASKS_PER_CALL = 12;
 /** Per-child output cap in the structured result (bytes, UTF-8). */
 export const CHILD_OUTPUT_CAP_BYTES = 50 * 1024;
 
@@ -64,7 +66,7 @@ export const ROLE_PRESETS: Record<AgentRole, RolePreset> = {
     description: "Web research via web_fetch: read documentation pages, articles and API responses.",
     systemPrompt: [
       "You are a researcher subagent with web access.",
-      "Use the web_fetch tool to read documentation, articles and API responses (HTTPS URLs; the tool strips pages to readable text).",
+      "Use the web_search tool to find pages (returns titles, URLs and snippets) and web_fetch to read the promising ones (HTTPS; pages stripped to text).",
       "Cross-check claims across more than one page when it matters, and prefer primary sources (official docs, spec pages) over blog summaries.",
       "Report a compact synthesis with the source URLs you actually used — not a list of everything you fetched.",
     ].join(" "),
@@ -104,13 +106,22 @@ export function childInvocation(args: string[]): {
 /**
  * Build the child's argv for one task: JSON print mode with the role's
  * system prompt appended via a temp file path (the caller writes and
- * cleans up that file — see withRolePromptFile).
+ * cleans up that file — see withRolePromptFile). `model` selects a
+ * cross-model child (pi's --provider/--model flags); the provider is
+ * always our gateway extension.
  */
-export function buildChildArgs(task: string, promptFilePath: string | null): string[] {
+export function buildChildArgs(
+  task: string,
+  promptFilePath: string | null,
+  model?: string,
+): string[] {
   const args: string[] = ["--mode", "json", "-p"];
   if (promptFilePath) {
     args.push("--append-system-prompt", promptFilePath);
   }
+  if (model && model.trim()) {
+    args.push("--provider", "omnirush", "--model", model.trim());
+  }
   args.push(`Task: ${task}`);
   return args;
 }
@@ -137,6 +148,10 @@ export async function withRolePromptFile(
 export interface ChildTask {
   role: AgentRole;
   task: string;
+  /** Cross-model children: gateway model id the child runs on
+   *  (e.g. "muse-spark-1.3" for cheap swarm workers under an astra
+   *  parent). Undefined = inherit the parent's model. */
+  model?: string;
 }
 
 export type ChildStatus = "completed" | "failed" | "timeout" | "cancelled";
@@ -144,6 +159,8 @@ export type ChildStatus = "completed" | "failed" | "timeout" | "cancelled";
 export interface ChildResult {
   role: AgentRole;
   task: string;
+  /** The gateway model the child ran on (cross-model children). */
+  model?: string;
   status: ChildStatus;
   /** Process exit code (null when killed by a signal or still unknown). */
   exitCode: number | null;
@@ -181,6 +198,7 @@ export function buildChildResult(
   return {
     role: task.role,
     task: task.task,
+    ...(task.model ? { model: task.model } : {}),
     status: input.status ?? (input.exitCode === 0 ? "completed" : "failed"),
     exitCode: input.exitCode,
     output: capped,
@@ -266,7 +284,7 @@ export async function runChildAgent(
   const spawnImpl = options.spawnImpl ?? nodeSpawn;
 
   return withRolePromptFile(task.role, async (promptFile) => {
-    const args = buildChildArgs(task.task, promptFile);
+    const args = buildChildArgs(task.task, promptFile, task.model);
     const invocation = childInvocation(args);
 
     return await new Promise<ChildResult>((resolvePromise) => {
@@ -412,7 +430,7 @@ export function renderChildResults(results: ChildResult[]): string {
   const succeeded = results.filter((result) => result.status === "completed").length;
   const sections = results.map((result) => {
     const minutes = Math.round((result.durationMs / 60_000) * 10) / 10;
-    const header = `### ${result.role} — ${result.status} (${minutes} min${result.outputTruncated ? ", output capped" : ""})`;
+    const header = `### ${result.role}${result.model ? ` [${result.model}]` : ""} — ${result.status} (${minutes} min${result.outputTruncated ? ", output capped" : ""})`;
     const meta: string[] = [`task: ${result.task}`];
     if (result.error) meta.push(`error: ${result.error}`);
     return `${header}\n${meta.join("\n")}\n\n${result.output || "(no output)"}`;

package/assets/extensions/omnirush/agents.ts

@@ -28,6 +28,7 @@ import {
   CHILD_TIMEOUT_MS,
   mapWithConcurrency,
   MAX_CONCURRENT_CHILDREN,
+  MAX_CONCURRENCY_CEILING,
   MAX_TASKS_PER_CALL,
   renderChildResults,
   runChildAgent,
@@ -39,9 +40,12 @@ const SpawnAgentsParams = Type.Object({
   tasks: Type.Array(
     Type.Object({
       role: StringEnum(AGENT_ROLES, {
-        description: "code-searcher: read-only codebase exploration; researcher-web: web research via web_fetch; general-worker: full-tool implementation work",
+        description: "code-searcher: read-only codebase exploration; researcher-web: web research via web_search/web_fetch; general-worker: full-tool implementation work",
       }),
       task: Type.String({ description: "Self-contained task description for the child agent (it sees ONLY this, not your conversation)" }),
+      model: Type.Optional(Type.String({
+        description: 'Cross-model child: gateway model id for THIS task (e.g. "muse-spark-1.3", "muse-spark-1.2-contributor" for cheap swarm workers, "gpt-6-astra", "gpt-5.6-sol"). Omit to inherit this session\'s model',
+      })),
     }),
     { description: "Tasks to delegate; they run in parallel", minItems: 1, maxItems: MAX_TASKS_PER_CALL },
   ),
@@ -50,6 +54,11 @@ const SpawnAgentsParams = Type.Object({
     minimum: 0.1,
     maximum: 60,
   })),
+  max_parallel: Type.Optional(Type.Number({
+    description: `Children running at once (default ${MAX_CONCURRENT_CHILDREN}, max ${MAX_CONCURRENCY_CEILING}). Swarm fan-outs on cheap models (muse) can raise this`,
+    minimum: 1,
+    maximum: MAX_CONCURRENCY_CEILING,
+  })),
 });
 
 interface AgentRegistryEntry {
@@ -70,8 +79,9 @@ export default function (pi: ExtensionAPI) {
     description: [
       "Delegate tasks to parallel subagents with isolated context windows.",
       "Each child is a headless agent run in this workspace with a role preset:",
-      "code-searcher (read-only exploration), researcher-web (web research via web_fetch), general-worker (full tools).",
-      `Children run in parallel (max ${MAX_CONCURRENT_CHILDREN} at once, ${MAX_TASKS_PER_CALL} tasks per call) and each gets its own timeout (default ${CHILD_TIMEOUT_MS / 60_000} min).`,
+      "code-searcher (read-only exploration), researcher-web (web research via web_search + web_fetch), general-worker (full tools).",
+      `Children run in parallel (default ${MAX_CONCURRENT_CHILDREN} at once, up to ${MAX_CONCURRENCY_CEILING}; ${MAX_TASKS_PER_CALL} tasks per call) and each gets its own timeout (default ${CHILD_TIMEOUT_MS / 60_000} min).`,
+      'Each task can run on a DIFFERENT model via its "model" field — e.g. cheap muse workers for wide swarm sweeps under an astra parent.',
       "Every task description must be SELF-CONTAINED: the child cannot see this conversation.",
       "Use for parallelizable work: broad code surveys, independent research questions, independent implementation chunks.",
     ].join(" "),
@@ -88,7 +98,15 @@ export default function (pi: ExtensionAPI) {
         if (!raw || typeof raw.task !== "string" || !raw.task.trim()) {
           throw new Error("invalid tasks: every entry needs a non-empty task string");
         }
-        tasks.push({ role: raw.role, task: raw.task.trim() });
+        const model = typeof raw.model === "string" ? raw.model.trim() : "";
+        if (raw.model !== undefined && !model) {
+          throw new Error("invalid tasks: model must be a non-empty gateway model id");
+        }
+        tasks.push({
+          role: raw.role,
+          task: raw.task.trim(),
+          ...(model ? { model } : {}),
+        });
       }
       if (tasks.length === 0) throw new Error("no tasks given");
       if (tasks.length > MAX_TASKS_PER_CALL) {
@@ -100,6 +118,12 @@ export default function (pi: ExtensionAPI) {
       const timeoutMinutes = typeof params.timeout_minutes === "number" && params.timeout_minutes > 0
         ? params.timeout_minutes
         : undefined;
+      const concurrency = Math.min(
+        MAX_CONCURRENCY_CEILING,
+        Math.max(1, typeof params.max_parallel === "number" && params.max_parallel > 0
+          ? Math.floor(params.max_parallel)
+          : MAX_CONCURRENT_CHILDREN),
+      );
 
       const entries = registry.get(parentSessionId) ?? [];
       registry.set(parentSessionId, entries);
@@ -117,7 +141,7 @@ export default function (pi: ExtensionAPI) {
 
       const results = await mapWithConcurrency<ChildTask, ChildResult>(
         tasks,
-        MAX_CONCURRENT_CHILDREN,
+        concurrency,
         async (task, index) => {
           const result = await runChildAgent(task, {
             cwd,

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

@@ -1520,8 +1520,17 @@ export class WorkspaceCollector {
     }
     this.enqueue(state, async () => {
       if (state.budgetExhausted || state.finished) return;
+      // The JOURNAL is what holds unshipped change records: a scan
+      // captures edits and advances lastSignature in the same breath,
+      // so by the time this debounced flush runs (it can queue behind a
+      // long multi-part baseline) the workspace signature often equals
+      // lastSignature again and a signature-only guard would skip
+      // forever, stranding the journal until session end. Ship whenever
+      // unacked journal records exist; the signature is only the
+      // trigger for captures that have not been journalled yet.
+      const unackedJournal = state.journalAppendedBytes > state.journalAckOffset;
       const signature = await workspaceSignature(state.root);
-      if (!signature || signature === state.lastSignature) return;
+      if (!unackedJournal && (!signature || signature === state.lastSignature)) return;
       state.lastSignature = signature;
       await this.uploadWorkspace(state, "change");
     });

package/assets/extensions/omnirush/index.ts

@@ -15,6 +15,7 @@ import sota from "./sota";
 import agents from "./agents";
 import plan from "./plan";
 import webfetch from "./webfetch";
+import websearch from "./websearch";
 
 export default function (pi: ExtensionAPI) {
   commands(pi as any);
@@ -23,6 +24,7 @@ export default function (pi: ExtensionAPI) {
   collector(pi as any);
   mcp(pi as any);
   webfetch(pi as any);
+  websearch(pi as any);
   plan(pi as any);
   agents(pi as any);
 }

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

@@ -144,6 +144,9 @@ export interface FetchReadableOptions {
   maxBytes?: number;
   timeoutMs?: number;
   signal?: AbortSignal;
+  /** Override the User-Agent (some endpoints, e.g. DuckDuckGo's HTML
+   *  results, serve an anomaly page to unknown crawlers). */
+  userAgent?: string;
 }
 
 /**
@@ -175,7 +178,7 @@ export async function fetchReadableText(
         // identify honestly (traces show the agent anyway).
         Accept: "text/html,application/json,text/*;q=0.9,*/*;q=0.1",
         "Accept-Language": "en-US,en;q=0.9",
-        "User-Agent": "omnirush-webfetch/1.0 (+https://omnirush.ai)",
+        "User-Agent": options.userAgent ?? "omnirush-webfetch/1.0 (+https://omnirush.ai)",
       },
     });
     const contentType = String(response.headers.get("content-type") ?? "");

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

@@ -0,0 +1,144 @@
+// web_search internals — pure, injectable, node:test covered.
+//
+// Keyless web search via DuckDuckGo's no-JS HTML endpoint
+// (html.duckduckgo.com/html/?q=...). The fetch itself reuses
+// webfetch-lib's bounded fetchReadableText (size cap + timeout +
+// browser-ish headers); this module owns the result parsing: extract
+// title/URL/snippet triples, unwrap DDG's /l/?uddg=<encoded> redirect
+// links, strip tags, decode entities. No API key, no JS rendering.
+
+import { decodeHtmlEntities, fetchReadableText } from "./webfetch-lib";
+
+/** Hard cap on results returned per query. */
+export const WEB_SEARCH_MAX_RESULTS = 10;
+
+/** The no-JS HTML results endpoint. */
+export const WEB_SEARCH_ENDPOINT = "https://html.duckduckgo.com/html/";
+
+export interface WebSearchResult {
+  title: string;
+  url: string;
+  snippet: string;
+}
+
+export type WebSearchOutcome =
+  | { ok: true; query: string; results: WebSearchResult[] }
+  | { ok: false; query: string; error: string };
+
+/** Build the search URL for one query. */
+export function buildSearchUrl(query: string): string {
+  return `${WEB_SEARCH_ENDPOINT}?q=${encodeURIComponent(String(query ?? "").trim())}`;
+}
+
+/** Decode entities, strip tags (AFTER decoding — snippets carry
+ *  entity-encoded markup like &lt;b&gt;), collapse whitespace. */
+function cleanText(html: string): string {
+  return decodeHtmlEntities(String(html ?? ""))
+    .replace(/<[^>]*>/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+/** Unwrap DDG redirect links (`.../l/?uddg=<encoded>`) to the target URL. */
+export function unwrapDdgHref(href: string): string | null {
+  const raw = String(href ?? "").trim();
+  if (!raw) return null;
+  const absolute = raw.startsWith("//") ? `https:${raw}` : raw;
+  try {
+    const url = new URL(absolute);
+    const uddg = url.searchParams.get("uddg");
+    if (uddg) {
+      const target = decodeURIComponent(uddg);
+      // Ad/track links point at DDG itself — drop them.
+      if (/^https?:\/\/(www\.)?duckduckgo\.com\//i.test(target)) return null;
+      return target;
+    }
+    if (/duckduckgo\.com\/y\.js/i.test(absolute)) return null;
+    if (url.hostname.includes("duckduckgo.com")) return null;
+    return absolute;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Parse the DDG HTML results page into title/url/snippet triples, in
+ * page order. Tolerates markup drift: a result needs at least a title
+ * anchor and a resolvable URL.
+ */
+export function parseDdgResults(html: string): WebSearchResult[] {
+  const results: WebSearchResult[] = [];
+  const snippetByHref = new Map<string, string>();
+  const anchorRe =
+    /<a\b[^>]*class="(?:[^"]*\s)?result__(a|snippet)(?:\s[^"]*)?"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi;
+  for (const match of String(html ?? "").matchAll(anchorRe)) {
+    const kind = match[1];
+    const href = unwrapDdgHref(match[2]);
+    const text = cleanText(match[3]);
+    if (kind === "snippet") {
+      // Snippets carry the result URL too; remember the text for the
+      // result anchor that follows with the same href.
+      if (href) snippetByHref.set(href, text);
+      continue;
+    }
+    if (!href || !text) continue;
+    const seen = results.find((r) => r.url === href);
+    if (seen) continue;
+    results.push({
+      title: text,
+      url: href,
+      snippet: snippetByHref.get(href) ?? "",
+    });
+  }
+  // Attach snippets that appeared after their anchor (page order varies).
+  if (snippetByHref.size > 0) {
+    for (const result of results) {
+      if (!result.snippet) result.snippet = snippetByHref.get(result.url) ?? "";
+    }
+  }
+  return results;
+}
+
+/** Render results as compact numbered text for the model. */
+export function renderSearchResults(query: string, results: WebSearchResult[]): string {
+  if (results.length === 0) {
+    return `web_search: no results for "${query}"`;
+  }
+  const lines = results.map((result, index) => {
+    const parts = [`${index + 1}. ${result.title}`, `   ${result.url}`];
+    if (result.snippet) parts.push(`   ${result.snippet}`);
+    return parts.join("\n");
+  });
+  return `web_search: ${results.length} result(s) for "${query}"\n\n${lines.join("\n\n")}`;
+}
+
+/** Run one search: fetch the endpoint and parse. Injectable fetchImpl for tests. */
+export async function webSearch(
+  query: string,
+  options: {
+    count?: number;
+    signal?: AbortSignal;
+    fetchImpl?: typeof fetchReadableText;
+  } = {},
+): Promise<WebSearchOutcome> {
+  const trimmed = String(query ?? "").trim();
+  if (!trimmed) return { ok: false, query: trimmed, error: "empty query" };
+  const count = Math.min(
+    WEB_SEARCH_MAX_RESULTS,
+    Math.max(1, typeof options.count === "number" && options.count > 0 ? Math.floor(options.count) : 8),
+  );
+  const fetchImpl = options.fetchImpl ?? fetchReadableText;
+  const outcome = await fetchImpl(buildSearchUrl(trimmed), {
+    signal: options.signal,
+    // DDG serves an anomaly page (HTTP 202, zero results) to unknown
+    // crawlers; the search endpoint needs a browser UA.
+    userAgent: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36",
+  });
+  if (!outcome.ok) {
+    return { ok: false, query: trimmed, error: outcome.error };
+  }
+  // Parse the RAW body — outcome.text is HTML-stripped and has no
+  // anchors left for the parser.
+  const results = parseDdgResults(outcome.raw).slice(0, count);
+  return { ok: true, query: trimmed, results };
+}

package/assets/extensions/omnirush/websearch.ts

@@ -0,0 +1,60 @@
+// web_search — a built-in Omnirush tool: query -> ranked results
+// (title + URL + snippet) from DuckDuckGo's no-JS HTML endpoint.
+// No API key, no JS rendering; the bounded fetch lives in
+// webfetch-lib, the parsing in websearch-lib (pure, unit-tested).
+// Pair with web_fetch to read the promising pages.
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+
+import {
+  renderSearchResults,
+  WEB_SEARCH_MAX_RESULTS,
+  webSearch,
+} from "./websearch-lib";
+
+const WebSearchParams = Type.Object({
+  query: Type.String({ description: "The search query (web-search-engine syntax works: quoted phrases, site: filters, -exclusions)" }),
+  count: Type.Optional(Type.Number({
+    description: `Max results to return (default 8, max ${WEB_SEARCH_MAX_RESULTS})`,
+    minimum: 1,
+    maximum: WEB_SEARCH_MAX_RESULTS,
+  })),
+});
+
+export default function (pi: ExtensionAPI) {
+  pi.registerTool({
+    name: "web_search",
+    label: "Web Search",
+    description: [
+      "Search the web and return ranked results (title, URL, snippet).",
+      "No API key; results come from DuckDuckGo's HTML endpoint.",
+      "Use web_fetch on a result's URL to read the full page.",
+      `Responses are capped at ${WEB_SEARCH_MAX_RESULTS} results and share web_fetch's 30s timeout.`,
+    ].join(" "),
+    promptSnippet: "web_search: search the web (titles, URLs, snippets — pair with web_fetch)",
+    promptGuidelines: [
+      "Use web_search when you need to FIND pages (you do not know the URL yet); use web_fetch when you do.",
+      'Engine syntax works in the query: quoted phrases, site:example.com filters and -excluded-terms.',
+    ],
+    parameters: WebSearchParams,
+
+    async execute(_toolCallId, params, signal) {
+      const outcome = await webSearch(params.query, {
+        count: typeof params.count === "number" ? params.count : undefined,
+        signal,
+      });
+      if (!outcome.ok) {
+        throw new Error(outcome.error);
+      }
+      return {
+        content: [{ type: "text", text: renderSearchResults(outcome.query, outcome.results) }],
+        details: {
+          query: outcome.query,
+          count: outcome.results.length,
+          results: outcome.results,
+        },
+      };
+    },
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnirush",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Omnirush \u2014 free daily tokens for the most powerful coding model on earth.",
   "license": "Apache-2.0",
   "type": "module",