@sagentlab/navarch-runtime 0.1.86 → 0.1.88

package/README.md

@@ -691,6 +691,14 @@ post-tool answer as the report, and reads aggregate `input_tokens` and
 `output_tokens` from the terminal `result` event. Gemini does not report USD
 cost, so an unknown value remains absent rather than becoming zero.
 
+Gemini's native sandbox launcher converts piped stdin back into a `--prompt`
+argument for its child. The adapter rejects prompts of 128 KiB or more when
+that sandbox is enabled, with an explicit diagnostic; reducing context or
+selecting another runtime preserves the worktree boundary. Navarch Docker
+mode disables the nested Gemini sandbox by default and can still pipe larger
+prompts. All Gemini runs reject prompts above 8 MiB because Gemini's stdin
+reader silently truncates input beyond that limit. These checks use UTF-8 bytes.
+
 The OpenCode adapter uses `opencode run --format json` with the prompt on
 stdin, and normalizes `text` and `step_finish` JSONL events into
 the shared report/token/cost boundary. It translates the lease MCP document
@@ -722,6 +730,9 @@ rejects any single argv or environment string over 128 KiB
 (`MAX_ARG_STRLEN`), so an argv prompt made large review sessions fail with
 `spawn E2BIG` before the agent started. Docker-mode sessions forward the same
 stdin through `docker exec -i`.
+Gemini's own sandbox relaunch is an exception to this transport guarantee,
+as described above; moving the initial spawn to stdin does not remove its
+internal argv limit.
 
 ## Architecture
 
@@ -740,7 +751,7 @@ cli.cts
                   into Docker when NAVARCH_SANDBOX_MODE=docker
                4. selectAdapter(config.agentType) (adapters/index.cts) picks one AgentAdapter
                   (adapters/types.cts) by NAVARCH_AGENT, then .run(...):
-                    - claudeCodeAdapter (adapters/claude.cts) — `claude -p --mcp-config <path> < prompt`
+                    - claudeCodeAdapter (adapters/claude.cts) — `claude -p --mcp-config <path> --output-format stream-json --verbose < prompt`
                     - codexAdapter      (adapters/codex.cts)  — `codex exec - --json -c mcp_servers.*=... < prompt`
                     - geminiAdapter     (adapters/gemini.cts) — `gemini --output-format stream-json < prompt`
                     - openCodeAdapter   (adapters/opencode.cts) — `opencode run --format json < prompt`
@@ -860,16 +871,17 @@ Claude Code headless → PR opens on GitHub → complete lands with evidence;
 secrets absent from disk after exit"):
 
 - Actually running `claude -p` headless and confirming its real
-  `--output-format json` shape (WP-13). `adapters/claude.cts` now appends
-  `--output-format json` by default and best-effort parses stdout as a single
-  JSON result object shaped like `{ type, subtype, is_error, result,
+  result shape (WP-13). `adapters/claude.cts` appends
+  `--output-format stream-json --verbose` by default, so the uploaded
+  transcript records every message and tool call, and best-effort parses the
+  last `type: "result"` record on stdout as a JSON result object shaped like `{ type, subtype, is_error, result,
   session_id, total_cost_usd, usage: { input_tokens, output_tokens,
   cache_creation_input_tokens, cache_read_input_tokens } }` (see
   `exit-conditions.cts#parseClaudeJsonResult` for the exact assumption and
   fallback behavior). Unit tests (`tests/adapter.test.cts`,
   `tests/exit-conditions.test.cts`) cover the parsing and arg-construction
-  logic against fixed JSON strings; what's untested offline is whether a real
-  `claude -p --output-format json` invocation actually produces this shape.
+  logic against fixed JSON strings recorded from Claude Code 2.1; a future
+  CLI release could still change this shape.
   If it doesn't, parsing degrades to `null` and `tokensIn`/`tokensOut`/
   `costUsd` fall back to 0 (session.cts's existing default) — never a thrown
   error — but cost/spend data silently goes missing until the shape is

package/dist/adapters/claude.cjs

@@ -13,7 +13,7 @@ function hasFlag(args, flag) {
 }
 /**
  * Headless Claude Code adapter (project-plan.md §3.9 / implementation-plan.md
- * WP-07): `claude -p --mcp-config platform-mcp.json --output-format json`
+ * WP-07): `claude -p --mcp-config platform-mcp.json --output-format stream-json --verbose`
  * with the context bundle on stdin (`claude -p` reads its prompt from stdin
  * when none is given; Linux rejects any single argv string over 128 KiB, so
  * an argv prompt failed `spawn E2BIG` before Claude started). Returns raw stdout/stderr/exit signals (plus
@@ -25,11 +25,10 @@ function hasFlag(args, flag) {
  * (adapters/types.cts) — see adapters/codex.cts for the Codex CLI sibling
  * session.cts picks between via NAVARCH_AGENT (config.cts's `agentType`).
  *
- * NEEDS LIVE VERIFICATION (WP-13): `--output-format json` is assumed to make
- * `claude -p` print a single JSON result object with a `usage` block, per
- * Claude Code's documented headless-mode output. This cannot be confirmed
- * without a real `claude` binary in this offline build environment. If the
- * real shape differs, parseClaudeJsonResult() returns null and
+ * `--output-format stream-json` prints one JSON record per line and ends with
+ * the same result object (`type: "result"`, `usage`, `total_cost_usd`) that
+ * `--output-format json` prints alone; parseClaudeJsonResult() reads that
+ * last record. If the real shape differs, parseClaudeJsonResult() returns null and
  * tokensIn/tokensOut/costUsd fall back to 0 (session.cts's existing
  * default) rather than throwing -- see runtime/README.md.
  */
@@ -135,9 +134,14 @@ async function runClaudeAttempt(options, automaticFallback) {
     // Only append the default when the caller hasn't already asked for a
     // specific --output-format (extraArgs wins so an operator can opt back
     // into plain-text output, e.g. while diagnosing a live-verification
-    // mismatch, without an adapter code change).
-    if (!options.extraArgs.includes("--output-format")) {
-        args.push("--output-format", "json");
+    // mismatch, without an adapter code change). stream-json records every
+    // message and tool call, which the task transcript viewer renders; plain
+    // `json` printed only the final result. Claude Code requires --verbose for
+    // stream-json under --print, and its last record is the same result object.
+    if (!hasFlag(options.extraArgs, "--output-format")) {
+        args.push("--output-format", "stream-json");
+        if (!hasFlag(options.extraArgs, "--verbose"))
+            args.push("--verbose");
     }
     args.push(...options.extraArgs);
     // Project/task policy is appended after machine-wide extra arguments so a
@@ -157,7 +161,7 @@ async function runClaudeAttempt(options, automaticFallback) {
     const raw = runOptions.dockerExec ? await runViaDocker(runOptions, args) : await runOnHost(runOptions, args);
     return attachUsage(raw);
 }
-/** Parses stdout for `claude -p --output-format json` usage and folds it onto the raw result (best-effort; leaves tokensIn/tokensOut/costUsd unset when parsing fails). */
+/** Parses the final `claude -p --output-format stream-json` result record for usage and folds it onto the raw result (best-effort; leaves tokensIn/tokensOut/costUsd unset when parsing fails). */
 function attachUsage(result) {
     const parsed = (0, exit_conditions_cjs_1.parseClaudeJsonResult)(result.stdout);
     if (!parsed)

package/dist/adapters/gemini.cjs

@@ -16,10 +16,20 @@ const kill_agent_cjs_1 = require("../kill-agent.cjs");
  * temporary system-settings file and restricts the run to those server names.
  *
  * The prompt arrives on stdin rather than `--prompt`: Gemini runs headlessly
- * whenever stdin is not a TTY and uses the piped text as the prompt, and
- * Linux rejects any single argv string over 128 KiB (`spawn E2BIG`).
+ * whenever stdin is not a TTY and uses the piped text as the prompt. Its
+ * native sandbox puts stdin back into argv, so that path still has Linux's
+ * 128 KiB per-string limit. Gemini also caps stdin at 8 MiB.
  */
 async function runGeminiAdapter(options) {
+    if (options.signal?.aborted) {
+        return { exitCode: null, timedOut: false, killedByLeaseLoss: true, stdout: "", stderr: "" };
+    }
+    const promptBytes = Buffer.byteLength(options.prompt, "utf8");
+    // Gemini's readStdin() silently truncates at 8 MiB. Reject before any
+    // settings writes or process launch rather than execute a partial task.
+    if (promptBytes > 8 * 1024 * 1024) {
+        return inputFailure(`Gemini CLI stdin is limited to 8 MiB; the task prompt is ${promptBytes} bytes. Reduce the context bundle or select another runtime.`);
+    }
     const args = [];
     const env = { ...options.env };
     if (!hasArg(options.extraArgs, "--output-format", "-o")) {
@@ -57,12 +67,41 @@ async function runGeminiAdapter(options) {
     args.push(...options.extraArgs);
     if (options.model)
         args.push("--model", options.model);
+    // Gemini's sandbox launcher reads stdin and injects it back into --prompt
+    // for its child process (packages/cli/src/gemini.tsx injectStdinIntoArgs).
+    // Moving our first spawn's prompt to stdin cannot fix that second spawn.
+    // Check the effective flag, including operator overrides, without disabling
+    // the worktree guard. Even on macOS a Docker sandbox may launch on Linux.
+    if (geminiSandboxEnabled(args) && promptBytes >= 128 * 1024) {
+        return inputFailure(`Gemini CLI re-encodes stdin as --prompt when launching its native sandbox; the ${promptBytes}-byte task prompt exceeds Linux's argv limit. Reduce the context bundle or select another runtime that supports large prompts in its sandbox.`);
+    }
     const runOptions = { ...options, env };
     const raw = runOptions.dockerExec
         ? await runViaDocker(runOptions, args)
         : await runOnHost(runOptions, args);
     return attachGeminiOutput(raw);
 }
+function inputFailure(stderr) {
+    return { exitCode: 1, timedOut: false, killedByLeaseLoss: false, stdout: "", stderr };
+}
+function geminiSandboxEnabled(args) {
+    // There is always a generated --sandbox flag unless extraArgs supplies one.
+    // Like yargs, later explicit values override earlier ones.
+    let enabled = false;
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index];
+        if (arg === "--sandbox" || arg === "-s") {
+            enabled = args[index + 1] !== "false";
+        }
+        else if (arg.startsWith("--sandbox=") || arg.startsWith("-s=")) {
+            enabled = arg.slice(arg.indexOf("=") + 1) !== "false";
+        }
+        else if (arg === "--no-sandbox") {
+            enabled = false;
+        }
+    }
+    return enabled;
+}
 function hasArg(args, ...flags) {
     return args.some((arg) => flags.some((flag) => arg === flag || arg.startsWith(`${flag}=`)));
 }

package/dist/exit-conditions.cjs

@@ -24,8 +24,9 @@ function agentAuthFailureReport(detail) {
         "Log the coding agent in again on this machine (`claude /login` or `codex login`), then resume the agent.";
 }
 /**
- * Best-effort parse of `claude -p --output-format json` stdout into the
- * assumed result shape above. Tries the whole trimmed stdout first (the
+ * Best-effort parse of `claude -p --output-format json` (or `stream-json`,
+ * whose last result record has the same shape) stdout into the assumed
+ * result shape above. Tries the whole trimmed stdout first (the
  * expected case); if that fails, tries each non-empty line that looks like a
  * JSON object, in case a warning/log line preceded the result (last such
  * line wins, since the final result is expected last). Returns null rather
@@ -39,6 +40,9 @@ function parseClaudeJsonResult(stdout) {
     const isUsableResult = (value) => typeof value === "object" &&
         value !== null &&
         !Array.isArray(value) &&
+        // stream-json output interleaves typed message/tool records with the
+        // final `type: "result"` record; only that record carries the outcome.
+        (!("type" in value) || value.type === "result") &&
         (!("result" in value) || typeof value.result === "string") &&
         ("result" in value || "usage" in value || "cost_usd" in value || "total_cost_usd" in value);
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sagentlab/navarch-runtime",
-  "version": "0.1.86",
+  "version": "0.1.88",
   "description": "Navarch machine-side session manager: claims delivery tasks and runs them through local coding agents.",
   "type": "commonjs",
   "license": "MIT",