@sagentlab/navarch-runtime 0.1.50 → 0.1.52

package/README.md

@@ -360,6 +360,7 @@ unchanged across the deployment.
 | `NAVARCH_LEASE_HEARTBEAT_INTERVAL_MS` | `300000` | Per-lease heartbeat interval; must stay well under the 60-minute lease TTL (schema-design.md §4). |
 | `NAVARCH_SESSION_TIMEOUT_MS` | `0` (disabled) | Optional absolute runtime budget across agent turns in a claimed session. |
 | `NAVARCH_SESSION_IDLE_TIMEOUT_MS` | `2700000` (45 min) | Stop after a continuously observed window with no stdout/stderr or process-tree CPU activity. `0` disables idle detection. |
+| `NAVARCH_OPENCODE_STARTUP_TIMEOUT_MS` | `120000` (2 min) | Stop OpenCode when it produces no stdout/stderr during startup. This catches provider auth/quota failures that leave its CLI process alive. `0` disables the startup deadline. |
 | `NAVARCH_WORKTREE_CLEANUP_INTERVAL_MS` | `3600000` (1 hour) | How often the runtime scans for session worktrees abandoned by a hard exit or host restart. |
 | `NAVARCH_WORKTREE_STALE_AFTER_MS` | `86400000` (24 hours) | Minimum inactivity age before an abandoned session worktree is removed. Active sessions are always protected. |
 | `NAVARCH_GIT_AUTHOR_NAME` / `NAVARCH_GIT_AUTHOR_EMAIL` | `sagentlab` / `z@sagentlab.com` | Git identity forced into session commits so host-level personal config is not inherited; override both for a project-authorized bot. |
@@ -368,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. |
@@ -600,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,
@@ -679,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.
 
@@ -781,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/activity-watchdog.cjs

@@ -16,6 +16,7 @@ class ActivityWatchdog {
     stopped = false;
     polling = false;
     pollTimer;
+    startupTimer;
     hardTimer;
     constructor(options) {
         this.options = options;
@@ -24,16 +25,23 @@ class ActivityWatchdog {
         if (options.idleTimeoutMs > 0) {
             this.pollTimer = setInterval(() => void this.poll(), Math.min(30_000, options.idleTimeoutMs / 4));
         }
+        if ((options.startupTimeoutMs ?? 0) > 0) {
+            this.startupTimer = setTimeout(() => this.expire("startup"), options.startupTimeoutMs);
+        }
         if (options.timeoutMs > 0)
             this.armHardLimit();
     }
     activity() {
-        if (!this.stopped)
+        if (!this.stopped) {
             this.lastActivity = this.now();
+            clearTimeout(this.startupTimer);
+            this.startupTimer = undefined;
+        }
     }
     stop() {
         this.stopped = true;
         clearInterval(this.pollTimer);
+        clearTimeout(this.startupTimer);
         clearTimeout(this.hardTimer);
     }
     armHardLimit() {
@@ -61,8 +69,11 @@ class ActivityWatchdog {
                 this.observed = false;
                 return;
             }
+            // Process-tree activity keeps the ordinary idle window alive, but only
+            // actual adapter output proves that a CLI got through startup. Some
+            // providers leave a quiet process behind after an auth/quota failure.
             if (!this.observed || signature !== this.signature)
-                this.activity();
+                this.lastActivity = this.now();
             this.signature = signature;
             this.observed = true;
             if (this.now() - this.lastActivity >= this.options.idleTimeoutMs)
@@ -79,15 +90,15 @@ class ActivityWatchdog {
 }
 exports.ActivityWatchdog = ActivityWatchdog;
 /** No command arguments or environment values are collected from other jobs. */
-async function processActivity(pid, containerName) {
+async function processActivity(pid, containerName, ignoreRootCpu = false) {
     if (!containerName && pid === undefined)
         return null;
     const output = await new Promise((resolve) => {
         (0, node_child_process_1.execFile)(containerName ? "docker" : "ps", containerName ? ["top", containerName, "-eo", "pid=,ppid=,time="] : ["-e", "-o", "pid=,ppid=,time="], { timeout: 5_000, maxBuffer: 4 * 1024 * 1024 }, (error, stdout) => resolve(error ? null : stdout));
     });
-    return output === null ? null : processTreeSignature(output, containerName ? undefined : pid);
+    return output === null ? null : processTreeSignature(output, containerName ? undefined : pid, ignoreRootCpu);
 }
-function processTreeSignature(output, rootPid) {
+function processTreeSignature(output, rootPid, ignoreRootCpu = false) {
     const rows = output.split("\n").flatMap((line) => {
         const match = /^\s*(\d+)\s+(\d+)\s+([\d:.\-]+)\s*$/.exec(line);
         return match ? [{ pid: Number(match[1]), parent: Number(match[2]), cpu: match[3] }] : [];
@@ -106,5 +117,5 @@ function processTreeSignature(output, rootPid) {
         }
     }
     return rows.filter((row) => included.has(row.pid)).sort((a, b) => a.pid - b.pid)
-        .map((row) => `${row.pid}:${row.cpu}`).join(",");
+        .map((row) => `${row.pid}:${ignoreRootCpu && row.pid === rootPid ? "root" : row.cpu}`).join(",");
 }

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/adapter-watchdog.cjs

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runWithActivityWatchdog = runWithActivityWatchdog;
 const activity_watchdog_cjs_1 = require("./activity-watchdog.cjs");
 /** Shared policy for every host/Docker/ACP adapter; adapters still own cancellation. */
-async function runWithActivityWatchdog(adapter, options, idleTimeoutMs) {
+async function runWithActivityWatchdog(adapter, options, idleTimeoutMs, startupTimeoutMs = 0) {
     const controller = new AbortController();
     const onAbort = () => controller.abort();
     options.signal?.addEventListener("abort", onAbort, { once: true });
@@ -13,8 +13,11 @@ async function runWithActivityWatchdog(adapter, options, idleTimeoutMs) {
     let timeoutReason;
     const watchdog = new activity_watchdog_cjs_1.ActivityWatchdog({
         idleTimeoutMs,
+        startupTimeoutMs,
         timeoutMs: options.timeoutMs,
-        probe: () => (0, activity_watchdog_cjs_1.processActivity)(pid, options.dockerExec?.containerName),
+        // OpenCode keeps doing root-process housekeeping after provider failures.
+        // Descendant work and stdout/stderr still count, but that churn does not.
+        probe: () => (0, activity_watchdog_cjs_1.processActivity)(pid, options.dockerExec?.containerName, adapter.agentType === "opencode" && !options.dockerExec),
         onTimeout: (reason) => {
             timeoutReason = reason;
             controller.abort();

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,14 +208,10 @@ 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();
     const activeSessionIds = new Set();
     const worktreeJanitor = new worktree_janitor_cjs_1.WorktreeJanitor({
         workspaceRoot: config.workspaceRoot,
@@ -219,7 +221,7 @@ async function startCommand(flags) {
     });
     const claimLoop = new claim_loop_cjs_1.ClaimLoop(api, config, capacity, (claimed, sessionId) => {
         activeSessionIds.add(sessionId);
-        return (0, session_cjs_1.runSession)({ api, config }, claimed, sessionId)
+        return (0, session_cjs_1.runSession)({ api, config, shutdownSignal: runtimeShutdown.signal }, claimed, sessionId)
             .finally(() => activeSessionIds.delete(sessionId));
     });
     const bootId = (0, node_crypto_1.randomUUID)();
@@ -243,8 +245,11 @@ async function startCommand(flags) {
             : `machine credentials for ${identity.name} were rejected by ${identity.api_base}; it can no longer claim tasks.`);
         log.error(`Re-enroll this machine with a fresh "Connect an agent" token, then run ` +
             `\`${superviseInvocation(config.configDir)}\` again.`);
-        // Active sessions keep running to completion; exiting mid-task would
-        // strand a worktree the control plane can no longer hear about either.
+        // Removal/revocation is terminal: stop detached agent process groups so
+        // a provider-side hang cannot keep consuming local resources forever.
+        // runSession checkpoints or retains the worktree before releasing its
+        // capacity slot.
+        runtimeShutdown.abort();
         void capacity.waitForIdle().then(() => process.exit(CREDENTIALS_REJECTED_EXIT_CODE));
     });
     updateCoordinatorRef.current = new update_coordinator_cjs_1.RuntimeUpdateCoordinator({
@@ -279,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
@@ -311,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)}`);
@@ -329,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/config.cjs

@@ -108,6 +108,7 @@ function loadRuntimeConfig(env = process.env) {
         leaseHeartbeatIntervalMs,
         sessionTimeoutMs: envRuntimeLimit(env, "NAVARCH_SESSION_TIMEOUT_MS", 0),
         sessionIdleTimeoutMs: envRuntimeLimit(env, "NAVARCH_SESSION_IDLE_TIMEOUT_MS", 45 * 60 * 1000),
+        opencodeStartupTimeoutMs: envRuntimeLimit(env, "NAVARCH_OPENCODE_STARTUP_TIMEOUT_MS", 2 * 60 * 1000),
         worktreeCleanupIntervalMs: envInt(env, "NAVARCH_WORKTREE_CLEANUP_INTERVAL_MS", 60 * 60 * 1000),
         worktreeStaleAfterMs: envInt(env, "NAVARCH_WORKTREE_STALE_AFTER_MS", 24 * 60 * 60 * 1000),
         agentType,

package/dist/exit-conditions.cjs

@@ -229,13 +229,25 @@ 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",
             exitStatus: "killed",
-            reportSummary: (result.timeoutReason === "idle"
-                ? "Session stopped: no output or process-tree CPU activity within the configured idle window."
-                : "Session killed: exceeded the configured max session duration.") +
+            reportSummary: (result.timeoutReason === "startup"
+                ? "Session stopped: the agent produced no output within the configured startup window."
+                : result.timeoutReason === "idle"
+                    ? "Session stopped: no output or process-tree CPU activity within the configured idle window."
+                    : "Session killed: exceeded the configured max session duration.") +
                 (result.checkpointPath ? ` Local recovery checkpoint: ${result.checkpointPath}` : "") +
                 (result.retainedWorktreePath ? ` Recovery worktree retained: ${result.retainedWorktreePath}` : ""),
             evidenceUrls,

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

@@ -211,6 +211,14 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
     let activeAbortController = null;
     let leaseLost = false;
     let leaseGone = false;
+    const abortForRuntimeShutdown = () => {
+        // Machine removal/revocation also makes lease completion impossible.
+        // Treat it like a terminal lease loss so the worktree is checkpointed
+        // and no remediation turn or authenticated API call is attempted.
+        leaseLost = true;
+        leaseGone = true;
+        activeAbortController?.abort();
+    };
     let sessionClosing = false;
     let retainWorktree = false;
     let heartbeatInFlight = null;
@@ -221,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;
@@ -392,6 +400,9 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
         activeAbortController?.abort();
     });
     const heartbeatTimer = setInterval(() => void pollLease(), config.leaseHeartbeatIntervalMs);
+    deps.shutdownSignal?.addEventListener("abort", abortForRuntimeShutdown);
+    if (deps.shutdownSignal?.aborted)
+        abortForRuntimeShutdown();
     lifecycle.enteredMainSessionTry = true;
     try {
         await gitWorktree.prepare();
@@ -427,7 +438,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
             // notification and start the first turn with the corrected prompt.
             pendingGuidance = [];
             activeAbortController = new AbortController();
-            if (leaseLost)
+            if (leaseLost || deps.shutdownSignal?.aborted)
                 activeAbortController.abort();
             const runPrompt = nextPrompt ??
                 (deliveredGuidance.length > (bundle.guidance?.length ?? 0)
@@ -459,7 +470,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                     cwd: gitWorktree.worktreePath,
                     dockerExec: sandbox ? { containerName: sandbox.name, runner: sandbox_cjs_1.nodeCommandRunner } : undefined,
                     signal: activeAbortController.signal,
-                }, task.idle_timeout_ms ?? config.sessionIdleTimeoutMs ?? 45 * 60_000);
+                }, task.idle_timeout_ms ?? config.sessionIdleTimeoutMs ?? 45 * 60_000, runtime === "opencode" ? config.opencodeStartupTimeoutMs : 0);
             activeAbortController = null;
             if (turnResult.timedOut || leaseLost)
                 await checkpointForRecovery(turnResult);
@@ -470,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
@@ -484,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,
@@ -711,6 +723,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
             .catch((completeErr) => log.warn(`complete() after crash also failed: ${String(completeErr)}`));
     }
     finally {
+        deps.shutdownSignal?.removeEventListener("abort", abortForRuntimeShutdown);
         sessionClosing = true;
         clearInterval(heartbeatTimer);
         heartbeatGuard.stop();
@@ -794,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.50",
+  "version": "0.1.52",
   "description": "Navarch machine-side session manager: claims delivery tasks and runs them through local coding agents.",
   "type": "commonjs",
   "license": "MIT",