@sagentlab/navarch-runtime 0.1.51 → 0.1.52

package/README.md

@@ -369,7 +369,7 @@ unchanged across the deployment.
 | `NAVARCH_SANDBOX_EGRESS_NETWORK` | _(unset)_ | Docker network that enforces a profile's egress allowlist. Docker cannot filter by domain itself, so an allowlist profile without this fails closed to `--network=none` and records the denial. |
 | `NAVARCH_DOCKER_IMAGE` | `ghcr.io/sagentlab/navarch-sandbox-agent:0.1.0` | Version-pinned per-session image with Node 20, git, GitHub CLI, ripgrep, jq, SSH, and Claude Code 2.1.218. Override with an image tag or digest you control. |
 | `NAVARCH_AGENT` | saved choice, then `claude-code` | Local choice of agent adapter: `claude-code`, `codex`, `gemini`, `opencode`, or `acp`. Overrides the choice saved by `connect`/`register`; `start --agent` has highest priority. |
-| `NAVARCH_RUNTIMES` | selected `NAVARCH_AGENT` | Comma list of installed/authenticated adapters advertised to dispatch. The control plane chooses among these per project/task. |
+| `NAVARCH_RUNTIMES` | resolved local agent choice | Comma list of installed/authenticated adapters advertised to dispatch. The control plane chooses among these per project/task. |
 | `NAVARCH_UPDATE_CHANNEL` | `stable` | Release channel advertised by the worker (`stable` or `canary`); the server-managed machine channel remains authoritative. |
 | `NAVARCH_AUTO_UPDATE` | on under `supervise` | Set `off`, `false`, or `0` to report releases without staging or activating them. Automatic activation is always off under plain `start`. |
 | `NAVARCH_CLAUDE_BIN` | `claude` | Path/name of the Claude Code CLI binary. |
@@ -601,6 +601,16 @@ to OpenCode's remote-server config with OAuth disabled and environment-backed
 headers. Missing accounting fields stay absent rather than becoming a
 fabricated zero.
 
+OpenCode also runs with `--print-logs --log-level ERROR` by default (see its
+[CLI flags](https://opencode.ai/docs/cli/#global-flags)), so provider errors
+that are missing from assistant messages still reach the runtime. A rate or
+usage limit in a provider error event or stream-error log stops the host
+process or Docker container immediately. The runtime checkpoints local work,
+records the error, and releases the lease with a failed session outcome.
+Pending guidance does not restart that session. New claims on this machine
+pause until the reported reset time (including relative resets such as
+“in 23 days”), or for 15 minutes when no reset time is available.
+
 The ACP adapter speaks the standard [Agent Client Protocol](https://agentclientprotocol.com)
 v1 JSON-RPC transport over stdio. It creates one protocol session in the task
 worktree, converts Navarch's HTTP/stdio MCP entries, consumes semantic message,
@@ -680,7 +690,7 @@ contract used by `api.cts`, including:
    distinct from the per-lease heartbeat, needed because `machines.last_heartbeat_at`
    /`status` must update even when no task is claimed.
 3. **`POST /api/dispatch/:leaseId/transcript-upload-url`** — a signed
-   Supabase Storage upload URL for the session's redacted transcript. The
+   R2 upload URL for the session's redacted transcript. The
    bucket is private; the legacy `public_url` response field is only an
    attested locator returned at completion, not an anonymous read URL.
 
@@ -782,7 +792,7 @@ secrets absent from disk after exit"):
   already-reassigned lease) — `session.cts` aborts the running adapter
   process and still attempts a best-effort `complete()` call, which the
   real server may reject; that path is untested against real semantics.
-- Transcript upload against a real signed Supabase Storage URL.
+- Transcript upload against a real signed R2 URL.
 - The end-to-end "Connect an agent to a project" flow against a real
   Supabase instance: an owner minting a token from `ConnectAgentPanel`
   (or the onboarding wizard's Agent step), `navarch-runtime connect`

package/dist/adapter-capacity.cjs

@@ -14,9 +14,9 @@ const MAX_RESET_SEARCH_MINUTES = 48 * 60;
 function detectAdapterCapacityLimit(result, nowMs = Date.now()) {
     const parsed = (0, exit_conditions_cjs_1.parseClaudeJsonResult)(result.stdout) ??
         (0, exit_conditions_cjs_1.parseClaudeJsonResult)(result.stderr);
-    if (parsed?.api_error_status !== 429)
+    if (!result.capacityError && parsed?.api_error_status !== 429)
         return null;
-    const detail = parsed.result ?? "";
+    const detail = result.capacityError ?? parsed?.result ?? "";
     if (!/\b(?:session|usage|rate)\s+limit\b|\btoo many requests\b/i.test(detail)) {
         return null;
     }
@@ -32,6 +32,13 @@ function detectAdapterCapacityLimit(result, nowMs = Date.now()) {
  * the platform's IANA timezone database.
  */
 function parseResetTime(detail, nowMs) {
+    const relative = detail.match(/\bresets?\s+in\s+(\d+(?:\.\d+)?)\s*(seconds?|minutes?|hours?|days?)\b/i);
+    if (relative) {
+        const units = { second: 1000, minute: 60_000, hour: 3_600_000, day: 86_400_000 };
+        const duration = Number(relative[1]) * units[relative[2].toLowerCase().replace(/s$/, "")];
+        if (Number.isFinite(duration) && duration > 0)
+            return nowMs + duration + RESET_GRACE_MS;
+    }
     const match = detail.match(/\bresets?\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)\s*\(([^)]+)\)/i);
     if (!match)
         return null;

package/dist/adapters/opencode.cjs

@@ -7,10 +7,10 @@ const node_fs_1 = require("node:fs");
 const config_cjs_1 = require("../config.cjs");
 const kill_agent_cjs_1 = require("../kill-agent.cjs");
 /**
- * Headless OpenCode adapter, fixture-pinned to the OpenCode 1.18 JSON/config
- * contract:
+ * Headless OpenCode adapter, fixture-pinned to the OpenCode JSON/config
+ * contract shared by V1 and V2 (verified against 2.0.6):
  *
- *   opencode run "<prompt>" --format json [--model provider/model]
+ *   opencode run "<prompt>" --format json [--model provider/model[#variant]]
  *
  * OpenCode merges configuration from several machine and project locations,
  * so each Navarch session gets an isolated XDG/config directory, disables
@@ -32,14 +32,18 @@ async function runOpenCodeAdapter(options) {
     const env = { ...options.env };
     await prepareOpenCodeConfig(options.mcpConfigPath, env);
     const args = ["run", options.prompt];
+    // Provider failures may only appear in logs, absent from assistant events.
+    if (!hasArg(options.extraArgs, "--print-logs"))
+        args.push("--print-logs");
+    if (!hasArg(options.extraArgs, "--log-level"))
+        args.push("--log-level", "ERROR");
     if (!hasArg(options.extraArgs, "--format"))
         args.push("--format", "json");
     args.push(...options.extraArgs);
     if (options.model && options.model !== "default" && !hasArg(options.extraArgs, "--model", "-m")) {
-        args.push("--model", options.model);
-    }
-    if (options.reasoningEffort && !hasArg(options.extraArgs, "--variant")) {
-        args.push("--variant", options.reasoningEffort);
+        // OpenCode V2 selects a reasoning variant through the model reference
+        // (`provider/model#variant`) rather than a separate flag.
+        args.push("--model", options.reasoningEffort ? `${options.model}#${options.reasoningEffort}` : options.model);
     }
     const runOptions = { ...options, env };
     const raw = runOptions.dockerExec
@@ -80,23 +84,22 @@ async function prepareOpenCodeConfig(mcpConfigPath, env) {
         mcp[name] = {
             type: "remote",
             url,
-            enabled: true,
+            disabled: false,
             oauth: false,
             ...(Object.keys(headers).length > 0 ? { headers } : {}),
         };
     }
     const config = {
         $schema: "https://opencode.ai/config.json",
-        autoupdate: false,
+        update: "disable",
         share: "disabled",
-        plugin: [],
-        mcp,
-        permission: {
-            "*": "allow",
-            external_directory: "deny",
-            question: "deny",
-            doom_loop: "deny",
-        },
+        plugins: [],
+        mcp: { servers: mcp },
+        permissions: [
+            { action: "*", resource: "*", effect: "allow" },
+            { action: "external_directory", resource: "*", effect: "deny" },
+            { action: "question", resource: "*", effect: "deny" },
+        ],
     };
     const configPath = `${mcpConfigPath}.opencode.json`;
     const configDir = `${mcpConfigPath}.opencode-config`;
@@ -186,6 +189,42 @@ function parseOpenCodeEvents(stdout) {
 function nonNegativeMetric(value) {
     return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
 }
+/** Inspect only provider error envelopes/logs, never tool output or assistant text. */
+function capacityMonitor(onLimit) {
+    const pending = { stdout: "", stderr: "" };
+    const inspect = (line, stream) => {
+        let detail = "";
+        try {
+            const event = JSON.parse(line);
+            if (event.type === "error" || event.type === "session.error") {
+                const error = event.error ?? event.properties?.error;
+                detail = typeof error === "string" ? error : error?.data?.message ?? error?.message ?? "";
+            }
+        }
+        catch {
+            // OpenCode's log format varies by version. Require a stream-error log
+            // to avoid confusing a tool's own HTTP 429 with provider exhaustion.
+            if (stream === "stderr" && /\bERROR\b/.test(line) && /stream error/i.test(line)) {
+                detail = line;
+            }
+        }
+        if (typeof detail === "string" && /\b(?:rate|usage|session)\s+limit\b|\btoo many requests\b/i.test(detail)) {
+            onLimit(detail);
+        }
+    };
+    return {
+        push(stream, chunk) {
+            const lines = (pending[stream] + chunk).split(/\r?\n/);
+            pending[stream] = lines.pop() ?? "";
+            for (const line of lines)
+                inspect(line, stream);
+        },
+        flush() {
+            inspect(pending.stdout, "stdout");
+            inspect(pending.stderr, "stderr");
+        },
+    };
+}
 async function runOnHost(options, args) {
     return new Promise((resolve) => {
         let stdout = "";
@@ -197,6 +236,11 @@ async function runOnHost(options, args) {
             cwd: options.cwd,
             env: { ...process.env, ...options.env },
         });
+        let capacityError;
+        const monitor = capacityMonitor((detail) => {
+            capacityError ??= detail;
+            (0, kill_agent_cjs_1.killAgent)(child);
+        });
         child.stdin?.end();
         options.onProcessStarted?.(child.pid);
         const timer = options.timeoutMs > 0 ? setTimeout(() => {
@@ -213,21 +257,25 @@ async function runOnHost(options, args) {
         child.stdout.on("data", (data) => {
             options.onActivity?.();
             stdout += data.toString();
+            monitor.push("stdout", data.toString());
         });
         child.stderr.on("data", (data) => {
             options.onActivity?.();
             stderr += data.toString();
+            monitor.push("stderr", data.toString());
         });
         child.on("error", (error) => {
             clearTimeout(timer);
             options.signal?.removeEventListener("abort", onAbort);
             stderr += `\n${String(error)}`;
-            resolve({ exitCode: null, timedOut, killedByLeaseLoss, stdout, stderr });
+            monitor.flush();
+            resolve({ exitCode: null, timedOut, killedByLeaseLoss, stdout, stderr, capacityError });
         });
         child.on("close", (code) => {
             clearTimeout(timer);
             options.signal?.removeEventListener("abort", onAbort);
-            resolve({ exitCode: code, timedOut, killedByLeaseLoss, stdout, stderr });
+            monitor.flush();
+            resolve({ exitCode: code, timedOut, killedByLeaseLoss, stdout, stderr, capacityError });
         });
     });
 }
@@ -236,8 +284,19 @@ async function runViaDocker(options, args) {
     const quoted = [options.bin, ...args].map(shellQuote).join(" ");
     const command = `[ -f /tmp/session.env ] && . /tmp/session.env; cd repo 2>/dev/null; ${quoted}`;
     let killedByLeaseLoss = false;
+    let capacityError;
+    const controller = new AbortController();
+    const streamed = { stdout: false, stderr: false };
+    const monitor = capacityMonitor((detail) => {
+        if (capacityError)
+            return;
+        capacityError = detail;
+        controller.abort();
+        runner.run("docker", ["kill", containerName], { timeoutMs: 10_000 }).catch(() => undefined);
+    });
     const onAbort = () => {
         killedByLeaseLoss = true;
+        controller.abort();
         runner.run("docker", ["kill", containerName], { timeoutMs: 10_000 }).catch(() => undefined);
     };
     options.signal?.addEventListener("abort", onAbort, { once: true });
@@ -247,10 +306,19 @@ async function runViaDocker(options, args) {
         const forwardedEnv = Object.keys(options.env).flatMap((name) => ["--env", name]);
         const result = await runner.run("docker", ["exec", ...forwardedEnv, containerName, "sh", "-c", command], { timeoutMs: options.timeoutMs,
             onActivity: options.onActivity,
-            signal: options.signal,
+            signal: controller.signal,
+            onStdout: (chunk) => { streamed.stdout = true; monitor.push("stdout", chunk); },
+            onStderr: (chunk) => { streamed.stderr = true; monitor.push("stderr", chunk); },
             env: { ...process.env, ...options.env },
         });
+        // Also inspect runners that only return buffered output.
+        if (!streamed.stdout)
+            monitor.push("stdout", result.stdout);
+        if (!streamed.stderr)
+            monitor.push("stderr", result.stderr);
+        monitor.flush();
         return {
+            capacityError,
             exitCode: result.code,
             timedOut: false,
             killedByLeaseLoss,
@@ -260,6 +328,7 @@ async function runViaDocker(options, args) {
     }
     catch (error) {
         return {
+            capacityError,
             exitCode: null,
             timedOut: false,
             killedByLeaseLoss,

package/dist/cli.cjs

@@ -61,11 +61,17 @@ function superviseInvocation(configDir) {
     return `${invocation("supervise")} --config-dir ${configDir}`;
 }
 /** Resolve CLI-local configuration without mutating the parent shell environment. */
-function configFromFlags(flags) {
-    const configDir = flags["config-dir"];
-    return (0, config_cjs_1.loadRuntimeConfig)(configDir
-        ? { ...process.env, NAVARCH_CONFIG_DIR: node_path_1.default.resolve(configDir) }
-        : process.env);
+function configFromFlags(flags, identity) {
+    const env = { ...process.env };
+    if (flags["config-dir"])
+        env.NAVARCH_CONFIG_DIR = node_path_1.default.resolve(flags["config-dir"]);
+    // Resolve the preferred adapter before deriving the advertised runtimes and
+    // applying host guards. Keep an explicit NAVARCH_RUNTIMES list intact.
+    const agentType = agentFromFlag(flags) ?? (env.NAVARCH_AGENT || identity?.agent_type);
+    if (agentType)
+        env.NAVARCH_AGENT = agentType;
+    const config = (0, config_cjs_1.loadRuntimeConfig)(env);
+    return { ...config, model: modelFromFlags(flags, config.agentType, identity) };
 }
 function agentFromFlag(flags) {
     const value = flags.agent;
@@ -202,12 +208,7 @@ async function connectCommand(flags) {
 async function startCommand(flags) {
     const baseConfig = configFromFlags(flags);
     const identity = await (0, machine_store_cjs_1.resolveMachineIdentity)(baseConfig.configDir, baseConfig.apiBase);
-    // Adapter selection belongs to the local machine: an explicit start flag
-    // wins, followed by NAVARCH_AGENT, the choice saved at connect/register
-    // time, and finally the backwards-compatible Claude Code default.
-    const agentType = agentFromFlag(flags) ??
-        (process.env.NAVARCH_AGENT ? baseConfig.agentType : identity.agent_type ?? baseConfig.agentType);
-    const config = { ...baseConfig, agentType, model: modelFromFlags(flags, agentType, identity) };
+    const config = configFromFlags(flags, identity);
     const api = new api_cjs_1.NavarchApiClient({ baseUrl: identity.api_base, token: identity.token });
     const capacity = new capacity_cjs_1.CapacityTracker(config.maxSessions);
     const runtimeShutdown = new AbortController();
@@ -283,19 +284,17 @@ async function startCommand(flags) {
     process.on("SIGTERM", shutdown);
 }
 async function superviseCommand(flags) {
-    const config = configFromFlags(flags);
-    const identity = await (0, machine_store_cjs_1.resolveMachineIdentity)(config.configDir, config.apiBase);
+    const baseConfig = configFromFlags(flags);
+    const identity = await (0, machine_store_cjs_1.resolveMachineIdentity)(baseConfig.configDir, baseConfig.apiBase);
+    const config = configFromFlags(flags, identity);
     // Resolve and pin the adapter before spawning the worker. The supervisor
     // passes machine credentials through the environment, so the child no
     // longer reads machine.json for identity fields (including agent_type).
     // Without an explicit worker argument, any saved non-Claude selection
     // would therefore fall back to Claude Code.
-    const agentType = agentFromFlag(flags) ??
-        (process.env.NAVARCH_AGENT ? config.agentType : identity.agent_type ?? config.agentType);
-    const workerArgs = ["--agent", agentType];
-    const model = modelFromFlags(flags, agentType, identity);
-    if (model)
-        workerArgs.push("--model", model);
+    const workerArgs = ["--agent", config.agentType];
+    if (config.model)
+        workerArgs.push("--model", config.model);
     // Pin the identity for this supervisor's lifetime. Without this snapshot, a
     // replacement worker rereads machine.json after an automatic update and can
     // silently become a different machine if another terminal reused the same
@@ -315,8 +314,17 @@ async function doctorCommand(flags) {
     // start (config.cts). Report that as the diagnosis instead of rethrowing it
     // as a bare CLI error.
     let config;
+    let identity;
     try {
         config = configFromFlags(flags);
+        try {
+            identity = await (0, machine_store_cjs_1.resolveMachineIdentity)(config.configDir, config.apiBase);
+        }
+        catch {
+            // Unregistered machines can still inspect their environment configuration.
+        }
+        if (identity)
+            config = configFromFlags(flags, identity);
     }
     catch (err) {
         console.log(`config:          UNUSABLE — ${err instanceof Error ? err.message : String(err)}`);
@@ -333,18 +341,12 @@ async function doctorCommand(flags) {
     console.log(`worktree_guard:  ${config.worktreeGuard ? "on" : "off"}`);
     console.log(`runtimes:        ${config.runtimes?.join(", ") ?? config.agentType}`);
     console.log(`docker:          ${dockerOk ? "available" : "NOT AVAILABLE (docker-backed sessions will fail)"}`);
-    let identity;
-    try {
-        identity = await (0, machine_store_cjs_1.resolveMachineIdentity)(config.configDir, config.apiBase);
-    }
-    catch {
+    if (!identity) {
         console.log(`machine:         not registered — run \`${invocation("register")}\``);
         return;
     }
-    const agentType = agentFromFlag(flags) ??
-        (process.env.NAVARCH_AGENT ? config.agentType : identity.agent_type ?? config.agentType);
     console.log(`machine:         ${identity.name} (${identity.machine_id})`);
-    console.log(`agent:           ${agentType}`);
+    console.log(`agent:           ${config.agentType}`);
 }
 function helpText() {
     return `navarch-runtime — Navarch machine-side session manager

package/dist/exit-conditions.cjs

@@ -229,6 +229,16 @@ function mapExitCondition(result) {
             evidenceUrls,
         };
     }
+    if (result.capacityError) {
+        return {
+            leaseOutcome: "failed",
+            exitStatus: "failed",
+            reportSummary: summarize(`Session stopped: provider capacity exhausted. ${result.capacityError}`) +
+                (result.checkpointPath ? ` Local recovery checkpoint: ${result.checkpointPath}` : "") +
+                (result.retainedWorktreePath ? ` Recovery worktree retained: ${result.retainedWorktreePath}` : ""),
+            evidenceUrls,
+        };
+    }
     if (result.timedOut) {
         return {
             leaseOutcome: "failed",

package/dist/sandbox.cjs

@@ -40,10 +40,12 @@ exports.nodeCommandRunner = {
             child.stdout?.on("data", (d) => {
                 opts.onActivity?.();
                 stdout += d.toString();
+                opts.onStdout?.(d.toString());
             });
             child.stderr?.on("data", (d) => {
                 opts.onActivity?.();
                 stderr += d.toString();
+                opts.onStderr?.(d.toString());
             });
             child.on("error", (err) => {
                 if (settled)

package/dist/session.cjs

@@ -229,7 +229,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
             return;
         try {
             result.checkpointPath = await gitWorktree.saveCheckpoint();
-            log.warn(`session ${leaseId} stopped for ${leaseLost ? "lease loss" : result.timeoutReason ?? "duration"}; recovery checkpoint: ${result.checkpointPath}`);
+            log.warn(`session ${leaseId} stopped for ${leaseLost ? "lease loss" : result.capacityError ? "provider capacity" : result.timeoutReason ?? "duration"}; recovery checkpoint: ${result.checkpointPath}`);
         }
         catch (error) {
             retainWorktree = true;
@@ -481,6 +481,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
             attempts.push(turnResult);
             const capacityLimit = (0, adapter_capacity_cjs_1.detectAdapterCapacityLimit)(turnResult);
             if (capacityLimit) {
+                await checkpointForRecovery(turnResult);
                 sessionOutcome.claimCooldownUntil = Math.max(sessionOutcome.claimCooldownUntil ?? 0, capacityLimit.retryAtMs);
             }
             // Close the small race between a naturally completed turn and the next
@@ -495,7 +496,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                 log.warn(`session ${leaseId} stopped without completion because its lease is no longer active.`);
                 return sessionOutcome;
             }
-            if (!leaseLost && !turnResult.timedOut && pendingGuidance.length > 0)
+            if (!capacityLimit && !leaseLost && !turnResult.timedOut && pendingGuidance.length > 0)
                 continue;
             const result = {
                 ...turnResult,
@@ -806,6 +807,8 @@ function verificationFailureReport(taskType, report) {
 }
 /** Rejection codes another agent turn in the same worktree can plausibly fix. */
 const REMEDIABLE_REJECTION_CODES = new Set([
+    "review_fix_required",
+    "review_fix_unavailable",
     "pr_required",
     // A video-deliverable build that completed without registering its render:
     // the file usually already exists in the worktree, so the remediation turn

package/dist/upload.cjs

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.uploadTranscript = uploadTranscript;
 /**
- * PUTs an already-redacted transcript to the signed Supabase Storage URL the
+ * PUTs an already-redacted transcript to the presigned R2 URL the
  * control plane hands back (schema-design.md §4 sessions.transcript_url;
  * implementation-plan.md WP-07). Kept as its own module so the storage
  * mechanism is a one-function swap if it ever changes.
@@ -16,9 +16,8 @@ async function uploadTranscript(uploadUrl, content, fetchImpl = fetch) {
         body: content,
     });
     if (!response.ok) {
-        // Supabase Storage answers with {statusCode, error, message} here, which is
-        // the only thing distinguishing an RLS rejection from a bad/expired token
-        // from a bucket misconfiguration. Without it a 403 is unattributable.
+        // Include the bounded storage response to distinguish expired signatures
+        // from bucket misconfiguration.
         throw new Error(`Transcript upload failed with ${response.status}: ${await readErrorBody(response)}`);
     }
 }

package/package.json

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