@turns/dev 0.0.31 → 0.0.33

package/dist/agent-anchor-client.js

@@ -58,7 +58,7 @@ export class AgentAnchorConnection {
             socket.once('connect', resolve);
             socket.once('error', reject);
         }), timeoutMs, `Agent anchor connection ${this.socketPath}`);
-        this.snapshot = await this.request('snapshot', {}, timeoutMs);
+        this.snapshot = await this.request('snapshot', STATUS_SNAPSHOT, timeoutMs);
         return this;
     }
     handleLine(line) {
@@ -228,6 +228,21 @@ export async function launchAgentAnchor(sessionId, timeoutMs = 15_000) {
     catch { }
     throw lastError || new Error(`Timed out starting agent anchor. See ${logPath}`);
 }
+/** Ask an anchor for its state without its buffered live events. Anchors
+ * older than this option ignore it and answer in full, as before. */
+export const STATUS_SNAPSHOT = { liveEvents: false };
+/**
+ * Whether a failed connection proves nothing is listening on an anchor socket.
+ *
+ * Only then may the socket file be removed. A timeout proves the opposite of
+ * nothing: a busy daemon or a slow, swapped or heavily loaded anchor answers
+ * late, and unlinking the path of an anchor that is alive orphans the agent
+ * running behind it. It can never be adopted again, its turn's result is lost,
+ * and the next prompt starts a second harness on the same session.
+ */
+export function anchorSocketIsAbandoned(error) {
+    return ['ECONNREFUSED', 'ENOENT', 'ENOTSOCK'].includes(String(error?.code || ''));
+}
 export async function connectExistingAgentAnchors() {
     const directory = agentAnchorDirectory();
     let paths = [];
@@ -250,8 +265,10 @@ export async function connectExistingAgentAnchors() {
             }
             anchors.push({ connection, snapshot });
         }
-        catch {
+        catch (error) {
             connection.close();
+            if (!anchorSocketIsAbandoned(error))
+                return;
             try {
                 fs.unlinkSync(socketPath);
             }
@@ -316,7 +333,7 @@ export function waitForAgentTurn(connection, messageId, timeoutMs = 12 * 60 * 60
             settle(initial);
         if (!settled)
             connection
-                .request('snapshot', {}, 5_000)
+                .request('snapshot', STATUS_SNAPSHOT, 5_000)
                 .then((latest) => {
                 const result = resultFromSnapshot(latest);
                 if (result)

package/dist/agent-anchor.js

@@ -111,6 +111,19 @@ function childResult(child, timeoutMs, harness, stderrTail) {
     timer.unref?.();
     return result.promise;
 }
+/** Run a transport operation, failing fast when its harness process has died. */
+function untilHarnessExit(transport, start) {
+    if (transport?.exited)
+        return Promise.reject(transport.exited);
+    let work;
+    try {
+        work = Promise.resolve(start());
+    }
+    catch (error) {
+        work = Promise.reject(error);
+    }
+    return typeof transport?.untilExit === 'function' ? transport.untilExit(work) : work;
+}
 class LineTransport {
     backgroundTasks;
     anchor;
@@ -120,6 +133,9 @@ class LineTransport {
     lastEventAt;
     child;
     stderrTail = new StderrTail();
+    /** Why the harness process is gone, once it is. */
+    exited = null;
+    exitSignal = deferred();
     constructor(anchor, harness, command, args, cwd, env = {}) {
         this.anchor = anchor;
         this.harness = harness;
@@ -150,8 +166,10 @@ class LineTransport {
                 phase: 'queued',
             });
         });
-        this.child.once('close', (code, signal) => {
-            const error = harnessExitError(anchor.source, code, signal, this.stderrTail.lines());
+        const ended = (error) => {
+            if (this.exited)
+                return;
+            this.exited = error;
             for (const waiter of this.pending.values())
                 waiter.reject(error);
             this.pending.clear();
@@ -159,7 +177,38 @@ class LineTransport {
             if (this.anchor.transport === this && this.anchor.status === 'idle')
                 this.anchor.scheduleExit();
             this.onClose?.(error);
-        });
+            // After the turn's own handling: a result that arrived with the exit wins.
+            setImmediate(() => this.exitSignal.resolve(error));
+        };
+        this.child.once('close', (code, signal) => ended(harnessExitError(anchor.source, code, signal, this.stderrTail.lines())));
+        // A process that never started (a working directory deleted since it was
+        // checked, no memory, a broken interpreter) reports `error`, not `close`.
+        // Unheard, that event is an uncaught exception that takes the anchor down
+        // and leaves the browser with "Agent anchor disconnected" for an answer.
+        this.child.once('error', (error) => ended(new Error(`${anchor.source} could not be started: ${error?.message || error}`)));
+        // A write racing the exit fails with EPIPE; the exit itself is the report.
+        this.child.stdin?.on('error', () => { });
+    }
+    /**
+     * Settle with `work`, or fail as soon as the harness process is gone.
+     *
+     * Requests already waiting when the process exits are rejected there. A
+     * request made afterwards writes to a closed pipe, which fails silently, and
+     * then waits for a reply that cannot come: a prompt sat "running" for the
+     * twelve-hour turn limit, and nothing the browser could send (interrupt,
+     * shutdown) got through either.
+     */
+    untilExit(work) {
+        if (this.exited) {
+            work.catch(() => { });
+            return Promise.reject(this.exited);
+        }
+        return Promise.race([
+            work,
+            this.exitSignal.promise.then((error) => {
+                throw error;
+            }),
+        ]);
     }
     emit(value, meta = {}) {
         const raw = JSON.stringify(value);
@@ -1136,6 +1185,9 @@ class RpcTransport extends LineTransport {
         const deadline = Date.now() + timeoutMs;
         while (Date.now() < deadline) {
             await new Promise((resolve) => setTimeout(resolve, 1_000));
+            // A dead process answers no state query; silence is not "idle".
+            if (this.exited)
+                throw this.exited;
             if (this.events === 0 || Date.now() - this.lastEventAt < 2_500)
                 continue;
             const state = await this.request('get_state', {}, 20_000).catch(() => null);
@@ -1280,6 +1332,8 @@ class OmpRpcTransport extends RpcTransport {
         this.lastEventAt = Date.now();
         while (Date.now() < deadline) {
             await new Promise((resolve) => setTimeout(resolve, 2_000));
+            if (this.exited)
+                throw this.exited;
             if (Date.now() - this.lastEventAt < 6_000 || this.openTurns > 0)
                 continue;
             if (this.eventsSincePrompt === 0 && Date.now() - startedAt < 45_000)
@@ -1515,7 +1569,16 @@ class Anchor {
         this.turnTimeoutMs = 12 * 60 * 60_000;
         this.idleTimer = null;
     }
-    snapshot() {
+    /**
+     * Everything a client needs to know about this anchor.
+     *
+     * The buffered live events (up to 2,000 of them, 8 MB) are only wanted by a
+     * daemon recovering a turn it did not watch. Status checks ask for the
+     * snapshot without them: serializing, sending and parsing that buffer every
+     * minute for each running session stalled the daemon's event loop for tens
+     * of milliseconds a time and kept a copy on its heap per anchor.
+     */
+    snapshot({ liveEvents = true } = {}) {
         return {
             protocol: 'turns.agent-anchor.v1',
             owner: 'turns.dev',
@@ -1545,7 +1608,7 @@ class Anchor {
             currentTurn: this.currentTurn ? { ...this.currentTurn } : null,
             pendingInteractions: [...this.pendingInteractions.values()].map((item) => item.interaction),
             lastEventSequence: this.sequence,
-            liveEvents: this.events.map((event) => ({ ...event })),
+            liveEvents: liveEvents ? this.events.map((event) => ({ ...event })) : [],
         };
     }
     broadcast(value) {
@@ -1811,32 +1874,32 @@ class Anchor {
             return interruptedBeforePrompt();
         if (this.source === 'claude') {
             if (!(this.transport instanceof ClaudeTransport) ||
-                this.transport.child.exitCode !== null ||
+                this.transport.exited || this.transport.child.exitCode !== null ||
                 this.transport.sessionId !== this.agentSessionId ||
                 this.transport.model !== this.model ||
                 this.transport.thinkingLevel !== this.thinkingLevel ||
                 this.transport.permissionMode !== this.permissionMode) {
                 this.transport?.stop?.();
                 this.transport = new ClaudeTransport(this, createSession);
-                await this.transport.open();
+                await untilHarnessExit(this.transport, () => this.transport.open());
             }
             if (interruptedBeforePrompt())
                 return interruptedBeforePrompt();
-            const result = await this.transport.prompt(this.currentTurn.prompt, timeoutMs);
+            const result = await untilHarnessExit(this.transport, () => this.transport.prompt(this.currentTurn.prompt, timeoutMs));
             return { exitCode: 0, signal: null, timedOut: false, error: null, stopReason: result?.subtype || 'completed' };
         }
         if (this.source === 'codex') {
             if (!(this.transport instanceof CodexAppServerTransport) ||
-                this.transport.child.exitCode !== null ||
+                this.transport.exited || this.transport.child.exitCode !== null ||
                 this.transport.threadId !== this.agentSessionId ||
                 this.transport.permissionMode !== this.permissionMode) {
                 this.transport?.stop?.();
                 this.transport = new CodexAppServerTransport(this);
-                await this.transport.open(createSession);
+                await untilHarnessExit(this.transport, () => this.transport.open(createSession));
             }
             if (interruptedBeforePrompt())
                 return interruptedBeforePrompt();
-            const result = await this.transport.prompt(this.currentTurn.prompt, timeoutMs);
+            const result = await untilHarnessExit(this.transport, () => this.transport.prompt(this.currentTurn.prompt, timeoutMs));
             return {
                 exitCode: 0,
                 signal: null,
@@ -1847,16 +1910,16 @@ class Anchor {
         }
         if (this.source === 'letta') {
             if (!(this.transport instanceof LettaTransport) ||
-                this.transport.child.exitCode !== null ||
+                this.transport.exited || this.transport.child.exitCode !== null ||
                 lettaSessionIdentity(this.transport.agentId, this.transport.conversationId) !== this.agentSessionId ||
                 this.transport.permissionMode !== this.permissionMode) {
                 this.transport?.stop?.();
                 this.transport = new LettaTransport(this, createSession);
-                await this.transport.open();
+                await untilHarnessExit(this.transport, () => this.transport.open());
             }
             if (interruptedBeforePrompt())
                 return interruptedBeforePrompt();
-            const result = await this.transport.prompt(this.currentTurn.prompt, timeoutMs);
+            const result = await untilHarnessExit(this.transport, () => this.transport.prompt(this.currentTurn.prompt, timeoutMs));
             return {
                 exitCode: 0,
                 signal: null,
@@ -1889,8 +1952,12 @@ class Anchor {
                 detached: process.platform !== 'win32',
             });
             this.child = child;
-            if (invocation.stdin)
+            if (invocation.stdin) {
+                // The harness may exit before reading its prompt; that exit is reported
+                // below, and the broken pipe must not crash the anchor first.
+                child.stdin.on('error', () => { });
                 child.stdin.end(`${invocation.stdin}\n`);
+            }
             const stderrTail = new StderrTail();
             for (const [stream, source] of [
                 [child.stdout, `${this.source}.stdout`],
@@ -1915,17 +1982,17 @@ class Anchor {
             if (!(this.transport instanceof AcpTransport) ||
                 this.transport.harness !== this.source ||
                 !this.transport.child ||
-                this.transport.child.exitCode !== null ||
+                this.transport.exited || this.transport.child.exitCode !== null ||
                 !this.transport.ready ||
                 this.transport.sessionId !== this.agentSessionId ||
                 this.transport.permissionMode !== this.permissionMode) {
                 this.transport?.stop?.();
                 this.transport = new AcpTransport(this, this.source, ACP_PROFILES[this.source]);
-                await this.transport.open(createSession);
+                await untilHarnessExit(this.transport, () => this.transport.open(createSession));
             }
             if (interruptedBeforePrompt())
                 return interruptedBeforePrompt();
-            const result = await this.transport.prompt(this.currentTurn.prompt, timeoutMs);
+            const result = await untilHarnessExit(this.transport, () => this.transport.prompt(this.currentTurn.prompt, timeoutMs));
             return { exitCode: 0, signal: null, timedOut: false, error: null, stopReason: result?.stopReason };
         }
         if (RPC_PROFILES[this.source]) {
@@ -1933,27 +2000,27 @@ class Anchor {
             const valid = specializedOmp
                 ? this.transport instanceof OmpRpcTransport
                 : this.transport instanceof RpcTransport && !(this.transport instanceof OmpRpcTransport);
-            if (!valid || this.transport.harness !== this.source || this.transport.child.exitCode !== null) {
+            if (!valid || this.transport.harness !== this.source || this.transport.exited || this.transport.child.exitCode !== null) {
                 this.transport?.stop?.();
                 this.transport = specializedOmp
                     ? new OmpRpcTransport(this, RPC_PROFILES.omp, createSession)
                     : new RpcTransport(this, this.source, RPC_PROFILES[this.source], createSession);
                 if (specializedOmp)
-                    await this.transport.open();
+                    await untilHarnessExit(this.transport, () => this.transport.open());
             }
             if (interruptedBeforePrompt())
                 return interruptedBeforePrompt();
-            await this.transport.prompt(this.currentTurn.prompt, timeoutMs);
+            await untilHarnessExit(this.transport, () => this.transport.prompt(this.currentTurn.prompt, timeoutMs));
             return { exitCode: 0, signal: null, timedOut: false, error: null };
         }
         if (this.source === 'deepseek') {
             if (!(this.transport instanceof DeepseekTransport)) {
                 this.transport = new DeepseekTransport(this);
-                await this.transport.open(createSession);
+                await untilHarnessExit(this.transport, () => this.transport.open(createSession));
             }
             if (interruptedBeforePrompt())
                 return interruptedBeforePrompt();
-            await this.transport.prompt(this.currentTurn.prompt, timeoutMs);
+            await untilHarnessExit(this.transport, () => this.transport.prompt(this.currentTurn.prompt, timeoutMs));
             return { exitCode: 0, signal: null, timedOut: false, error: null };
         }
         throw new Error(`Turns has no anchor transport for harness "${this.source}".`);
@@ -2015,7 +2082,7 @@ class Anchor {
         this.expirePendingInteractions('The turn was interrupted before this interaction was answered.');
         try {
             if (this.transport?.interrupt)
-                await this.transport.interrupt();
+                await untilHarnessExit(this.transport, () => this.transport.interrupt());
             else if (this.child) {
                 try {
                     process.kill(-this.child.pid, 'SIGINT');
@@ -2046,7 +2113,7 @@ class Anchor {
             await this.interrupt(String(this.currentTurn?.messageId || ''));
             return { steered: true, mode: 'interrupt' };
         }
-        await this.transport.steer(prompt, messageId);
+        await untilHarnessExit(this.transport, () => this.transport.steer(prompt, messageId));
         this.emitLive({
             event: 'turn.steer',
             agent: this.source,
@@ -2069,7 +2136,7 @@ class Anchor {
         this.setStatus('running');
         this.emitLive({ event: 'compaction.started', agent: this.source, phase: 'queued' });
         try {
-            const result = await this.transport.compact(this.turnTimeoutMs);
+            const result = await untilHarnessExit(this.transport, () => this.transport.compact(this.turnTimeoutMs));
             this.emitLive({ event: 'compaction.complete', agent: this.source, phase: 'queued' });
             return { compacted: true, result };
         }
@@ -2120,7 +2187,9 @@ fs.mkdirSync(path.dirname(socketPath), { recursive: true, mode: 0o700 });
 const server = net.createServer((socket) => {
     anchor.clients.add(socket);
     socket.setEncoding('utf8');
-    writeLine(socket, { type: 'anchor_hello', anchor: anchor.snapshot() });
+    // The greeting identifies the anchor. A client that wants the buffered
+    // events asks for a snapshot, as every client already does on connecting.
+    writeLine(socket, { type: 'anchor_hello', anchor: anchor.snapshot({ liveEvents: false }) });
     const lines = readline.createInterface({ input: socket });
     const detach = () => {
         anchor.clients.delete(socket);
@@ -2147,7 +2216,7 @@ const server = net.createServer((socket) => {
         Promise.resolve()
             .then(async () => {
             if (request.type === 'snapshot')
-                return anchor.snapshot();
+                return anchor.snapshot({ liveEvents: request.liveEvents !== false });
             if (request.type === 'send_message')
                 return anchor.start(request);
             if (request.type === 'interrupt')

package/dist/harness-auth.js

@@ -24,6 +24,7 @@
 import { spawn } from 'node:child_process';
 import os from 'node:os';
 import { readCodexAccountStatus } from "./codex-account.js";
+import { executablePath } from "./executable-path.js";
 import { readVibeAccount, readLocalHarnessAccount, parseNativeHarnessAccount, NATIVE_ACCOUNT_COMMANDS, } from "./harness-account.js";
 import { ACP_PROFILES, HARNESS_IDS, resolveHarnessCommand } from "./harness-registry.js";
 /** Harnesses whose account status this module can inspect. Mirrors the shared
@@ -84,12 +85,19 @@ export function parseCodexLoginStatus(output) {
         return { authenticated: false };
     return { authenticated: null };
 }
+/**
+ * Match the PATH agent anchors launch with, so a Node-backed CLI found
+ * outside the daemon's inherited PATH can still locate its interpreter.
+ */
+function harnessEnvironment() {
+    return { ...process.env, PATH: executablePath() };
+}
 /** Both streams interleaved: codex reports status on stderr, claude on stdout. */
 function runCommand(command, args, timeoutMs) {
     return new Promise((resolve) => {
         const child = spawn(command, args, {
             cwd: os.homedir(),
-            env: process.env,
+            env: harnessEnvironment(),
             stdio: ['ignore', 'pipe', 'pipe'],
         });
         let output = '';
@@ -210,7 +218,7 @@ export function createHarnessAuthManager() {
         flows.set(harness, flow);
         const child = spawn(command, args, {
             cwd: os.homedir(),
-            env: process.env,
+            env: harnessEnvironment(),
             stdio: ['pipe', 'pipe', 'pipe'],
         });
         flow.child = child;

package/dist/harness-registry.js

@@ -264,6 +264,9 @@ export const HARNESS_IDS = [
 function executable(candidate) {
     try {
         fs.accessSync(candidate, fs.constants.X_OK);
+        // X_OK also passes for directories, which cannot be launched.
+        if (!fs.statSync(candidate).isFile())
+            return '';
         return candidate;
     }
     catch {
@@ -325,6 +328,15 @@ export function resolveHarnessCommand(harness, profile = {}, dependencies = {})
                 return found;
         }
     }
+    // Claude Code's older "local" installer puts a wrapper script here and
+    // relies on a shell alias rather than PATH, so a daemon (which never reads
+    // the user's shell config) would otherwise miss it. Living in the shared
+    // resolver covers agent launch, auth status, and login alike.
+    if (harness === 'claude') {
+        const found = executable(path.join(home, '.claude', 'local', 'claude'));
+        if (found)
+            return found;
+    }
     throw new Error(`Agent executable not found for harness "${harness}" (${command}).`);
 }
 export function processInvocation({ harness, sessionId, transcriptPath, cwd, prompt, createSession, model, thinkingLevel, timeoutMs, }) {

package/dist/local-session-sources.js

@@ -1490,7 +1490,6 @@ function nativeProcessSnapshots(procRoot) {
             continue;
         let argv = [];
         let environ = '';
-        let fdTargets = [];
         try {
             argv = fs
                 .readFileSync(path.join(procRoot, entry.name, 'cmdline'), 'utf8')
@@ -1502,22 +1501,39 @@ function nativeProcessSnapshots(procRoot) {
             environ = fs.readFileSync(path.join(procRoot, entry.name, 'environ'), 'utf8');
         }
         catch { }
-        try {
-            fdTargets = fs.readdirSync(path.join(procRoot, entry.name, 'fd')).flatMap((descriptor) => {
+        if (!argv.length && !environ)
+            continue;
+        // Open files are wanted only for the few processes that turn out to be a
+        // harness, and listing them is the expensive part of this scan (a readlink
+        // per descriptor of every process on the machine), so they are read on
+        // first use.
+        let fdTargets = null;
+        processes.push({
+            pid: entry.name,
+            argv,
+            cmdline: argv.join(' '),
+            environ,
+            get fdTargets() {
+                if (fdTargets)
+                    return fdTargets;
+                fdTargets = [];
                 try {
-                    const target = fs
-                        .readlinkSync(path.join(procRoot, entry.name, 'fd', descriptor))
-                        .replace(/ \(deleted\)$/u, '');
-                    return path.isAbsolute(target) ? [target] : [];
+                    fdTargets = fs.readdirSync(path.join(procRoot, entry.name, 'fd')).flatMap((descriptor) => {
+                        try {
+                            const target = fs
+                                .readlinkSync(path.join(procRoot, entry.name, 'fd', descriptor))
+                                .replace(/ \(deleted\)$/u, '');
+                            return path.isAbsolute(target) ? [target] : [];
+                        }
+                        catch {
+                            return [];
+                        }
+                    });
                 }
-                catch {
-                    return [];
-                }
-            });
-        }
-        catch { }
-        if (argv.length || environ)
-            processes.push({ pid: entry.name, argv, cmdline: argv.join(' '), environ, fdTargets });
+                catch { }
+                return fdTargets;
+            },
+        });
     }
     return processes;
 }
@@ -1625,6 +1641,22 @@ function registeredClaudeSessionIds(processes, procRoot, sessionsRoot) {
     }
     return sessionIds;
 }
+/**
+ * A descriptor's transcript path with symlinks resolved, remembered with the
+ * descriptor. This scan runs every ten seconds on the daemon's main thread over
+ * every known session, and resolving thousands of paths each time (twice) was
+ * most of a stall that delayed live rows. Descriptors are replaced wholesale by
+ * each discovery, so a path that is re-pointed is seen at the next one.
+ */
+const canonicalDescriptorFiles = new WeakMap();
+function descriptorCanonicalFile(descriptor) {
+    const held = canonicalDescriptorFiles.get(descriptor);
+    if (held !== undefined)
+        return held;
+    const file = canonicalProcessFile(descriptor.file);
+    canonicalDescriptorFiles.set(descriptor, file);
+    return file;
+}
 function queueManagedKeysFromProcesses(descriptors, processes) {
     const transcriptFiles = new Set();
     for (const process of processes) {
@@ -1644,17 +1676,16 @@ function queueManagedKeysFromProcesses(descriptors, processes) {
             transcriptFiles.add(path.resolve(environment.TURNS_TRANSCRIPT_PATH));
         }
     }
+    // No queue-managed harness is running: nothing to match, and no reason to
+    // resolve every known transcript's path to find that out.
+    if (!transcriptFiles.size)
+        return new Set();
     return new Set(descriptors.flatMap((descriptor) => {
         if (!descriptor?.file)
             return [];
-        let file;
-        try {
-            file = fs.realpathSync(descriptor.file);
-        }
-        catch {
-            file = path.resolve(descriptor.file);
-        }
-        return transcriptFiles.has(file) ? [`${descriptor.harness}\0${descriptor.sourcePath}`] : [];
+        return transcriptFiles.has(descriptorCanonicalFile(descriptor))
+            ? [`${descriptor.harness}\0${descriptor.sourcePath}`]
+            : [];
     }));
 }
 export function queueManagedNativeDescriptorKeys(descriptors, procRoot = '/proc') {
@@ -1670,14 +1701,13 @@ export function externallyManagedNativeDescriptorKeys(descriptors, procRoot = '/
         if (queueManaged.has(key))
             continue;
         const session = descriptorNativeSessionId(descriptor);
-        const file = descriptor?.file ? canonicalProcessFile(descriptor.file) : '';
         // A process with no session key is evidence only that a harness is
         // running, not that it owns every historical transcript for that harness.
         // An exact open transcript, however, identifies that one descriptor.
-        if (!session && !file)
+        if (!session && !descriptor?.file)
             continue;
         const group = byHarness.get(descriptor.harness) || [];
-        group.push({ key, session, file });
+        group.push({ key, session, descriptor });
         byHarness.set(descriptor.harness, group);
     }
     const managed = new Set();
@@ -1697,7 +1727,9 @@ export function externallyManagedNativeDescriptorKeys(descriptors, procRoot = '/
             const openFiles = new Set(process.fdTargets.map(canonicalProcessFile));
             for (const candidate of candidates) {
                 if ((candidate.session && process.cmdline.includes(candidate.session)) ||
-                    (candidate.file && openFiles.has(candidate.file))) {
+                    (openFiles.size > 0 &&
+                        candidate.descriptor?.file &&
+                        openFiles.has(descriptorCanonicalFile(candidate.descriptor)))) {
                     managed.add(candidate.key);
                 }
             }

package/dist/queue-worker.js

@@ -6,7 +6,7 @@ import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
 import { logError } from "./logging.js";
 import { QueueDispatchLifecycle, QUEUE_RESTART_MESSAGE } from "./queue-lifecycle.js";
-import { anchorId, connectExistingAgentAnchors, launchAgentAnchor, waitForAgentTurn } from "./agent-anchor-client.js";
+import { anchorId, connectExistingAgentAnchors, launchAgentAnchor, STATUS_SNAPSHOT, waitForAgentTurn, } from "./agent-anchor-client.js";
 import { createHarnessUpdateManager } from "./harness-update.js";
 import { isAsyncQuestionId } from "./codex-async-question-recovery.js";
 import { assertAllowedWorkingDirectory, workingDirectoryIsAllowed } from "./directory-policy.js";
@@ -31,7 +31,7 @@ const DEFAULT_REDACTOR = createSecretRedactor();
 export async function answerAnchorInteraction(entry, interactionId, response) {
     if (!entry || entry.connection.closed)
         throw new Error('The detached harness is offline.');
-    entry.snapshot = await entry.connection.request('snapshot', {}, 5_000).catch(() => entry.snapshot);
+    entry.snapshot = await entry.connection.request('snapshot', STATUS_SNAPSHOT, 5_000).catch(() => entry.snapshot);
     const pending = entry.snapshot?.pendingInteractions?.some((interaction) => interaction.id === interactionId);
     // Async questions can be reconstructed from the native transcript without
     // appearing in the app-server's live/resumed item projection. Let the anchor
@@ -379,7 +379,7 @@ export function queueFailureIsRetryable(error, promptStarted) {
 export async function actualHarnessStatus(entry) {
     if (!entry || entry.connection.closed)
         return 'stopped';
-    const snapshot = await entry.connection.request('snapshot', {}, 5_000);
+    const snapshot = await entry.connection.request('snapshot', STATUS_SNAPSHOT, 5_000);
     entry.snapshot = snapshot;
     return snapshot.status === 'running' ? 'running' : 'idle';
 }
@@ -594,7 +594,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
     const usableAnchor = async (sessionId, source, agentSessionId, modelSettings = false) => {
         let entry = anchors.get(sessionId);
         if (entry && !entry.connection.closed) {
-            entry.snapshot = await entry.connection.request('snapshot', {}, 5_000).catch(() => entry.snapshot);
+            entry.snapshot = await entry.connection.request('snapshot', STATUS_SNAPSHOT, 5_000).catch(() => entry.snapshot);
             if (String(entry.snapshot.source || '') === source &&
                 String(entry.snapshot.agentSessionId || '') === agentSessionId &&
                 (!modelSettings || entry.snapshot.capabilities?.includes('model_settings')))
@@ -843,7 +843,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                     idleTimeoutMs: QUEUE_WARM_MS,
                 }, 30_000);
             });
-            entry.snapshot = await entry.connection.request('snapshot', {}, 5_000).catch(() => entry.snapshot);
+            entry.snapshot = await entry.connection.request('snapshot', STATUS_SNAPSHOT, 5_000).catch(() => entry.snapshot);
             // Registration after acceptance is safe: the connection retains recent
             // events and the snapshot carries a turn that completed immediately.
             result = await waitForAgentTurn(entry.connection, claim.prompt.id, QUEUE_TURN_TIMEOUT_MS, entry.snapshot, eventCursor);
@@ -852,7 +852,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                 await request({ type: 'session.native.bind', sessionId, agentSessionId: createdIdentity });
             }
         }
-        entry.snapshot = await entry.connection.request('snapshot', {}, 5_000).catch(() => ({
+        entry.snapshot = await entry.connection.request('snapshot', STATUS_SNAPSHOT, 5_000).catch(() => ({
             ...entry.snapshot,
             status: 'idle',
         }));
@@ -888,7 +888,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
             stopClaimRenewal(held);
             if (held?.entry && !held.entry.connection.closed) {
                 held.entry.snapshot = await held.entry.connection
-                    .request('snapshot', {}, 2_000)
+                    .request('snapshot', STATUS_SNAPSHOT, 2_000)
                     .catch(() => held.entry.snapshot);
                 await reportHarness(sessionId, held.entry.snapshot?.status === 'running' ? 'running' : 'idle', held.entry).catch(() => { });
             }
@@ -915,8 +915,15 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
     };
     const recoverAnchors = async () => {
         for (const [sessionId, entry] of anchors) {
-            const snapshot = await entry.connection.request('snapshot', {}, 5_000).catch(() => entry.snapshot);
-            entry.snapshot = snapshot;
+            // Recovery is the one reader of an anchor's buffered events, so it is the
+            // one request that asks for them; they are not kept past this pass.
+            // A full buffer can be megabytes; give a busy anchor a second, longer
+            // chance before recovering the turn without its buffered events.
+            const snapshot = await entry.connection
+                .request('snapshot', {}, 5_000)
+                .catch(() => entry.connection.request('snapshot', {}, 20_000))
+                .catch(() => entry.snapshot);
+            entry.snapshot = { ...snapshot, liveEvents: [] };
             await reportHarness(sessionId, snapshot.status === 'running' ? 'running' : 'idle', entry).catch(() => { });
             const turn = snapshot.currentTurn;
             // A warm anchor retains its terminal turn for diagnostics. Probe the
@@ -1047,7 +1054,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
         try {
             if (!entry || entry.connection.closed)
                 throw new Error('The detached harness is offline.');
-            entry.snapshot = await entry.connection.request('snapshot', {}, 5_000);
+            entry.snapshot = await entry.connection.request('snapshot', STATUS_SNAPSHOT, 5_000);
             if (entry.snapshot?.status === 'running')
                 throw new Error('The detached harness is actively running.');
             if (action === 'compact' && entry.snapshot?.pendingInteractions?.length) {
@@ -1056,7 +1063,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
             await entry.connection.request(action, {}, action === 'compact' ? QUEUE_TURN_TIMEOUT_MS : 5_000);
             if (action === 'compact') {
                 await flushRuntime(sessionId);
-                entry.snapshot = await entry.connection.request('snapshot', {}, 5_000).catch(() => entry.snapshot);
+                entry.snapshot = await entry.connection.request('snapshot', STATUS_SNAPSHOT, 5_000).catch(() => entry.snapshot);
                 await reportHarness(sessionId, 'idle', entry);
             }
             else {

package/dist/upload-sessions.js

@@ -481,32 +481,39 @@ function nativeTimestamp(raw, descriptor, rowIndex) {
     const base = Date.parse(descriptor.createdAt) || descriptor.mtimeMs || Date.now();
     return new Date(base + rowIndex).toISOString();
 }
-async function* completeNativeFileLines(file, startOffset, endOffset) {
+export async function* completeNativeFileLines(file, startOffset, endOffset) {
     if (endOffset < startOffset)
         return;
-    let carry = Buffer.alloc(0);
-    let carryOffset = startOffset;
+    // The unfinished line so far, as the chunks it arrived in. Joining them on
+    // every read and searching the whole thing again made one very long row
+    // (inline images, a giant tool output) quadratic: 80 MB took half a minute.
+    let carried = [];
+    let carriedBytes = 0;
+    let consumed = startOffset;
     const input = fs.createReadStream(file, { start: startOffset, end: endOffset });
     try {
         for await (const chunk of input) {
-            const buffer = carry.length ? Buffer.concat([carry, chunk]) : chunk;
-            const bufferOffset = carryOffset;
             let lineStart = 0;
             for (;;) {
-                const newline = buffer.indexOf(0x0a, lineStart);
+                // Only the new chunk can contain the newline that ends the carry.
+                const newline = chunk.indexOf(0x0a, lineStart);
                 if (newline < 0)
                     break;
-                let line = buffer.subarray(lineStart, newline);
+                const tail = chunk.subarray(lineStart, newline);
+                let line = carried.length ? Buffer.concat([...carried, tail], carriedBytes + tail.length) : tail;
+                consumed += line.length + 1;
+                carried = [];
+                carriedBytes = 0;
                 if (line.at(-1) === 0x0d)
                     line = line.subarray(0, -1);
-                yield {
-                    raw: line.toString('utf8'),
-                    endOffset: bufferOffset + newline + 1,
-                };
+                yield { raw: line.toString('utf8'), endOffset: consumed };
                 lineStart = newline + 1;
             }
-            carry = buffer.subarray(lineStart);
-            carryOffset = bufferOffset + lineStart;
+            if (lineStart < chunk.length) {
+                const rest = chunk.subarray(lineStart);
+                carried.push(rest);
+                carriedBytes += rest.length;
+            }
         }
     }
     finally {
@@ -2068,6 +2075,10 @@ async function uploadNative(options, machine, redactor = DEFAULT_REDACTOR) {
                     String(descriptor.parentSessionId || ''),
                     NATIVE_DESCRIPTOR_VERSION,
                     String(previousFingerprint?.[5] || nativeDescriptorMetadataFingerprint(descriptor)),
+                    // The same optional slot nativeDescriptorFingerprint appends. Without
+                    // it a continued session's fingerprint lost the slot on every append,
+                    // and each discovery reopened the session to put it back.
+                    ...(descriptor.supersedesSessionId ? [String(descriptor.supersedesSessionId)] : []),
                 ]);
             }
         }

package/package.json

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