@sagentlab/navarch-runtime 0.1.88 → 0.1.90

package/README.md

@@ -72,7 +72,11 @@ machine.
 During a connected run, the runtime reports preparation, agent start, output
 activity, and completion checks to the control plane. Project members can see
 these phase updates in the task view. The activity signal contains no prompt
-or CLI output; the redacted transcript is uploaded when the run finishes.
+or CLI output. The redacted transcript is uploaded to the session's private
+transcript object every 10 seconds while the agent produces output (backing
+off to 30–60 seconds for multi-megabyte transcripts), and once more in full
+when the run finishes, so the task view can follow a connected run live.
+Live snapshots hold the current turn's stderr back until the turn ends.
 
 The machine operator selects **Claude Code**, **OpenAI Codex**, **Google
 Gemini CLI**, **OpenCode**, or an **Agent Client Protocol (ACP)** agent when connecting a worker. Any selected agent can

package/dist/adapters/acp.cjs

@@ -51,6 +51,7 @@ async function runAcpAdapter(options) {
     child.stdout.on("data", (chunk) => {
         options.onActivity?.();
         rawStdout.push(chunk);
+        options.onOutput?.("stdout", chunk.toString("utf8"));
         protocolInput.write(chunk);
     });
     child.stdout.on("end", () => protocolInput.end());
@@ -58,6 +59,7 @@ async function runAcpAdapter(options) {
     child.stderr.on("data", (chunk) => {
         options.onActivity?.();
         stderr.push(chunk);
+        options.onOutput?.("stderr", chunk);
     });
     child.on("error", (error) => {
         stderr.push(`\n${describeError(error)}`);

package/dist/adapters/claude.cjs

@@ -205,11 +205,15 @@ async function runOnHost(options, args) {
             onAbort();
         child.stdout.on("data", (d) => {
             options.onActivity?.();
-            stdout += d.toString();
+            const text = d.toString();
+            stdout += text;
+            options.onOutput?.("stdout", text);
         });
         child.stderr.on("data", (d) => {
             options.onActivity?.();
-            stderr += d.toString();
+            const text = d.toString();
+            stderr += text;
+            options.onOutput?.("stderr", text);
         });
         child.on("error", (err) => {
             clearTimeout(timer);
@@ -245,6 +249,8 @@ async function runViaDocker(options, args) {
             input: options.prompt,
             timeoutMs: options.timeoutMs,
             onActivity: options.onActivity,
+            onStdout: (chunk) => options.onOutput?.("stdout", chunk),
+            onStderr: (chunk) => options.onOutput?.("stderr", chunk),
             signal: options.signal,
         });
         return {

package/dist/adapters/codex.cjs

@@ -195,11 +195,15 @@ async function runOnHost(options, args) {
             onAbort();
         child.stdout.on("data", (d) => {
             options.onActivity?.();
-            stdout += d.toString();
+            const text = d.toString();
+            stdout += text;
+            options.onOutput?.("stdout", text);
         });
         child.stderr.on("data", (d) => {
             options.onActivity?.();
-            stderr += d.toString();
+            const text = d.toString();
+            stderr += text;
+            options.onOutput?.("stderr", text);
         });
         child.on("error", (err) => {
             clearTimeout(timer);
@@ -237,6 +241,8 @@ async function runViaDocker(options, args) {
             input: options.prompt,
             timeoutMs: options.timeoutMs,
             onActivity: options.onActivity,
+            onStdout: (chunk) => options.onOutput?.("stdout", chunk),
+            onStderr: (chunk) => options.onOutput?.("stderr", chunk),
             signal: options.signal,
             env: { ...process.env, ...options.env },
         });

package/dist/adapters/gemini.cjs

@@ -217,11 +217,15 @@ async function runOnHost(options, args) {
             onAbort();
         child.stdout.on("data", (data) => {
             options.onActivity?.();
-            stdout += data.toString();
+            const text = data.toString();
+            stdout += text;
+            options.onOutput?.("stdout", text);
         });
         child.stderr.on("data", (data) => {
             options.onActivity?.();
-            stderr += data.toString();
+            const text = data.toString();
+            stderr += text;
+            options.onOutput?.("stderr", text);
         });
         child.on("error", (err) => {
             clearTimeout(timer);
@@ -255,9 +259,10 @@ async function runViaDocker(options, args) {
         const result = await runner.run("docker", ["exec", "-i", ...forwardedEnv, containerName, "sh", "-c", command], { input: options.prompt,
             timeoutMs: options.timeoutMs,
             onActivity: options.onActivity,
+            onStdout: (chunk) => options.onOutput?.("stdout", chunk),
+            onStderr: (chunk) => options.onOutput?.("stderr", chunk),
             signal: options.signal,
-            env: { ...process.env, ...options.env },
-        });
+            env: { ...process.env, ...options.env }, });
         return {
             exitCode: result.code,
             timedOut: false,

package/dist/adapters/opencode.cjs

@@ -356,12 +356,16 @@ async function runOnHost(options, args, input = "") {
             onAbort();
         child.stdout.on("data", (data) => {
             options.onActivity?.();
-            stdout += data.toString();
+            const text = data.toString();
+            stdout += text;
+            options.onOutput?.("stdout", text);
             monitor.push("stdout", data.toString());
         });
         child.stderr.on("data", (data) => {
             options.onActivity?.();
-            stderr += data.toString();
+            const text = data.toString();
+            stderr += text;
+            options.onOutput?.("stderr", text);
             monitor.push("stderr", data.toString());
         });
         child.on("error", (error) => {
@@ -408,8 +412,8 @@ async function runViaDocker(options, args, input) {
             timeoutMs: options.timeoutMs,
             onActivity: options.onActivity,
             signal: controller.signal,
-            onStdout: (chunk) => { streamed.stdout = true; monitor.push("stdout", chunk); },
-            onStderr: (chunk) => { streamed.stderr = true; monitor.push("stderr", chunk); },
+            onStdout: (chunk) => { streamed.stdout = true; monitor.push("stdout", chunk); options.onOutput?.("stdout", chunk); },
+            onStderr: (chunk) => { streamed.stderr = true; monitor.push("stderr", chunk); options.onOutput?.("stderr", chunk); },
             env: { ...process.env, ...options.env },
         });
         // Also inspect runners that only return buffered output.

package/dist/adapters/pi.cjs

@@ -344,11 +344,15 @@ async function runOnHost(options, args, local = false) {
                 onAbort();
             child.stdout.on("data", (data) => {
                 options.onActivity?.();
-                stdout += data.toString();
+                const text = data.toString();
+                stdout += text;
+                options.onOutput?.("stdout", text);
             });
             child.stderr.on("data", (data) => {
                 options.onActivity?.();
-                stderr += data.toString();
+                const text = data.toString();
+                stderr += text;
+                options.onOutput?.("stderr", text);
             });
             child.on("error", (err) => {
                 clearTimeout(timer);
@@ -408,6 +412,8 @@ async function runViaDocker(options, args) {
             input: options.prompt,
             timeoutMs: options.timeoutMs,
             onActivity: options.onActivity,
+            onStdout: (chunk) => options.onOutput?.("stdout", chunk),
+            onStderr: (chunk) => options.onOutput?.("stderr", chunk),
             signal: options.signal,
             env: { ...process.env, ...options.env },
         });

package/dist/adapters/qoder.cjs

@@ -102,11 +102,15 @@ async function runOnHost(options, args) {
             onAbort();
         child.stdout.on("data", (d) => {
             options.onActivity?.();
-            stdout += d.toString();
+            const text = d.toString();
+            stdout += text;
+            options.onOutput?.("stdout", text);
         });
         child.stderr.on("data", (d) => {
             options.onActivity?.();
-            stderr += d.toString();
+            const text = d.toString();
+            stderr += text;
+            options.onOutput?.("stderr", text);
         });
         child.on("error", (err) => {
             clearTimeout(timer);
@@ -139,6 +143,8 @@ async function runViaDocker(options, args) {
             input: options.prompt,
             timeoutMs: options.timeoutMs,
             onActivity: options.onActivity,
+            onStdout: (chunk) => options.onOutput?.("stdout", chunk),
+            onStderr: (chunk) => options.onOutput?.("stderr", chunk),
             signal: options.signal,
         });
         return {

package/dist/browser-probe.cjs

@@ -192,7 +192,17 @@ async function probeCodexSandbox(config, deps) {
             readRoots: [node_path_1.default.dirname(await node_fs_1.promises.realpath(process.execPath)), node_path_1.default.dirname(playwrightDir)],
         });
         const env = { NAVARCH_PROBE_PLAYWRIGHT: playwrightDir };
-        for (const key of ["HOME", "PATH", "TMPDIR", "CODEX_HOME", "PLAYWRIGHT_BROWSERS_PATH", "XDG_CACHE_HOME"]) {
+        for (const key of [
+            "HOME",
+            "PATH",
+            "TMPDIR",
+            "CODEX_HOME",
+            "PLAYWRIGHT_BROWSERS_PATH",
+            "XDG_CACHE_HOME",
+            // Agent sessions inherit it; without it Node falls back to the default
+            // config path, which can disagree with what sessions actually load.
+            "OPENSSL_CONF",
+        ]) {
             if (process.env[key])
                 env[key] = process.env[key];
         }
@@ -204,12 +214,16 @@ async function probeCodexSandbox(config, deps) {
             // bwrap could not find the program it was asked to start inside the
             // sandbox view: a path outside the granted read roots, not an old CLI.
             const hidden = /bwrap: execvp .*No such file or directory/.test(output);
+            const opensslConfig = /OpenSSL configuration error/.test(output);
             return ("Could not verify a browser inside the Codex sandbox: `codex sandbox` did not run the probe " +
                 `(${result.timedOut ? "timed out" : output.trim() ? summarizeLaunchFailure(output) : `exit ${result.code}`}). ` +
                 (hidden
                     ? "The sandbox cannot see that executable; add its install directory to NAVARCH_GUARD_EXTRA_ROOTS, " +
                         "or run browser tasks with another agent."
-                    : "Update the Codex CLI, or run browser tasks with another agent."));
+                    : opensslConfig
+                        ? "Node cannot read its OpenSSL config inside the sandbox, so Codex sessions cannot run node either; " +
+                            "update the Navarch runtime, or add that file's directory to NAVARCH_GUARD_EXTRA_ROOTS."
+                        : "Update the Codex CLI, or run browser tasks with another agent."));
         }
         const detail = result.timedOut ? "the launch timed out." : summarizeLaunchFailure(output);
         const machPort = /bootstrap_check_in|MachPortRendezvous|mach_port_rendezvous/i.test(output);
@@ -236,6 +250,15 @@ function summarizeLaunchFailure(output) {
         // "[pid=1][err] [1001/210406.593317:FATAL:base/apple/mach_port_rendezvous_mac.cc:159] Check failed: ..."
         return fatal.replace(/^.*FATAL:[^\]]*\]\s*/, "");
     }
+    const opensslIndex = lines.findIndex((line) => /OpenSSL configuration error/.test(line));
+    if (opensslIndex >= 0) {
+        // "<node>: OpenSSL configuration error:" with the reason on the next line:
+        // "...:error:80000001:system library:BIO_new_file:Operation not permitted:...:calling fopen(<path>, rb)"
+        const reason = lines[opensslIndex + 1] ?? "";
+        const cause = /:system library:[^:]*:([^:]+):/.exec(reason)?.[1];
+        const file = /fopen\(([^,]+),/.exec(reason)?.[1];
+        return `OpenSSL configuration error${cause ? `: ${cause}` : ""}${file ? ` reading ${node_path_1.default.normalize(file)}` : ""}`;
+    }
     const missing = lines.find((line) => /Executable doesn't exist/.test(line));
     if (missing)
         return "Chromium is not installed for the runtime's Playwright.";

package/dist/live-transcript.cjs

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveTranscriptPublisher = void 0;
+exports.renderSessionTranscript = renderSessionTranscript;
+exports.renderLiveTranscript = renderLiveTranscript;
+exports.liveUploadIntervalMs = liveUploadIntervalMs;
+/** The shape both the live snapshots and the completion upload use. */
+function renderSessionTranscript(attempts, redact) {
+    return attempts
+        .flatMap((attempt, index) => [
+        `# agent turn ${index + 1} stdout`,
+        redact(attempt.stdout),
+        "",
+        `# agent turn ${index + 1} stderr`,
+        redact(attempt.stderr),
+        "",
+    ])
+        .join("\n");
+}
+function renderLiveTranscript(attempts, currentStdout, redact, knownSecrets = []) {
+    const finished = attempts.length ? `${renderSessionTranscript(attempts, redact)}\n` : "";
+    const end = currentStdout.lastIndexOf("\n");
+    // A secret split across the cut would escape redaction, so redact whole lines only.
+    let complete = end >= 0 ? currentStdout.slice(0, end + 1) : "";
+    // Complete lines can still contain the beginning of a multiline secret.
+    // Hold that line and everything after it until redaction can see the value.
+    let safeEnd = complete.length;
+    for (const secret of knownSecrets) {
+        const newline = secret.indexOf("\n");
+        if (newline < 0)
+            continue;
+        const start = complete.lastIndexOf(secret.slice(0, newline + 1));
+        if (start >= 0 && complete.length - start < secret.length && secret.startsWith(complete.slice(start))) {
+            safeEnd = Math.min(safeEnd, complete.lastIndexOf("\n", start - 1) + 1);
+        }
+    }
+    const pem = /-----BEGIN ([A-Z0-9 ]*PRIVATE KEY)-----/g;
+    for (const match of complete.matchAll(pem)) {
+        if (!complete.includes(`-----END ${match[1]}-----`, match.index + match[0].length)) {
+            safeEnd = Math.min(safeEnd, complete.lastIndexOf("\n", match.index - 1) + 1);
+        }
+    }
+    complete = complete.slice(0, safeEnd);
+    return `${finished}# agent turn ${attempts.length + 1} stdout\n${redact(complete)}`;
+}
+/** Signed upload URLs last an hour; refresh well before that. */
+const UPLOAD_URL_TTL_MS = 45 * 60_000;
+const DEFAULT_INTERVAL_MS = 10_000;
+function liveUploadIntervalMs(bytes, baseMs = DEFAULT_INTERVAL_MS) {
+    if (bytes > 8 * 1024 * 1024)
+        return Math.max(baseMs, 60_000);
+    if (bytes > 1024 * 1024)
+        return Math.max(baseMs, 30_000);
+    return baseMs;
+}
+class LiveTranscriptPublisher {
+    options;
+    now;
+    intervalMs;
+    timer = null;
+    inFlight = null;
+    dirty = false;
+    stopped = false;
+    paused = false;
+    lastUploadedAt = 0;
+    lastUploaded = "";
+    uploadUrl = null;
+    published = null;
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? Date.now;
+        this.intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;
+    }
+    /** Call whenever output arrives or a turn ends. */
+    markDirty() {
+        if (this.stopped)
+            return;
+        this.paused = false;
+        this.dirty = true;
+        this.schedule();
+    }
+    /** Locator of the last live snapshot that reached storage, if any. */
+    get publishedUrl() {
+        return this.published;
+    }
+    /** Cancels a pending upload and waits for an in-flight one, so neither can
+     * overwrite the completion transcript. A later markDirty() re-arms it. */
+    async idle() {
+        this.paused = true;
+        this.dirty = false;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+        await this.inFlight;
+    }
+    async stop() {
+        this.stopped = true;
+        await this.idle();
+    }
+    schedule() {
+        if (this.timer || this.inFlight || this.stopped || this.paused)
+            return;
+        const gap = liveUploadIntervalMs(this.lastUploaded.length, this.intervalMs);
+        const wait = Math.max(0, this.lastUploadedAt + gap - this.now());
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            this.inFlight = this.flush().finally(() => {
+                this.inFlight = null;
+                if (this.dirty)
+                    this.schedule();
+            });
+        }, wait);
+        this.timer.unref?.();
+    }
+    async flush() {
+        if (this.stopped)
+            return;
+        this.dirty = false;
+        const content = this.options.render();
+        if (content === this.lastUploaded)
+            return;
+        try {
+            if (!this.uploadUrl || this.now() - this.uploadUrl.at > UPLOAD_URL_TTL_MS) {
+                const { uploadUrl, publicUrl } = await this.options.requestUploadUrl();
+                this.uploadUrl = { url: uploadUrl, publicUrl, at: this.now() };
+            }
+            if (this.stopped)
+                return;
+            await this.options.upload(this.uploadUrl.url, content);
+            this.lastUploaded = content;
+            this.published = this.uploadUrl.publicUrl;
+        }
+        catch (error) {
+            // A rejected signature is refreshed on the next attempt.
+            this.uploadUrl = null;
+            this.options.onError?.(error);
+        }
+        finally {
+            this.lastUploadedAt = this.now();
+        }
+    }
+}
+exports.LiveTranscriptPublisher = LiveTranscriptPublisher;

package/dist/session.cjs

@@ -15,6 +15,7 @@ const index_cjs_1 = require("./adapters/index.cjs");
 const exit_conditions_cjs_1 = require("./exit-conditions.cjs");
 const redact_cjs_1 = require("./redact.cjs");
 const upload_cjs_1 = require("./upload.cjs");
+const live_transcript_cjs_1 = require("./live-transcript.cjs");
 const prompt_cjs_1 = require("./prompt.cjs");
 const mcp_config_cjs_1 = require("./mcp-config.cjs");
 const logger_cjs_1 = require("./logger.cjs");
@@ -441,6 +442,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
         abortForRuntimeShutdown();
     lifecycle.enteredMainSessionTry = true;
     let browserEvidence;
+    let liveTranscript;
     try {
         reportActivity("preparing");
         await gitWorktree.prepare();
@@ -494,6 +496,18 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
         const adapter = (0, index_cjs_1.selectAdapter)(runtime);
         const { bin, extraArgs } = adapterCommand(config, runtime);
         const attempts = [];
+        // The task view follows the run through periodic redacted snapshots of
+        // the same object the completion upload below finally overwrites.
+        let liveStdout = "";
+        liveTranscript = new live_transcript_cjs_1.LiveTranscriptPublisher({
+            requestUploadUrl: async () => {
+                const { upload_url, public_url } = await api.getTranscriptUploadUrl(leaseId);
+                return { uploadUrl: upload_url, publicUrl: public_url };
+            },
+            upload: upload_cjs_1.uploadTranscript,
+            render: () => (0, live_transcript_cjs_1.renderLiveTranscript)(attempts, liveStdout, (text) => (0, redact_cjs_1.redactText)(text, registry.list()), registry.list()),
+            onError: (error) => log.warn(`live transcript upload failed for ${leaseId}: ${(0, redact_cjs_1.redactText)(String(error), registry.list())}`),
+        });
         const agentBudgetStartedAt = node_perf_hooks_1.performance.now();
         const maxRuntimeMs = task.max_runtime_ms ?? config.sessionTimeoutMs;
         let nextPrompt = null;
@@ -544,6 +558,12 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                     dockerExec: sandbox ? { containerName: sandbox.name, runner: sandbox_cjs_1.nodeCommandRunner } : undefined,
                     signal: activeAbortController.signal,
                     onActivity: () => { outputObservedAt = Date.now(); outputUpdates += 1; },
+                    onOutput: (stream, chunk) => {
+                        if (stream !== "stdout")
+                            return;
+                        liveStdout += chunk;
+                        liveTranscript?.markDirty();
+                    },
                 }, task.idle_timeout_ms ?? config.sessionIdleTimeoutMs ?? 45 * 60_000, runtime === "opencode" ? config.opencodeStartupTimeoutMs : 0);
             activeAbortController = null;
             adapterRunning = false;
@@ -554,6 +574,8 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                 executionReport = { ...executionReport, model: turnResult.model };
             }
             attempts.push(turnResult);
+            liveStdout = "";
+            liveTranscript.markDirty();
             reportActivity("finishing");
             const capacityLimit = (0, adapter_capacity_cjs_1.detectAdapterCapacityLimit)(turnResult);
             if (capacityLimit) {
@@ -691,16 +713,8 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
             if (mapping.leaseOutcome === "failed") {
                 log.warn(`adapter failed for ${leaseId}: ${(0, redact_cjs_1.redactText)(mapping.reportSummary, knownSecrets)}`);
             }
-            const transcript = attempts
-                .flatMap((attempt, index) => [
-                `# agent turn ${index + 1} stdout`,
-                (0, redact_cjs_1.redactText)(attempt.stdout, knownSecrets),
-                "",
-                `# agent turn ${index + 1} stderr`,
-                (0, redact_cjs_1.redactText)(attempt.stderr, knownSecrets),
-                "",
-            ])
-                .join("\n");
+            const transcript = (0, live_transcript_cjs_1.renderSessionTranscript)(attempts, (text) => (0, redact_cjs_1.redactText)(text, knownSecrets));
+            await liveTranscript.idle();
             let transcriptUrl;
             try {
                 const { upload_url, public_url } = await api.getTranscriptUploadUrl(leaseId);
@@ -711,6 +725,8 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                 // The message carries up to 500 chars of the storage response body, so
                 // redact it like every other warn in this block.
                 log.warn(`transcript upload failed for ${leaseId}: ${(0, redact_cjs_1.redactText)(String(err), knownSecrets)}`);
+                // The last live snapshot is still in storage; keep it reviewable.
+                transcriptUrl = liveTranscript.publishedUrl ?? undefined;
             }
             const redactedReport = (0, redact_cjs_1.redactText)(mapping.reportSummary, knownSecrets);
             const completion = {
@@ -800,6 +816,9 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
         }
     }
     catch (err) {
+        await liveTranscript?.stop();
+        // A live snapshot already in storage is the best transcript a crash has.
+        const crashTranscriptUrl = lastCompletion?.transcript_url ?? liveTranscript?.publishedUrl;
         const knownSecrets = registry.list();
         // NavarchApiError's message is only the status line; the control plane's
         // explanation rides in `err.body`. Keep it in the agent log (redacted like
@@ -820,9 +839,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
             failed_before_start: !adapterStarted,
             evidence_urls: lastCompletion?.evidence_urls ?? [],
             cost: lastCompletion?.cost ?? { tokens_in: 0, tokens_out: 0, cost_usd: 0 },
-            ...(lastCompletion?.transcript_url
-                ? { transcript_url: lastCompletion.transcript_url }
-                : {}),
+            ...(crashTranscriptUrl ? { transcript_url: crashTranscriptUrl } : {}),
             exit_status: "crashed",
             agent_type: runtime,
             ...executionReport,
@@ -830,6 +847,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
             .catch((completeErr) => log.warn(`complete() after crash also failed: ${String(completeErr)}`));
     }
     finally {
+        await liveTranscript?.stop();
         deps.shutdownSignal?.removeEventListener("abort", abortForRuntimeShutdown);
         sessionClosing = true;
         clearInterval(heartbeatTimer);

package/dist/worktree-guard.cjs

@@ -138,6 +138,9 @@ function codexToolReadRoots(env = process.env, platform = process.platform) {
         node_path_1.default.join(miseDataDir(env, homeDir), "installs"),
         node_path_1.default.join(env.NVM_DIR?.trim() || node_path_1.default.join(homeDir, ".nvm"), "versions"),
         ...(platform === "darwin" ? MACOS_TOOLCHAIN_READ_ROOTS : []),
+        // An operator-chosen OpenSSL config is read by every Node (and OpenSSL
+        // CLI) start; the agent inherits OPENSSL_CONF, so the file must be too.
+        ...(env.OPENSSL_CONF?.trim() ? [env.OPENSSL_CONF.trim()] : []),
     ];
 }
 function miseDataDir(env, homeDir) {
@@ -209,7 +212,16 @@ function resolveExecutable(bin, env) {
  * system prefixes for the Claude hook (bin/worktree-guard-hook.cjs), so this
  * only brings the Codex profile level with it.
  */
-const MACOS_TOOLCHAIN_READ_ROOTS = ["/Library/Developer", "/Applications"];
+const MACOS_TOOLCHAIN_READ_ROOTS = [
+    "/Library/Developer",
+    "/Applications",
+    // Official nodejs.org macOS builds (nvm, fnm, volta, the .pkg installer)
+    // load OPENSSLDIR/openssl.cnf on every start and exit with "OpenSSL
+    // configuration error: ... Operation not permitted" when seatbelt denies
+    // the read, so no `node` or `npm` runs. Grant only the file: the directory
+    // also holds private/.
+    "/System/Library/OpenSSL/openssl.cnf",
+];
 /**
  * Per-user macOS build state that Xcode and SwiftPM write during a build or
  * test run: simulator devices and DerivedData under `~/Library/Developer`,

package/package.json

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