@kevin5251984/guild 0.2.18 → 0.2.19

package/src/mention.ts

@@ -1,8 +1,13 @@
 /** @channel / @quest / @here / @all still mean the whole quest. */
 const BROADCAST = /(^|\s)@(channel|quest|here|all)\b/i;
 const HANDLE = /@([A-Za-z0-9_-]+)/g;
-/** Consecutive @handles at the start of a line. */
-const LINE_LEAD = /^[ \t]*((?:@[A-Za-z0-9_-]+[\s,、]*)+)/;
+/** Consecutive @handles at the start of a line (optional backticks). */
+const LINE_LEAD = /^[ \t]*((?:`?@[A-Za-z0-9_-]+`?[\s,、]*)+)/;
+/** `1. @design` / `- @infra`. */
+const LIST_MARK = /^[ \t]*(?:\d+[.)、]\s*|[-*•]\s+)/;
+/** Assignee right after the marker, or after 通過後/最後/再叫… — not the first @ anywhere on the line. */
+const LIST_ASSIGN =
+  /^(?:`?@([A-Za-z0-9_-]+)`?|(?:通過後|最後|再叫|交給|交棒(?:給)?|指派|(?:call|ask)\s+)\s*`?@([A-Za-z0-9_-]+)`?)/i;
 
 /** Drop fenced / inline code so `@pm` in a snippet does not dispatch. */
 export function stripMentionNoise(text: string): string {
@@ -32,13 +37,24 @@ export type MentionBlock = {
   start: number;
   end: number;
   handles: string[];
+  kind: "lead" | "list";
 };
 
-/** Line-start @handle groups. Prose `@pm` in the middle of a line is not a block. */
+function knownHandlesIn(chunk: string, known: Set<string>): string[] {
+  const names: string[] = [];
+  for (const row of chunk.matchAll(HANDLE)) {
+    const key = row[1].toLowerCase();
+    if (!known.has(key) || names.includes(key)) continue;
+    names.push(key);
+  }
+  return names;
+}
+
+/** Line-start @handle groups, plus markdown list items that name a seat. */
 export function lineStartMentions(text: string, handles: string[]): MentionBlock[] {
   const raw = String(text ?? "");
   const known = new Set(handles.map((handle) => handle.toLowerCase()));
-  const starts: { start: number; handles: string[] }[] = [];
+  const starts: { start: number; handles: string[]; kind: "lead" | "list" }[] = [];
   let fence = false;
   let offset = 0;
   for (const part of raw.split(/(\r?\n)/)) {
@@ -53,15 +69,22 @@ export function lineStartMentions(text: string, handles: string[]): MentionBlock
       continue;
     }
     if (!fence) {
+      const listed = LIST_MARK.test(part);
       const lead = part.match(LINE_LEAD);
-      if (lead) {
-        const names: string[] = [];
-        for (const row of lead[1].matchAll(HANDLE)) {
-          const key = row[1].toLowerCase();
-          if (!known.has(key) || names.includes(key)) continue;
-          names.push(key);
-        }
-        if (names.length) starts.push({ start: offset, handles: names });
+      let names: string[] = [];
+      if (lead) names = knownHandlesIn(lead[1], known);
+      if (!names.length && listed) {
+        const rest = part.replace(LIST_MARK, "");
+        const hit = rest.match(LIST_ASSIGN);
+        const key = (hit?.[1] || hit?.[2] || "").toLowerCase();
+        if (key && known.has(key)) names = [key];
+      }
+      if (names.length) {
+        starts.push({
+          start: offset,
+          handles: names,
+          kind: listed ? "list" : "lead",
+        });
       }
     }
     offset += part.length;
@@ -70,6 +93,7 @@ export function lineStartMentions(text: string, handles: string[]): MentionBlock
     start: row.start,
     end: i + 1 < starts.length ? starts[i + 1].start : raw.length,
     handles: row.handles,
+    kind: row.kind,
   }));
 }
 
@@ -104,6 +128,87 @@ export function summonedHandles(text: string, handles: string[]): string[] {
   return [];
 }
 
+/** Fenced samples only. Keep inline `code` so 「再叫 `@infra`」 still parses. */
+function stripFences(text: string): string {
+  return String(text ?? "").replace(/```[\s\S]*?```/g, " ");
+}
+
+/**
+ * Bot replies: line-start specs, else first prose @handle, plus assignment verbs
+ * even when the handle is wrapped in backticks (models quote @infra a lot).
+ * Fixture chatter like `(@pm / @rd)` has no verb, so it does not hop.
+ */
+const HANDOFF_ASK =
+  /(?:(?:再叫|交給|交棒(?:給)?|指派)\s*|(?:call|ask|ping|notify|handoff(?:\s+to)?)\s+)`?@([A-Za-z0-9_-]+)`?/gi;
+
+export function handoffHandles(text: string, handles: string[]): string[] {
+  const known = new Set(handles.map((handle) => handle.toLowerCase()));
+  const out = summonedHandles(text, handles);
+  const ask = new RegExp(HANDOFF_ASK.source, "gi");
+  for (const row of stripFences(text).matchAll(ask)) {
+    const key = row[1].toLowerCase();
+    if (!known.has(key) || out.includes(key)) continue;
+    out.push(key);
+  }
+  return out;
+}
+
+export type MentionBot = { id: string; handle: string };
+
+export function sanitizeMentionIds(
+  raw: unknown,
+  bots: MentionBot[],
+): string[] {
+  if (!Array.isArray(raw)) return [];
+  const known = new Set(bots.map((bot) => bot.id));
+  const out: string[] = [];
+  for (const item of raw) {
+    if (typeof item !== "string") continue;
+    const id = item.trim();
+    if (!id || !known.has(id) || out.includes(id)) continue;
+    out.push(id);
+  }
+  return out;
+}
+
+export function parseMentionIds(
+  text: string,
+  bots: MentionBot[],
+  kind: "user" | "bot",
+): string[] {
+  if (isBroadcastMention(text)) return [];
+  const handles = bots.map((bot) => bot.handle);
+  const names =
+    kind === "bot" ? handoffHandles(text, handles) : summonedHandles(text, handles);
+  const out: string[] = [];
+  for (const name of names) {
+    const bot = bots.find(
+      (row) => row.handle.toLowerCase() === name.toLowerCase(),
+    );
+    if (!bot || out.includes(bot.id)) continue;
+    out.push(bot.id);
+  }
+  return out;
+}
+
+/**
+ * Prefer the stored mention list. Older rows without the field still parse the body.
+ * An empty stored list means nobody.
+ */
+export function messageMentionIds(
+  message: { author: string; body: string; mentions?: string[] },
+  bots: MentionBot[],
+): string[] {
+  const ids = Array.isArray(message.mentions)
+    ? sanitizeMentionIds(message.mentions, bots)
+    : parseMentionIds(
+        message.body,
+        bots,
+        message.author === "you" ? "user" : "bot",
+      );
+  return ids.filter((id) => id !== message.author);
+}
+
 /**
  * Spec for one seat: shared preamble plus that @handle's line-start block.
  * Full text when the handle was only summoned in prose.
@@ -119,6 +224,8 @@ export function assignmentFor(
   if (!key || !blocks.length) return raw;
   const mine = blocks.filter((block) => block.handles.includes(key));
   if (!mine.length) return raw;
+  // Numbered plans share constraints ("don't ship until PM signs off"). Slice only classic specs.
+  if (!blocks.some((block) => block.kind === "lead")) return raw;
   const preamble = raw.slice(0, blocks[0].start).trim();
   const chunks = mine.map((block) => raw.slice(block.start, block.end).trim());
   return [preamble, ...chunks].filter(Boolean).join("\n\n");

package/src/oauth.ts

@@ -1057,6 +1057,109 @@ function thinkingText(message: AssistantMessage | undefined): string {
     .trim();
 }
 
+/**
+ * Codex `DEFAULT_STREAM_IDLE_TIMEOUT_MS`. No tokens on the stream — not a
+ * wall clock on the whole turn. Do not pass this as Pi `timeoutMs` for xAI:
+ * OpenAI-completions maps that to the SDK request timeout and kills thinking.
+ */
+export const STREAM_IDLE_TIMEOUT_MS = 300_000;
+
+export function isTransientLlmError(err: unknown): boolean {
+  if (err instanceof StreamIdleError) return false;
+  const text = err instanceof Error ? `${err.name} ${err.message}` : String(err);
+  return /econnreset|econnrefused|etimedout|enotfound|eai_again|fetch failed|socket|network|empty reply|429|502|503|504|5\d\d/i.test(
+    text,
+  );
+}
+
+export async function withTransientRetries<T>(
+  run: () => Promise<T>,
+  opts: {
+    signal?: AbortSignal;
+    attempts?: number;
+    onRetry?: (attempt: number, err: unknown) => void;
+  } = {},
+): Promise<T> {
+  const attempts = opts.attempts ?? 3;
+  let last: unknown;
+  for (let i = 0; i < attempts; i++) {
+    if (opts.signal?.aborted) {
+      throw userAborted(opts.signal);
+    }
+    try {
+      return await run();
+    } catch (err) {
+      last = err;
+      if (err instanceof Error && err.name === "AbortError") throw err;
+      if (opts.signal?.aborted) throw err;
+      if (!isTransientLlmError(err) || i === attempts - 1) throw err;
+      opts.onRetry?.(i + 1, err);
+      await new Promise((resolve) => setTimeout(resolve, 400 * (i + 1)));
+    }
+  }
+  throw last instanceof Error ? last : new Error(String(last));
+}
+
+export class StreamIdleError extends Error {
+  readonly idleMs: number;
+  constructor(idleMs: number) {
+    super(
+      `stream idle: no tokens for ${Math.round(idleMs / 1000)}s (Codex-style; not a turn wall clock). Resend or switch models.`,
+    );
+    this.name = "StreamIdleError";
+    this.idleMs = idleMs;
+  }
+}
+
+export function startStreamIdle(
+  idleMs: number,
+  parent?: AbortSignal,
+): {
+  signal: AbortSignal;
+  bump: () => void;
+  dispose: () => void;
+  timedOut: () => boolean;
+} {
+  const ctrl = new AbortController();
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let timedOut = false;
+  const fire = () => {
+    if (timedOut || ctrl.signal.aborted) return;
+    timedOut = true;
+    ctrl.abort();
+  };
+  const bump = () => {
+    if (timedOut || parent?.aborted) return;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(fire, idleMs);
+  };
+  const onParent = () => {
+    if (timer) clearTimeout(timer);
+    ctrl.abort();
+  };
+  if (parent?.aborted) {
+    ctrl.abort();
+  } else {
+    parent?.addEventListener("abort", onParent, { once: true });
+  }
+  bump();
+  return {
+    signal: ctrl.signal,
+    bump,
+    dispose: () => {
+      if (timer) clearTimeout(timer);
+      parent?.removeEventListener("abort", onParent);
+    },
+    timedOut: () => timedOut,
+  };
+}
+
+function userAborted(signal?: AbortSignal): Error {
+  const err = new Error("aborted");
+  err.name = "AbortError";
+  return err;
+}
+
 /** Pi streamSimple: Think chips only from thinking_delta, not a planted placeholder. */
 async function streamOAuthMessage(
   models: MutableModels,
@@ -1066,7 +1169,11 @@ async function streamOAuthMessage(
   toolCtx: ToolContext,
   traces: ToolTrace[],
 ): Promise<AssistantMessage> {
-  const stream = models.streamSimple(model, context, options);
+  const idle = startStreamIdle(STREAM_IDLE_TIMEOUT_MS, options?.signal);
+  const stream = models.streamSimple(model, context, {
+    ...options,
+    signal: idle.signal,
+  });
   let lastEmit = 0;
   const flush = (partial: AssistantMessage | undefined, force: boolean) => {
     const think = thinkingText(partial);
@@ -1076,19 +1183,40 @@ async function streamOAuthMessage(
     lastEmit = now;
     emitProgress(toolCtx, traces, think);
   };
-  for await (const event of stream) {
-    if (event.type === "thinking_start" || event.type === "thinking_delta") {
-      flush(event.partial, event.type === "thinking_start");
-    } else if (event.type === "thinking_end") {
-      flush(event.partial, true);
-    } else if (event.type === "done") {
-      flush(event.message, true);
-      return event.message;
-    } else if (event.type === "error") {
-      return event.error;
+  const failIfIdle = (): never => {
+    if (options?.signal?.aborted) throw userAborted(options.signal);
+    throw new StreamIdleError(STREAM_IDLE_TIMEOUT_MS);
+  };
+  try {
+    for await (const event of stream) {
+      idle.bump();
+      if (event.type === "thinking_start" || event.type === "thinking_delta") {
+        flush(event.partial, event.type === "thinking_start");
+      } else if (event.type === "thinking_end") {
+        flush(event.partial, true);
+      } else if (event.type === "done") {
+        flush(event.message, true);
+        return event.message;
+      } else if (event.type === "error") {
+        if (idle.timedOut() || options?.signal?.aborted) failIfIdle();
+        return event.error;
+      }
+    }
+    if (idle.timedOut() || options?.signal?.aborted) failIfIdle();
+    return stream.result();
+  } catch (err) {
+    if (err instanceof StreamIdleError) throw err;
+    if (err instanceof Error && err.name === "AbortError") {
+      if (options?.signal?.aborted) throw err;
+      if (idle.timedOut()) throw new StreamIdleError(STREAM_IDLE_TIMEOUT_MS);
+    }
+    if (idle.timedOut() && !(options?.signal?.aborted)) {
+      throw new StreamIdleError(STREAM_IDLE_TIMEOUT_MS);
     }
+    throw err;
+  } finally {
+    idle.dispose();
   }
-  return stream.result();
 }
 
 function abortWhen(signal?: AbortSignal): Promise<never> {
@@ -1252,21 +1380,70 @@ export async function completeOAuth(input: {
       if (fitted.length < transcript.length) {
         transcript.splice(0, transcript.length, ...fitted);
       }
-      const result = await Promise.race([
-        streamOAuthMessage(
-          models,
-          model,
+      let result: AssistantMessage;
+      try {
+        result = await withTransientRetries(
+          async () => {
+            const got = await Promise.race([
+              streamOAuthMessage(
+                models,
+                model,
+                {
+                  systemPrompt: input.system,
+                  messages: transcript,
+                  ...(useTools ? { tools } : {}),
+                },
+                options,
+                toolCtx,
+                traces,
+              ),
+              abortWhen(options.signal),
+            ]);
+            if (got.stopReason === "aborted") {
+              const err = new Error("aborted");
+              err.name = "AbortError";
+              throw err;
+            }
+            if (got.stopReason === "error") {
+              throw new Error(
+                formatOAuthError(sub.id, got.errorMessage) ||
+                  `${sub.id} request failed`,
+              );
+            }
+            const text = contentText(got.content).trim();
+            const toolCalls =
+              got.stopReason === "toolUse"
+                ? got.content.filter(
+                    (part): part is Extract<typeof part, { type: "toolCall" }> =>
+                      part.type === "toolCall",
+                  )
+                : [];
+            if (!toolCalls.length && !text && traces.length === 0) {
+              throw new Error(`${sub.id} returned an empty reply`);
+            }
+            return got;
+          },
           {
-            systemPrompt: input.system,
-            messages: transcript,
-            ...(useTools ? { tools } : {}),
+            signal: options.signal,
+            onRetry: () => {
+              emitProgress(
+                toolCtx,
+                traces,
+                thinkingChunks.join("\n\n") || "連線中斷，重試中…",
+              );
+            },
           },
-          options,
-          toolCtx,
-          traces,
-        ),
-        abortWhen(options.signal),
-      ]);
+        );
+      } catch (err) {
+        if (err instanceof StreamIdleError) {
+          return {
+            calls: [],
+            text: err.message,
+            thinking: thinkingChunks.join("\n\n"),
+          };
+        }
+        throw err;
+      }
       if (result.stopReason === "aborted" || toolCtx.signal?.aborted || options.signal?.aborted) {
         const err = new Error("aborted");
         err.name = "AbortError";

package/src/opencode-free.ts

@@ -0,0 +1,247 @@
+import type { ModelEntry, ProviderEntry } from "@guild/protocol";
+
+/** Built-in alias `free` → this provider, matching Hermes Agent (2026-08). */
+export const OPENCODE_FREE_PROVIDER_ID = "opencode-free";
+export const OPENCODE_FREE_BASE_URL = "https://opencode.ai/zen/v1";
+
+const ALIASES = new Set(["opencode-free", "free", "opencode_free"]);
+
+/**
+ * Offline floor — Hermes Agent's curated catalog.
+ * Live GET /zen/v1/models is the source of truth when reachable.
+ * Known-delisted slugs must not stay here (they 401 keyless).
+ */
+export const OPENCODE_FREE_FLOOR = [
+  "laguna-s-2.1-free",
+  "mimo-v2.5-free",
+  "nemotron-3.5-lightning-free",
+  "nemotron-3-ultra-free",
+  "muse-spark-1.2-contributor-free",
+  "ling-3.0-flash-fin-free",
+  "deepseek-v4-flash-free",
+] as const;
+
+/** Default pick — user-facing Guild default, routed to `/v1/responses`. */
+export const OPENCODE_FREE_DEFAULT_MODEL = "muse-spark-1.2-contributor-free";
+
+/**
+ * Hermes `opencode_model_api_mode`: Muse Spark on Zen/Go is Responses-only.
+ * `/v1/chat/completions` 500s; `/v1/responses` completes.
+ */
+export function usesZenResponses(model: string): boolean {
+  return String(model || "")
+    .trim()
+    .toLowerCase()
+    .startsWith("muse-spark");
+}
+
+/** Free slugs that do not end in `-free` (OpenCode's rotating stealth slot). */
+const EXTRA_SLUGS = new Set(["big-pickle"]);
+
+/** `-free` suffix but KEYED (Go subscription), not anonymous. */
+const KEYED_FREE_SUFFIX = new Set(["ox-alpha-free"]);
+
+export function isKeylessProvider(id: string): boolean {
+  return ALIASES.has(String(id || "").trim().toLowerCase());
+}
+
+export function prettyOpenCodeFreeName(id: string): string {
+  const bare = String(id || "").trim().split("/").pop() || String(id || "");
+  const slug = bare.replace(/-/g, " ").replace(/\s+/g, " ").trim();
+  if (!slug) return id;
+  return slug.replace(/\b([a-z])/g, (ch) => ch.toUpperCase());
+}
+
+export function openCodeFreeModels(ids: readonly string[] = OPENCODE_FREE_FLOOR): ModelEntry[] {
+  return ids.map((id) => ({ id, name: prettyOpenCodeFreeName(id) }));
+}
+
+export function openCodeFreeProvider(): ProviderEntry {
+  return {
+    name: "OpenCode Free",
+    baseUrl: OPENCODE_FREE_BASE_URL,
+    api: "openai-completions",
+    apiKey: "",
+    models: openCodeFreeModels(),
+  };
+}
+
+export function filterOpenCodeFreeIds(ids: string[]): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const raw of ids) {
+    const id = String(raw || "").trim();
+    if (!id) continue;
+    const bare = (id.split("/").pop() || id).toLowerCase();
+    const ok =
+      (bare.endsWith("-free") && !KEYED_FREE_SUFFIX.has(bare)) ||
+      EXTRA_SLUGS.has(bare);
+    if (!ok || seen.has(bare)) continue;
+    seen.add(bare);
+    out.push(id.includes("/") ? bare : id);
+  }
+  return out;
+}
+
+export function llmRequestHeaders(target: {
+  providerId: string;
+  apiKey: string;
+  headers?: Record<string, string>;
+}): Record<string, string> {
+  const extra = { ...(target.headers ?? {}) };
+  if (isKeylessProvider(target.providerId)) {
+    const headers: Record<string, string> = {
+      "content-type": "application/json",
+      "http-referer": "https://github.com/Jakevin/guild",
+      "x-title": "Guild",
+      "user-agent": "Guild/0.2.19",
+      ...extra,
+    };
+    delete headers.authorization;
+    delete headers.Authorization;
+    return headers;
+  }
+  const headers: Record<string, string> = {
+    "content-type": "application/json",
+    ...extra,
+  };
+  if (!headers.authorization && !headers.Authorization) {
+    headers.authorization = `Bearer ${target.apiKey}`;
+  }
+  return headers;
+}
+
+let liveMemo: { at: number; ids: string[] | null } | null = null;
+const LIVE_TTL_MS = 300_000;
+
+export async function fetchOpenCodeFreeModels(
+  timeoutMs = 4_000,
+  force = false,
+): Promise<string[] | null> {
+  const now = Date.now();
+  if (!force && liveMemo && now - liveMemo.at < LIVE_TTL_MS) {
+    return liveMemo.ids ? [...liveMemo.ids] : null;
+  }
+  try {
+    const res = await fetch(`${OPENCODE_FREE_BASE_URL}/models`, {
+      headers: {
+        accept: "application/json",
+        "user-agent": "Guild/0.2.19",
+        "http-referer": "https://github.com/Jakevin/guild",
+        "x-title": "Guild",
+      },
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!res.ok) {
+      liveMemo = { at: now, ids: null };
+      return null;
+    }
+    const body = (await res.json()) as { data?: { id?: string }[] } | { id?: string }[];
+    const rows = Array.isArray(body) ? body : body.data;
+    const ids = filterOpenCodeFreeIds(
+      (rows ?? [])
+        .map((row) => (row && typeof row.id === "string" ? row.id : ""))
+        .filter(Boolean),
+    );
+    const result = ids.length ? ids : null;
+    liveMemo = { at: now, ids: result };
+    return result ? [...result] : null;
+  } catch {
+    liveMemo = { at: now, ids: null };
+    return null;
+  }
+}
+
+/** Tests only. */
+export function resetOpenCodeFreeMemo(): void {
+  liveMemo = null;
+}
+
+export type OpenCodeFreeProbe = {
+  id: string;
+  ok: boolean;
+  status: number;
+  reason?: string;
+};
+
+/** Health ping — not a turn timer. Muse /responses often needs ~7s. */
+export const OPENCODE_FREE_PROBE_TIMEOUT_MS = 12_000;
+const PROBE_CONCURRENCY = 4;
+
+type FetchLike = typeof fetch;
+
+export function selectOpenCodeFreeIds(
+  live: string[],
+  probe: OpenCodeFreeProbe[],
+  keepId?: string,
+): string[] {
+  const ok = new Set(probe.filter((row) => row.ok).map((row) => row.id));
+  const picked = live.filter((id) => ok.has(id));
+  if (keepId && live.includes(keepId) && !picked.includes(keepId) && picked.length) {
+    picked.push(keepId);
+  }
+  return picked;
+}
+
+export async function probeOpenCodeFreeModel(
+  id: string,
+  fetcher: FetchLike = fetch,
+): Promise<OpenCodeFreeProbe> {
+  const model = String(id || "").trim();
+  if (!model) return { id: model, ok: false, status: 0, reason: "empty" };
+  const responses = usesZenResponses(model);
+  const url = `${OPENCODE_FREE_BASE_URL}${responses ? "/responses" : "/chat/completions"}`;
+  const body = responses
+    ? { model, input: [{ role: "user", content: "ping" }] }
+    : {
+        model,
+        messages: [{ role: "user", content: "ping" }],
+        max_tokens: 16,
+      };
+  try {
+    const res = await fetcher(url, {
+      method: "POST",
+      headers: llmRequestHeaders({
+        providerId: OPENCODE_FREE_PROVIDER_ID,
+        apiKey: "",
+      }),
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(OPENCODE_FREE_PROBE_TIMEOUT_MS),
+    });
+    if (res.status === 429) {
+      return { id: model, ok: true, status: 429, reason: "rate-limited" };
+    }
+    if (!res.ok) {
+      return { id: model, ok: false, status: res.status, reason: `HTTP ${res.status}` };
+    }
+    return { id: model, ok: true, status: res.status };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const timeout = /timeout|aborted/i.test(message);
+    return {
+      id: model,
+      ok: false,
+      status: 0,
+      reason: timeout ? "timeout" : message || "error",
+    };
+  }
+}
+
+export async function probeOpenCodeFreeModels(
+  ids: string[],
+  fetcher: FetchLike = fetch,
+): Promise<OpenCodeFreeProbe[]> {
+  const list = ids.filter(Boolean);
+  const results: OpenCodeFreeProbe[] = new Array(list.length);
+  let next = 0;
+  const worker = async () => {
+    while (true) {
+      const i = next++;
+      if (i >= list.length) return;
+      results[i] = await probeOpenCodeFreeModel(list[i], fetcher);
+    }
+  };
+  const n = Math.min(PROBE_CONCURRENCY, Math.max(list.length, 0));
+  await Promise.all(Array.from({ length: n }, () => worker()));
+  return results;
+}