pullfrog 0.1.5 → 0.1.6

package/dist/cli.mjs

@@ -19935,10 +19935,10 @@ var require_core = __commonJS({
       (0, command_1.issueCommand)("set-env", { name }, convertedVal);
     }
     exports.exportVariable = exportVariable;
-    function setSecret4(secret) {
+    function setSecret5(secret) {
       (0, command_1.issueCommand)("add-mask", {}, secret);
     }
-    exports.setSecret = setSecret4;
+    exports.setSecret = setSecret5;
     function addPath(inputPath) {
       const filePath = process.env["GITHUB_PATH"] || "";
       if (filePath) {
@@ -47954,7 +47954,7 @@ var require_core3 = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     var id_1 = require_id();
     var ref_1 = require_ref();
-    var core8 = [
+    var core9 = [
       "$schema",
       "$id",
       "$defs",
@@ -47964,7 +47964,7 @@ var require_core3 = __commonJS({
       id_1.default,
       ref_1.default
     ];
-    exports.default = core8;
+    exports.default = core9;
   }
 });
 
@@ -99202,12 +99202,12 @@ var import_picocolors2 = __toESM(require_picocolors(), 1);
 import { basename as basename2 } from "node:path";
 
 // commands/gha.ts
-var core7 = __toESM(require_core(), 1);
+var core8 = __toESM(require_core(), 1);
 var import_arg = __toESM(require_arg(), 1);
 import { dirname as dirname6 } from "node:path";
 
 // main.ts
-var core6 = __toESM(require_core(), 1);
+var core7 = __toESM(require_core(), 1);
 import { existsSync as existsSync7, readdirSync } from "node:fs";
 import { readFile as readFile4 } from "node:fs/promises";
 import { join as join17 } from "node:path";
@@ -110025,12 +110025,41 @@ function installSignalHandler() {
     killTrackedChildren();
   });
 }
+var DEFAULT_MAX_RETAINED_BYTES = 8 * 1024 * 1024;
+var TailBuffer = class {
+  // explicit field declarations rather than constructor parameter properties:
+  // node's strip-only TS loader (used by action/test/run.ts in CI) rejects
+  // `constructor(private readonly cap: number)` with ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX.
+  cap;
+  buffer = "";
+  truncatedBytes = 0;
+  constructor(cap) {
+    this.cap = cap;
+  }
+  append(chunk) {
+    if (this.cap <= 0) return;
+    this.buffer += chunk;
+    if (this.buffer.length > this.cap) {
+      const drop = this.buffer.length - this.cap;
+      this.truncatedBytes += drop;
+      this.buffer = this.buffer.slice(drop);
+    }
+  }
+  toString() {
+    if (this.truncatedBytes === 0) return this.buffer;
+    const mib = (this.truncatedBytes / 1024 / 1024).toFixed(1);
+    return `... [${mib} MiB truncated by retain:tail cap] ...
+${this.buffer}`;
+  }
+};
 async function spawn(options) {
   const activityTimeoutMs = options.activityTimeout ?? DEFAULT_ACTIVITY_TIMEOUT_MS;
   installSignalHandler();
   const startTime = performance3.now();
-  let stdoutBuffer = "";
-  let stderrBuffer = "";
+  const retain = options.retain ?? "tail";
+  const cap = options.maxRetainedBytes ?? DEFAULT_MAX_RETAINED_BYTES;
+  const stdoutBuffer = retain === "none" ? null : new TailBuffer(cap);
+  const stderrBuffer = retain === "none" ? null : new TailBuffer(cap);
   const killGroup = options.killGroup ?? false;
   return new Promise((resolve3, reject) => {
     const child = nodeSpawn(options.cmd, options.args, {
@@ -110104,17 +110133,29 @@ async function spawn(options) {
     }
     if (child.stdout) {
       child.stdout.on("data", (data) => {
-        updateActivity();
-        const chunk = data.toString();
-        stdoutBuffer += chunk;
-        options.onStdout?.(chunk);
+        try {
+          updateActivity();
+          const chunk = data.toString();
+          stdoutBuffer?.append(chunk);
+          options.onStdout?.(chunk);
+        } catch (err) {
+          log.debug(
+            `spawn stdout handler threw: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
       });
     }
     if (child.stderr) {
       child.stderr.on("data", (data) => {
-        const chunk = data.toString();
-        stderrBuffer += chunk;
-        options.onStderr?.(chunk);
+        try {
+          const chunk = data.toString();
+          stderrBuffer?.append(chunk);
+          options.onStderr?.(chunk);
+        } catch (err) {
+          log.debug(
+            `spawn stderr handler threw: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
       });
     }
     child.on("close", (exitCode, signal) => {
@@ -110141,7 +110182,7 @@ async function spawn(options) {
         return;
       }
       let resolvedExitCode = exitCode ?? 0;
-      let resolvedStderr = stderrBuffer;
+      let resolvedStderr = stderrBuffer?.toString() ?? "";
       if (exitCode === null && signal) {
         const killMsg = `[spawn] ${options.cmd}: killed by signal ${signal}`;
         resolvedStderr = resolvedStderr ? `${resolvedStderr}
@@ -110149,7 +110190,7 @@ ${killMsg}` : killMsg;
         resolvedExitCode = 1;
       }
       resolve3({
-        stdout: stdoutBuffer,
+        stdout: stdoutBuffer?.toString() ?? "",
         stderr: resolvedStderr,
         exitCode: resolvedExitCode,
         durationMs
@@ -110163,11 +110204,12 @@ ${killMsg}` : killMsg;
       if (activityCheckIntervalId) clearInterval(activityCheckIntervalId);
       const errMsg = `[spawn] ${options.cmd}: ${error49.message}`;
       console.error(errMsg);
-      stderrBuffer = stderrBuffer ? `${stderrBuffer}
+      const existingStderr = stderrBuffer?.toString() ?? "";
+      const finalStderr = existingStderr ? `${existingStderr}
 ${errMsg}` : errMsg;
       resolve3({
-        stdout: stdoutBuffer,
-        stderr: stderrBuffer,
+        stdout: stdoutBuffer?.toString() ?? "",
+        stderr: finalStderr,
         exitCode: 1,
         durationMs
       });
@@ -138076,7 +138118,7 @@ var require_core4 = /* @__PURE__ */ __commonJSMin(((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   const id_1 = require_id2();
   const ref_1 = require_ref2();
-  const core8 = [
+  const core9 = [
     "$schema",
     "$id",
     "$defs",
@@ -138086,7 +138128,7 @@ var require_core4 = /* @__PURE__ */ __commonJSMin(((exports) => {
     id_1.default,
     ref_1.default
   ];
-  exports.default = core8;
+  exports.default = core9;
 }));
 var require_limitNumber2 = /* @__PURE__ */ __commonJSMin(((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -142596,7 +142638,7 @@ var import_semver = __toESM(require_semver2(), 1);
 // package.json
 var package_default = {
   name: "pullfrog",
-  version: "0.1.5",
+  version: "0.1.6",
   type: "module",
   bin: {
     pullfrog: "dist/cli.mjs",
@@ -146673,6 +146715,8 @@ For simple, well-defined tasks, skip the plan phase and go straight to build.`
    - **4\u20135 lenses (high-stakes subsystem touches)** \u2014 any billing/payments change (billing-subsystem + correctness + security + operational-readiness); new auth flow (auth-subsystem + correctness + security + test-integrity); schema migration (schema-migration-subsystem + correctness + operational-readiness + impact); cross-subsystem PR that touches billing AND auth AND schema (one subsystem lens per domain + correctness)
    - **6+ lenses** \u2014 almost always a smell; you're either covering overlapping ground or this PR should have been split. push back via the review body rather than expanding lens count.
 
+   **lens-add discipline.** Each lens needs to clear a specific bar before you dispatch it: name the concrete failure mode this lens would catch *that the diff plausibly introduces*, in one sentence. "Could apply", "good to have", "for completeness" do not qualify. If you can't name what the lens is going to find, drop it. The "when unsure, treat as non-trivial" rule above is for the trivial-vs-non-trivial gate at step 3 \u2014 it does not license expanding lens count without articulated risk. Every extra lens adds wall-time, log noise, and pulls subagent attention onto speculative angles, which biases the final review toward bloat-shaped findings.
+
    lenses come in two flavors, and you can mix them:
    - **themed lenses** \u2014 a perspective applied across the whole diff (correctness, security, user-journey, performance, etc.).
    - **subsystem lenses** \u2014 a domain-scoped frame for high-stakes subsystems the PR touches (e.g. "the auth lens", "the billing lens", "the schema-migration lens"). a subsystem lens is "review the PR specifically for what could go wrong in this subsystem" and naturally combines theme + scope. **for high-stakes domains, lead with the subsystem lens rather than the generic themed equivalent** \u2014 "billing-subsystem" outperforms "correctness on billing code" because the framing primes the subagent to remember domain-specific failure modes (double-charges, refund races, currency rounding, dispute flows) the generic lens misses.
@@ -146680,7 +146724,7 @@ For simple, well-defined tasks, skip the plan phase and go straight to build.`
    starter menu (combine, omit, or invent your own):
    - **correctness & invariants** \u2014 bugs, races, error handling, edge cases, state-machine boundaries
    - **impact** \u2014 when the PR removes features, deletes exports, renames identifiers, or changes architectural patterns: stale references in code, tests, docs (\`docs/\`, \`wiki/\`), comments, configs, UI
-   - **research-validated assumptions** \u2014 third-party API contracts, SDK semantics, framework directives, version-gated behavior. the subagent must verify load-bearing claims via web search and quote source URLs.
+   - **research-validated assumptions** \u2014 third-party API contracts, SDK semantics, framework directives, version-gated behavior. **only pick when the PR's correctness depends on the contract behaving a specific way** \u2014 not when the API is merely used. An idempotency key as a backstop, a timeout as a hint, a retry as belt-and-suspenders: not load-bearing, skip this lens. The bar is "if the third-party contract differs from what the diff assumes, the PR is incorrect." When dispatched, the subagent must verify load-bearing claims via web search and quote source URLs.
    - **security** \u2014 new endpoints, authZ, input validation, secrets handling, replay/CSRF/injection, cross-tenant isolation
    - **user-journey** \u2014 UX-touching flows: walk through happy path and failure modes as a user
    - **operational readiness** \u2014 observability, alerting, migrations (forward + rollback), feature flags, on-call burden
@@ -146769,7 +146813,7 @@ ${PR_SUMMARY_FORMAT}`
    "Looks trivial but isn't" (do NOT skip \u2014 same anti-patterns as Review mode): 1-line changes to SQL/regex/auth/billing/permissions/signature-verification code; flipping feature-flag defaults or retry/timeout constants; money/tax/HTTP-method/redirect changes; tightening or loosening a comparison operator; mixed diffs with a semantic line buried in formatting.
    When unsure, treat as non-trivial.
 
-   otherwise pick lenses by where the new commits concentrate risk \u2014 **there's no fixed count**, same calibration as Review mode (1 lens for pure refactor / isolated fix; 2\u20133 for typical features; 4\u20135 for high-stakes subsystem touches; 6+ is a smell). lens framing follows Review mode: themed lenses (correctness & invariants, impact when new commits remove/rename/deprecate things, research-validated assumptions, security, user-journey, operational readiness, integration & cross-cutting, test integrity, performance, holistic) and subsystem lenses (auth, billing, schema migration, etc.) \u2014 for high-stakes domains lead with the subsystem lens rather than the generic themed equivalent.
+   otherwise pick lenses by where the new commits concentrate risk \u2014 **there's no fixed count**, same calibration as Review mode (1 lens for pure refactor / isolated fix; 2\u20133 for typical features; 4\u20135 for high-stakes subsystem touches; 6+ is a smell). same **lens-add discipline** as Review mode applies: each lens needs to name the concrete failure mode it would catch *that the new commits plausibly introduce* \u2014 "could apply" doesn't qualify, drop it. **research-validated assumptions** specifically: only pick when the new commits' correctness depends on a third-party contract behaving a specific way; merely using an API doesn't qualify. lens framing follows Review mode: themed lenses (correctness & invariants, impact when new commits remove/rename/deprecate things, research-validated assumptions, security, user-journey, operational readiness, integration & cross-cutting, test integrity, performance, holistic) and subsystem lenses (auth, billing, schema migration, etc.) \u2014 for high-stakes domains lead with the subsystem lens rather than the generic themed equivalent.
 
    dispatch one \`${REVIEWER_AGENT_NAME}\` subagent per lens \u2014 its baked-in system prompt enforces the non-mutative + non-recursive contract (read-only file/search/web tools and read-only MCP queries; no writes, shell side effects, state-changing MCP calls, or nested subagent dispatch). dispatch them in a **single assistant turn with multiple parallel subagent calls** (serial dispatch collapses the fan-out). if a subagent errors out, times out, or returns nothing usable, retry once with the same lens; if it still fails, proceed with partial coverage and note the missing lens in the review body \u2014 do not skip step 5 entirely on a single subagent failure. each subagent gets:
    - the diff scope (incremental diff path if available, full diff otherwise). do NOT tell them to skip pre-existing issues \u2014 that suppresses regressions the new commits amplified; the "issues must be NEW" filter lives at aggregation time (step 6), not in the subagent prompt
@@ -147139,20 +147183,30 @@ var ThinkingTimer = class {
     maximumFractionDigits: 1
   });
   lastToolResultTimestamp = null;
+  formatLine;
+  // node's native TS strip-only mode does not support parameter properties,
+  // so the formatter is declared as a field and assigned in the body.
+  constructor(formatLine = (l) => l) {
+    this.formatLine = formatLine;
+  }
   markToolResult() {
     this.lastToolResultTimestamp = performance5.now();
-    log.debug(`\xBB thinking timer: markToolResult at ${this.lastToolResultTimestamp}`);
+    log.debug(
+      this.formatLine(`\xBB thinking timer: markToolResult at ${this.lastToolResultTimestamp}`)
+    );
   }
   markToolCall() {
     const now = performance5.now();
     log.debug(
-      `\xBB thinking timer: markToolCall at ${now}, lastToolResult=${this.lastToolResultTimestamp}`
+      this.formatLine(
+        `\xBB thinking timer: markToolCall at ${now}, lastToolResult=${this.lastToolResultTimestamp}`
+      )
     );
     if (this.lastToolResultTimestamp === null) return;
     const elapsed = now - this.lastToolResultTimestamp;
     if (elapsed < THINKING_THRESHOLD) return;
     const seconds = elapsed / 1e3;
-    log.info(`\xBB thought for ${this.durationFormatter.format(seconds)}`);
+    log.info(this.formatLine(`\xBB thought for ${this.durationFormatter.format(seconds)}`));
   }
 };
 
@@ -147401,19 +147455,39 @@ function deriveLabelFromTaskInput(input) {
 }
 var SessionLabeler = class {
   labels = /* @__PURE__ */ new Map();
+  labelsByToolUseId = /* @__PURE__ */ new Map();
   pendingLabels = [];
   fallbackCounter = 0;
-  recordTaskDispatch(input) {
+  /**
+   * Record a Task/Agent tool dispatch.
+   *
+   * @param input  Task tool input — used to derive the lens label.
+   * @param toolUseId  Optional Agent tool_use id. When provided, future events
+   *                   carrying `parent_tool_use_id === toolUseId` resolve
+   *                   directly to this label without consuming the FIFO queue
+   *                   (Claude path). Always also pushed to the FIFO queue so
+   *                   the OpenCode path still works when toolUseId is absent.
+   */
+  recordTaskDispatch(input, toolUseId) {
     const label = deriveLabelFromTaskInput(input);
     this.pendingLabels.push(label);
+    if (toolUseId) this.labelsByToolUseId.set(toolUseId, label);
     return label;
   }
   /**
-   * Return a label for the given sessionID. Binds on first call.
-   * Pass undefined/empty for events that lack a session id — the caller
-   * gets ORCHESTRATOR_LABEL so the line is still attributable.
+   * Return a label for the given event.
+   *
+   * @param sessionID         Session id from the event (OpenCode: per-session;
+   *                          Claude: shared across orchestrator + subagents).
+   * @param parentToolUseId   Claude's `parent_tool_use_id` — non-null on
+   *                          subagent messages. When set and known, takes
+   *                          priority over the FIFO/sessionID path.
    */
-  labelFor(sessionID) {
+  labelFor(sessionID, parentToolUseId) {
+    if (parentToolUseId) {
+      const direct = this.labelsByToolUseId.get(parentToolUseId);
+      if (direct) return direct;
+    }
     if (!sessionID) return ORCHESTRATOR_LABEL;
     const existing = this.labels.get(sessionID);
     if (existing) return existing;
@@ -147497,7 +147571,23 @@ function tailLines(text, maxCodeUnits) {
 async function runClaude(params) {
   const startTime = performance6.now();
   let eventCount = 0;
-  const thinkingTimer = new ThinkingTimer();
+  const labeler = new SessionLabeler();
+  function eventLabel(event) {
+    return labeler.labelFor(event.session_id ?? null, event.parent_tool_use_id ?? null);
+  }
+  function withLabel(label, message) {
+    return label === ORCHESTRATOR_LABEL ? message : formatWithLabel(label, message);
+  }
+  const thinkingTimers = /* @__PURE__ */ new Map();
+  function timerFor(label) {
+    let t2 = thinkingTimers.get(label);
+    if (!t2) {
+      const formatLine = (line) => label === ORCHESTRATOR_LABEL ? line : formatWithLabel(label, line);
+      t2 = new ThinkingTimer(formatLine);
+      thinkingTimers.set(label, t2);
+    }
+    return t2;
+  }
   let finalOutput = "";
   let sessionId;
   let resultErrorSubtype = null;
@@ -147518,17 +147608,22 @@ async function runClaude(params) {
     } : void 0;
   }
   const handlers2 = {
-    system: (_event) => {
-      log.debug(`\xBB ${params.label} system event`);
+    system: (event) => {
+      const label = eventLabel(event);
+      log.debug(withLabel(label, `\xBB ${params.label} system event`));
     },
     assistant: (event) => {
       const content = event.message?.content;
       if (!content) return;
+      const label = eventLabel(event);
+      const boxTitle = label === ORCHESTRATOR_LABEL ? params.label : `${params.label} [${label}]`;
       for (const block of content) {
         if (block.type === "text" && block.text?.trim()) {
           const message = block.text.trim();
-          log.box(message, { title: params.label });
-          finalOutput = message;
+          log.box(message, { title: boxTitle });
+          if (label === ORCHESTRATOR_LABEL) {
+            finalOutput = message;
+          }
         } else if (block.type === "tool_use") {
           const toolName = block.name || "unknown";
           if (params.onToolUse) {
@@ -147537,20 +147632,25 @@ async function runClaude(params) {
               input: block.input
             });
           }
-          thinkingTimer.markToolCall();
-          log.toolCall({ toolName, input: block.input || {} });
-          if (toolName === "Task" && block.input && typeof block.input === "object") {
+          timerFor(label).markToolCall();
+          const inputFormatted = formatJsonValue(block.input || {});
+          const toolCallLine = inputFormatted !== "{}" ? `\xBB ${toolName}(${inputFormatted})` : `\xBB ${toolName}()`;
+          log.info(withLabel(label, toolCallLine));
+          if ((toolName === "Task" || toolName === "Agent") && block.input && typeof block.input === "object") {
             const taskInput = block.input;
-            const label = deriveLabelFromTaskInput(taskInput);
+            const dispatchedLabel = labeler.recordTaskDispatch(taskInput, block.id ?? null);
             log.info(
-              `\xBB dispatching subagent: ${label}` + (taskInput.subagent_type ? ` (subagent_type=${taskInput.subagent_type})` : "")
+              withLabel(
+                label,
+                `\xBB dispatching subagent: ${dispatchedLabel}` + (taskInput.subagent_type ? ` (subagent_type=${taskInput.subagent_type})` : "")
+              )
             );
           }
           if (toolName.includes("report_progress") && params.todoTracker) {
             log.debug("\xBB report_progress detected, disabling todo tracking");
             params.todoTracker.cancel();
           }
-          if (toolName === "TodoWrite" && params.todoTracker?.enabled) {
+          if (toolName === "TodoWrite" && params.todoTracker?.enabled && label === ORCHESTRATOR_LABEL) {
             params.todoTracker.update(block.input);
           }
         }
@@ -147566,17 +147666,18 @@ async function runClaude(params) {
     user: (event) => {
       const content = event.message?.content;
       if (!content) return;
+      const label = eventLabel(event);
       for (const block of content) {
         if (typeof block === "string") continue;
         if (block.type === "tool_result") {
-          thinkingTimer.markToolResult();
+          timerFor(label).markToolResult();
           const outputContent = typeof block.content === "string" ? block.content : Array.isArray(block.content) ? block.content.map(
             (entry) => typeof entry === "string" ? entry : typeof entry === "object" && entry !== null && "text" in entry ? String(entry.text) : JSON.stringify(entry)
           ).join("\n") : String(block.content);
           if (block.is_error) {
-            log.info(`\xBB tool error: ${outputContent}`);
+            log.info(withLabel(label, `\xBB tool error: ${outputContent}`));
           } else {
-            log.debug(`\xBB tool output: ${outputContent}`);
+            log.debug(withLabel(label, `\xBB tool output: ${outputContent}`));
           }
         }
       }
@@ -147646,7 +147747,7 @@ async function runClaude(params) {
   };
   const recentStderr = [];
   let lastProviderError = null;
-  let output = "";
+  const output = new TailBuffer(DEFAULT_MAX_RETAINED_BYTES);
   let stdoutBuffer = "";
   try {
     const result = await spawn({
@@ -147663,9 +147764,14 @@ async function runClaude(params) {
       // there's no shim-orphan issue like opencode-ai/bin/opencode, but
       // detached + killGroup is the right default for any agent runtime.
       killGroup: true,
+      // claude already drains every chunk via onStdout (NDJSON parsing) and
+      // onStderr (recentStderr ring buffer). retaining a second copy in the
+      // spawn wrapper would grow unbounded for long sessions and previously
+      // crashed the wrapper with RangeError. see issue #680.
+      retain: "none",
       onStdout: async (chunk) => {
         const text = chunk.toString();
-        output += text;
+        output.append(text);
         markActivity();
         stdoutBuffer += text;
         const lines = stdoutBuffer.split("\n");
@@ -147740,16 +147846,18 @@ ${stderrContext}`);
     const usage = buildUsage();
     if (result.exitCode !== 0) {
       const errorContext = lastProviderError ? ` (${lastProviderError})` : "";
-      const truncatedStdout = result.stdout ? tailLines(result.stdout, 2048) : "";
-      const errorMessage = lastResultError || result.stderr || truncatedStdout || `unknown error - no output from Claude CLI${errorContext}`;
+      const stdoutSnapshot = output.toString();
+      const stderrSnapshot = recentStderr.join("\n");
+      const truncatedStdout = stdoutSnapshot ? tailLines(stdoutSnapshot, 2048) : "";
+      const errorMessage = lastResultError || stderrSnapshot || truncatedStdout || `unknown error - no output from Claude CLI${errorContext}`;
       log.error(
         `${params.label} exited with code ${result.exitCode}${errorContext}: ${errorMessage}`
       );
-      log.debug(`stdout: ${result.stdout?.substring(0, 500)}`);
-      log.debug(`stderr: ${result.stderr?.substring(0, 500)}`);
+      log.debug(`stdout: ${stdoutSnapshot.substring(0, 500)}`);
+      log.debug(`stderr: ${stderrSnapshot.substring(0, 500)}`);
       return {
         success: false,
-        output: finalOutput || output,
+        output: finalOutput || stdoutSnapshot,
         error: errorMessage,
         usage,
         sessionId
@@ -147758,7 +147866,7 @@ ${stderrContext}`);
     if (eventCount === 0 && lastProviderError) {
       return {
         success: false,
-        output: finalOutput || output,
+        output: finalOutput || output.toString(),
         error: `provider error: ${lastProviderError}`,
         usage,
         sessionId
@@ -147767,13 +147875,13 @@ ${stderrContext}`);
     if (resultErrorSubtype) {
       return {
         success: false,
-        output: finalOutput || output,
+        output: finalOutput || output.toString(),
         error: lastResultError || `result subtype: ${resultErrorSubtype}`,
         usage,
         sessionId
       };
     }
-    return { success: true, output: finalOutput || output, usage, sessionId };
+    return { success: true, output: finalOutput || output.toString(), usage, sessionId };
   } catch (error49) {
     params.todoTracker?.cancel();
     const duration4 = performance6.now() - startTime;
@@ -147792,7 +147900,7 @@ ${stderrContext}`
       );
     return {
       success: false,
-      output: finalOutput || output,
+      output: finalOutput || output.toString(),
       error: `${errorMessage} [${diagnosis}]`,
       usage: buildUsage(),
       sessionId
@@ -148028,6 +148136,15 @@ function buildSecurityConfig(ctx, model) {
       [pullfrogMcpName]: { type: "remote", url: ctx.mcpServerUrl }
     },
     agent: buildReviewerAgentConfig(),
+    // opt into opencode's experimental `batch` tool (added in
+    // anomalyco/opencode PR #2983, opt-in via `experimental.batch_tool`). it
+    // exposes a single `batch` tool that runs 1-25 independent tool calls
+    // (read/grep/glob/bash/etc.) concurrently in one assistant turn, which
+    // collapses the dominant grep→20×read pattern into a single round trip.
+    // edits are explicitly disallowed inside the batch upstream. paired with
+    // the "Parallel tool execution" guidance in utils/instructions.ts so the
+    // model actually reaches for it. see wiki/prompt.md.
+    experimental: { batch_tool: true },
     provider: {
       google: {
         models: Object.fromEntries(
@@ -148100,7 +148217,6 @@ function autoSelectModel(cliPath) {
 async function runOpenCode(params) {
   const startTime = performance7.now();
   let eventCount = 0;
-  const thinkingTimer = new ThinkingTimer();
   let finalOutput = "";
   let accumulatedTokens = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
   let accumulatedCostUsd = 0;
@@ -148117,6 +148233,16 @@ async function runOpenCode(params) {
   function withLabel(label, message) {
     return label === ORCHESTRATOR_LABEL ? message : formatWithLabel(label, message);
   }
+  const thinkingTimers = /* @__PURE__ */ new Map();
+  function timerFor(label) {
+    let t2 = thinkingTimers.get(label);
+    if (!t2) {
+      const formatLine = (line) => label === ORCHESTRATOR_LABEL ? line : formatWithLabel(label, line);
+      t2 = new ThinkingTimer(formatLine);
+      thinkingTimers.set(label, t2);
+    }
+    return t2;
+  }
   const taskDispatchByCallID = /* @__PURE__ */ new Map();
   const pendingTaskDispatches = [];
   const knownNonTaskCallIDs = /* @__PURE__ */ new Set();
@@ -148265,7 +148391,7 @@ async function runOpenCode(params) {
           input: event.part?.state?.input
         });
       }
-      thinkingTimer.markToolCall();
+      timerFor(label).markToolCall();
       const inputFormatted = formatJsonValue(event.part?.state?.input || {});
       const toolCallLine = inputFormatted !== "{}" ? `\xBB ${toolName}(${inputFormatted})` : `\xBB ${toolName}()`;
       log.info(withLabel(label, toolCallLine));
@@ -148289,7 +148415,7 @@ async function runOpenCode(params) {
       const status = event.part?.state?.status || event.status || "unknown";
       const output2 = event.part?.state?.output || event.output;
       const label = eventLabel(event);
-      thinkingTimer.markToolResult();
+      timerFor(label).markToolResult();
       if (taskDispatchByCallID.size > 0 || pendingTaskDispatches.length > 0) {
         if (toolId && taskDispatchByCallID.has(toolId)) {
           const dispatch = taskDispatchByCallID.get(toolId);
@@ -148414,7 +148540,7 @@ async function runOpenCode(params) {
   const recentStderr = [];
   let lastProviderError = null;
   let agentErrorEvent = null;
-  let output = "";
+  const output = new TailBuffer(DEFAULT_MAX_RETAINED_BYTES);
   let stdoutBuffer = "";
   try {
     const result = await spawn({
@@ -148432,6 +148558,11 @@ async function runOpenCode(params) {
       // never fires — producing zombie runs. detached + killGroup nukes the
       // whole tree.
       killGroup: true,
+      // we already drain every chunk via onStdout/onStderr (NDJSON parsing
+      // + recentStderr ring buffer). retaining a second copy in the spawn
+      // wrapper would grow unbounded for multi-lens Reviews and previously
+      // crashed the wrapper with RangeError at ~1 GiB. see issue #680.
+      retain: "none",
       // NB: we used to pass `isPausedExternally: isSubagentInFlight` to suspend
       // the activity timer during subagent dispatches. unnecessary now that
       // our injected plugin (action/agents/opencodePlugin.ts) re-emits
@@ -148441,7 +148572,7 @@ async function runOpenCode(params) {
       // (~3.3 plugin events/sec during a typical subagent run).
       onStdout: async (chunk) => {
         const text = chunk.toString();
-        output += text;
+        output.append(text);
         markActivity();
         stdoutBuffer += text;
         const lines = stdoutBuffer.split("\n");
@@ -148530,18 +148661,25 @@ ${stderrContext}`);
     const usage = buildUsage();
     if (result.exitCode !== 0) {
       const errorContext = lastProviderError ? ` (${lastProviderError})` : "";
-      const errorMessage = result.stderr || result.stdout || `unknown error - no output from OpenCode CLI${errorContext}`;
+      const stdoutSnapshot = output.toString();
+      const stderrSnapshot = recentStderr.join("\n");
+      const errorMessage = stderrSnapshot || stdoutSnapshot || `unknown error - no output from OpenCode CLI${errorContext}`;
       log.error(
         `${params.label} exited with code ${result.exitCode}${errorContext}: ${errorMessage}`
       );
-      log.debug(`stdout: ${result.stdout?.substring(0, 500)}`);
-      log.debug(`stderr: ${result.stderr?.substring(0, 500)}`);
-      return { success: false, output: finalOutput || output, error: errorMessage, usage };
+      log.debug(`stdout: ${stdoutSnapshot.substring(0, 500)}`);
+      log.debug(`stderr: ${stderrSnapshot.substring(0, 500)}`);
+      return {
+        success: false,
+        output: finalOutput || stdoutSnapshot,
+        error: errorMessage,
+        usage
+      };
     }
     if (eventCount === 0 && lastProviderError) {
       return {
         success: false,
-        output: finalOutput || output,
+        output: finalOutput || output.toString(),
         error: `provider error: ${lastProviderError}`,
         usage
       };
@@ -148552,12 +148690,12 @@ ${stderrContext}`);
       const errorMessage = errorEvent.error?.data?.message || errorEvent.error?.name || JSON.stringify(errorEvent);
       return {
         success: false,
-        output: finalOutput || output,
+        output: finalOutput || output.toString(),
         error: `${errorName}: ${errorMessage}`,
         usage
       };
     }
-    return { success: true, output: finalOutput || output, usage };
+    return { success: true, output: finalOutput || output.toString(), usage };
   } catch (error49) {
     params.todoTracker?.cancel();
     const duration4 = performance7.now() - startTime;
@@ -148576,7 +148714,7 @@ ${stderrContext}`
       );
     return {
       success: false,
-      output: finalOutput || output,
+      output: finalOutput || output.toString(),
       error: `${errorMessage} [${diagnosis}]`,
       usage: buildUsage()
     };
@@ -152482,6 +152620,14 @@ function isOIDCAvailable() {
     process.env.ACTIONS_ID_TOKEN_REQUEST_URL && process.env.ACTIONS_ID_TOKEN_REQUEST_TOKEN
   );
 }
+var TokenExchangeError = class extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.name = "TokenExchangeError";
+    this.status = status;
+  }
+};
 async function acquireTokenViaOIDC(opts) {
   const oidcToken = await core2.getIDToken("pullfrog-api");
   const repos = [...opts?.repos ?? []];
@@ -152506,7 +152652,16 @@ async function acquireTokenViaOIDC(opts) {
     });
     clearTimeout(timeoutId);
     if (!tokenResponse.ok) {
-      throw new Error(`Token exchange failed: ${tokenResponse.status} ${tokenResponse.statusText}`);
+      let serverMessage;
+      try {
+        const body = await tokenResponse.json();
+        if (typeof body.error === "string") serverMessage = body.error;
+      } catch {
+      }
+      throw new TokenExchangeError(
+        tokenResponse.status,
+        serverMessage ?? `Token exchange failed: ${tokenResponse.status} ${tokenResponse.statusText}`
+      );
     }
     const tokenData = await tokenResponse.json();
     return tokenData.token;
@@ -152627,7 +152782,10 @@ async function acquireNewToken(opts) {
   if (isOIDCAvailable()) {
     return await retry(() => acquireTokenViaOIDC(opts), {
       label: "token exchange",
-      shouldRetry: (error49) => error49 instanceof Error && (error49.name === "AbortError" || error49.message.includes("fetch failed") || error49.message.includes("ECONNRESET") || error49.message.includes("ETIMEDOUT") || error49.message.includes("Token exchange failed"))
+      shouldRetry: (error49) => {
+        if (error49 instanceof TokenExchangeError) return error49.status >= 500 || error49.status === 429;
+        return error49 instanceof Error && (error49.message.includes("timed out") || error49.message.includes("fetch failed") || error49.message.includes("ECONNRESET") || error49.message.includes("ETIMEDOUT"));
+      }
     });
   } else {
     return await acquireTokenViaGitHubApp(opts);
@@ -153174,6 +153332,21 @@ ${getStandaloneModeInstructions(ctx.payload.event.trigger, t2, ctx.outputSchema)
 
 Trust the tools \u2014 do not repeatedly verify file contents or git status after operations. If a tool reports success, proceed to the next step. Only verify if you encounter an actual error. Exception: right before \`${t2("push_branch")}\`, ensure the working tree is clean \u2014 that tool rejects dirty trees, and tests you ran earlier often leave untracked output.
 
+### Parallel tool execution
+
+For maximum efficiency, whenever you need to perform multiple independent operations, invoke all relevant tools simultaneously in a single assistant turn rather than sequentially. The dominant failure mode is grep \u2192 read \u2192 read \u2192 read \u2192 read across separate turns when one round trip would do. Always parallelize when calls are independent:
+- reading multiple files (especially after a grep returns candidates)
+- multiple greps with different patterns
+- glob + grep + read combos
+- listing multiple directories
+- inspecting multiple MCP tools or resources
+
+Do NOT parallelize operations that depend on prior output (e.g. create a file then read it), or ordered stateful mutations. Edits are not parallelizable \u2014 sequence those normally.${ctx.agentId === "opencode" ? `
+
+On OpenCode you also have a \`batch\` tool that bundles 1-25 independent calls into one wrapper call. Reach for it whenever you have >=2 independent calls. Native parallel tool_use and \`batch\` both achieve one round trip instead of N \u2014 use whichever your provider supports best.` : `
+
+Emit multiple \`tool_use\` blocks in the same assistant message for independent calls \u2014 the runtime executes them concurrently. Do not wait for one tool result before issuing the next independent call.`}
+
 ### Command execution
 
 Never use \`sleep\` to wait for commands to complete. Commands run synchronously \u2014 when the shell tool returns, the command has finished.
@@ -153300,10 +153473,22 @@ async function readLearningsFile(path3) {
 }
 
 // utils/normalizeEnv.ts
-function maskValue(value2) {
-  if (value2 && typeof value2 === "string" && value2.trim().length > 0) {
-    console.log(`::add-mask::${value2}`);
+var core4 = __toESM(require_core(), 1);
+function sanitizeSecret(key, value2) {
+  const trimmed = value2.trim();
+  if (trimmed.length === 0) {
+    log.warning(
+      `\xBB ${key} is whitespace-only \u2014 leaving env var unchanged. check your secret value.`
+    );
+    return null;
   }
+  if (trimmed !== value2) {
+    log.warning(
+      `\xBB stripped whitespace from ${key} (whitespace in secret values breaks GitHub Actions log masking)`
+    );
+  }
+  core4.setSecret(trimmed);
+  return trimmed;
 }
 function normalizeEnv() {
   const upperKeys = /* @__PURE__ */ new Map();
@@ -153314,11 +153499,6 @@ function normalizeEnv() {
     upperKeys.set(upper2, existing);
   }
   for (const [upperKey, keys] of upperKeys) {
-    if (isSensitiveEnvName(upperKey)) {
-      for (const key of keys) {
-        maskValue(process.env[key]);
-      }
-    }
     if (keys.length === 1) {
       const key = keys[0];
       if (key !== upperKey) {
@@ -153341,10 +153521,17 @@ function normalizeEnv() {
     }
     process.env[upperKey] = preferredValue;
   }
+  for (const key of Object.keys(process.env)) {
+    if (!isSensitiveEnvName(key)) continue;
+    const value2 = process.env[key];
+    if (typeof value2 !== "string" || value2.length === 0) continue;
+    const sanitized = sanitizeSecret(key, value2);
+    if (sanitized !== null) process.env[key] = sanitized;
+  }
 }
 
 // utils/payload.ts
-var core4 = __toESM(require_core(), 1);
+var core5 = __toESM(require_core(), 1);
 import { isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
 
 // utils/versioning.ts
@@ -153408,7 +153595,7 @@ function resolveCwd(cwd) {
   return workspace ? resolve2(workspace, cwd) : cwd;
 }
 function resolvePromptInput() {
-  const prompt = core4.getInput("prompt", { required: true });
+  const prompt = core5.getInput("prompt", { required: true });
   let parsed2;
   try {
     parsed2 = JSON.parse(prompt);
@@ -153424,11 +153611,11 @@ function resolvePromptInput() {
 }
 function resolveNonPromptInputs() {
   return Inputs.omit("prompt").assert({
-    model: core4.getInput("model") || void 0,
-    timeout: core4.getInput("timeout") || void 0,
-    cwd: core4.getInput("cwd") || void 0,
-    push: core4.getInput("push") || void 0,
-    shell: core4.getInput("shell") || void 0
+    model: core5.getInput("model") || void 0,
+    timeout: core5.getInput("timeout") || void 0,
+    cwd: core5.getInput("cwd") || void 0,
+    push: core5.getInput("push") || void 0,
+    shell: core5.getInput("shell") || void 0
   });
 }
 var isPullfrog = (actor) => {
@@ -153684,13 +153871,13 @@ async function fetchRunContext(params) {
 }
 
 // utils/runContextData.ts
-var core5 = __toESM(require_core(), 1);
+var core6 = __toESM(require_core(), 1);
 async function resolveRunContextData(params) {
   log.info(`\xBB running Pullfrog v${package_default.version}...`);
   const repoContext = parseRepoContext();
   let oidcToken;
   try {
-    oidcToken = await core5.getIDToken("pullfrog-api");
+    oidcToken = await core6.getIDToken("pullfrog-api");
   } catch {
   }
   const [repoResponse, runContext] = await Promise.all([
@@ -153993,7 +154180,7 @@ async function resolveRun(params) {
 
 // main.ts
 function resolveOutputSchema() {
-  const raw2 = core6.getInput("output_schema");
+  const raw2 = core7.getInput("output_schema");
   if (!raw2) return void 0;
   let parsed2;
   try {
@@ -154161,7 +154348,7 @@ async function buildProxyTokenHeaders(ctx) {
   if (ctx.oidcCredentials) {
     process.env.ACTIONS_ID_TOKEN_REQUEST_URL = ctx.oidcCredentials.requestUrl;
     process.env.ACTIONS_ID_TOKEN_REQUEST_TOKEN = ctx.oidcCredentials.requestToken;
-    const oidcToken = await core6.getIDToken("pullfrog-api");
+    const oidcToken = await core7.getIDToken("pullfrog-api");
     delete process.env.ACTIONS_ID_TOKEN_REQUEST_URL;
     delete process.env.ACTIONS_ID_TOKEN_REQUEST_TOKEN;
     return { Authorization: `Bearer ${oidcToken}` };
@@ -154183,7 +154370,7 @@ async function resolveProxyModel(ctx) {
   const key = await mintProxyKey({ oidcCredentials: ctx.oidcCredentials, repo: ctx.repo });
   if (!key) return;
   process.env.OPENROUTER_API_KEY = key;
-  core6.setSecret(key);
+  core7.setSecret(key);
   ctx.payload.proxyModel = ctx.proxyModel;
   const label = ctx.oss ? "oss" : "router";
   log.info(`\xBB proxy: ${label} \u2192 ${ctx.proxyModel}`);
@@ -154295,8 +154482,8 @@ async function main() {
     if (runContext.dbSecrets) {
       for (const [key, value2] of Object.entries(runContext.dbSecrets)) {
         if (!process.env[key]) {
-          process.env[key] = value2;
-          core6.setSecret(value2);
+          const sanitized = sanitizeSecret(key, value2);
+          if (sanitized !== null) process.env[key] = sanitized;
         }
       }
       const count = Object.keys(runContext.dbSecrets).length;
@@ -154634,7 +154821,7 @@ ${instructions.user}` : null,
         }
         if (toolState.output) {
           log.info(`::pullfrog-output::${Buffer.from(toolState.output).toString("base64")}`);
-          core6.setOutput("result", toolState.output);
+          core7.setOutput("result", toolState.output);
         }
         return await handleAgentResult({
           result,
@@ -154723,27 +154910,27 @@ async function runMain() {
     }
   } catch (error49) {
     const errorMessage = error49 instanceof Error ? error49.message : "unknown error occurred";
-    core7.setFailed(`action failed: ${errorMessage}`);
+    core8.setFailed(`action failed: ${errorMessage}`);
   }
 }
 async function tokenMain() {
-  const reposInput = core7.getInput("repos");
+  const reposInput = core8.getInput("repos");
   const additionalRepos = reposInput ? reposInput.split(",").map((r) => r.trim()).filter(Boolean) : [];
   const token = await acquireNewToken({ repos: additionalRepos });
-  core7.setSecret(token);
-  core7.saveState(STATE_TOKEN, token);
-  core7.setOutput("token", token);
+  core8.setSecret(token);
+  core8.saveState(STATE_TOKEN, token);
+  core8.setOutput("token", token);
   const scope2 = additionalRepos.length ? `current repo + ${additionalRepos.join(", ")}` : "current repo only";
-  core7.info(`\xBB installation token acquired (${scope2})`);
+  core8.info(`\xBB installation token acquired (${scope2})`);
 }
 async function tokenPost() {
-  const token = core7.getState(STATE_TOKEN);
+  const token = core8.getState(STATE_TOKEN);
   if (!token) {
-    core7.debug("no token found in state, skipping revocation");
+    core8.debug("no token found in state, skipping revocation");
     return;
   }
   await revokeGitHubInstallationToken(token);
-  core7.info("\xBB installation token revoked");
+  core8.info("\xBB installation token revoked");
 }
 function printGhaUsage(params) {
   params.stream(`usage: ${params.prog} gha [subcommand]
@@ -154859,7 +155046,7 @@ async function run(args2) {
     }
   } catch (error49) {
     const message = error49 instanceof Error ? error49.message : String(error49);
-    core7.setFailed(message);
+    core8.setFailed(message);
   }
 }
 
@@ -156523,7 +156710,7 @@ async function run2() {
 }
 
 // cli.ts
-var VERSION10 = "0.1.5";
+var VERSION10 = "0.1.6";
 var bin = basename2(process.argv[1] || "");
 var PROG = bin === "pf" || bin === "pullfrog" ? bin : "pullfrog";
 var rawArgs = process.argv.slice(2);