@turns/dev 0.0.30 → 0.0.32

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-exit.js

@@ -38,7 +38,7 @@ export function harnessExitError(harness, code, signal, stderr) {
         harnessExit: { harness: String(harness), code: code ?? null, signal: signal ?? null, stderr },
     });
 }
-function harnessLabel(harness) {
+export function harnessLabel(harness) {
     const name = String(harness || 'agent');
     return name.charAt(0).toUpperCase() + name.slice(1);
 }

package/dist/harness-update.js

@@ -0,0 +1,236 @@
+/** Machine-local harness CLI upgrades, 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 { harnessLabel } from "./harness-exit.js";
+import { ACP_PROFILES, codexCommandIsAppManaged, HARNESS_IDS, RPC_PROFILES, resolveHarnessCommand, } from "./harness-registry.js";
+const VERSION_TIMEOUT_MS = 15_000;
+const UPDATE_TIMEOUT_MS = 5 * 60_000;
+const OUTPUT_LIMIT = 64 * 1024;
+/**
+ * Native installers whose CLI updates itself without prompting. Each entry was
+ * checked against the CLI's own `--help`; a harness absent here is upgradable
+ * only when a package manager owns its executable. Some updaters ask before
+ * installing (Devin) or rewrite a source checkout (Hermes), so they are left
+ * out rather than run unattended.
+ */
+const SELF_UPDATE_ARGS = {
+    claude: ['update'],
+    codex: ['update'],
+    cursor: ['update'],
+    antigravity: ['update'],
+    omp: ['update'],
+    grok: ['update'],
+    goose: ['update'],
+    fx: ['upgrade'],
+    kimi: ['upgrade'],
+    opencode: ['upgrade'],
+    kilo: ['upgrade'],
+};
+/** Run the resolved executable directly—never through a shell—so update
+ * requests cannot become arbitrary command execution. */
+function runCommand(command, args, timeoutMs) {
+    return new Promise((resolve) => {
+        const child = spawn(command, args, {
+            cwd: os.homedir(),
+            // npm and npm-installed CLIs 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 = '';
+        let settled = false;
+        const settle = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(result);
+        };
+        const timer = setTimeout(() => {
+            try {
+                child.kill('SIGKILL');
+            }
+            catch { }
+            settle({ output, exitCode: null, timedOut: true });
+        }, timeoutMs);
+        timer.unref?.();
+        const collect = (chunk) => {
+            if (output.length < OUTPUT_LIMIT)
+                output += String(chunk).slice(0, OUTPUT_LIMIT - output.length);
+        };
+        child.stdout.on('data', collect);
+        child.stderr.on('data', collect);
+        child.on('error', () => settle({ output, exitCode: null, failed: true }));
+        child.on('close', (exitCode) => settle({ output, exitCode }));
+    });
+}
+/** The first dotted version in a CLI's `--version` output, whatever its
+ * prefix (`codex-cli 0.164.0`, `omp/18.0.4`, `GitHub Copilot CLI 1.0.80.`). */
+export function parseHarnessVersion(output) {
+    const text = String(output || '').replace(/\u001b\[[0-9;?]*[A-Za-z]/gu, '');
+    const version = text.match(/\d+(?:\.\d+)+(?:-[0-9A-Za-z.]+)?/u)?.[0] || '';
+    return version.replace(/\.$/u, '').slice(0, 120);
+}
+function commandFailure(result, label, fallback) {
+    if (result.timedOut)
+        return new Error(`The ${label} update timed out.`);
+    const lines = result.output
+        .replace(/\u001b\[[0-9;?]*[A-Za-z]/gu, '')
+        .split('\n')
+        .map((line) => line.trim())
+        // npm ends every failure by pointing at its debug log.
+        .filter((line) => line && !/A complete log of this run can be found/iu.test(line));
+    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 harnessUpgradeCommand(harness, command, lookup = {}) {
+    const resolved = (lookup.realpath || realpathOrSelf)(command).replaceAll('\\', '/');
+    const find = lookup.findExecutable || findExecutable;
+    const platform = lookup.platform || process.platform;
+    // `npm i -g <pkg>` links <prefix>/bin/<cli> into <prefix>/lib/node_modules.
+    // Requiring the `lib/` layout keeps pnpm and Bun global stores, which also
+    // contain node_modules, away from an npm that would install a second copy.
+    // Windows npm is a .cmd shim, which cannot be spawned without a shell.
+    const npm = resolved.match(/^(.+?)\/lib\/node_modules\/((?:@[^/]+\/)?[^/@][^/]*)\//u);
+    if (npm && platform !== 'win32') {
+        const [, prefix, name] = npm;
+        const binary = find('npm', [path.join(prefix, 'bin')]);
+        if (binary) {
+            return {
+                manager: 'npm',
+                command: binary,
+                args: ['install', '-g', '--prefix', prefix, `${name}@latest`],
+                check: {
+                    args: ['view', name, 'version'],
+                    failure: `${name} is not published on the npm registry, so this installation must be updated on the machine.`,
+                },
+            };
+        }
+    }
+    const brew = resolved.match(/^(.+?)\/(Cellar|Caskroom)\/([^/]+)\//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'] : []), brew[3]],
+            };
+    }
+    const uv = resolved.match(/\/uv\/tools\/([^/]+)\//u);
+    if (uv) {
+        const binary = find('uv', []);
+        if (binary)
+            return { manager: 'uv', command: binary, args: ['tool', 'upgrade', uv[1]] };
+    }
+    const pipx = resolved.match(/\/pipx\/venvs\/([^/]+)\//u);
+    if (pipx) {
+        const binary = find('pipx', []);
+        if (binary)
+            return { manager: 'pipx', command: binary, args: ['upgrade', pipx[1]] };
+    }
+    const self = SELF_UPDATE_ARGS[harness];
+    return self ? { manager: 'self', command, args: self } : null;
+}
+/** The executable the agent anchor launches for a harness. */
+function harnessExecutable(harness) {
+    return resolveHarnessCommand(harness, ACP_PROFILES[harness] || RPC_PROFILES[harness] || {});
+}
+export function createHarnessUpdateManager(dependencies = {}) {
+    const harnesses = dependencies.harnesses || HARNESS_IDS;
+    const resolveCommand = dependencies.resolveCommand || harnessExecutable;
+    const isAppManaged = dependencies.isAppManaged ||
+        ((harness, command) => harness === 'codex' && codexCommandIsAppManaged(command));
+    const upgradeCommand = dependencies.upgradeCommand || ((harness, command) => harnessUpgradeCommand(harness, command));
+    const run = dependencies.run || runCommand;
+    const active = new Map();
+    const plan = (harness) => {
+        const label = harnessLabel(harness);
+        if (!harnesses.includes(harness))
+            throw new Error(`Turns cannot update ${label}.`);
+        const command = resolveCommand(harness);
+        if (isAppManaged(harness, command)) {
+            throw new Error(`${label} is managed by the macOS app. Update the ${label} app to update its bundled CLI.`);
+        }
+        const upgrade = upgradeCommand(harness, command);
+        if (!upgrade)
+            throw new Error(`Turns does not know how to update this ${label} installation. Update it on the machine.`);
+        return { label, command, upgrade };
+    };
+    const readVersion = async (command, label, fallback) => {
+        const result = await run(command, ['--version'], VERSION_TIMEOUT_MS);
+        if (result.failed || result.timedOut || result.exitCode !== 0)
+            throw commandFailure(result, label, fallback);
+        return parseHarnessVersion(result.output);
+    };
+    const perform = async (harness) => {
+        const { label, command, upgrade } = plan(harness);
+        const previousVersion = await readVersion(command, label, `${label} is not installed or its version could not be read.`);
+        if (upgrade.check) {
+            const checked = await run(upgrade.command, upgrade.check.args, VERSION_TIMEOUT_MS);
+            if (checked.timedOut)
+                throw new Error(`The ${label} update timed out.`);
+            if (checked.failed || checked.exitCode !== 0)
+                throw new Error(upgrade.check.failure);
+        }
+        const updateRun = await run(upgrade.command, upgrade.args, UPDATE_TIMEOUT_MS);
+        if (updateRun.failed || updateRun.timedOut || updateRun.exitCode !== 0) {
+            const manual = [path.basename(upgrade.command), ...upgrade.args].join(' ');
+            throw commandFailure(updateRun, label, upgrade.manager === 'self'
+                ? `${label} could not update itself. Run \`${manual}\` in a terminal on the machine.`
+                : `${upgrade.manager} could not upgrade ${label}. Run \`${manual}\` in a terminal on the machine.`);
+        }
+        // Resolve again because the updater may replace a shim or install path.
+        const currentVersion = await readVersion(resolveCommand(harness), label, `${label} updated, but its new version could not be read.`);
+        return {
+            ...(previousVersion ? { previousVersion } : {}),
+            ...(currentVersion ? { currentVersion } : {}),
+            updated: Boolean(previousVersion && currentVersion && previousVersion !== currentVersion),
+        };
+    };
+    return {
+        /** Harnesses installed here in a way this daemon can upgrade. */
+        available() {
+            return harnesses.filter((harness) => {
+                try {
+                    plan(harness);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            });
+        },
+        /** Concurrent clicks for one harness share one installer process instead
+         * of racing writes to the same installation. */
+        update(harness) {
+            let pending = active.get(harness);
+            if (!pending) {
+                pending = perform(harness).finally(() => active.delete(harness));
+                active.set(harness, pending);
+            }
+            return pending;
+        },
+    };
+}

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/path-resolution.js

@@ -87,7 +87,11 @@ export function pathCandidates(row) {
             continue;
         if (found.includes(candidate))
             continue;
-        found.push(candidate);
+        // A regex match is a slice of the row it came from, and a slice keeps the
+        // whole row alive for as long as it is remembered. The resolver remembers
+        // candidates per session for the life of the daemon, so each one has to
+        // be its own small string rather than a window onto kilobytes of transcript.
+        found.push(Buffer.from(candidate).toString());
         if (found.length >= MAX_PATH_CANDIDATES_PER_ROW)
             break;
     }

package/dist/queue-worker.js

@@ -6,8 +6,8 @@ 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 { createCodexUpdateManager } from "./codex-update.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";
 import { browseMachinePath, streamMachineFileRange } from "./file-browsing.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
@@ -341,6 +341,14 @@ export function runtimeEvent(anchorName, messageId, event, redactor = DEFAULT_RE
     }
     return null;
 }
+/** Registration capabilities for harness upgrades. `codexUpdate` remains for
+ * backends that only know how to route Codex upgrades. */
+export function updateCapabilities(harnesses) {
+    return {
+        ...(harnesses.length ? { harnessUpdates: harnesses } : {}),
+        ...(harnesses.includes('codex') ? { codexUpdate: true } : {}),
+    };
+}
 export function resultError(result) {
     if (!result)
         return new Error('The anchored agent returned no result.');
@@ -371,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';
 }
@@ -586,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')))
@@ -835,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);
@@ -844,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',
         }));
@@ -880,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(() => { });
             }
@@ -907,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
@@ -1039,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) {
@@ -1048,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 {
@@ -1339,18 +1354,22 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
             });
         }
     };
-    /** Upgrade the machine's Codex installation. Only this fixed, resolved
-     * command is exposed; the browser cannot supply a binary, arguments, or
-     * shell input. Errors are redacted before crossing the machine boundary. */
-    const codexUpdate = createCodexUpdateManager();
-    const handleCodexUpdate = async (message, replyRpc) => {
+    /** Upgrade one of the machine's harness CLIs. Only a fixed command chosen
+     * from the resolved executable's install location is run; the browser names
+     * a harness but cannot supply a binary, arguments, or shell input. Errors
+     * are redacted before crossing the machine boundary. The message keeps its
+     * Codex-era name; a request without a harness is from a Codex-only backend. */
+    const harnessUpdate = createHarnessUpdateManager();
+    const handleHarnessUpdate = async (message, replyRpc) => {
         const sessionId = String(message.sessionId || '');
+        const harness = String(message.harness || 'codex');
         try {
-            const answer = await codexUpdate.update();
+            const answer = await harnessUpdate.update(harness);
             replyRpc.notify({
                 type: 'session.codex.update.result',
                 requestId: message.requestId,
                 sessionId,
+                harness,
                 ok: true,
                 answer,
             });
@@ -1360,6 +1379,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                 type: 'session.codex.update.result',
                 requestId: message.requestId,
                 sessionId,
+                harness,
                 ok: false,
                 error: redactor.redactText(error?.message || String(error)),
             });
@@ -1424,33 +1444,44 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
         }
     }, HARNESS_HEARTBEAT_MS);
     heartbeat.unref?.();
+    // A browser request is answered over the same socket it arrived on. When
+    // that socket drops mid-request, the handler's reply throws, and so does the
+    // error reply in its catch block. Nothing awaits these handlers, so that
+    // second throw used to surface as an unhandled rejection and take the whole
+    // daemon down with every running session's watcher. The browser has already
+    // been told its connection closed; there is nobody left to answer.
+    const answer = (handler, message) => {
+        void Promise.resolve()
+            .then(() => handler(message, rpc))
+            .catch((error) => logError(`Could not answer ${message.type}: ${error?.message || error}\n`));
+    };
     rpc.onEvent((message) => {
         if (lifecycle.stopping)
             return;
         if (message.type === 'queue.ready')
             void tryClaim(message.sessionId);
         if (message.type === 'session.steer')
-            void handleSteer(message, rpc);
+            answer(handleSteer, message);
         if (message.type === 'session.interrupt.request')
-            void handleInterrupt(message, rpc);
+            answer(handleInterrupt, message);
         if (message.type === 'session.anchor.action.request')
-            void handleAnchorAction(message, rpc);
+            answer(handleAnchorAction, message);
         if (message.type === 'session.interaction.answer.request')
-            void handleInteractionAnswer(message, rpc);
+            answer(handleInteractionAnswer, message);
         if (message.type === 'session.file.browse.request')
-            void handleFileBrowse(message, rpc);
+            answer(handleFileBrowse, message);
         if (message.type === 'session.file.range.request')
-            void handleFileRange(message, rpc);
+            answer(handleFileRange, message);
         if (message.type === 'session.file.search.request')
-            void handleFileSearch(message, rpc);
+            answer(handleFileSearch, message);
         if (message.type === 'session.git.read.request')
-            void handleGitRead(message, rpc);
+            answer(handleGitRead, message);
         if (message.type === 'session.harness.auth.request')
-            void handleHarnessAuth(message, rpc);
+            answer(handleHarnessAuth, message);
         if (message.type === 'session.codex.update.request')
-            void handleCodexUpdate(message, rpc);
+            answer(handleHarnessUpdate, message);
         if (message.type === 'session.file.edit.request')
-            void handleFileEdit(message, rpc);
+            answer(handleFileEdit, message);
     });
     const registered = new WeakSet();
     const registering = new WeakSet();
@@ -1469,7 +1500,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                     git: true,
                     fileRanges: true,
                     harnessAuth: true,
-                    ...(codexUpdate.available() ? { codexUpdate: true } : {}),
+                    ...updateCapabilities(harnessUpdate.available()),
                 },
                 workerId,
                 workerInstanceId,
@@ -1490,7 +1521,15 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
     rpc.onConnect((control) => {
         void registerControl(control);
     });
-    await registerControl(await rpc.current());
+    // Starting offline must not end this function: the loop below is the only
+    // thing that sends heartbeats, probes for a half-open socket and re-polls
+    // for missed queue events, and it already tolerates a failed connection.
+    try {
+        await registerControl(await rpc.current());
+    }
+    catch (error) {
+        logError(`Queue worker could not connect yet: ${error?.message || error}\n`);
+    }
     while (!lifecycle.stopping) {
         await backgroundWait(MACHINE_HEARTBEAT_MS);
         if (lifecycle.stopping)

package/dist/upload-sessions.js

@@ -404,6 +404,37 @@ export function linkNativeSessionParents(machine, descriptors) {
         ];
     });
 }
+/**
+ * The row the server has reached, when a rejected ingest batch was in fact
+ * already stored in full; null when the rejection is a real one.
+ */
+export function ingestOffsetAcknowledges(error, startRow, rowCount) {
+    const offset = /^ROW_OFFSET:(\d+)$/u.exec(String(error?.code || ''));
+    if (!offset)
+        return null;
+    const reached = Number(offset[1]);
+    return reached >= startRow + rowCount ? reached : null;
+}
+/**
+ * Bring a descriptor up to the file as it is now.
+ *
+ * The inventory scan stats each transcript in a worker and the result is
+ * recorded here some time later. An agent that wrote in between leaves the
+ * descriptor describing a shorter file than the one on disk. Recording the
+ * fresh stat as "already seen" while uploading only to the descriptor's stale
+ * size strands those rows: nothing looks changed until the next append or the
+ * five-minute audit. A database projection's file is its whole store, not the
+ * session, so its size says nothing about the session and is left alone.
+ */
+export function adoptGrowthSinceInventory(descriptor, stat) {
+    if (String(descriptor.sourcePath || '').includes('.db#'))
+        return false;
+    if (Number(stat.size) === Number(descriptor.size))
+        return false;
+    descriptor.size = stat.size;
+    descriptor.mtimeMs = stat.mtimeMs;
+    return true;
+}
 export function nativeDescriptorFingerprint(descriptor) {
     return JSON.stringify([
         Number(descriptor.size) || 0,
@@ -450,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 {
@@ -638,6 +676,10 @@ export class RpcSocket {
             this.socket.on('message', (data) => this.onMessage(String(data), (ready) => settle(resolve, ready), (error) => settle(reject, error)));
             this.socket.on('close', (code, reason) => {
                 const error = socketError(`WebSocket closed (${code}): ${String(reason)}`);
+                // A server that accepts the upgrade and closes before saying "ready"
+                // (a deploy, a restarting object) has answered. Without this the
+                // connect waited out the whole ready deadline before it could retry.
+                settle(reject, error);
                 for (const request of this.pending.values()) {
                     clearTimeout(request.timer);
                     request.reject(error);
@@ -1087,13 +1129,27 @@ export async function uploadNativeSession(rpc, machine, descriptor, cursor = {},
         if (!held.length)
             return;
         const rows = held.map((entry) => entry.event);
-        const acknowledgement = await rpc.request({
-            type: 'ingest',
-            sessionId: uploadSessionId,
-            startRow: rows[0].index,
-            rows,
-            ...(initialUpload ? { deferReduction: true } : {}),
-        });
+        let acknowledgement;
+        try {
+            acknowledgement = await rpc.request({
+                type: 'ingest',
+                sessionId: uploadSessionId,
+                startRow: rows[0].index,
+                rows,
+                ...(initialUpload ? { deferReduction: true } : {}),
+            });
+        }
+        catch (error) {
+            // The connection resends a request whose socket died. When only the
+            // acknowledgement was lost, the server already holds these rows and
+            // answers the resend with the offset it has reached. That is an
+            // acknowledgement: treating it as a failure put the session into backoff
+            // and then re-read its whole transcript from the first byte.
+            const acknowledged = ingestOffsetAcknowledges(error, rows[0].index, rows.length);
+            if (acknowledged === null)
+                throw error;
+            acknowledgement = { nextRow: acknowledged };
+        }
         nextRow = Number(acknowledgement.nextRow);
         sent += rows.length;
         batchesSent += 1;
@@ -1624,6 +1680,7 @@ async function uploadNative(options, machine, redactor = DEFAULT_REDACTOR) {
             try {
                 const stat = fs.statSync(descriptor.file);
                 physicalStats.set(sessionId, { size: stat.size, mtimeMs: stat.mtimeMs });
+                adoptGrowthSinceInventory(descriptor, stat);
             }
             catch { }
             const saved = state.get(sessionId);
@@ -2018,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.30",
+  "version": "0.0.32",
   "description": "Upload local AI agent sessions to turns.dev",
   "license": "MIT",
   "type": "module",

package/dist/codex-update.js

@@ -1,162 +0,0 @@
-/** 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;
-const OUTPUT_LIMIT = 64 * 1024;
-/** Run the resolved executable directly—never through a shell—so update
- * requests cannot become arbitrary command execution. */
-function runCommand(command, args, timeoutMs) {
-    return new Promise((resolve) => {
-        const child = spawn(command, args, {
-            cwd: os.homedir(),
-            // 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 = '';
-        let settled = false;
-        const settle = (result) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            resolve(result);
-        };
-        const timer = setTimeout(() => {
-            try {
-                child.kill('SIGKILL');
-            }
-            catch { }
-            settle({ output, exitCode: null, timedOut: true });
-        }, timeoutMs);
-        timer.unref?.();
-        const collect = (chunk) => {
-            if (output.length < OUTPUT_LIMIT)
-                output += String(chunk).slice(0, OUTPUT_LIMIT - output.length);
-        };
-        child.stdout.on('data', collect);
-        child.stderr.on('data', collect);
-        child.on('error', () => settle({ output, exitCode: null, failed: true }));
-        child.on('close', (exitCode) => settle({ output, exitCode }));
-    });
-}
-export function parseCodexVersion(output) {
-    const text = String(output || '').trim();
-    const prefixed = text.match(/codex(?:-cli)?\s+([^\s]+)/iu);
-    return (prefixed?.[1] || text.split(/\s+/u).at(-1) || '').slice(0, 120);
-}
-function commandFailure(result, fallback) {
-    if (result.timedOut)
-        return new Error('The Codex update timed out.');
-    const lines = result.output
-        .replace(/\u001b\[[0-9;?]*[A-Za-z]/gu, '')
-        .split('\n')
-        .map((line) => line.trim())
-        .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();
-        if (isAppManaged(command)) {
-            throw new Error('Codex is managed by the macOS app. Update the Codex app to update its bundled CLI.');
-        }
-        return command;
-    };
-    const perform = async () => {
-        const beforeRun = await run(updateCommand(), ['--version'], VERSION_TIMEOUT_MS);
-        if (beforeRun.failed || beforeRun.timedOut || beforeRun.exitCode !== 0) {
-            throw commandFailure(beforeRun, 'Codex is not installed or its version could not be read.');
-        }
-        const previousVersion = parseCodexVersion(beforeRun.output);
-        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, 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);
-        if (afterRun.failed || afterRun.timedOut || afterRun.exitCode !== 0) {
-            throw commandFailure(afterRun, 'Codex updated, but its new version could not be read.');
-        }
-        const currentVersion = parseCodexVersion(afterRun.output);
-        return {
-            ...(previousVersion ? { previousVersion } : {}),
-            ...(currentVersion ? { currentVersion } : {}),
-            updated: Boolean(previousVersion && currentVersion && previousVersion !== currentVersion),
-        };
-    };
-    return {
-        /** App-bundled Codex is updated with the app, not by its CLI command. */
-        available() {
-            try {
-                return !isAppManaged(resolveCommand());
-            }
-            catch {
-                return false;
-            }
-        },
-        /** Concurrent clicks share one installer process instead of racing writes. */
-        update() {
-            if (!active)
-                active = perform().finally(() => (active = null));
-            return active;
-        },
-    };
-}