pi-supernova 0.0.15 → 0.1.0

package/index.js

@@ -1,5 +1,5 @@
 import { createRequire } from "node:module";
-import { isString, isFunction, isObject } from "./decode.js";
+import { isString, isFunction } from "./decode.js";
 import { buildCatalog, searchCatalog, describeTool, mergeNativeToolDefinitions } from "./catalog.js";
 import { loadConfig } from "./config.js";
 import { createHostBridge } from "./host-bridge.js";
@@ -82,7 +82,7 @@ function errorText(outcome, call) {
 
 function successText(outcome, call) {
   const truncated = outcome.returnTruncated ? " [return truncated]" : "";
-  const hint = outcome.undefinedReturn ? " (no return statement; add \`return\` to get a value)" : "";
+  const hint = outcome.undefinedReturn ? " (no return statement; add `return` to get a value)" : "";
   return `ok #${call} ${outcome.wallMs}ms${truncated}${logsBlock(outcome, "\n--- result")}\n${outcome.resultText}${hint}`;
 }
 const TOOL_DESCRIPTION = `Run one JavaScript program that composes host tools. Async body or arrow; \`return\` a small shaped value (compact literal, capped; strings raw; console.log is captured).
@@ -111,50 +111,38 @@ export default function piSupernova(pi) {
     getCwd: () => cwd,
   });
 
-  function refreshCatalog() {
-    let tools = [];
-    try {
-      if (isFunction(pi.getAllTools)) {
-        tools = pi.getAllTools() || [];
-      }
-    } catch {
-      tools = [];
-    }
-    const discoverable = mergeNativeToolDefinitions(tools, bridge.executors.keys());
+  function refreshCatalog(target = bridge) {
+    const tools = target.refreshTools();
+    const discoverable = mergeNativeToolDefinitions(tools, target.externalNames())
+      .filter(tool => target.isCallable(tool.name))
+      .map(tool => {
+        const schema = tool.parameters;
+        try {
+          if (isFunction(schema?.toJsonSchema)) return { ...tool, parameters: schema.toJsonSchema() };
+          if (schema && !schema.type && pi.zod?.toJSONSchema && (schema._zod || schema._def)) {
+            return { ...tool, parameters: pi.zod.toJSONSchema(schema, { io: "input" }) };
+          }
+          return tool;
+        } catch (error) {
+          return { ...tool, parameters: undefined, schemaError: error.message };
+        }
+      });
     catalog = buildCatalog(discoverable, config.excludeTools || []);
     return catalog;
   }
 
-  function makeNovaApi() {
+  function makeNovaApi(runBridge, runCatalog, cancel) {
     return {
-      async search(query, limit) {
-        const cat = catalog.length ? catalog : refreshCatalog();
-        const lim = Number.isInteger(limit) ? limit : config.maxSearchResults;
-        return searchCatalog(cat, query, lim);
-      },
-      async describe(name) {
-        const cat = catalog.length ? catalog : refreshCatalog();
-        return describeTool(cat, name);
-      },
-      async call(name, args) {
-        return bridge.call(name, args);
-      },
-      async callMany(calls) {
-        return bridge.callMany(calls);
-      },
-      speculateBegin() {
-        bridge.beginSpeculation();
-      },
-      async speculateCommit() {
-        await bridge.commitSpeculation();
-      },
-      speculateRollback() {
-        bridge.rollbackSpeculation();
-      },
-      names() {
-        const cat = catalog.length ? catalog : refreshCatalog();
-        return [...new Set([...cat.map((t) => t.name), ...bridge.executors.keys(), ...Object.keys(bridge.natives)])];
-      },
+      search: async (query, limit) => searchCatalog(runCatalog, query, Number.isInteger(limit) ? limit : config.maxSearchResults),
+      describe: async (name) => describeTool(runCatalog, name),
+      call: (name, args) => runBridge.call(name, args),
+      callMany: (calls) => runBridge.callMany(calls),
+      speculateBegin: () => runBridge.beginSpeculation(),
+      speculateCommit: () => runBridge.commitSpeculation(),
+      speculateRollback: () => runBridge.rollbackSpeculation(),
+      names: () => runCatalog.map(tool => tool.name),
+      batchRead: runBridge.supportsBatchRead(),
+      cancel,
     };
   }
 
@@ -177,70 +165,62 @@ export default function piSupernova(pi) {
     renderCall: renderSupernovaCall,
     renderResult: renderSupernovaResult,
     async execute(_id, params, signal, onUpdate, ctx) {
-      if (ctx && isString(ctx.cwd) && ctx.cwd) cwd = ctx.cwd;
+      const runCwd = ctx?.cwd || cwd;
       const runController = new AbortController();
       const abortRun = () => runController.abort(signal?.reason);
       if (signal?.aborted) abortRun();
       else signal?.addEventListener("abort", abortRun, { once: true });
+      const runBridge = bridge.fork({ getCwd: () => runCwd });
+      runBridge.bindCallContext(ctx, runController.signal);
+      runBridge.resetCallBudget();
 
-      bridge.bindCallContext(ctx, runController.signal);
-      bridge.resetCallBudget();
-      refreshCatalog();
-      bridge.beginSpeculation();
       const call = ++programSeq;
-      bridge.ledger.beginProgram(call);
+      runBridge.ledger.beginProgram(call);
       const emitProgress = progressEmitter(onUpdate);
-      bridge.setCallListener((_record, allTrace) => emitProgress(allTrace));
+      runBridge.setCallListener((_record, trace) => emitProgress(trace));
       emitProgress([]);
-
+      const started = performance.now();
       let outcome;
       try {
-        outcome = await runProgram(params, runController.signal, abortRun);
+        const runCatalog = refreshCatalog(runBridge);
+        runBridge.beginSpeculation();
+        outcome = await runGuestProgram({
+          code: params?.code,
+          nova: makeNovaApi(runBridge, runCatalog, abortRun),
+          config: { ...config, timeoutMs: Number.isInteger(params?.timeoutMs) ? params.timeoutMs : config.timeoutMs },
+          signal: runController.signal,
+          onTimeout: abortRun,
+        });
+        runBridge.close();
+        if (outcome.ok) {
+          if (runBridge.getOverlayDepth() !== 1) throw new Error("program ended with an unfinished nova.speculate branch; await it before returning");
+          await runBridge.commitSpeculation();
+        }
+        else runBridge.rollbackSpeculation();
+      } catch (error) {
+        abortRun();
+        runBridge.close();
+        runBridge.rollbackSpeculation();
+        outcome = { ok: false, error: error instanceof Error ? error.message : String(error), logs: outcome?.logs ?? [], wallMs: Math.round(performance.now() - started) };
       } finally {
-        bridge.setCallListener(null);
+        runBridge.setCallListener(null);
         emitProgress.flush();
         signal?.removeEventListener("abort", abortRun);
       }
-
-      const trace = bridge.getTrace();
-      if (!outcome.ok) {
-        bridge.rollbackSpeculation();
-        return result(bridge.ledger.dedupe(errorText(outcome, call), call), { ok: false, error: outcome.error, wallMs: outcome.wallMs, logs: outcome.logs, trace });
-      }
-      await bridge.commitSpeculation();
-      return result(bridge.ledger.dedupe(successText(outcome, call), call), {
-        ok: true,
-        wallMs: outcome.wallMs,
-        returnTruncated: outcome.returnTruncated,
-        logTruncated: outcome.logTruncated,
-        logs: outcome.logs,
-        result: outcome.result,
-        trace,
+      const trace = runBridge.getTrace();
+      const text = outcome.ok ? successText(outcome, call) : errorText(outcome, call);
+      return result(runBridge.ledger.dedupe(text, call), {
+        ok: outcome.ok, error: outcome.error, wallMs: outcome.wallMs,
+        returnTruncated: outcome.returnTruncated, logTruncated: outcome.logTruncated,
+        logs: outcome.logs, result: outcome.result, trace,
       });
     },
   });
 
-  async function runProgram(params, signal, onTimeout) {
-    const runStartedAt = performance.now();
-    const runConfig = {
-      ...config,
-      timeoutMs: Number.isInteger(params?.timeoutMs) ? params.timeoutMs : config.timeoutMs,
-    };
-    try {
-      return await runGuestProgram({ code: String(params?.code || ""), nova: makeNovaApi(), config: runConfig, signal, onTimeout });
-    } catch (error) {
-      return {
-        ok: false,
-        error: error instanceof Error ? error.message : String(error),
-        logs: [],
-        wallMs: Math.round(performance.now() - runStartedAt),
-      };
-    }
-  }
-
   pi.on("session_start", (_event, ctx) => {
     if (ctx && isString(ctx.cwd) && ctx.cwd) cwd = ctx.cwd;
     // A new session is a new model context: nothing has been seen yet.
+    bridge.bindCallContext(ctx);
     bridge.ledger.reset();
     programSeq = 0;
     refreshCatalog();
@@ -248,14 +228,15 @@ export default function piSupernova(pi) {
   });
 
   pi.registerCommand("supernova", {
-    description: "Show pi-supernova status (catalog size, captured executors)",
+    description: "Show pi-supernova status (callable tools and session statistics)",
     handler: async (_args, ctx) => {
+      bridge.bindCallContext(ctx);
       refreshCatalog();
-      const captured = [...bridge.executors.keys()].sort();
-      const natives = Object.keys(bridge.natives).sort();
+      const external = bridge.externalNames().filter(bridge.isCallable).sort();
+      const natives = Object.keys(bridge.natives).filter(name => bridge.isCallable(name) && !external.includes(name)).sort();
       const lines = [
         `pi-supernova catalog: ${catalog.length} tools`,
-        `captured executors: ${captured.length ? captured.join(", ") : "(none yet; load this package early)"}`,
+        `external tools: ${external.length ? external.join(", ") : "(none)"}`,
         `native adapters: ${natives.join(", ")}`,
         `timeoutMs=${config.timeoutMs} maxCallResultChars=${config.maxCallResultChars} maxReturnChars=${config.maxReturnChars} maxBridgeCalls=${config.maxBridgeCalls} maxHeapMb=${config.maxHeapMb}`,
         sessionStats(bridge.ledger.stats),

package/ledger.js

@@ -1,13 +1,3 @@
-// Seen-ledger: the model's context window is a memory. Nothing that already reached the
-// model in this session is sent again verbatim. A run of identical lines (≥ MIN_RUN, with
-// enough substantive lines) collapses to one marker that cites the earlier program and,
-// when the lines came from a file, path:a–b, so one read(path, a, n) recovers them.
-//
-// This is not compression: every collapsed line already exists, verbatim, in the model's
-// context. Changed lines are never collapsed, so a re-read after an edit shows exactly the
-// delta. Lines the current program read with an explicit offset/limit are pinned and always
-// shown: that is the model asking for a specific window on purpose.
-
 const MIN_RUN = 6;
 const MIN_SUBSTANTIVE = 4;
 const MAX_CANDIDATES = 8;
@@ -15,136 +5,118 @@ const DEFAULT_WINDOW = 40;
 const MAX_STORED_LINES = 200_000;
 
 function hashLine(line) {
-  let h = 0x811c9dc5;
-  for (let i = 0; i < line.length; i++) {
-    h ^= line.charCodeAt(i);
-    h = Math.imul(h, 0x01000193);
-  }
-  return h >>> 0;
+  let hash = 0x811c9dc5;
+  for (let i = 0; i < line.length; i++) hash = Math.imul(hash ^ line.charCodeAt(i), 0x01000193);
+  return hash >>> 0;
 }
-
-function substantive(line) {
-  return line.trim().length >= 8;
+function substantive(line) { return line.trim().length >= 8; }
+function newHistory() {
+  return { results: new Map(), occurrences: new Map(), storedLines: 0, latestCall: 0,
+    stats: { programs: 0, returnedChars: 0, collapsedChars: 0, collapsedRuns: 0 } };
 }
 
 export class SeenLedger {
-  constructor({ window = DEFAULT_WINDOW } = {}) {
+  constructor({ window = DEFAULT_WINDOW, history } = {}) {
     this.window = window;
-    this.results = new Map(); // call → { hashes: Uint32Array, lines: string[] }
-    this.occurrences = new Map(); // hash → [{ call, index }]
-    this.origins = new Map(); // hash → { path, line }  (provenance recorded by the bridge)
-    this.pinned = new Set(); // "path:line" pinned by the current program
-    this.storedLines = 0;
-    this.stats = { programs: 0, returnedChars: 0, collapsedChars: 0, collapsedRuns: 0 };
+    this.history = history ?? newHistory();
+    this.origins = new Map();
+    this.pinned = new Set();
   }
+  get results() { return this.history.results; }
+  get occurrences() { return this.history.occurrences; }
+  get storedLines() { return this.history.storedLines; }
+  get stats() { return this.history.stats; }
+  fork() { return new SeenLedger({ window: this.window, history: this.history }); }
 
   reset() {
-    this.results.clear();
-    this.occurrences.clear();
+    Object.assign(this.history, newHistory());
     this.origins.clear();
     this.pinned.clear();
-    this.storedLines = 0;
-    this.stats = { programs: 0, returnedChars: 0, collapsedChars: 0, collapsedRuns: 0 };
   }
 
   beginProgram(call) {
+    this.origins.clear();
     this.pinned.clear();
     this.stats.programs++;
-    for (const old of [...this.results.keys()]) {
-      if (old <= call - this.window) this.forget(old);
-    }
+    this.history.latestCall = Math.max(this.history.latestCall, call);
+    for (const old of this.results.keys()) if (old <= this.history.latestCall - this.window) this.forget(old);
   }
 
   forget(call) {
     const entry = this.results.get(call);
     if (!entry) return;
-    for (let i = 0; i < entry.hashes.length; i++) {
-      const list = this.occurrences.get(entry.hashes[i]);
-      if (!list) continue;
-      const kept = list.filter((o) => o.call !== call);
-      if (kept.length) this.occurrences.set(entry.hashes[i], kept);
-      else this.occurrences.delete(entry.hashes[i]);
+    for (const hash of new Set(entry.hashes)) {
+      const kept = (this.occurrences.get(hash) ?? []).filter(item => item.call !== call);
+      if (kept.length) this.occurrences.set(hash, kept);
+      else this.occurrences.delete(hash);
     }
-    this.storedLines -= entry.hashes.length;
+    this.history.storedLines -= entry.lines.length;
     this.results.delete(call);
   }
 
-  /** Provenance for lines the bridge is about to hand to the program: file text, outlines, evidence spans. */
   recordOrigin(path, firstLine, lines, pin = false) {
+    if (this.window === 0) return;
     for (let i = 0; i < lines.length; i++) {
-      if (!substantive(lines[i])) continue;
-      this.origins.set(hashLine(lines[i]), { path, line: firstLine + i });
-      if (pin) this.pinned.add(path + ":" + (firstLine + i));
+      const text = lines[i];
+      if (!substantive(text)) continue;
+      if (this.origins.size >= MAX_STORED_LINES && !this.origins.has(text)) this.origins.delete(this.origins.keys().next().value);
+      this.origins.set(text, { path, line: firstLine + i });
+      if (pin) this.pinned.add(text);
     }
   }
 
-  isPinned(hash) {
-    const o = this.origins.get(hash);
-    return o !== undefined && this.pinned.has(o.path + ":" + o.line);
-  }
-
-  /** Length of the identical run between lines[i…] and earlier result `cand`, stopping at pinned lines. */
-  runLength(hashes, cand, i) {
-    const earlier = this.results.get(cand.call);
+  runLength(lines, hashes, candidate, index) {
+    const earlier = this.results.get(candidate.call);
     if (!earlier) return 0;
-    let k = 0;
-    while (i + k < hashes.length && cand.index + k < earlier.hashes.length && earlier.hashes[cand.index + k] === hashes[i + k] && !this.isPinned(hashes[i + k])) k++;
-    return k;
+    let count = 0;
+    while (index + count < lines.length && candidate.index + count < earlier.lines.length
+      && hashes[index + count] === earlier.hashes[candidate.index + count]
+      && lines[index + count] === earlier.lines[candidate.index + count]
+      && !this.pinned.has(lines[index + count])) count++;
+    return count;
   }
 
-  /** Longest earlier run starting at lines[i]; null when shorter than MIN_RUN or not substantive enough. */
-  longestRun(hashes, lines, i) {
-    const candidates = this.occurrences.get(hashes[i]);
+  longestRun(lines, hashes, index, call) {
+    const candidates = this.occurrences.get(hashes[index]);
     if (!candidates) return null;
     let best = null;
-    for (const cand of candidates.slice(-MAX_CANDIDATES)) {
-      const length = this.runLength(hashes, cand, i);
-      if (length >= MIN_RUN && (!best || length > best.length)) best = { call: cand.call, index: cand.index, length };
+    for (const candidate of candidates.filter(item => item.call < call).slice(-MAX_CANDIDATES)) {
+      const length = this.runLength(lines, hashes, candidate, index);
+      if (length >= MIN_RUN && (!best || length > best.length)) best = { ...candidate, length };
     }
     if (!best) return null;
-    const substantiveCount = lines.slice(i, i + best.length).filter(substantive).length;
-    return substantiveCount >= MIN_SUBSTANTIVE ? best : null;
+    let count = 0;
+    for (let i = index; i < index + best.length; i++) if (substantive(lines[i])) count++;
+    return count >= MIN_SUBSTANTIVE ? best : null;
   }
 
-  /** "path:a–b" when every line of the run has consecutive provenance in one file, else "". */
-  citation(hashes, i, length) {
-    const first = this.origins.get(hashes[i]);
+  citation(lines, index, run) {
+    const earlier = this.results.get(run.call);
+    const origin = offset => this.origins.get(lines[index + offset]) ?? earlier?.origins[run.index + offset];
+    const first = origin(0);
     if (!first) return "";
-    let expectLine = first.line;
-    for (let k = 0; k < length; k++) {
-      const o = this.origins.get(hashes[i + k]);
-      if (o) {
-        if (o.path !== first.path || o.line < expectLine) return "";
-        expectLine = o.line + 1;
-      } else {
-        expectLine++;
-      }
+    let expected = first.line;
+    for (let i = 0; i < run.length; i++) {
+      const item = origin(i);
+      if (item && (item.path !== first.path || item.line !== expected)) return "";
+      expected++;
     }
-    return first.path + ":" + first.line + "–" + (expectLine - 1);
+    return first.path + ":" + first.line + "–" + (expected - 1);
   }
 
-  /**
-   * Collapse runs already shown; returns the text to send and remembers exactly that text as call N.
-   */
   dedupe(text, call) {
-    const lines = text.split("\n");
-    if (lines.length < MIN_RUN) {
+    if (this.window === 0) {
       this.stats.returnedChars += text.length;
-      this.remember(call, lines);
       return text;
     }
-    const hashes = new Uint32Array(lines.length);
-    for (let i = 0; i < lines.length; i++) hashes[i] = hashLine(lines[i]);
+    const lines = text.split("\n");
+    const hashes = Uint32Array.from(lines, hashLine);
     const out = [];
     let collapsedChars = 0;
-    for (let i = 0; i < lines.length; ) {
-      const run = substantive(lines[i]) ? this.longestRun(hashes, lines, i) : null;
-      if (!run) {
-        out.push(lines[i]);
-        i++;
-        continue;
-      }
-      const cite = this.citation(hashes, i, run.length);
+    for (let i = 0; i < lines.length;) {
+      const run = substantive(lines[i]) ? this.longestRun(lines, hashes, i, call) : null;
+      if (!run) { out.push(lines[i++]); continue; }
+      const cite = this.citation(lines, i, run);
       out.push("⋯ " + run.length + " lines same as #" + run.call + (cite ? " · " + cite : "") + " ⋯");
       for (let k = 0; k < run.length; k++) collapsedChars += lines[i + k].length + 1;
       this.stats.collapsedRuns++;
@@ -158,21 +130,21 @@ export class SeenLedger {
   }
 
   remember(call, lines) {
-    if (this.storedLines + lines.length > MAX_STORED_LINES) {
-      for (const old of [...this.results.keys()].sort((a, b) => a - b)) {
-        this.forget(old);
-        if (this.storedLines + lines.length <= MAX_STORED_LINES) break;
-      }
+    if (this.window === 0 || call <= this.history.latestCall - this.window || lines.length > MAX_STORED_LINES) return;
+    if (this.results.has(call)) this.forget(call);
+    for (const old of [...this.results.keys()].sort((a, b) => a - b)) {
+      if (this.storedLines + lines.length <= MAX_STORED_LINES) break;
+      this.forget(old);
     }
-    const hashes = new Uint32Array(lines.length);
+    const hashes = Uint32Array.from(lines, hashLine);
+    const origins = lines.map(line => this.origins.get(line));
     for (let i = 0; i < lines.length; i++) {
-      hashes[i] = hashLine(lines[i]);
       if (!substantive(lines[i])) continue;
       let list = this.occurrences.get(hashes[i]);
       if (!list) this.occurrences.set(hashes[i], (list = []));
       list.push({ call, index: i });
     }
-    this.results.set(call, { hashes });
-    this.storedLines += lines.length;
+    this.results.set(call, { hashes, lines, origins });
+    this.history.storedLines += lines.length;
   }
 }

package/omp-frame.js

@@ -127,7 +127,6 @@ function renderPortableFrame(theme, { header, sections = [], state = "pending",
 	const border = borderPaint(theme, state, borderColor);
 	const bgFn = bgFnForState(theme, state);
 	const h = box.horizontal;
-	const v = box.vertical;
 	const cap = h.repeat(3);
 
 	const paintBar = (leftChar, rightChar, label) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-supernova",
-  "version": "0.0.15",
+  "version": "0.1.0",
   "description": "Dual-host CodeMode for Pi/OMP: progressive tool discovery, result bottleneck, and Amdahl Auto parallel.",
   "type": "module",
   "author": "AdityaVG13",
@@ -90,5 +90,9 @@
   "bugs": {
     "url": "https://github.com/AdityaVG13/pi-stack/issues"
   },
-  "homepage": "https://github.com/AdityaVG13/pi-stack/tree/main/packages/pi-supernova#readme"
+  "homepage": "https://github.com/AdityaVG13/pi-stack/tree/main/packages/pi-supernova#readme",
+  "dependencies": {
+    "acorn": "^8.18.0",
+    "string-width": "^8.2.2"
+  }
 }

package/parallel.js

@@ -1,47 +1,55 @@
+import { isFunction } from "./decode.js";
 
-import { isString } from "./decode.js";
-export function isMutatingTool(name, config) {
-  const exact = new Set(config.mutatingTools || []);
-  if (exact.has(name)) return true;
-  const prefixes = config.mutatingPrefixes || [];
-  for (const prefix of prefixes) {
-    if (isString(prefix) && prefix.length > 0 && name.startsWith(prefix)) return true;
+const READ_ONLY_TOOLS = new Set(["read", "grep", "glob", "find", "ls", "snap", "evidence", "surface", "asgrep_search", "asgrep_status", "ast_grep", "web_search"]);
+const READ_ONLY_LSP = new Set(["definition", "references", "hover", "symbols", "diagnostics", "implementation", "type_definition", "incoming_calls", "outgoing_calls"]);
+
+export function isMutatingTool(name, config = {}, args = {}, definition) {
+  if ((config.mutatingTools ?? []).includes(name)) return true;
+  if ((config.mutatingPrefixes ?? []).some(prefix => prefix && name.startsWith(prefix))) return true;
+  if (definition?.annotations?.readOnlyHint === true) return false;
+  if (name === "lsp") {
+    const action = args.action ?? args.operation;
+    if (READ_ONLY_LSP.has(action)) return false;
+    if (["rename", "rename_file"].includes(action)) return args.apply !== false;
+    if (action === "code_actions") return args.apply === true;
+    return true;
   }
-  return false;
-}
-async function runSerial(list) {
-  const out = [];
-  for (const thunk of list) out.push(await thunk());
-  return out;
+  if (name === "todo") return args.op !== "view";
+  if (name === "hub") return !["list", "ps", "logs", "describe"].includes(args.op);
+  return !READ_ONLY_TOOLS.has(name);
 }
-function shouldParallelize(mode, anyMutating, count) {
-  if (mode === "parallel") return true;
-  if (mode !== "auto") return false;
-  if (anyMutating) return false;
-  return count > 1;
+
+function requireArray(value, name) {
+  if (!Array.isArray(value)) throw new TypeError(name + " requires an array");
+  return value;
 }
+
 export async function runParallelWave(thunks, meta, options = {}) {
-  const list = Array.isArray(thunks) ? thunks : [];
-  if (list.length === 0) return { results: [], mode: "serial", reason: "empty" };
+  const list = requireArray(thunks, "parallel wave");
+  if (list.some(item => !isFunction(item))) throw new TypeError("parallel wave requires functions");
+  if (!list.length) return { results: [], mode: "serial", reason: "empty" };
   const { mode = "auto", config = {} } = options;
-  const names = Array.isArray(meta?.names) ? meta.names : [];
-  const anyMutating = names.some((n) => isString(n) && isMutatingTool(n, config));
-  if (shouldParallelize(mode, anyMutating, list.length)) {
-    const results = await Promise.all(list.map((thunk) => thunk()));
-    return { results, mode: "parallel", reason: "independent-reads" };
+  const names = meta?.names ?? [];
+  const mutating = names.length !== list.length || names.some((name, i) => isMutatingTool(name, config, meta?.calls?.[i]?.args, meta?.definitions?.[i]));
+  if (!mutating && (mode === "parallel" || (mode === "auto" && list.length > 1))) {
+    // Do not finish a wave while its already-started host calls are still running.
+    const settled = await Promise.allSettled(list.map(thunk => Promise.resolve().then(thunk)));
+    const failure = settled.find(item => item.status === "rejected");
+    if (failure) throw failure.reason;
+    return { results: settled.map(item => item.value), mode: "parallel", reason: "independent-reads" };
   }
-  const results = await runSerial(list);
-  if (anyMutating) return { results, mode: "serial", reason: "mutating" };
-  return { results, mode: "serial", reason: "single-or-forced" };
+  const results = [];
+  for (const thunk of list) results.push(await thunk());
+  return { results, mode: "serial", reason: mutating ? "mutating" : "single-or-forced" };
 }
+
 export async function parallel(items) {
-  const list = Array.isArray(items) ? items : [];
-  return Promise.all(list.map((item) => (item instanceof Function ? item() : item)));
+  return Promise.all(requireArray(items, "parallel").map(item => isFunction(item) ? item() : item));
 }
+
 export async function pipeline(items, ...stages) {
-  let current = Array.isArray(items) ? items.slice() : [];
-  for (const stage of stages) {
-    current = await Promise.all(current.map((item) => stage(item)));
-  }
+  let current = requireArray(items, "pipeline");
+  if (stages.some(stage => !isFunction(stage))) throw new TypeError("pipeline stages must be functions");
+  for (const stage of stages) current = await Promise.all(current.map(item => stage(item)));
   return current;
 }