@sagentlab/navarch-runtime 0.1.87 → 0.1.89

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
@@ -751,7 +755,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`
@@ -871,16 +875,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/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

@@ -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)
@@ -201,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);
@@ -241,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/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/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/package.json

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