chainlesschain 0.162.167 → 0.162.169

package/src/lib/hook-runner.cjs

@@ -26,8 +26,9 @@ const {
   buildPowershellArgv,
   loadShellConfig,
 } = require("./shell-selector.cjs");
+const { mergeHookDecisions } = require("./hook-event-bus.cjs");
 
-const _deps = { spawnSync: cpDefault.spawnSync };
+const _deps = { spawnSync: cpDefault.spawnSync, spawn: cpDefault.spawn };
 
 const HOOK_DECISIONS = Object.freeze({
   BLOCK: "block",
@@ -116,43 +117,65 @@ function tryParseDecision(stdout) {
  *            stdout?:string, stderr?:string, additionalContext?:string,
  *            nonBlockingError?:boolean, error?:string }}
  */
+// Circuit breaker (gap 2026-07-11 P2 "Hooks 硬化"): N consecutive non-blocking
+// failures (spawn error / timeout / non-zero non-2 exit) of the SAME command
+// trip an open state — further runs are skipped for a cooldown, then one
+// half-open trial runs; success (or a real block/ask decision) closes it.
+// CC_HOOK_BREAKER_THRESHOLD=0 disables. Extracted so the sync + async runners
+// share ONE breaker implementation.
+function _breakerShortCircuit(command, breaker) {
+  if (breaker.threshold <= 0) return null;
+  const st = _breaker.get(command);
+  if (st && st.fails >= breaker.threshold) {
+    const now = Date.now();
+    if (now - st.openedAt < breaker.cooldownMs) {
+      return {
+        decision: HOOK_DECISIONS.CONTINUE,
+        reason: `hook circuit breaker open (${st.fails} consecutive failures) — skipped for cooldown`,
+        exitCode: null,
+        skipped: true,
+        breakerOpen: true,
+      };
+    }
+    // half-open: let this one trial through; the outcome records below.
+  }
+  return null;
+}
+
+function _breakerRecord(command, breaker, result) {
+  if (breaker.threshold <= 0) return;
+  if (result.nonBlockingError) {
+    const st = _breaker.get(command) || { fails: 0, openedAt: 0 };
+    st.fails += 1;
+    if (st.fails >= breaker.threshold) st.openedAt = Date.now();
+    _breaker.set(command, st);
+  } else {
+    _breaker.delete(command); // success / block / ask closes the breaker
+  }
+}
+
 function runCommandHook(command, input = {}, opts = {}) {
   if (!command) {
     return { decision: HOOK_DECISIONS.CONTINUE, reason: null, exitCode: 0 };
   }
-  // Circuit breaker (gap 2026-07-11 P2 "Hooks 硬化"): N consecutive
-  // non-blocking failures (spawn error / timeout / non-zero non-2 exit) of
-  // the SAME command trip an open state — further runs are skipped for a
-  // cooldown, then one half-open trial runs; success (or a real block/ask
-  // decision) closes it. CC_HOOK_BREAKER_THRESHOLD=0 disables.
   const breaker = hookBreakerConfig();
-  if (breaker.threshold > 0) {
-    const st = _breaker.get(command);
-    if (st && st.fails >= breaker.threshold) {
-      const now = Date.now();
-      if (now - st.openedAt < breaker.cooldownMs) {
-        return {
-          decision: HOOK_DECISIONS.CONTINUE,
-          reason: `hook circuit breaker open (${st.fails} consecutive failures) — skipped for cooldown`,
-          exitCode: null,
-          skipped: true,
-          breakerOpen: true,
-        };
-      }
-      // half-open: let this one trial through; the outcome below decides.
-    }
-  }
+  const shortCircuit = _breakerShortCircuit(command, breaker);
+  if (shortCircuit) return shortCircuit;
   const result = _runCommandHookInner(command, input, opts);
-  if (breaker.threshold > 0) {
-    if (result.nonBlockingError) {
-      const st = _breaker.get(command) || { fails: 0, openedAt: 0 };
-      st.fails += 1;
-      if (st.fails >= breaker.threshold) st.openedAt = Date.now();
-      _breaker.set(command, st);
-    } else {
-      _breaker.delete(command); // success / block / ask closes the breaker
-    }
+  _breakerRecord(command, breaker, result);
+  return result;
+}
+
+/** Async counterpart of runCommandHook (same breaker + protocol). */
+async function runCommandHookAsync(command, input = {}, opts = {}) {
+  if (!command) {
+    return { decision: HOOK_DECISIONS.CONTINUE, reason: null, exitCode: 0 };
   }
+  const breaker = hookBreakerConfig();
+  const shortCircuit = _breakerShortCircuit(command, breaker);
+  if (shortCircuit) return shortCircuit;
+  const result = await _runCommandHookInnerAsync(command, input, opts);
+  _breakerRecord(command, breaker, result);
   return result;
 }
 
@@ -230,7 +253,19 @@ function _runCommandHookInner(command, input = {}, opts = {}) {
       nonBlockingError: true,
     };
   }
-  // spawnSync surfaces timeout/ENOENT on res.error (status null) — non-blocking.
+  return interpretHookOutcome(res);
+}
+
+/**
+ * Interpret a finished hook process — a spawnSync result OR the collected output
+ * of an async spawn — into a normalized decision. The exit-code / JSON-stdout
+ * protocol lives in ONE place so the sync and async runners can never drift.
+ *
+ * @param {{error?:Error|null, status:number|null, stdout?:string, stderr?:string}} res
+ */
+function interpretHookOutcome(res) {
+  // A surfaced spawn error (timeout / ENOENT, status null) is non-blocking — a
+  // broken hook must never wedge the agent; only an explicit block blocks.
   if (res.error) {
     return {
       decision: HOOK_DECISIONS.CONTINUE,
@@ -287,19 +322,157 @@ function _runCommandHookInner(command, input = {}, opts = {}) {
 }
 
 /**
- * Run a list of command hooks in order; first BLOCK (or ASK) short-circuits.
- * @returns {{ decision, reason, hook?, results }}
+ * Async single-hook runner — mirrors _runCommandHookInner but uses async spawn
+ * so a batch can run CONCURRENTLY (see runHooksParallel). stdin gets the JSON
+ * payload; stdout/stderr are collected (bounded); a hard timeout SIGKILLs a hung
+ * hook and reports it as a non-blocking error. Interpretation is shared via
+ * interpretHookOutcome so the exit-code protocol matches the sync path exactly.
+ */
+async function _runCommandHookInnerAsync(command, input = {}, opts = {}) {
+  const { cwd, event } = opts;
+  const _rawTimeout = Number(opts.timeout);
+  const timeout =
+    Number.isFinite(_rawTimeout) && _rawTimeout > 0
+      ? Math.min(_rawTimeout, 600000)
+      : 60000;
+  const shellKind = normalizeShellKind(opts.shell);
+  const usePowershell = shellKind === "powershell" || shellKind === "pwsh";
+  const wd = cwd || process.cwd();
+  const inputJson = JSON.stringify({
+    ...input,
+    schema_version: input.schema_version ?? HOOK_PAYLOAD_SCHEMA_VERSION,
+  });
+  const spawnEnv = {
+    ...process.env,
+    CLAUDE_HOOK_EVENT: event || input.hook_event_name || "",
+  };
+
+  let child;
+  try {
+    if (usePowershell) {
+      const { executionPolicy } = loadShellConfig({ cwd: wd });
+      const inv = buildPowershellArgv(command, shellKind, { executionPolicy });
+      child = _deps.spawn(inv.file, inv.argv, { cwd: wd, env: spawnEnv });
+    } else {
+      child = _deps.spawn(command, { cwd: wd, env: spawnEnv, shell: true });
+    }
+  } catch (err) {
+    return {
+      decision: HOOK_DECISIONS.CONTINUE,
+      reason: `hook spawn failed: ${err.message}`,
+      exitCode: null,
+      error: err.message,
+      nonBlockingError: true,
+    };
+  }
+
+  return await new Promise((resolve) => {
+    const MAXB = 8 * 1024 * 1024;
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const done = (res) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(interpretHookOutcome(res));
+    };
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+        /* already exited */
+      }
+      done({
+        error: new Error(`hook timed out after ${timeout}ms`),
+        status: null,
+        stdout,
+        stderr,
+      });
+    }, timeout);
+    if (typeof timer.unref === "function") timer.unref();
+
+    child.on("error", (err) =>
+      done({ error: err, status: null, stdout, stderr }),
+    );
+    if (child.stdout) {
+      child.stdout.on("data", (d) => {
+        if (stdout.length < MAXB) stdout += d.toString("utf8");
+      });
+    }
+    if (child.stderr) {
+      child.stderr.on("data", (d) => {
+        if (stderr.length < MAXB) stderr += d.toString("utf8");
+      });
+    }
+    child.on("close", (code) =>
+      done({ error: null, status: code, stdout, stderr }),
+    );
+    // Feed the payload to the hook's stdin. A fast-exiting hook may close its
+    // end first (EPIPE) — that is harmless, the exit code still governs.
+    try {
+      if (child.stdin) {
+        child.stdin.on("error", () => {});
+        child.stdin.write(inputJson);
+        child.stdin.end();
+      }
+    } catch {
+      /* stdin already closed */
+    }
+  });
+}
+
+/**
+ * Run a list of command hooks and reduce to one decision.
+ *
+ * Default (`opts.mergeStrict` falsy): in-order, the first BLOCK **or** ASK
+ * short-circuits — byte-identical to the historical behavior.
+ *
+ * `opts.mergeStrict: true`: run EVERY matching hook (no short-circuit) then take
+ * the STRICTEST decision (block > ask > allow > continue) via mergeHookDecisions.
+ * This closes the safety gap where an earlier hook's `ask` masks a LATER hook's
+ * `block` (the short-circuit path returns `ask` and never runs the blocker).
+ * Claude-Code parity: all matching hooks contribute to the merged decision.
+ * spawnSync is synchronous so execution is sequential — but the MERGE is
+ * order-independent, so the outcome matches a parallel run.
+ *
+ * @returns {{ decision, reason, hook?, results, contributing? }}
  */
 function runHooks(commandHooks, input = {}, opts = {}) {
   const results = [];
-  for (const h of commandHooks || []) {
-    const r = runCommandHook(h.command, input, {
+  const hooks = commandHooks || [];
+  const runOne = (h) =>
+    runCommandHook(h.command, input, {
       ...opts,
       timeout: h.timeout != null ? h.timeout * 1000 : opts.timeout,
       // per-hook shell selection (P1 #8): `{ "type":"command", "command":…,
       // "shell":"powershell" }` in the settings hook entry
       shell: h.shell != null ? h.shell : opts.shell,
     });
+
+  if (opts.mergeStrict) {
+    const decisions = [];
+    for (const h of hooks) {
+      const r = runOne(h);
+      results.push({ command: h.command, ...r });
+      decisions.push({
+        decision: r.decision,
+        reason: r.reason,
+        hook: h.command,
+      });
+    }
+    const merged = mergeHookDecisions(decisions);
+    return {
+      decision: merged.decision,
+      reason: merged.reason,
+      hook: merged.hook,
+      results,
+      contributing: merged.contributing,
+    };
+  }
+
+  for (const h of hooks) {
+    const r = runOne(h);
     results.push({ command: h.command, ...r });
     if (
       r.decision === HOOK_DECISIONS.BLOCK ||
@@ -316,9 +489,48 @@ function runHooks(commandHooks, input = {}, opts = {}) {
   return { decision: HOOK_DECISIONS.CONTINUE, reason: null, results };
 }
 
+/**
+ * Run every matching hook CONCURRENTLY (async spawn) and reduce to the strictest
+ * decision (block > ask > allow > continue) via mergeHookDecisions — the true-
+ * parallel form of runHooks({mergeStrict}). Wall-clock is the slowest single hook
+ * rather than their sum; the merge is order-independent so the outcome matches
+ * the sequential strict merge exactly. Same per-hook timeout/shell resolution as
+ * runHooks. Returns the same shape ({decision, reason, hook, results,
+ * contributing}) so the decision consumers are unchanged.
+ */
+async function runHooksParallel(commandHooks, input = {}, opts = {}) {
+  const hooks = commandHooks || [];
+  const settled = await Promise.all(
+    hooks.map((h) =>
+      runCommandHookAsync(h.command, input, {
+        ...opts,
+        timeout: h.timeout != null ? h.timeout * 1000 : opts.timeout,
+        shell: h.shell != null ? h.shell : opts.shell,
+      }).then((r) => ({ h, r })),
+    ),
+  );
+  const results = settled.map(({ h, r }) => ({ command: h.command, ...r }));
+  const decisions = settled.map(({ h, r }) => ({
+    decision: r.decision,
+    reason: r.reason,
+    hook: h.command,
+  }));
+  const merged = mergeHookDecisions(decisions);
+  return {
+    decision: merged.decision,
+    reason: merged.reason,
+    hook: merged.hook,
+    results,
+    contributing: merged.contributing,
+  };
+}
+
 module.exports = {
   runCommandHook,
+  runCommandHookAsync,
   runHooks,
+  runHooksParallel,
+  interpretHookOutcome,
   tryParseDecision,
   HOOK_DECISIONS,
   HOOK_PAYLOAD_SCHEMA_VERSION,

package/src/lib/install-command-policy.js

@@ -128,8 +128,18 @@ function unwrapArgv(tokens) {
  * @returns {{manager:string, subcommand:string, packages:string[], global:boolean}|null}
  */
 export function classifyInstallSegment(segment) {
-  const argv = unwrapArgv(tokenizeShellCommand(segment));
+  let argv = unwrapArgv(tokenizeShellCommand(segment));
   if (argv.length === 0) return null;
+  // Module invocation: `python -m pip install …` (and `py -m pip …`) is the
+  // canonical way run_code's auto-install — and plenty of humans — invoke pip;
+  // treat the module as the binary so it classifies like a direct `pip`.
+  if (
+    /^(python[0-9.]*|py)$/.test(normalizeBin(argv[0])) &&
+    argv[1] === "-m" &&
+    argv.length > 2
+  ) {
+    argv = argv.slice(2);
+  }
   const bin = normalizeBin(argv[0]);
   const mgr = MANAGERS.find((m) => m.bin.test(bin));
   if (!mgr) return null;
@@ -269,6 +279,35 @@ export function classifyCodeAcquisition(command) {
   };
 }
 
+/**
+ * Classify a PLUGIN install (`cc plugin add`/`upgrade`) into the unified
+ * "downloading and running third-party code" trail. A plugin ships executable
+ * components (bin/hooks/LSP/MCP servers run as processes), so installing one
+ * is the plugin-runtime sibling of a global package install — same audit
+ * file, same opt-in policy. Pure; returns null for a nameless input.
+ */
+export function classifyPluginInstall({
+  name,
+  version,
+  scope,
+  source,
+  capabilities,
+} = {}) {
+  if (!name || typeof name !== "string") return null;
+  return {
+    manager: "cc-plugin",
+    packages: [version ? `${name}@${version}` : name],
+    // A user-scope plugin loads in EVERY repo the user runs cc in — the
+    // plugin-runtime analogue of `npm install -g`. Project/local scopes stay
+    // confined to one repository.
+    global: scope === "user",
+    ...(source ? { source: String(source) } : {}),
+    ...(Array.isArray(capabilities) && capabilities.length
+      ? { capabilities }
+      : {}),
+  };
+}
+
 /**
  * Resolve the install-command policy from env/settings (opt-in, so the default
  * shell path is byte-unchanged). `audit` enables the audit trail; `riskFloor`

package/src/lib/lsp/code-intelligence.js

@@ -64,7 +64,11 @@ export class CodeIntelligence {
       /* plugin LSP contributions are best-effort */
     }
     this.manager =
-      opts.manager || new LSPManager({ projectRoot: opts.projectRoot });
+      opts.manager ||
+      new LSPManager({
+        projectRoot: opts.projectRoot,
+        ...(opts.lspOptions || {}),
+      });
     this._ownsManager = !opts.manager;
     // One-shot callers (the `cc code-intel` CLI) spawn a cold server per run and
     // must wait for the project to load before querying; the long-lived agent

package/src/lib/lsp/workspace-roots.js

@@ -0,0 +1,115 @@
+/**
+ * workspace-roots — pure helpers for multi-root LSP workspaces (P2 LSP slice,
+ * CLAUDE_CODE_CLI_INCREMENTAL_GAP_ANALYSIS_2026-07-12 §"LSP 与 Code Review").
+ *
+ * A session started with `--add-dir` works across several project roots, but
+ * `code_intelligence` always keyed its shared language-server pool on the cwd
+ * alone — a query for a file living in an additional root spawned (or reused)
+ * the WRONG project's server, and `workspace_symbols` could only ever see the
+ * cwd project. These helpers make root selection explicit and testable:
+ *
+ *  - `workspaceRootsFor(cwd, additionalDirectories)` — the deduped, resolved
+ *    root list (cwd first, mirroring the roots the system prompt advertises).
+ *  - `pickRootForFile(file, roots)` — the root that CONTAINS the file
+ *    (deepest match wins so nested roots resolve to the more specific
+ *    project); falls back to the first root (cwd) for out-of-root files,
+ *    which is the pre-multi-root behavior.
+ *  - `mergeWorkspaceSymbolResults(results, roots)` — fold per-root
+ *    `workspaceSymbols` outcomes into one: available when ANY root answered,
+ *    symbols concatenated in root order and stamped with their `root` so
+ *    same-named symbols from different projects stay unambiguous.
+ *
+ * Pure + IO-free (path math only) so agent-core can consume them without any
+ * new export surface of its own.
+ */
+
+import path from "node:path";
+
+/** Case-fold for prefix comparison on case-insensitive filesystems. */
+function fold(p) {
+  return process.platform === "win32" ? p.toLowerCase() : p;
+}
+
+/**
+ * Resolved, deduped workspace roots — cwd first, then each additional
+ * directory. Non-string/empty entries are dropped; never returns empty (falls
+ * back to process.cwd()).
+ */
+export function workspaceRootsFor(cwd, additionalDirectories) {
+  const out = [];
+  const seen = new Set();
+  const push = (dir) => {
+    if (typeof dir !== "string" || dir.trim() === "") return;
+    const resolved = path.resolve(dir);
+    const key = fold(resolved);
+    if (seen.has(key)) return;
+    seen.add(key);
+    out.push(resolved);
+  };
+  push(cwd || process.cwd());
+  for (const d of Array.isArray(additionalDirectories)
+    ? additionalDirectories
+    : []) {
+    push(d);
+  }
+  if (out.length === 0) out.push(path.resolve(process.cwd()));
+  return out;
+}
+
+/**
+ * The workspace root that contains `file` — deepest containing root wins
+ * (nested roots resolve to the more specific project). Files outside every
+ * root fall back to the FIRST root (cwd), preserving the single-root
+ * behavior byte-for-byte.
+ */
+export function pickRootForFile(file, roots) {
+  const list = Array.isArray(roots) && roots.length > 0 ? roots : null;
+  if (!list) return path.resolve(process.cwd());
+  if (typeof file !== "string" || file.trim() === "") return list[0];
+  const f = fold(path.resolve(file));
+  let best = null;
+  for (const root of list) {
+    const r = fold(path.resolve(root));
+    if (f === r || f.startsWith(r + path.sep)) {
+      if (best === null || r.length > fold(best).length) {
+        best = path.resolve(root);
+      }
+    }
+  }
+  return best || list[0];
+}
+
+/**
+ * Merge per-root `workspaceSymbols` results (same order as `roots`).
+ * Any available root makes the merged result available; each symbol is
+ * stamped with its `root`. All-unavailable folds the reasons together so the
+ * caller still sees WHY (first reason wins the summary, all are listed).
+ */
+export function mergeWorkspaceSymbolResults(results, roots = []) {
+  const list = Array.isArray(results) ? results : [];
+  const symbols = [];
+  const reasons = [];
+  let anyAvailable = false;
+  for (let i = 0; i < list.length; i++) {
+    const r = list[i];
+    if (r && r.available) {
+      anyAvailable = true;
+      for (const s of Array.isArray(r.symbols) ? r.symbols : []) {
+        symbols.push(roots[i] ? { ...s, root: roots[i] } : s);
+      }
+    } else if (r) {
+      reasons.push(
+        roots[i]
+          ? `${roots[i]}: ${r.reason || "unavailable"}`
+          : r.reason || "unavailable",
+      );
+    }
+  }
+  if (!anyAvailable) {
+    return {
+      available: false,
+      reason: reasons.join("; ") || "language server unavailable",
+    };
+  }
+  return { available: true, symbols };
+}

package/src/lib/session-lifecycle.js

@@ -86,6 +86,9 @@ const STATE_ALIASES = new Map([
   ["waiting-permission", SESSION_STATES.WAITING_APPROVAL],
   ["waiting_approval", SESSION_STATES.WAITING_APPROVAL],
   ["awaiting_approval", SESSION_STATES.WAITING_APPROVAL],
+  // A resumed turn with UNKNOWN-outcome side effects blocks on confirmation.
+  ["uncertain_side_effect", SESSION_STATES.WAITING_APPROVAL],
+  ["uncertain-side-effect", SESSION_STATES.WAITING_APPROVAL],
   // supervisor liveness — a running process that vanished is a failure.
   ["lost", SESSION_STATES.FAILED],
   // IDE connection / transport

package/src/lib/settings-hook-events.cjs

@@ -47,7 +47,15 @@ function withDeliveryId(event, payload, { sessionId, traceId, parentId } = {}) {
       /* best-effort — recording must not break the turn */
     }
   }
-  return { ...payload, event_id: env.event_id };
+  // trace_id/parent_id are stamped onto the DELIVERED payload only when the
+  // caller actually threaded them (agent-core context) — absent they are
+  // omitted entirely, keeping every legacy payload byte-identical.
+  return {
+    ...payload,
+    event_id: env.event_id,
+    ...(env.trace_id ? { trace_id: env.trace_id } : {}),
+    ...(env.parent_id ? { parent_id: env.parent_id } : {}),
+  };
 }
 
 /**
@@ -343,7 +351,7 @@ function runObserveHooks(
   settingsHooks,
   event,
   payload = {},
-  { cwd, matchTarget } = {},
+  { cwd, matchTarget, traceId, parentId } = {},
 ) {
   if (!settingsHooks) return { decision: "continue", results: [] };
   const matched = collectHooks(settingsHooks, event, matchTarget || "");
@@ -351,12 +359,17 @@ function runObserveHooks(
   if (sync.length === 0) return { decision: "continue", results: [] };
   return runHooks(
     sync,
-    withDeliveryId(event, { hook_event_name: event, cwd, ...payload }),
+    withDeliveryId(
+      event,
+      { hook_event_name: event, cwd, ...payload },
+      { traceId, parentId },
+    ),
     { cwd, event },
   );
 }
 
 module.exports = {
+  withDeliveryId,
   runUserPromptSubmitHooks,
   runSessionStartHooks,
   runCwdChangedHooks,

package/src/lib/sub-agent-context.js

@@ -87,6 +87,10 @@ export class SubAgentContext {
     // restricts run_skill/list_skills in this context's loop to those skills.
     this.skillAllowlist =
       options.skillAllowlist != null ? options.skillAllowlist : null;
+    // Hook-envelope tracing: the spawning run's id — this child loop stamps it
+    // as parent_id on every settings-hook payload it fires (its own runId
+    // becomes the trace_id). null → top-level semantics (no parent).
+    this._hookParentTraceId = options.hookParentTraceId || null;
     this.cwd = options.cwd || process.cwd();
     this.status = "active";
     this.result = null;
@@ -98,6 +102,10 @@ export class SubAgentContext {
     this._worktreePath = null;
     this._worktreeBranch = null;
     this._repoDir = this.cwd;
+    // Optional worktree creation options (large-monorepo): { sparsePaths,
+    // symlinkDirectories } — only materialize the needed packages and reuse
+    // approved dep dirs. null → full checkout (byte-identical default).
+    this._worktreeOptions = options.worktreeOptions || null;
 
     // ── Isolated state ──────────────────────────────────────────────
     // Independent message history — never shared with parent
@@ -254,6 +262,7 @@ export class SubAgentContext {
           this.cwd = wtPath;
           return this._runCore(userPrompt, loopOptions);
         },
+        this._worktreeOptions || {},
       );
 
       // Annotate result with worktree info + diff preview
@@ -328,6 +337,10 @@ export class SubAgentContext {
       subAgentContract: this.subAgentContract,
       // Skill allow-list restricting run_skill/list_skills in this loop.
       skillAllowlist: this.skillAllowlist,
+      // Parent trace for hook envelopes (absent → key omitted, no parent_id).
+      ...(this._hookParentTraceId
+        ? { hookParentTraceId: this._hookParentTraceId }
+        : {}),
       ...loopOptions,
     };
     if (this.iterationBudget) {