@turns/dev 0.0.28 → 0.0.30

package/dist/agent-anchor.js

@@ -13,7 +13,9 @@ import { ACP_PROFILES, lettaHeadlessEnvironment, lettaSessionIdentity, PROCESS_H
 import { asyncQuestionInteractions, asyncQuestionReplyText, isAsyncQuestionInteraction, parseAsyncQuestionReplies, } from "./codex-async-questions.js";
 import { recordLettaSessionContext } from "./letta-session-context.js";
 import { recoverAsyncQuestion } from "./codex-async-question-recovery.js";
+import { existingTranscriptPath } from "./compressed-transcripts.js";
 import { BackgroundTaskState } from "./background-task-state.js";
+import { harnessExitError, StderrTail } from "./harness-exit.js";
 const socketIndex = process.argv.indexOf('--socket');
 const socketPath = socketIndex >= 0 ? path.resolve(process.argv[socketIndex + 1] || '') : '';
 if (!socketPath)
@@ -72,7 +74,7 @@ function writeLine(socket, value) {
     if (!socket.destroyed && socket.writable)
         socket.write(`${JSON.stringify(value)}\n`);
 }
-function childResult(child, timeoutMs) {
+function childResult(child, timeoutMs, harness, stderrTail) {
     const result = deferred();
     let settled = false;
     const finish = (value) => {
@@ -83,7 +85,17 @@ function childResult(child, timeoutMs) {
         }
     };
     child.once('error', (error) => finish({ exitCode: null, signal: null, timedOut: false, error: { message: errorText(error) } }));
-    child.once('close', (code, signal) => finish({ exitCode: code, signal, timedOut: false, error: null }));
+    child.once('close', (code, signal) => {
+        if (!code)
+            return finish({ exitCode: code, signal, timedOut: false, error: null });
+        const error = harnessExitError(harness, code, signal, stderrTail.lines());
+        finish({
+            exitCode: code,
+            signal,
+            timedOut: false,
+            error: { message: error.message, harnessExit: error.harnessExit },
+        });
+    });
     const timer = setTimeout(() => {
         try {
             process.kill(-child.pid, 'SIGTERM');
@@ -107,6 +119,7 @@ class LineTransport {
     pending;
     lastEventAt;
     child;
+    stderrTail = new StderrTail();
     constructor(anchor, harness, command, args, cwd, env = {}) {
         this.anchor = anchor;
         this.harness = harness;
@@ -128,14 +141,17 @@ class LineTransport {
         });
         anchor.child = this.child;
         readline.createInterface({ input: this.child.stdout }).on('line', (line) => this.receive(line));
-        readline.createInterface({ input: this.child.stderr }).on('line', (line) => anchor.emitLive({
-            event: 'process.line',
-            source: `${harness}.stderr`,
-            raw: line,
-            phase: 'queued',
-        }));
+        readline.createInterface({ input: this.child.stderr }).on('line', (line) => {
+            this.stderrTail.observe(line);
+            anchor.emitLive({
+                event: 'process.line',
+                source: `${harness}.stderr`,
+                raw: line,
+                phase: 'queued',
+            });
+        });
         this.child.once('close', (code, signal) => {
-            const error = new Error(`${harness} transport exited with ${signal || code}`);
+            const error = harnessExitError(anchor.source, code, signal, this.stderrTail.lines());
             for (const waiter of this.pending.values())
                 waiter.reject(error);
             this.pending.clear();
@@ -747,7 +763,9 @@ class CodexAppServerTransport extends LineTransport {
                     : 'workspace-write',
             approvalPolicy: this.anchor.permissionMode === 'bypassPermissions' ? 'never' : 'on-request',
         };
-        const resumePath = !createSession && fs.existsSync(this.anchor.transcriptPath) ? this.anchor.transcriptPath : '';
+        // Codex may have compressed or restored the rollout since discovery; it
+        // resumes either spelling and writes the plain `.jsonl` back.
+        const resumePath = createSession ? '' : existingTranscriptPath(this.anchor.transcriptPath);
         const opened = createSession
             ? await this.request('thread/start', {
                 ...configuration,
@@ -1769,7 +1787,12 @@ class Anchor {
             result: null,
         };
         this.setStatus('running');
-        void this.run(Boolean(request.createSession), this.turnTimeoutMs).then((result) => this.finish(result), (error) => this.finish({ exitCode: 1, signal: null, timedOut: false, error: { message: errorText(error) } }));
+        void this.run(Boolean(request.createSession), this.turnTimeoutMs).then((result) => this.finish(result), (error) => this.finish({
+            exitCode: 1,
+            signal: null,
+            timedOut: false,
+            error: { message: errorText(error), ...(error?.harnessExit ? { harnessExit: error.harnessExit } : {}) },
+        }));
         return { accepted: true, messageId: this.currentTurn.messageId, pid: process.pid };
     }
     async run(createSession, timeoutMs) {
@@ -1868,6 +1891,7 @@ class Anchor {
             this.child = child;
             if (invocation.stdin)
                 child.stdin.end(`${invocation.stdin}\n`);
+            const stderrTail = new StderrTail();
             for (const [stream, source] of [
                 [child.stdout, `${this.source}.stdout`],
                 [child.stderr, `${this.source}.stderr`],
@@ -1881,9 +1905,11 @@ class Anchor {
                     const processSessionId = processEventSessionId(this.source, json);
                     if (processSessionId && processSessionId !== this.agentSessionId)
                         this.updateIdentity(processSessionId);
+                    if (stream === child.stderr)
+                        stderrTail.observe(line);
                     this.emitLive({ event: 'process.line', source, raw: line, json, phase: 'queued' });
                 });
-            return childResult(child, timeoutMs);
+            return childResult(child, timeoutMs, this.source, stderrTail);
         }
         if (ACP_PROFILES[this.source]) {
             if (!(this.transport instanceof AcpTransport) ||

package/dist/codex-async-question-recovery.js

@@ -1,6 +1,8 @@
 import fs from 'node:fs';
 import readline from 'node:readline';
+import { Readable } from 'node:stream';
 import { ASYNC_QUESTION_TOOL, asyncQuestionInteractions, parseAsyncQuestionReplies } from "./codex-async-questions.js";
+import { existingTranscriptPath, isCompressedTranscript, readTranscriptSync } from "./compressed-transcripts.js";
 export function isAsyncQuestionId(value) {
     if (typeof value !== 'string')
         return false;
@@ -30,7 +32,22 @@ export async function recoverAsyncQuestion(transcriptPath, interactionId) {
     const [, callId] = JSON.parse(interactionId);
     let candidate = null;
     let delivered = false;
-    const stream = fs.createReadStream(transcriptPath, { encoding: 'utf8' });
+    // Codex compresses idle rollouts and restores them on resume, so read
+    // whichever spelling of this anchor's rollout exists now.
+    const file = existingTranscriptPath(transcriptPath);
+    if (!file)
+        return null;
+    let stream;
+    try {
+        stream = isCompressedTranscript(file)
+            ? Readable.from([readTranscriptSync(file).toString('utf8')])
+            : fs.createReadStream(file, { encoding: 'utf8' });
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return null;
+        throw error;
+    }
     const lines = readline.createInterface({ input: stream, crlfDelay: Infinity });
     try {
         for await (const line of lines) {

package/dist/codex-update.js

@@ -1,6 +1,9 @@
 /** Machine-local Codex CLI self-update, callable by the Turns daemon. */
 import { spawn } from 'node:child_process';
+import fs from 'node:fs';
 import os from 'node:os';
+import path from 'node:path';
+import { executablePath } from "./executable-path.js";
 import { codexCommandIsAppManaged, resolveHarnessCommand } from "./harness-registry.js";
 const VERSION_TIMEOUT_MS = 15_000;
 const UPDATE_TIMEOUT_MS = 5 * 60_000;
@@ -11,7 +14,9 @@ function runCommand(command, args, timeoutMs) {
     return new Promise((resolve) => {
         const child = spawn(command, args, {
             cwd: os.homedir(),
-            env: process.env,
+            // npm and Codex's npm launcher are `#!/usr/bin/env node` scripts; a
+            // service manager's PATH may not include the daemon's own Node.
+            env: { ...process.env, PATH: executablePath() },
             stdio: ['ignore', 'pipe', 'pipe'],
         });
         let output = '';
@@ -56,10 +61,54 @@ function commandFailure(result, fallback) {
         .filter(Boolean);
     return new Error(lines.at(-1) || fallback);
 }
+function realpathOrSelf(file) {
+    try {
+        return fs.realpathSync(file);
+    }
+    catch {
+        return file;
+    }
+}
+function findExecutable(name, preferred) {
+    for (const directory of [...preferred, ...executablePath().split(path.delimiter)]) {
+        const candidate = path.join(directory, name);
+        try {
+            fs.accessSync(candidate, fs.constants.X_OK);
+            return candidate;
+        }
+        catch { }
+    }
+    return '';
+}
+export function codexUpgradeCommand(command, lookup = {}) {
+    const resolved = (lookup.realpath || realpathOrSelf)(command).replaceAll('\\', '/');
+    const find = lookup.findExecutable || findExecutable;
+    // `npm i -g @openai/codex` links <prefix>/bin/codex to the package's launcher.
+    const npm = resolved.match(/^(.*?)\/(?:lib\/)?node_modules\/@openai\/codex\//u);
+    // Windows npm is a .cmd shim, which cannot be spawned without a shell.
+    if (npm && process.platform !== 'win32') {
+        const prefix = npm[1];
+        const binary = find('npm', [path.join(prefix, 'bin')]);
+        if (binary)
+            return { manager: 'npm', command: binary, args: ['install', '-g', '--prefix', prefix, '@openai/codex@latest'] };
+    }
+    const brew = resolved.match(/^(.*?)\/(Cellar|Caskroom)\/codex\//u);
+    if (brew) {
+        const binary = find('brew', [path.join(brew[1], 'bin')]);
+        if (binary)
+            return {
+                manager: 'brew',
+                command: binary,
+                args: ['upgrade', ...(brew[2] === 'Caskroom' ? ['--cask'] : []), 'codex'],
+            };
+    }
+    return { manager: 'codex', command, args: ['update'] };
+}
 export function createCodexUpdateManager(dependencies = {}) {
     const resolveCommand = dependencies.resolveCommand || (() => resolveHarnessCommand('codex'));
     const isAppManaged = dependencies.isAppManaged || codexCommandIsAppManaged;
     const run = dependencies.run || runCommand;
+    const upgradeCommand = dependencies.upgradeCommand || ((command) => codexUpgradeCommand(command));
     let active = null;
     const updateCommand = () => {
         const command = resolveCommand();
@@ -74,9 +123,12 @@ export function createCodexUpdateManager(dependencies = {}) {
             throw commandFailure(beforeRun, 'Codex is not installed or its version could not be read.');
         }
         const previousVersion = parseCodexVersion(beforeRun.output);
-        const updateRun = await run(updateCommand(), ['update'], UPDATE_TIMEOUT_MS);
+        const upgrade = upgradeCommand(updateCommand());
+        const updateRun = await run(upgrade.command, upgrade.args, UPDATE_TIMEOUT_MS);
         if (updateRun.failed || updateRun.timedOut || updateRun.exitCode !== 0) {
-            throw commandFailure(updateRun, 'Codex could not update itself. Run `codex update` in a terminal on the machine.');
+            throw commandFailure(updateRun, upgrade.manager === 'codex'
+                ? 'Codex could not update itself. Run `codex update` in a terminal on the machine.'
+                : `${upgrade.manager} could not upgrade Codex. Run \`${[path.basename(upgrade.command), ...upgrade.args].join(' ')}\` in a terminal on the machine.`);
         }
         // Resolve again because the updater may replace a shim or install path.
         const afterRun = await run(updateCommand(), ['--version'], VERSION_TIMEOUT_MS);

package/dist/compressed-transcripts.js

@@ -0,0 +1,99 @@
+import fs from 'node:fs';
+import { zstdDecompressSync } from 'node:zlib';
+/**
+ * Codex compresses idle rollouts in place (`rollout-*.jsonl` becomes
+ * `rollout-*.jsonl.zst`) and restores the plain file when the thread resumes.
+ * Both spellings are one logical transcript: descriptors keep the `.jsonl`
+ * source path so the turns.dev session ID is unchanged across that rename, and
+ * only the physical `file` names the compressed copy.
+ */
+const COMPRESSED_SUFFIX = '.zst';
+const PREFIX_CACHE_BYTES = 32 * 1024 * 1024;
+const MAX_PREFIX_BYTES = 1024 * 1024;
+export function isCompressedTranscript(file) {
+    return /\.jsonl\.zst$/iu.test(String(file || ''));
+}
+/** The plain `.jsonl` path a compressed rollout was made from. */
+export function logicalTranscriptPath(file) {
+    return isCompressedTranscript(file) ? file.slice(0, -COMPRESSED_SUFFIX.length) : file;
+}
+function isFile(file) {
+    try {
+        return fs.statSync(file).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/** True when a compressed rollout should yield to its live plain sibling. */
+export function compressedTranscriptIsShadowed(file) {
+    return isCompressedTranscript(file) && isFile(logicalTranscriptPath(file));
+}
+/**
+ * The on-disk spelling of a logical transcript right now. Codex may compress
+ * or restore the file between discovery and use, so callers holding either
+ * path get whichever one exists, preferring the plain file.
+ */
+export function existingTranscriptPath(file) {
+    const plain = logicalTranscriptPath(file);
+    if (isFile(plain))
+        return plain;
+    if (/\.jsonl$/iu.test(plain) && isFile(`${plain}${COMPRESSED_SUFFIX}`))
+        return `${plain}${COMPRESSED_SUFFIX}`;
+    return isFile(file) ? file : '';
+}
+function statFingerprint(file) {
+    const stat = fs.statSync(file);
+    return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}`;
+}
+// Sync zstd decoding cannot stop early, so every read decompresses the whole
+// frame. A compressed rollout is idle by construction, so metadata probes
+// (working directory, subagent markers, lineage) share a fingerprinted cache
+// of bounded prefixes instead of re-decoding on every inventory pass. Whole
+// bodies are never cached: a long rollout can decode to hundreds of MB.
+const prefixes = new Map();
+let prefixBytes = 0;
+/** Whole decoded contents of a transcript file, compressed or not. */
+export function readTranscriptSync(file) {
+    const contents = fs.readFileSync(file);
+    return isCompressedTranscript(file) ? zstdDecompressSync(contents) : contents;
+}
+function plainPrefix(file, maxBytes) {
+    const handle = fs.openSync(file, 'r');
+    try {
+        const buffer = Buffer.alloc(Math.max(0, Math.min(fs.fstatSync(handle).size, maxBytes)));
+        const bytesRead = fs.readSync(handle, buffer, 0, buffer.length, 0);
+        return buffer.subarray(0, bytesRead);
+    }
+    finally {
+        fs.closeSync(handle);
+    }
+}
+/** At most `maxBytes` decoded bytes from the start of a transcript file. */
+export function readTranscriptPrefixSync(file, maxBytes) {
+    if (!isCompressedTranscript(file))
+        return plainPrefix(file, maxBytes);
+    const fingerprint = statFingerprint(file);
+    const cached = prefixes.get(file);
+    if (cached?.fingerprint === fingerprint &&
+        (cached.prefix.length >= maxBytes || cached.prefix.length < MAX_PREFIX_BYTES)) {
+        prefixes.delete(file);
+        prefixes.set(file, cached);
+        return cached.prefix.subarray(0, maxBytes);
+    }
+    const contents = readTranscriptSync(file);
+    if (cached) {
+        prefixes.delete(file);
+        prefixBytes -= cached.prefix.length;
+    }
+    // Copy so the cache never pins a whole decoded rollout.
+    const prefix = Buffer.from(contents.subarray(0, MAX_PREFIX_BYTES));
+    prefixes.set(file, { fingerprint, prefix });
+    prefixBytes += prefix.length;
+    while (prefixBytes > PREFIX_CACHE_BYTES && prefixes.size > 1) {
+        const [oldest, entry] = prefixes.entries().next().value;
+        prefixes.delete(oldest);
+        prefixBytes -= entry.prefix.length;
+    }
+    return contents.subarray(0, maxBytes);
+}

package/dist/harness-exit.js

@@ -0,0 +1,44 @@
+/** Failure details for a harness process that exits underneath Turns. */
+const STDERR_TAIL_LINES = 12;
+const STDERR_TAIL_CHARS = 4_000;
+/** The last few stderr lines of a harness process. When the process exits on
+ * its own, they are usually the only explanation (for example, an outdated CLI
+ * rejecting an argument), and the turn's failure must carry them. */
+export class StderrTail {
+    recent = [];
+    observe(line) {
+        const text = String(line)
+            .replace(/\u001b\[[0-9;?]*[A-Za-z]/gu, '')
+            .trimEnd();
+        if (!text.trim())
+            return;
+        this.recent.push(text.slice(0, STDERR_TAIL_CHARS));
+        if (this.recent.length > STDERR_TAIL_LINES)
+            this.recent.shift();
+    }
+    lines() {
+        const kept = [];
+        let size = 0;
+        for (const line of [...this.recent].reverse()) {
+            size += line.length + 1;
+            if (size > STDERR_TAIL_CHARS)
+                break;
+            kept.unshift(line);
+        }
+        return kept;
+    }
+}
+/** A harness process that ended underneath Turns rather than reporting a
+ * failure through its own protocol. */
+export function harnessExitError(harness, code, signal, stderr) {
+    const label = harnessLabel(harness);
+    const how = signal ? `was stopped by ${signal}` : `exited with code ${code}`;
+    const message = [`${label} ${how} before the turn finished.`, ...(stderr.length ? ['', ...stderr] : [])].join('\n');
+    return Object.assign(new Error(message), {
+        harnessExit: { harness: String(harness), code: code ?? null, signal: signal ?? null, stderr },
+    });
+}
+function harnessLabel(harness) {
+    const name = String(harness || 'agent');
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}

package/dist/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
@@ -225,6 +226,22 @@ async function runUpload(credentials, { paths, watch = false, all = false, inter
         provider?.close();
     }
 }
+/** First lines of `turns daemon run`, printed before authentication so a
+ * report pasted from a terminal or log always says which build and runtime
+ * produced it (`npx` can silently run an older cached release). */
+export function daemonStartupBanner({ version, nodeVersion = process.version, platform = process.platform, arch = process.arch, osName = `${os.type()} ${os.release()}`, hostname = os.hostname(), pid = process.pid, packageDirectory = CLI_DIRECTORY, paths, allowedDirectories = [], }) {
+    return [
+        `Turns daemon ${version}`,
+        `  Node ${nodeVersion} on ${platform}-${arch} (${osName}), host ${hostname}, pid ${pid}`,
+        `  Package ${packageDirectory}`,
+        `  Config ${paths.configDirectory}`,
+        `  State ${paths.stateDirectory}`,
+        allowedDirectories.length
+            ? `  Directories:\n${allowedDirectories.map((value) => `    ${value}`).join('\n')}`
+            : '  Directories: all',
+        '',
+    ].join('\n');
+}
 async function main(rawArguments = process.argv.slice(2)) {
     const parsed = parseGlobalArguments(rawArguments);
     const argv = parsed.argv;
@@ -274,6 +291,7 @@ async function main(rawArguments = process.argv.slice(2)) {
             throw new Error('--once cannot be combined with `turns daemon run`.');
         if (parsed.devUser && !parsed.origin)
             throw new Error('--dev-user requires an explicit --server URL.');
+        logInfo(daemonStartupBanner({ version: pkg.version, paths, allowedDirectories }));
         let credentials;
         if (parsed.devUser) {
             credentials = { origin: normalizeOrigin(parsed.origin) };
@@ -282,9 +300,6 @@ async function main(rawArguments = process.argv.slice(2)) {
             await migrateLegacyCredentials(paths, parsed.origin);
             credentials = await authenticate({ origin: parsed.origin, paths, interactive: false });
         }
-        if (allowedDirectories.length) {
-            logInfo(`Daemon directory allowlist:\n${allowedDirectories.map((value) => `  ${value}`).join('\n')}\n`);
-        }
         await runUpload(credentials, {
             paths,
             watch: true,

package/dist/local-session-sources.js

@@ -4,6 +4,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { StringDecoder } from 'node:string_decoder';
+import { compressedTranscriptIsShadowed, existingTranscriptPath, isCompressedTranscript, logicalTranscriptPath, readTranscriptPrefixSync, } from "./compressed-transcripts.js";
 import { readDeepseekTrajectoryHeader } from "./deepseek-trajectories.js";
 import { lettaSessionIdentity } from "./harness-registry.js";
 import { readLettaSessionContext } from "./letta-session-context.js";
@@ -38,7 +39,8 @@ const EXTRA_FILE_STORES = {
     },
     codex: {
         root: path.join(process.env.CODEX_HOME || path.join(HOME, '.codex'), 'sessions'),
-        include: (file) => /[\\/]rollout-[^\\/]+\.jsonl$/i.test(file),
+        // Codex zstd-compresses idle rollouts in place; see compressed-transcripts.ts.
+        include: (file) => /[\\/]rollout-[^\\/]+\.jsonl(?:\.zst)?$/i.test(file),
     },
     grok: { root: path.join(HOME, '.grok', 'sessions'), include: (file) => path.basename(file) === 'chat_history.jsonl' },
     kimi: {
@@ -281,6 +283,10 @@ function descriptorNativeSessionId(descriptor) {
         nativeSessionIdFromPath(String(descriptor?.harness || ''), descriptor?.sourcePath || descriptor?.file));
 }
 function fileDescriptor(harness, file) {
+    // While Codex restores or recompresses a rollout both spellings can exist
+    // briefly; the plain file is the one a live writer appends to.
+    if (compressedTranscriptIsShadowed(file))
+        return null;
     const stat = safeStat(file);
     if (!stat?.isFile() || stat.size === 0)
         return null;
@@ -288,7 +294,7 @@ function fileDescriptor(harness, file) {
         harness,
         agent: harness,
         file,
-        sourcePath: displayPath(file),
+        sourcePath: displayPath(logicalTranscriptPath(file)),
         size: stat.size,
         mtimeMs: stat.mtimeMs,
         createdAt: (stat.birthtimeMs > 0 ? stat.birthtime : stat.mtime).toISOString(),
@@ -301,14 +307,16 @@ export function nativeDescriptorForSource(harness, sourcePath) {
     const store = Object.hasOwn(EXTRA_FILE_STORES, harness) ? EXTRA_FILE_STORES[harness] : null;
     if (!store || !sourcePath || sourcePath.includes('\0'))
         return null;
-    const file = sourcePath.startsWith('~/') ? path.join(HOME, sourcePath.slice(2)) : sourcePath;
-    if (!path.isAbsolute(file))
+    const logical = sourcePath.startsWith('~/') ? path.join(HOME, sourcePath.slice(2)) : sourcePath;
+    if (!path.isAbsolute(logical) || !store.include(logical))
         return null;
+    // A source path always names the plain transcript; follow it to the
+    // compressed copy when that is what exists on disk now.
+    const physical = existingTranscriptPath(logical);
+    const file = physical && store.include(physical) ? physical : logical;
     const relative = path.relative(store.root, file);
     if (!relative || relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
         return null;
-    if (!store.include(file))
-        return null;
     // Discovery does not traverse symlinked entries. Keep this direct lookup
     // from admitting a transcript that an inventory walk would never discover.
     try {
@@ -383,6 +391,17 @@ function firstJsonDocument(file) {
     const stat = safeStat(file);
     if (!stat?.isFile())
         return null;
+    if (isCompressedTranscript(file)) {
+        try {
+            const source = readTranscriptPrefixSync(file, 1024 * 1024)
+                .toString('utf8')
+                .replace(/^\uFEFF/u, '');
+            return JSON.parse(source.split(/\r?\n/u, 1)[0]);
+        }
+        catch {
+            return null;
+        }
+    }
     let descriptor;
     try {
         descriptor = fs.openSync(file, 'r');
@@ -896,6 +915,17 @@ function filePrefix(file, maxBytes) {
     }
 }
 function recordPrefix(file, limit, maxBytes) {
+    if (isCompressedTranscript(file)) {
+        try {
+            // Callers split and cap the record count themselves.
+            return readTranscriptPrefixSync(file, maxBytes)
+                .toString('utf8')
+                .replace(/^\uFEFF/u, '');
+        }
+        catch {
+            return '';
+        }
+    }
     let handle;
     try {
         const stat = fs.statSync(file);

package/dist/queue-worker.js

@@ -301,6 +301,28 @@ export function runtimeEvent(anchorName, messageId, event, redactor = DEFAULT_RE
             value: redactor.redactJsonLine(JSON.stringify(event)),
         };
     }
+    // A harness that exits underneath its turn often reports the reason only on
+    // stderr, before any protocol frame the reducer could show. Record that
+    // ending explicitly so the transcript can explain the failed turn.
+    if (event?.event === 'turn.complete' && event.result?.error?.harnessExit && !event.result.interrupted) {
+        const exit = event.result.error.harnessExit;
+        return {
+            eventKey: key,
+            kind: 'session.harness_exit',
+            phase: 'queued',
+            ts,
+            source: 'agent-anchor',
+            value: redactor.redactJsonLine(JSON.stringify({
+                type: 'turns.session.harness_exit',
+                messageId: String(event.messageId || messageId || ''),
+                harness: String(exit.harness || event.agent || ''),
+                code: typeof exit.code === 'number' ? exit.code : null,
+                signal: exit.signal ? String(exit.signal) : null,
+                message: String(event.result.error.message || ''),
+                stderr: Array.isArray(exit.stderr) ? exit.stderr.map(String) : [],
+            })),
+        };
+    }
     if (event?.event === 'turn.steer') {
         return {
             eventKey: key,

package/dist/upload-sessions.js

@@ -9,6 +9,7 @@ import WebSocket from 'ws';
 import { logError, logInfo } from "./logging.js";
 import { NativeInventoryWorker } from "./native-inventory-worker.js";
 import { QueueDispatchLifecycle } from "./queue-lifecycle.js";
+import { isCompressedTranscript, readTranscriptSync } from "./compressed-transcripts.js";
 import { streamDeepseekTrajectoryLines } from "./deepseek-trajectories.js";
 import { normalizeAllowedDirectories, workingDirectoryIsAllowed } from "./directory-policy.js";
 import { discoverGitAssociation } from "./git-association.js";
@@ -481,6 +482,22 @@ async function* completeNativeFileLines(file, startOffset, endOffset) {
         input.destroy();
     }
 }
+/** Complete lines of a compressed rollout. Offsets are decoded-byte offsets,
+ * which never compare with the compressed file size, so these files always
+ * rescan from the start (see canResumeNativeCursor). */
+function* completeDecodedLines(contents) {
+    let lineStart = 0;
+    for (;;) {
+        const newline = contents.indexOf(0x0a, lineStart);
+        if (newline < 0)
+            return;
+        let line = contents.subarray(lineStart, newline);
+        if (line.at(-1) === 0x0d)
+            line = line.subarray(0, -1);
+        yield { raw: line.toString('utf8'), endOffset: newline + 1 };
+        lineStart = newline + 1;
+    }
+}
 async function* nativeSourceRecords(descriptor, cursor) {
     if (descriptor.harness === 'deepseek') {
         for await (const raw of streamDeepseekTrajectoryLines(descriptor.file)) {
@@ -502,6 +519,10 @@ async function* nativeSourceRecords(descriptor, cursor) {
         }
         return;
     }
+    if (isCompressedTranscript(descriptor.file)) {
+        yield* completeDecodedLines(readTranscriptSync(descriptor.file));
+        return;
+    }
     yield* completeNativeFileLines(descriptor.file, Number(cursor.offset) || 0, Math.max(-1, (Number(descriptor.size) || 0) - 1));
 }
 /** Stream canonical raw events while retaining only one WebSocket batch. The
@@ -962,6 +983,7 @@ function nativeSourceIdentity(file) {
 function canResumeNativeCursor(descriptor, cursor, nextRow) {
     return Boolean(cursor &&
         !descriptor.file.endsWith('.json') &&
+        !isCompressedTranscript(descriptor.file) &&
         descriptor.harness !== 'deepseek' &&
         !descriptor.sourcePath.includes('.db#') &&
         cursor.file === descriptor.file &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turns/dev",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "description": "Upload local AI agent sessions to turns.dev",
   "license": "MIT",
   "type": "module",