@turns/dev 0.0.1

package/dist/upload-sessions.js

@@ -0,0 +1,2016 @@
+#!/usr/bin/env node
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import WebSocket from 'ws';
+import { createPathResolver, pathCandidates } from "./path-resolution.js";
+import { streamDeepseekTrajectoryLines } from "./deepseek-trajectories.js";
+import { normalizeAllowedDirectories, workingDirectoryIsAllowed } from "./directory-policy.js";
+import { discoverGitAssociation } from "./git-association.js";
+import { discoverLocalSessions, externallyManagedNativeDescriptorKeys, nativeDescriptorAgentSessionId, nativeDescriptorLineage, nativeDescriptorWorkingDirectory, nativeSessionShallowWatchRoots, nativeSessionWatchRoots, } from "./local-session-sources.js";
+import { compactNativeRaw } from "./native-record-compaction.js";
+import { httpBaseUrl, watchQueuedPrompts } from "./queue-worker.js";
+import { createSecretRedactor, REDACTION_VERSION } from "./secret-redaction.js";
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const DEFAULT_RUNS = path.resolve(HERE, '../scaffolding/scenario/runs');
+// Keep a single User DO transaction short enough for multiplexed queue,
+// presence, and ingestion requests to interleave during archive replay.
+const MAX_BATCH_BYTES = 256_000;
+const MAX_BATCH_ROWS = 100;
+/** Rows the server accepts in one runtime append. */
+const MAX_RUNTIME_EVENT_BATCH = 250;
+const RPC_TIMEOUT_MS = 5 * 60_000;
+const MAX_SOCKET_RETRIES = 8;
+const MAX_NATIVE_SETTLE_PASSES = 4;
+const MAX_EXTERNAL_STATUS_BATCH = 1_000;
+const NATIVE_STATE_VERSION = 1;
+const NATIVE_DESCRIPTOR_VERSION = 3;
+const NATIVE_DISCOVERY_INTERVAL_MS = Math.max(30_000, Number(process.env.TURNS_NATIVE_DISCOVERY_INTERVAL_MS) || 5 * 60_000);
+const NATIVE_POLL_INTERVAL_MS = Math.max(10_000, Number(process.env.TURNS_NATIVE_POLL_INTERVAL_MS) || 30_000);
+const NATIVE_WATCH_INTERVAL_MS = Math.max(1_000, Number(process.env.TURNS_NATIVE_WATCH_INTERVAL_MS) || 10_000);
+const NATIVE_CHANGE_DEBOUNCE_MS = 100;
+const NATIVE_DISCOVERY_DEBOUNCE_MS = 250;
+// Historical redaction replays are deliberately cooperative: one bounded DO
+// transaction, then a pause and another scheduler pass. A file that changes
+// during backfill is promoted and receives a larger quantum immediately.
+const HISTORICAL_REPLAY_BATCHES_PER_SLICE = 1;
+const ACTIVE_REPLAY_BATCHES_PER_SLICE = 4;
+const RECENT_SESSION_PRIORITY_MS = 5 * 60_000;
+const HISTORICAL_REPLAY_DELAY_MS = Math.max(100, Number(process.env.TURNS_HISTORICAL_REPLAY_DELAY_MS) || 1_500);
+const FAILURE_RETRY_BASE_MS = 5_000;
+const FAILURE_RETRY_MAX_MS = 5 * 60_000;
+const DEFAULT_REDACTOR = createSecretRedactor();
+const TIME_FIELDS = [
+    'ts',
+    'timestamp',
+    'time',
+    'created_at',
+    'createdAt',
+    'created_timestamp',
+    'time_created',
+    'recorded_at',
+    'occurred_at_ms',
+];
+const TIME_CONTAINERS = ['data', 'payload', 'message', 'chat_message', 'node'];
+function epochToIso(value) {
+    const milliseconds = value > 1e14 ? value / 1000 : value > 1e11 ? value : value > 1e9 ? value * 1000 : NaN;
+    if (!Number.isFinite(milliseconds))
+        return undefined;
+    const date = new Date(milliseconds);
+    return Number.isNaN(+date) ? undefined : date.toISOString();
+}
+/** Extract the source record's creation time without importing the reducer. */
+export function documentTime(document, depth = 0) {
+    if (!document || typeof document !== 'object' || Array.isArray(document))
+        return undefined;
+    for (const field of TIME_FIELDS) {
+        const value = document[field];
+        if (typeof value === 'number') {
+            const iso = epochToIso(value);
+            if (iso)
+                return iso;
+        }
+        if (typeof value === 'string' && /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}/u.test(value)) {
+            const zoned = /(Z|[+-]\d{2}:?\d{2})$/u.test(value) ? value : `${value.replace(' ', 'T')}Z`;
+            const date = new Date(zoned);
+            if (!Number.isNaN(+date))
+                return date.toISOString();
+        }
+    }
+    if (depth >= 2)
+        return undefined;
+    for (const field of TIME_CONTAINERS) {
+        const nested = document[field];
+        let parsed = nested;
+        if (typeof nested === 'string') {
+            try {
+                parsed = JSON.parse(nested);
+            }
+            catch {
+                parsed = null;
+            }
+        }
+        const found = documentTime(parsed, depth + 1);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+function socketError(message, cause) {
+    return Object.assign(new Error(message, cause ? { cause } : undefined), { code: 'SOCKET_CLOSED' });
+}
+function authenticationError(message) {
+    return Object.assign(new Error(message), { code: 'AUTH_REJECTED' });
+}
+export function isSocketError(error) {
+    return error?.code === 'SOCKET_CLOSED' || error?.code === 'SOCKET_TIMEOUT';
+}
+function reconnectDelay(attempt) {
+    return Math.min(15_000, 750 * 2 ** Math.min(attempt, 5)) + Math.floor(Math.random() * 250);
+}
+function wait(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function reportingRedactor(tokens) {
+    const counts = new Map();
+    const redactor = createSecretRedactor({
+        literals: [...(Array.isArray(tokens) ? tokens : [tokens]), process.env.TURNS_UPLOAD_TOKEN].filter(Boolean),
+        onFinding: ({ rule, count }) => counts.set(rule, (counts.get(rule) || 0) + count),
+    });
+    const report = () => {
+        if (!counts.size)
+            return;
+        const rules = Object.fromEntries([...counts].sort((left, right) => right[1] - left[1]));
+        counts.clear();
+        process.stderr.write(`Secret filtering applied (v${REDACTION_VERSION}): ${JSON.stringify(rules)}\n`);
+    };
+    const timer = setInterval(report, 60_000);
+    timer.unref?.();
+    return {
+        redactor,
+        close() {
+            clearInterval(timer);
+            report();
+        },
+    };
+}
+function argumentsFrom(argv, { allowMissingToken = false } = {}) {
+    const options = {
+        url: process.env.TURNS_URL || 'wss://turns.dev/api/socket',
+        token: process.env.TURNS_UPLOAD_TOKEN || '',
+        runs: DEFAULT_RUNS,
+        native: false,
+        dryRun: false,
+        watch: false,
+        only: '',
+        rewriteSession: '',
+        nativeStateFile: process.env.TURNS_NATIVE_STATE_FILE || path.join(HERE, '.native-upload-state.json'),
+        machineIdFile: process.env.TURNS_MACHINE_ID_FILE || path.join(HERE, '.machine-id'),
+        directory: '',
+        all: false,
+        devUser: '',
+        allowedDirectories: [],
+    };
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        const next = () => {
+            const value = argv[++index];
+            if (!value)
+                throw new Error(`${argument} requires a value`);
+            return value;
+        };
+        if (argument === '--url')
+            options.url = next();
+        else if (argument === '--token')
+            options.token = next();
+        else if (argument === '--runs')
+            options.runs = path.resolve(next());
+        else if (argument === '--native')
+            options.native = true;
+        else if (argument === '--dry-run')
+            options.dryRun = true;
+        else if (argument === '--only')
+            options.only = next();
+        else if (argument === '--rewrite-session')
+            options.rewriteSession = next();
+        else if (argument === '--native-state-file')
+            options.nativeStateFile = path.resolve(next());
+        else if (argument === '--machine-id-file')
+            options.machineIdFile = path.resolve(next());
+        else if (argument === '--directory')
+            options.directory = path.resolve(next());
+        else if (argument === '--all')
+            options.all = true;
+        else if (argument === '--dev-user')
+            options.devUser = next().trim().toLowerCase();
+        else if (argument === '--allow-directory')
+            options.allowedDirectories.push(next());
+        else if (argument === '--watch')
+            options.watch = true;
+        else if (argument === '--help') {
+            process.stdout.write(`Usage: node upload-sessions.ts [options]\n\n` +
+                `  --watch              keep rescanning and uploading changed sessions\n` +
+                `  --native             upload native harness session stores, not captures\n` +
+                `  --rewrite-session ID reset and fully replay one exact native session\n` +
+                `  --dry-run            inventory native sessions without uploading\n` +
+                `  --runs PATH          capture root (default: ${DEFAULT_RUNS})\n` +
+                `  --only TEXT          upload paths containing TEXT\n` +
+                `  --directory PATH     upload sessions whose working directory is PATH\n` +
+                `  --all                upload sessions across all working directories\n` +
+                `  --allow-directory P  upload/launch only inside directory prefix P (repeatable)\n` +
+                `  --dev-user LOGIN     authenticate as a local Wrangler DEV_USER uploader\n` +
+                `  --url WS_URL         websocket endpoint\n` +
+                `  --token TOKEN        internal/test bearer token override\n` +
+                `  --machine-id-file PATH persistent machine identity\n` +
+                `  --native-state-file PATH persistent native upload cursor\n`);
+            process.exit(0);
+        }
+        else
+            throw new Error(`Unknown argument: ${argument}`);
+    }
+    if (options.rewriteSession && !options.native) {
+        throw new Error('--rewrite-session requires --native.');
+    }
+    if (options.directory && options.all)
+        throw new Error('--directory cannot be combined with --all.');
+    if (options.allowedDirectories.length && (options.directory || options.all)) {
+        throw new Error('--allow-directory cannot be combined with --directory or --all.');
+    }
+    options.allowedDirectories = normalizeAllowedDirectories(options.allowedDirectories);
+    if (!options.dryRun && !options.token && !options.devUser && !allowMissingToken) {
+        throw new Error('No uploader credential provider. Run uploads through the `turns` CLI.');
+    }
+    return options;
+}
+function machineId(file = path.join(HERE, '.machine-id')) {
+    if (fs.existsSync(file))
+        return fs.readFileSync(file, 'utf8').trim();
+    const id = crypto.randomUUID();
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(file, `${id}\n`, { mode: 0o600 });
+    return id;
+}
+export function discover(root, only = '') {
+    const files = [];
+    for (const folder of ['', 'imports', 'archive']) {
+        const directory = path.join(root, folder);
+        if (!fs.existsSync(directory))
+            continue;
+        for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+            if (!entry.isFile() || !entry.name.endsWith('.jsonl'))
+                continue;
+            const file = path.join(directory, entry.name);
+            const relative = path.relative(root, file);
+            if (only && !relative.toLowerCase().includes(only.toLowerCase()))
+                continue;
+            files.push({ file, relative });
+        }
+    }
+    return files.sort((left, right) => left.relative.localeCompare(right.relative));
+}
+export function completeLines(file) {
+    const source = fs.readFileSync(file, 'utf8');
+    const lines = source.split('\n');
+    if (!source.endsWith('\n'))
+        lines.pop();
+    while (lines.at(-1) === '')
+        lines.pop();
+    const rows = [];
+    const raw = [];
+    for (const line of lines) {
+        try {
+            rows.push(JSON.parse(line));
+            raw.push(line);
+        }
+        catch {
+            break;
+        }
+    }
+    return { rows, raw };
+}
+function harnessOf(relative, rows) {
+    const fromRow = String(rows[0]?.harness || '').trim();
+    if (fromRow)
+        return fromRow;
+    return path.basename(relative, '.jsonl').split('__').at(-1) || 'unknown';
+}
+export function stableNativeSessionId(machine, harness, sourcePath) {
+    const fingerprint = crypto
+        .createHash('sha256')
+        .update(`${machine}\0native\0${harness}\0${sourcePath}`)
+        .digest('hex')
+        .slice(0, 24);
+    return `${harness}-native-${fingerprint}`.slice(0, 240);
+}
+/** Resolve harness-native parent keys to the machine-stable turns.dev IDs. */
+export function linkNativeSessionParents(machine, descriptors) {
+    const records = descriptors.map((descriptor) => ({
+        descriptor,
+        lineage: nativeDescriptorLineage(descriptor),
+    }));
+    const byNativeId = new Map();
+    for (const record of records) {
+        if (!record.lineage.nativeSessionId)
+            continue;
+        const key = `${record.descriptor.harness}\0${record.lineage.nativeSessionId}`;
+        const candidates = byNativeId.get(key) || [];
+        candidates.push(record.descriptor);
+        byNativeId.set(key, candidates);
+    }
+    const storeNamespace = (descriptor) => {
+        const sourcePath = String(descriptor?.sourcePath || '').replaceAll('\\', '/');
+        if (descriptor?.harness === 'gemini')
+            return /^(.*?\/chats)(?:\/|$)/iu.exec(sourcePath)?.[1] || '';
+        return '';
+    };
+    return records.flatMap(({ descriptor, lineage }) => {
+        // Internal harness sidechains such as Claude's compaction worker are still
+        // children for identity/resume safety, but never become uploaded sessions.
+        if (lineage.uploadable === false)
+            return [];
+        const candidates = lineage.parentNativeSessionId
+            ? byNativeId.get(`${descriptor.harness}\0${lineage.parentNativeSessionId}`) || []
+            : [];
+        const namespace = storeNamespace(descriptor);
+        const localCandidates = namespace
+            ? candidates.filter((candidate) => storeNamespace(candidate) === namespace)
+            : candidates;
+        // Native IDs are not globally unique for every harness. Prefer the child's
+        // own store. Gemini can retain multiple timestamped files for one native
+        // session in that store; those aliases converge server-side, so use its
+        // newest file deterministically. Do not guess for unnamespaced collisions.
+        const parent = localCandidates.length === 1
+            ? localCandidates[0]
+            : namespace && localCandidates.length > 1
+                ? [...localCandidates].sort((left, right) => Number(right.mtimeMs || 0) - Number(left.mtimeMs || 0) ||
+                    String(right.sourcePath).localeCompare(String(left.sourcePath)))[0]
+                : null;
+        // An exact structural parent path is stronger than a harness-wide native
+        // ID match. This matters for Claude descendants, whose short runtime agent
+        // IDs can recur in another project while the adjacent sidecar names the
+        // correct transcript in this session's flat subagents directory.
+        const parentSourcePath = lineage.parentSourcePath || parent?.sourcePath;
+        // An unresolved child cannot satisfy the sidebar contract. Leave it out of
+        // native upload until its store exposes enough lineage to nest it safely.
+        if (lineage.isSubagent && !parentSourcePath)
+            return [];
+        return [
+            {
+                ...descriptor,
+                isSubagent: lineage.isSubagent,
+                ...(lineage.nativeTitle ? { nativeTitle: lineage.nativeTitle } : {}),
+                ...(lineage.nativeSubagentType ? { nativeSubagentType: lineage.nativeSubagentType } : {}),
+                ...(lineage.nativeSubagentDepth ? { nativeSubagentDepth: lineage.nativeSubagentDepth } : {}),
+                ...(parentSourcePath
+                    ? {
+                        parentSessionId: stableNativeSessionId(machine, descriptor.harness, parentSourcePath),
+                    }
+                    : {}),
+            },
+        ];
+    });
+}
+export function nativeDescriptorFingerprint(descriptor) {
+    return JSON.stringify([
+        Number(descriptor.size) || 0,
+        Number(descriptor.mtimeMs) || 0,
+        nativeDescriptorWorkingDirectory(descriptor),
+        String(descriptor.parentSessionId || ''),
+        NATIVE_DESCRIPTOR_VERSION,
+        nativeDescriptorMetadataFingerprint(descriptor),
+    ]);
+}
+function nativeDescriptorMetadataFingerprint(descriptor) {
+    return JSON.stringify([
+        String(descriptor.nativeTitle || ''),
+        String(descriptor.nativeSubagentType || ''),
+        Number(descriptor.nativeSubagentDepth) || 0,
+    ]);
+}
+function nativeDescriptorKey(descriptor) {
+    return `${descriptor.harness}\0${descriptor.sourcePath}`;
+}
+export function nativeExternalManagementStatuses(machine, descriptors, managedKeys, observedAt) {
+    return descriptors.map((descriptor) => ({
+        sessionId: stableNativeSessionId(machine, descriptor.harness, descriptor.sourcePath),
+        externallyManaged: managedKeys.has(nativeDescriptorKey(descriptor)),
+        observedAt,
+    }));
+}
+export function nativeTitle(descriptor) {
+    const fallback = path.basename(descriptor.sourcePath.split('#', 1)[0]);
+    const firstLine = String(descriptor.nativeTitle || fallback || `${descriptor.harness} session`)
+        .trim()
+        .split('\n')[0];
+    return firstLine.length > 120 ? `${firstLine.slice(0, 119)}…` : firstLine;
+}
+function nativeTimestamp(raw, descriptor, rowIndex) {
+    try {
+        const timestamp = documentTime(JSON.parse(raw));
+        if (timestamp)
+            return timestamp;
+    }
+    catch { }
+    const base = Date.parse(descriptor.createdAt) || descriptor.mtimeMs || Date.now();
+    return new Date(base + rowIndex).toISOString();
+}
+async function* completeNativeFileLines(file, startOffset, endOffset) {
+    if (endOffset < startOffset)
+        return;
+    let carry = Buffer.alloc(0);
+    let carryOffset = 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);
+                if (newline < 0)
+                    break;
+                let line = buffer.subarray(lineStart, newline);
+                if (line.at(-1) === 0x0d)
+                    line = line.subarray(0, -1);
+                yield {
+                    raw: line.toString('utf8'),
+                    endOffset: bufferOffset + newline + 1,
+                };
+                lineStart = newline + 1;
+            }
+            carry = buffer.subarray(lineStart);
+            carryOffset = bufferOffset + lineStart;
+        }
+    }
+    finally {
+        input.destroy();
+    }
+}
+async function* nativeSourceRecords(descriptor, cursor) {
+    if (descriptor.harness === 'deepseek') {
+        for await (const raw of streamDeepseekTrajectoryLines(descriptor.file)) {
+            yield { raw, endOffset: Number(descriptor.size) || 0 };
+        }
+        return;
+    }
+    if (descriptor.file.endsWith('.json')) {
+        let list = [];
+        try {
+            const parsed = JSON.parse(fs.readFileSync(descriptor.file, 'utf8'));
+            const candidate = Array.isArray(parsed) ? parsed : parsed?.messages || parsed?.conversation || [];
+            if (Array.isArray(candidate))
+                list = candidate;
+        }
+        catch { }
+        for (const value of list) {
+            yield { raw: JSON.stringify(value), endOffset: Number(descriptor.size) || 0 };
+        }
+        return;
+    }
+    yield* completeNativeFileLines(descriptor.file, Number(cursor.offset) || 0, Math.max(-1, (Number(descriptor.size) || 0) - 1));
+}
+/** Stream canonical raw events while retaining only one WebSocket batch. The
+ * mutable cursor is byte-accurate for append-only JSONL stores and lets the
+ * daemon resume at the first unseen source byte instead of reparsing history. */
+export async function* nativeCaptureRowStream(descriptor, cursor = {}) {
+    let rowIndex = Number(cursor.rowCount) || 0;
+    let lineNumber = Number(cursor.lineNumber) || 0;
+    let offset = Number(cursor.offset) || 0;
+    for await (const record of nativeSourceRecords(descriptor, { offset })) {
+        lineNumber += 1;
+        offset = record.endOffset;
+        cursor.offset = offset;
+        cursor.lineNumber = lineNumber;
+        if (!record.raw)
+            continue;
+        const compacted = compactNativeRaw(record.raw);
+        if (descriptor.harness === 'deepseek') {
+            try {
+                const document = JSON.parse(compacted);
+                if (document?.type === 'session/title' && String(document?.data?.title || '').trim()) {
+                    descriptor.nativeTitle = String(document.data.title).trim();
+                }
+            }
+            catch { }
+        }
+        const row = {
+            seq: rowIndex,
+            ts: nativeTimestamp(compacted, descriptor, lineNumber),
+            elapsedMs: rowIndex,
+            runId: 'native',
+            harness: descriptor.harness,
+            kind: 'transcript.line',
+            phase: 'native',
+            path: descriptor.sourcePath,
+            lineNumber,
+            mutation: 'append',
+            source: descriptor.sourcePath.includes('.db#') ? 'sqlite' : 'file',
+            scope: 'root',
+            value: compacted,
+        };
+        rowIndex += 1;
+        cursor.rowCount = rowIndex;
+        yield { row, raw: JSON.stringify(row), endOffset: offset, lineNumber, rowCount: rowIndex };
+    }
+    cursor.offset = offset;
+    cursor.lineNumber = lineNumber;
+    cursor.rowCount = rowIndex;
+}
+// Kept as a small compatibility helper for fixtures and one-shot callers.
+export async function nativeCaptureRows(descriptor) {
+    const rows = [];
+    for await (const capture of nativeCaptureRowStream(descriptor, {}))
+        rows.push(capture.row);
+    return rows;
+}
+export function sessionIdOf(machine, relative, rows, harness) {
+    const runId = String(rows[0]?.runId || path.basename(relative, '.jsonl').split('__')[0] || 'session');
+    const fingerprint = crypto
+        .createHash('sha256')
+        .update(`${machine}\0${relative}\0${runId}\0${harness}`)
+        .digest('hex')
+        .slice(0, 24);
+    return `${harness}-${runId}-${fingerprint}`.slice(0, 240);
+}
+function titleOf(relative) {
+    const firstLine = path.basename(relative, '.jsonl');
+    return firstLine.length > 120 ? `${firstLine.slice(0, 119)}…` : firstLine;
+}
+export class RpcSocket {
+    pending;
+    listeners;
+    closed;
+    resolveClosed;
+    ready;
+    socket;
+    constructor(url, token, devUser = '') {
+        this.pending = new Map();
+        this.listeners = new Set();
+        this.closed = new Promise((resolve) => {
+            this.resolveClosed = resolve;
+        });
+        this.ready = new Promise((resolve, reject) => {
+            const headers = devUser
+                ? { 'x-turns-dev-user': devUser, 'x-turns-dev-role': 'uploader' }
+                : { Authorization: `Bearer ${token}` };
+            this.socket = new WebSocket(url, { headers });
+            this.socket.once('unexpected-response', (_request, response) => {
+                response.resume?.();
+                if (response.statusCode === 401 || response.statusCode === 403) {
+                    reject(authenticationError(`Turns rejected uploader authentication (HTTP ${response.statusCode}).`));
+                }
+                else {
+                    reject(socketError(`Unexpected WebSocket response (HTTP ${response.statusCode}).`));
+                }
+            });
+            this.socket.once('error', (error) => reject(socketError(`WebSocket connection failed: ${error.message}`, error)));
+            this.socket.on('message', (data) => this.onMessage(String(data), resolve, reject));
+            this.socket.on('close', (code, reason) => {
+                const error = socketError(`WebSocket closed (${code}): ${String(reason)}`);
+                for (const request of this.pending.values()) {
+                    clearTimeout(request.timer);
+                    request.reject(error);
+                }
+                this.pending.clear();
+                this.resolveClosed?.({ code, reason: String(reason) });
+            });
+        });
+    }
+    onMessage(raw, resolveReady, rejectReady) {
+        let message;
+        try {
+            message = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if (message.type === 'ready') {
+            if (message.role !== 'uploader')
+                rejectReady(new Error('Endpoint did not grant uploader access.'));
+            else
+                resolveReady(message);
+            return;
+        }
+        if (!message.requestId) {
+            for (const listener of this.listeners)
+                listener(message);
+            return;
+        }
+        const request = this.pending.get(message.requestId);
+        if (!request) {
+            for (const listener of this.listeners)
+                listener(message);
+            return;
+        }
+        this.pending.delete(message.requestId);
+        clearTimeout(request.timer);
+        if (message.type === 'error')
+            request.reject(Object.assign(new Error(message.message), { code: message.code }));
+        else
+            request.resolve(message);
+    }
+    async request(message, timeoutMs = RPC_TIMEOUT_MS) {
+        await this.ready;
+        if (this.socket.readyState !== WebSocket.OPEN)
+            throw socketError('WebSocket is not open.');
+        const id = message.requestId || crypto.randomUUID();
+        const payload = { ...message, requestId: id };
+        const promise = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(Object.assign(new Error(`WebSocket request timed out after ${timeoutMs / 1000} seconds.`), {
+                    code: 'SOCKET_TIMEOUT',
+                }));
+                this.socket.terminate();
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+        });
+        try {
+            this.socket.send(JSON.stringify(payload));
+        }
+        catch (error) {
+            const request = this.pending.get(id);
+            if (request)
+                clearTimeout(request.timer);
+            this.pending.delete(id);
+            throw socketError('WebSocket send failed.', error);
+        }
+        return promise;
+    }
+    notify(message) {
+        if (this.socket.readyState !== WebSocket.OPEN)
+            throw socketError('WebSocket is not open.');
+        this.socket.send(JSON.stringify(message));
+    }
+    onEvent(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    close() {
+        if (this.socket.readyState === WebSocket.OPEN)
+            this.socket.close(1000, 'upload complete');
+        else if (this.socket.readyState === WebSocket.CONNECTING)
+            this.socket.terminate();
+    }
+}
+export async function connectUploader(options, machine, reconnect = false) {
+    let authenticationRecoveries = 0;
+    for (let attempt = 0; attempt <= MAX_SOCKET_RETRIES; attempt += 1) {
+        if (options.credentialProvider) {
+            const credentials = await options.credentialProvider.refreshIfDue();
+            options.token = credentials.accessToken;
+        }
+        const rpc = new RpcSocket(options.url, options.token, options.devUser);
+        try {
+            const ready = await rpc.ready;
+            process.stdout.write(`${reconnect ? 'Reconnected' : 'Connected'} to ${options.url} as @${ready.user.login} ` +
+                `from ${os.hostname()} (${machine})\n`);
+            return rpc;
+        }
+        catch (error) {
+            rpc.close();
+            if (error?.code === 'AUTH_REJECTED' && options.credentialProvider && authenticationRecoveries < 2) {
+                authenticationRecoveries += 1;
+                const credentials = await options.credentialProvider.recover();
+                options.token = credentials.accessToken;
+                process.stderr.write('Uploader authentication was rejected; refreshed credentials.\n');
+                attempt -= 1;
+                continue;
+            }
+            if (!isSocketError(error) || attempt === MAX_SOCKET_RETRIES)
+                throw error;
+            const delay = reconnectDelay(attempt);
+            process.stderr.write(`  WebSocket connection failed: ${error.message}; retrying in ` +
+                `${(delay / 1000).toFixed(1)}s (${attempt + 1}/${MAX_SOCKET_RETRIES})\n`);
+            await wait(delay);
+        }
+    }
+    throw socketError('Could not establish an uploader WebSocket.');
+}
+/** One reconnecting, multiplexed uploader transport for ingestion, queue
+ * control, live rows, ownership, and machine presence. RpcSocket request IDs
+ * already make concurrent calls independent, so separate TCP/WebSocket
+ * connections only duplicate authentication and presence state. */
+export class SharedUploaderConnection {
+    options;
+    machine;
+    connectImpl;
+    rpc;
+    connecting;
+    stopped;
+    hasConnected;
+    listeners;
+    connectListeners;
+    unsubscribeEvents;
+    reconnectTimer;
+    constructor(options, machine, connect = connectUploader) {
+        this.options = options;
+        this.machine = machine;
+        this.connectImpl = connect;
+        this.rpc = null;
+        this.connecting = null;
+        this.stopped = false;
+        this.hasConnected = false;
+        this.listeners = new Set();
+        this.connectListeners = new Set();
+        this.unsubscribeEvents = null;
+        this.reconnectTimer = null;
+    }
+    invalidate(rpc) {
+        if (this.rpc !== rpc)
+            return;
+        this.unsubscribeEvents?.();
+        this.unsubscribeEvents = null;
+        this.rpc = null;
+    }
+    scheduleReconnect() {
+        if (this.stopped || this.reconnectTimer)
+            return;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            void this.current().catch((error) => {
+                process.stderr.write(`Shared uploader reconnect failed: ${error?.message || error}\n`);
+                this.scheduleReconnect();
+            });
+        }, 1_000);
+        this.reconnectTimer.unref?.();
+    }
+    async current() {
+        if (this.stopped)
+            throw socketError('Shared uploader connection is closed.');
+        if (this.rpc)
+            return this.rpc;
+        if (this.connecting)
+            return this.connecting;
+        this.connecting = this.connectImpl(this.options, this.machine, this.hasConnected)
+            .then((rpc) => {
+            if (this.stopped) {
+                rpc.close();
+                throw socketError('Shared uploader connection is closed.');
+            }
+            this.hasConnected = true;
+            this.rpc = rpc;
+            this.unsubscribeEvents = rpc.onEvent((message) => {
+                for (const listener of this.listeners)
+                    listener(message);
+            });
+            void rpc.closed.then(() => {
+                this.invalidate(rpc);
+                this.scheduleReconnect();
+            });
+            for (const listener of this.connectListeners) {
+                queueMicrotask(() => listener(rpc));
+            }
+            return rpc;
+        })
+            .finally(() => {
+            this.connecting = null;
+        });
+        return this.connecting;
+    }
+    async request(message, timeoutMs = RPC_TIMEOUT_MS) {
+        for (let attempt = 0; attempt <= MAX_SOCKET_RETRIES; attempt += 1) {
+            const rpc = await this.current();
+            try {
+                return await rpc.request(message, timeoutMs);
+            }
+            catch (error) {
+                if (!isSocketError(error) || attempt === MAX_SOCKET_RETRIES)
+                    throw error;
+                this.invalidate(rpc);
+                rpc.close();
+                await wait(reconnectDelay(attempt));
+            }
+        }
+        throw socketError('Shared uploader request exhausted its reconnect attempts.');
+    }
+    notify(message) {
+        if (!this.rpc)
+            throw socketError('Shared uploader WebSocket is reconnecting.');
+        this.rpc.notify(message);
+    }
+    onEvent(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    onConnect(listener) {
+        this.connectListeners.add(listener);
+        if (this.rpc)
+            queueMicrotask(() => listener(this.rpc));
+        return () => this.connectListeners.delete(listener);
+    }
+    close() {
+        this.stopped = true;
+        clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+        const rpc = this.rpc;
+        this.invalidate(rpc);
+        rpc?.close();
+    }
+}
+function* batches(rows, raw, startRow, redactor = DEFAULT_REDACTOR) {
+    let heldRows = [];
+    let heldBytes = 0;
+    for (let index = startRow; index < rows.length; index += 1) {
+        const row = rows[index];
+        const sourceLine = raw[index];
+        if (!row || sourceLine === undefined)
+            continue;
+        const line = redactor.redactJsonLine(sourceLine);
+        const bytes = Buffer.byteLength(line) + 1;
+        const event = {
+            index,
+            seq: Number(row.seq) || 0,
+            kind: String(row.kind || 'unknown'),
+            ...(row.phase ? { phase: String(row.phase) } : {}),
+            ...(row.elapsedMs !== undefined ? { elapsedMs: Number(row.elapsedMs) } : {}),
+            ...(row.ts ? { ts: String(row.ts) } : {}),
+            raw: line,
+            bytes,
+        };
+        const estimated = bytes;
+        if (heldRows.length && (heldRows.length >= MAX_BATCH_ROWS || heldBytes + estimated > MAX_BATCH_BYTES)) {
+            yield { startRow: heldRows[0].index, rows: heldRows };
+            heldRows = [];
+            heldBytes = 0;
+        }
+        heldRows.push(event);
+        heldBytes += estimated;
+    }
+    if (heldRows.length)
+        yield { startRow: heldRows[0].index, rows: heldRows };
+}
+async function uploadFile(rpc, machine, root, capture, redactor = DEFAULT_REDACTOR) {
+    const { rows, raw } = completeLines(capture.file);
+    if (!rows.length)
+        return { rows: 0, sent: 0, skipped: true };
+    const harness = harnessOf(capture.relative, rows);
+    const sessionId = sessionIdOf(machine, capture.relative, rows, harness);
+    const opened = await rpc.request({
+        type: 'session.open',
+        session: {
+            sessionId,
+            machineId: machine,
+            machineHostname: os.hostname(),
+            harness,
+            sourcePath: path.join(root, capture.relative),
+            title: redactor.redactText(titleOf(capture.relative)),
+            createdAt: String(rows[0]?.ts || new Date(fs.statSync(capture.file).birthtimeMs).toISOString()),
+            redactionVersion: REDACTION_VERSION,
+        },
+    });
+    if (opened.type === 'session_tombstoned')
+        return { rows: 0, sent: 0, skipped: true, tombstoned: true };
+    let nextRow = Number(opened.nextRow) || 0;
+    if (Number(opened.redactionVersion || 0) !== REDACTION_VERSION) {
+        await rpc.request({ type: 'session.reset', sessionId, redactionVersion: REDACTION_VERSION });
+        nextRow = 0;
+    }
+    if (nextRow > rows.length)
+        throw new Error(`${capture.relative}: remote has ${nextRow} rows, local file has ${rows.length}`);
+    if (nextRow === rows.length)
+        return { rows: rows.length, sent: 0, skipped: true };
+    let sent = 0;
+    for (const batch of batches(rows, raw, nextRow, redactor)) {
+        let acknowledgement;
+        try {
+            acknowledgement = await rpc.request({ type: 'ingest', sessionId, ...batch });
+        }
+        catch (error) {
+            const offset = /^ROW_OFFSET:(\d+)$/u.exec(String(error.code || ''));
+            if (!offset)
+                throw error;
+            nextRow = Number(offset[1]);
+            if (nextRow >= batch.startRow + batch.rows.length)
+                continue;
+            throw error;
+        }
+        nextRow = Number(acknowledgement.nextRow);
+        sent += batch.rows.length;
+        process.stdout.write(`  ${capture.relative}: ${nextRow}/${rows.length} rows · revision ${acknowledgement.revision}${acknowledgement.archived ? ' · archived' : ''}\n`);
+    }
+    return { rows: rows.length, sent, skipped: false };
+}
+function nativeSourceIdentity(file) {
+    try {
+        const stat = fs.statSync(file);
+        return `${stat.dev}:${stat.ino}`;
+    }
+    catch {
+        return '';
+    }
+}
+function canResumeNativeCursor(descriptor, cursor, nextRow) {
+    return Boolean(cursor &&
+        !descriptor.file.endsWith('.json') &&
+        descriptor.harness !== 'deepseek' &&
+        !descriptor.sourcePath.includes('.db#') &&
+        cursor.file === descriptor.file &&
+        cursor.sourceIdentity === nativeSourceIdentity(descriptor.file) &&
+        Number(cursor.rowCount) === nextRow &&
+        Number(cursor.offset) >= 0 &&
+        Number(cursor.offset) <= Number(descriptor.size));
+}
+function gitAssociationForSession(cwd, redactor) {
+    const found = discoverGitAssociation(cwd);
+    if (!found)
+        return null;
+    return {
+        root: found.root,
+        remotes: found.remotes.map((remote) => ({
+            name: remote.name,
+            url: redactor?.redactText ? redactor.redactText(remote.url) : remote.url,
+        })),
+    };
+}
+/**
+ * @param {any} rpc
+ * @param {string} machine
+ * @param {any} descriptor
+ * @param {any} [cursor]
+ * @param {(progress: any) => void} [onProgress]
+ * @param {any} [redactor]
+ * @param {object} [options]
+ * @param {number} [options.maxBatches]
+ * @param {() => boolean} [options.shouldYield]
+ * @param {boolean} [options.recoverRemoteAhead]
+ */
+export async function uploadNativeSession(rpc, machine, descriptor, cursor = {}, onProgress = () => { }, redactor = DEFAULT_REDACTOR, { maxBatches = Number.POSITIVE_INFINITY, shouldYield = () => false, recoverRemoteAhead = true, onPathCandidates = (_sessionId, _workingDirectory, _candidates) => { }, } = {}) {
+    const workingDirectory = await nativeDescriptorWorkingDirectory(descriptor);
+    const agentSessionId = await nativeDescriptorAgentSessionId(descriptor);
+    const git = gitAssociationForSession(workingDirectory, redactor);
+    const sessionId = stableNativeSessionId(machine, descriptor.harness, descriptor.sourcePath);
+    const opened = await rpc.request({
+        type: 'session.open',
+        session: {
+            sessionId,
+            machineId: machine,
+            machineHostname: descriptor.machineHostname || os.hostname(),
+            ...(workingDirectory ? { workingDirectory } : {}),
+            ...(git ? { git } : {}),
+            harness: descriptor.harness,
+            sourcePath: descriptor.sourcePath,
+            title: redactor.redactText(nativeTitle(descriptor)),
+            createdAt: descriptor.createdAt || new Date(descriptor.mtimeMs).toISOString(),
+            redactionVersion: REDACTION_VERSION,
+            ...(descriptor.readOnly === true ? { readOnly: true } : {}),
+            ...(agentSessionId ? { agentSessionId } : {}),
+            ...(descriptor.parentSessionId ? { parentSessionId: descriptor.parentSessionId } : {}),
+        },
+    });
+    if (opened.type === 'session_tombstoned') {
+        return { rows: 0, sent: 0, skipped: true, tombstoned: true };
+    }
+    const uploadSessionId = String(opened.sessionId || sessionId);
+    let nextRow = Number(opened.nextRow) || 0;
+    if (Number(opened.redactionVersion || 0) !== REDACTION_VERSION) {
+        await rpc.request({ type: 'session.reset', sessionId: uploadSessionId, redactionVersion: REDACTION_VERSION });
+        nextRow = 0;
+        for (const key of Object.keys(cursor))
+            delete cursor[key];
+    }
+    const resumable = canResumeNativeCursor(descriptor, cursor, nextRow);
+    const scanCursor = resumable
+        ? { offset: Number(cursor.offset), rowCount: Number(cursor.rowCount), lineNumber: Number(cursor.lineNumber) || 0 }
+        : { offset: 0, rowCount: 0, lineNumber: 0 };
+    const sourceIdentity = nativeSourceIdentity(descriptor.file);
+    let held = [];
+    let heldBytes = 0;
+    let pathMentions = [];
+    let sent = 0;
+    let batchesSent = 0;
+    let sawRows = false;
+    const commitCursor = (capture) => {
+        Object.assign(cursor, {
+            file: descriptor.file,
+            sourceIdentity,
+            offset: capture.endOffset,
+            rowCount: capture.rowCount,
+            lineNumber: capture.lineNumber,
+        });
+    };
+    const flush = async () => {
+        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,
+        });
+        nextRow = Number(acknowledgement.nextRow);
+        sent += rows.length;
+        batchesSent += 1;
+        // Only after the rows are acknowledged: a resolution is appended to the
+        // session's own log and refers to prose in it, so the sentence has to be
+        // stored before what it named is.
+        if (pathMentions.length) {
+            onPathCandidates(uploadSessionId, workingDirectory || '', pathMentions);
+            pathMentions = [];
+        }
+        const last = held.at(-1).capture;
+        if (nextRow >= last.rowCount)
+            commitCursor(last);
+        held = [];
+        heldBytes = 0;
+        onProgress({
+            nextRow,
+            total: Math.max(nextRow, Number(scanCursor.rowCount) || 0),
+            revision: Number(acknowledgement.revision),
+            archived: Boolean(acknowledgement.archived),
+        });
+    };
+    for await (const capture of nativeCaptureRowStream(descriptor, scanCursor)) {
+        sawRows = true;
+        if (capture.rowCount <= nextRow) {
+            commitCursor(capture);
+            continue;
+        }
+        const outboundRaw = redactor.redactJsonLine(capture.raw);
+        for (const candidate of pathCandidates(outboundRaw)) {
+            if (!pathMentions.includes(candidate))
+                pathMentions.push(candidate);
+        }
+        const bytes = Buffer.byteLength(outboundRaw) + 1;
+        if (held.length && (held.length >= MAX_BATCH_ROWS || heldBytes + bytes > MAX_BATCH_BYTES)) {
+            await flush();
+            if (batchesSent >= maxBatches || shouldYield()) {
+                return { rows: nextRow, sent, skipped: false, partial: true };
+            }
+        }
+        held.push({
+            capture,
+            event: {
+                index: capture.row.seq,
+                seq: capture.row.seq,
+                kind: capture.row.kind,
+                phase: capture.row.phase,
+                elapsedMs: capture.row.elapsedMs,
+                ts: capture.row.ts,
+                raw: outboundRaw,
+                bytes,
+            },
+        });
+        heldBytes += bytes;
+    }
+    await flush();
+    if (nextRow > scanCursor.rowCount) {
+        if (recoverRemoteAhead) {
+            // Harnesses such as Grok rewrite their native transcript in place during
+            // compaction. Rewind only the native source cursor: the canonical rows
+            // are an append-only audit log and include runtime events that cannot be
+            // reconstructed from the rewritten file.
+            await rpc.request({
+                type: 'session.native.rewind',
+                sessionId: uploadSessionId,
+                redactionVersion: REDACTION_VERSION,
+            });
+            for (const key of Object.keys(cursor))
+                delete cursor[key];
+            return uploadNativeSession(rpc, machine, descriptor, cursor, onProgress, redactor, {
+                maxBatches,
+                shouldYield,
+                recoverRemoteAhead: false,
+                onPathCandidates,
+            });
+        }
+        const error = /** @type {Error & { code?: string }} */ (new Error(`${descriptor.sourcePath}: remote has ${nextRow} rows, local session has ${scanCursor.rowCount}`));
+        error.code = 'REMOTE_AHEAD';
+        throw error;
+    }
+    if (nextRow === scanCursor.rowCount) {
+        Object.assign(cursor, {
+            file: descriptor.file,
+            sourceIdentity,
+            offset: scanCursor.offset,
+            rowCount: scanCursor.rowCount,
+            lineNumber: scanCursor.lineNumber,
+        });
+    }
+    if (!sawRows && scanCursor.rowCount === 0) {
+        return { rows: 0, sent: 0, skipped: true, empty: true };
+    }
+    return { rows: scanCursor.rowCount, sent, skipped: sent === 0 };
+}
+export function nativeFailureRetryDelay(attempts) {
+    const exponent = Math.max(0, Math.min(16, Math.floor(Number(attempts) || 1) - 1));
+    return Math.min(FAILURE_RETRY_MAX_MS, FAILURE_RETRY_BASE_MS * 2 ** exponent);
+}
+export function createNativeUploadState(file, machine) {
+    let document = { version: NATIVE_STATE_VERSION, machineId: machine, sessions: {} };
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        if (parsed?.version === NATIVE_STATE_VERSION &&
+            parsed.machineId === machine &&
+            parsed.sessions &&
+            typeof parsed.sessions === 'object')
+            document = parsed;
+    }
+    catch { }
+    let timer = null;
+    let dirty = false;
+    const persist = () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = null;
+        if (!dirty)
+            return;
+        dirty = false;
+        fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+        const temporary = `${file}.${process.pid}.tmp`;
+        fs.writeFileSync(temporary, `${JSON.stringify(document)}\n`, { mode: 0o600 });
+        fs.renameSync(temporary, file);
+    };
+    return {
+        get(sessionId) {
+            return document.sessions[sessionId] || null;
+        },
+        isTombstoned(sessionId) {
+            return document.sessions[sessionId]?.tombstoned === true;
+        },
+        tombstone(sessionId) {
+            document.sessions[sessionId] = { tombstoned: true };
+            dirty = true;
+            // A deletion acknowledgement must survive an immediate daemon restart;
+            // delaying this write could resurrect the session during that window.
+            persist();
+        },
+        set(sessionId, fingerprint, cursor, redactionVersion = REDACTION_VERSION) {
+            if (document.sessions[sessionId]?.tombstoned === true)
+                return;
+            document.sessions[sessionId] = { fingerprint, cursor: { ...cursor }, redactionVersion };
+            dirty = true;
+            if (!timer) {
+                timer = setTimeout(persist, 15_000);
+                timer.unref?.();
+            }
+        },
+        retain(sessionIds) {
+            const keep = new Set(sessionIds);
+            let changed = false;
+            for (const sessionId of Object.keys(document.sessions)) {
+                if (keep.has(sessionId) || document.sessions[sessionId]?.tombstoned === true)
+                    continue;
+                delete document.sessions[sessionId];
+                changed = true;
+            }
+            if (changed)
+                dirty = true;
+        },
+        persist,
+        close() {
+            persist();
+        },
+    };
+}
+/** Recursive directory notifications provide low-latency append detection;
+ * callers retain stat polling and periodic discovery as correctness fallbacks. */
+export function watchNativeSessionDirectories({ roots, shallowRoots = [], files = [], onFile, onDirectory }) {
+    const watchers = new Map();
+    const resolvedRoots = roots.map((root) => path.resolve(root));
+    const resolvedShallowRoots = new Set(shallowRoots.map((root) => path.resolve(root)));
+    const recursiveRoots = new Set();
+    const trackedFiles = new Set(files.map((file) => path.resolve(file)));
+    let closed = false;
+    const addDirectory = (directory, recursive = false) => {
+        const resolved = path.resolve(directory);
+        if (closed || watchers.has(resolved))
+            return false;
+        try {
+            const watcher = fs.watch(resolved, { persistent: false, recursive }, (_event, filename) => {
+                if (!filename) {
+                    onDirectory(resolved);
+                    return;
+                }
+                const changed = path.join(resolved, filename.toString());
+                let stat;
+                try {
+                    stat = fs.statSync(changed);
+                }
+                catch { }
+                if (stat?.isDirectory()) {
+                    // Watch the new level immediately. A following inventory refresh
+                    // adds only the descendant directories that actually contain a
+                    // transcript, avoiding tens of thousands of unrelated watchers.
+                    if (!recursive)
+                        addDirectory(changed);
+                    onDirectory(changed);
+                }
+                else {
+                    onFile(changed);
+                }
+            });
+            watcher.on('error', () => {
+                watcher.close();
+                watchers.delete(resolved);
+                if (recursive) {
+                    recursiveRoots.delete(resolved);
+                    addDirectory(resolved);
+                    for (const file of trackedFiles)
+                        addFile(file);
+                }
+            });
+            watchers.set(resolved, watcher);
+            if (recursive)
+                recursiveRoots.add(resolved);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    const addFile = (file) => {
+        let directory = path.dirname(path.resolve(file));
+        const root = resolvedRoots.find((candidate) => directory === candidate || directory.startsWith(`${candidate}${path.sep}`));
+        if (!root)
+            return;
+        if (recursiveRoots.has(root))
+            return;
+        for (;;) {
+            addDirectory(directory);
+            if (directory === root)
+                break;
+            const parent = path.dirname(directory);
+            if (parent === directory)
+                break;
+            directory = parent;
+        }
+    };
+    for (const root of resolvedRoots) {
+        if (resolvedShallowRoots.has(root) || !addDirectory(root, true))
+            addDirectory(root);
+    }
+    for (const file of trackedFiles)
+        addFile(file);
+    return {
+        get count() {
+            return watchers.size;
+        },
+        addFiles(nextFiles) {
+            for (const file of nextFiles) {
+                trackedFiles.add(path.resolve(file));
+                addFile(file);
+            }
+        },
+        close() {
+            closed = true;
+            for (const watcher of watchers.values())
+                watcher.close();
+            watchers.clear();
+        },
+    };
+}
+const nativeWorkingDirectoryCache = new Map();
+export async function filterNativeSessionsByDirectory(sessions, directory, resolveWorkingDirectory = nativeDescriptorWorkingDirectory) {
+    if (!directory)
+        return sessions;
+    const selected = path.resolve(directory);
+    const scoped = [];
+    for (const descriptor of sessions) {
+        const key = `${descriptor.harness}\0${descriptor.sourcePath}`;
+        let workingDirectory = nativeWorkingDirectoryCache.get(key) || '';
+        if (!workingDirectory) {
+            workingDirectory = await resolveWorkingDirectory(descriptor);
+            if (workingDirectory)
+                nativeWorkingDirectoryCache.set(key, workingDirectory);
+        }
+        if (workingDirectory && path.resolve(workingDirectory) === selected)
+            scoped.push(descriptor);
+    }
+    return scoped;
+}
+export async function filterNativeSessionsByAllowedDirectories(sessions, allowedDirectories, resolveWorkingDirectory = nativeDescriptorWorkingDirectory) {
+    if (!allowedDirectories?.length)
+        return sessions;
+    const scoped = [];
+    for (const descriptor of sessions) {
+        const key = `${descriptor.harness}\0${descriptor.sourcePath}`;
+        let workingDirectory = nativeWorkingDirectoryCache.get(key) || '';
+        if (!workingDirectory) {
+            workingDirectory = await resolveWorkingDirectory(descriptor);
+            if (workingDirectory)
+                nativeWorkingDirectoryCache.set(key, workingDirectory);
+        }
+        if (workingDirectoryIsAllowed(workingDirectory, allowedDirectories))
+            scoped.push(descriptor);
+    }
+    return scoped;
+}
+async function nativeInventory(options, machine) {
+    let sessions = linkNativeSessionParents(machine, discoverLocalSessions(options.rewriteSession ? '' : options.only));
+    sessions = await filterNativeSessionsByDirectory(sessions, options.directory);
+    sessions = await filterNativeSessionsByAllowedDirectories(sessions, options.allowedDirectories);
+    if (!options.rewriteSession)
+        return sessions;
+    const exact = sessions.filter((descriptor) => stableNativeSessionId(machine, descriptor.harness, descriptor.sourcePath) === options.rewriteSession);
+    if (exact.length !== 1) {
+        throw new Error(`--rewrite-session matched ${exact.length} local sessions; expected exactly one.`);
+    }
+    return exact;
+}
+async function reportExternalManagement(rpc, machine, descriptors, previous = new Map()) {
+    let managedKeys;
+    try {
+        managedKeys = externallyManagedNativeDescriptorKeys(descriptors);
+    }
+    catch (error) {
+        process.stderr.write(`External ownership scan failed: ${error?.message || error}\n`);
+        return { rpc, managed: null };
+    }
+    const observedAt = new Date().toISOString();
+    const allStatuses = nativeExternalManagementStatuses(machine, descriptors, managedKeys, observedAt);
+    // Positive leases must be renewed. False values are sent once for newly
+    // discovered sessions and once on a true -> false transition; continuously
+    // retransmitting thousands of unchanged false rows only burns CPU/network.
+    const statuses = allStatuses.filter((status) => status.externallyManaged || previous.get(status.sessionId) !== false);
+    for (let start = 0; start < statuses.length; start += MAX_EXTERNAL_STATUS_BATCH) {
+        const batch = statuses.slice(start, start + MAX_EXTERNAL_STATUS_BATCH);
+        try {
+            await rpc.request({
+                type: 'session.external.update',
+                watcherId: machine,
+                statuses: batch,
+            });
+        }
+        catch (error) {
+            process.stderr.write(`External ownership upload failed: ${error?.message || error}\n`);
+            return { managed: null, previous };
+        }
+    }
+    for (const status of allStatuses)
+        previous.set(status.sessionId, status.externallyManaged);
+    return { managed: managedKeys.size, previous };
+}
+async function watchExternalManagement(rpc, machine, getDescriptors) {
+    let lastManagedCount = -1;
+    let previous = new Map();
+    for (;;) {
+        try {
+            const reported = await reportExternalManagement(rpc, machine, getDescriptors(), previous);
+            previous = reported.previous;
+            if (reported.managed !== null && reported.managed !== lastManagedCount) {
+                lastManagedCount = reported.managed;
+                process.stdout.write(`External ownership: ${reported.managed} managed session${reported.managed === 1 ? '' : 's'}\n`);
+            }
+        }
+        catch (error) {
+            process.stderr.write(`External ownership watcher failed: ${error?.message || error}\n`);
+        }
+        await wait(NATIVE_WATCH_INTERVAL_MS);
+    }
+}
+export function nativeUploadProgressSnapshot({ machine, descriptors, seen, fingerprints, cursors, redactionPending, rewritePending, tombstoned = new Set(), }) {
+    let totalBytes = 0;
+    let completedBytes = 0;
+    let remainingSessions = 0;
+    let totalSessions = 0;
+    for (const descriptor of descriptors) {
+        const sessionId = stableNativeSessionId(machine, descriptor.harness, descriptor.sourcePath);
+        if (tombstoned.has(sessionId))
+            continue;
+        totalSessions += 1;
+        const size = Math.max(0, Math.floor(Number(descriptor.size) || 0));
+        totalBytes += size;
+        const pending = rewritePending.has(sessionId) ||
+            redactionPending.has(sessionId) ||
+            seen.get(sessionId) !== fingerprints.get(sessionId);
+        if (!pending) {
+            completedBytes += size;
+            continue;
+        }
+        remainingSessions += 1;
+        const cursor = cursors.get(sessionId);
+        if (cursor?.file === descriptor.file) {
+            completedBytes += Math.max(0, Math.min(size, Math.floor(Number(cursor.offset) || 0)));
+        }
+    }
+    const safe = (value) => Math.min(Number.MAX_SAFE_INTEGER, Math.max(0, Math.floor(value)));
+    return {
+        totalSessions,
+        remainingSessions,
+        totalBytes: safe(totalBytes),
+        completedBytes: safe(Math.min(totalBytes, completedBytes)),
+    };
+}
+async function uploadNative(options, machine, redactor = DEFAULT_REDACTOR) {
+    let initialSessions = await nativeInventory(options, machine);
+    const descriptorRegistry = { sessions: initialSessions };
+    const byHarness = new Map();
+    for (const session of initialSessions)
+        byHarness.set(session.harness, (byHarness.get(session.harness) || 0) + 1);
+    process.stdout.write(`Native inventory: ${initialSessions.length} sessions across ${byHarness.size} harnesses\n`);
+    for (const [harness, count] of [...byHarness].sort())
+        process.stdout.write(`  ${harness}: ${count}\n`);
+    if (options.dryRun)
+        return;
+    const state = createNativeUploadState(options.nativeStateFile, machine);
+    const seen = new Map();
+    const cursors = new Map();
+    const fingerprints = new Map();
+    const descriptorBySession = new Map();
+    const sessionByFile = new Map();
+    const physicalStats = new Map();
+    const redactionPending = new Set();
+    const redactionStarted = new Set();
+    const livePriority = new Set();
+    const tombstoned = new Set();
+    let nativeMonitor = null;
+    const rememberInventory = (sessions, retainState = false, forceMetadataDirectories = new Set()) => {
+        const previousFingerprints = new Map(fingerprints);
+        descriptorBySession.clear();
+        sessionByFile.clear();
+        fingerprints.clear();
+        physicalStats.clear();
+        for (const descriptor of sessions) {
+            const sessionId = stableNativeSessionId(machine, descriptor.harness, descriptor.sourcePath);
+            descriptorBySession.set(sessionId, descriptor);
+            sessionByFile.set(path.resolve(descriptor.file), sessionId);
+            try {
+                const stat = fs.statSync(descriptor.file);
+                physicalStats.set(sessionId, { size: stat.size, mtimeMs: stat.mtimeMs });
+            }
+            catch { }
+            const saved = state.get(sessionId);
+            const previousFingerprint = previousFingerprints.get(sessionId) || String(saved?.fingerprint || '');
+            let fingerprint = '';
+            try {
+                const previous = JSON.parse(previousFingerprint);
+                const metadataForced = forceMetadataDirectories.has(path.dirname(path.resolve(descriptor.file)));
+                if (!metadataForced &&
+                    Number(previous?.[0]) === Number(descriptor.size) &&
+                    Number(previous?.[1]) === Number(descriptor.mtimeMs) &&
+                    String(previous?.[3] || '') === String(descriptor.parentSessionId || '') &&
+                    Number(previous?.[4]) === NATIVE_DESCRIPTOR_VERSION &&
+                    String(previous?.[5] || '') === nativeDescriptorMetadataFingerprint(descriptor)) {
+                    fingerprint = previousFingerprint;
+                }
+            }
+            catch { }
+            fingerprints.set(sessionId, fingerprint || nativeDescriptorFingerprint(descriptor));
+            if (saved?.tombstoned === true) {
+                tombstoned.add(sessionId);
+                continue;
+            }
+            const redactionCurrent = Number(saved?.redactionVersion || 0) === REDACTION_VERSION;
+            if (saved && redactionCurrent && !seen.has(sessionId)) {
+                seen.set(sessionId, String(saved.fingerprint || ''));
+            }
+            if (saved?.cursor && redactionCurrent && !cursors.has(sessionId)) {
+                cursors.set(sessionId, { ...saved.cursor });
+            }
+            if (saved && !redactionCurrent) {
+                redactionPending.add(sessionId);
+                // A stale-version session is urgent at startup only when its source is
+                // genuinely recent. Fingerprints can differ for old metadata/schema
+                // reasons and must not promote the entire historical fleet.
+                if (Date.now() - Number(descriptor.mtimeMs || 0) <= RECENT_SESSION_PRIORITY_MS) {
+                    livePriority.add(sessionId);
+                }
+            }
+            else if (saved && redactionCurrent && !saved.fingerprint) {
+                // An interrupted replay stores a current version with an empty
+                // fingerprint. Resume it cooperatively rather than treating it as an
+                // ordinary live append after a daemon restart.
+                redactionPending.add(sessionId);
+                redactionStarted.add(sessionId);
+            }
+        }
+        if (retainState && !options.only && !options.rewriteSession)
+            state.retain(descriptorBySession.keys());
+        descriptorRegistry.sessions = sessions;
+        nativeMonitor?.addFiles(sessions.map((descriptor) => descriptor.file));
+    };
+    rememberInventory(initialSessions);
+    // A single request-id-multiplexed transport carries ingestion, ownership,
+    // queue control, and live rows. These tasks remain concurrent without
+    // duplicating authentication or machine-presence sockets.
+    let rpc = options.watch ? new SharedUploaderConnection(options, machine) : await connectUploader(options, machine);
+    // Only the shared connection has a `current()` handle, and only the watch path builds one.
+    // Only the shared connection has a `current()` handle, and only the watch path builds one.
+    if (options.watch)
+        await rpc.current();
+    if (options.watch)
+        void watchExternalManagement(rpc, machine, () => descriptorRegistry.sessions);
+    // Paths an agent wrote about are resolved from the rows themselves and
+    // recorded on the session's own log, in both the one-shot and watching
+    // uploaders: a session uploaded once and never revisited still says what its
+    // prose referred to.
+    const resolvedPaths = createPathResolver({
+        options,
+        machine,
+        baseUrl: httpBaseUrl(options.url),
+        redactor,
+        appendResolutions: async (sessionId, resolutions) => {
+            // Resolutions are ordinary rows in the session's log, written the way the
+            // anchor writes its own: one request per bounded batch.
+            for (let start = 0; start < resolutions.length; start += MAX_RUNTIME_EVENT_BATCH) {
+                await rpc.request({
+                    type: 'session.runtime.append',
+                    sessionId,
+                    events: resolutions.slice(start, start + MAX_RUNTIME_EVENT_BATCH).map((resolution) => ({
+                        // Keyed by what it resolved, so replaying a rewritten transcript
+                        // records the same substring once.
+                        eventKey: `path:${resolution.text}`.slice(0, 400),
+                        kind: 'session.path_resolution',
+                        value: JSON.stringify({ paths: [resolution] }),
+                    })),
+                });
+            }
+        },
+    });
+    if (options.watch) {
+        void watchQueuedPrompts({
+            rpc,
+            options,
+            machine,
+            getDescriptors: () => descriptorRegistry.sessions,
+            stableSessionId: stableNativeSessionId,
+            redactor,
+        }).catch((error) => {
+            process.stderr.write(`Queue worker stopped unexpectedly: ${error?.stack || error}\n`);
+        });
+    }
+    const totals = { current: 0, uploaded: 0, rows: 0, empty: 0, failed: 0 };
+    const failures = new Map();
+    const rewritePending = new Set(options.rewriteSession ? [options.rewriteSession] : []);
+    let uploadProgressTimer = null;
+    let lastUploadProgress = '';
+    let uploadProgressError = '';
+    const reportUploadProgress = async (force = false) => {
+        const progress = nativeUploadProgressSnapshot({
+            machine,
+            descriptors: descriptorRegistry.sessions,
+            seen,
+            fingerprints,
+            cursors,
+            redactionPending,
+            rewritePending,
+            tombstoned,
+        });
+        const signature = JSON.stringify(progress);
+        if (!force && signature === lastUploadProgress)
+            return;
+        lastUploadProgress = signature;
+        try {
+            await rpc.request({
+                type: 'machine.upload_progress',
+                machineId: machine,
+                ...progress,
+            });
+            uploadProgressError = '';
+        }
+        catch (error) {
+            lastUploadProgress = '';
+            const message = error?.message || String(error);
+            if (message !== uploadProgressError) {
+                uploadProgressError = message;
+                process.stderr.write(`Upload progress report failed: ${message}\n`);
+            }
+        }
+    };
+    const scheduleUploadProgress = () => {
+        if (uploadProgressTimer)
+            return;
+        uploadProgressTimer = setTimeout(() => {
+            uploadProgressTimer = null;
+            void reportUploadProgress();
+        }, 500);
+        uploadProgressTimer.unref?.();
+    };
+    if (rpc instanceof SharedUploaderConnection) {
+        rpc.onConnect(() => {
+            lastUploadProgress = '';
+            scheduleUploadProgress();
+        });
+    }
+    rpc.onEvent((message) => {
+        if (message.type !== 'session_tombstoned' || !message.sessionId)
+            return;
+        resolvedPaths.forget(message.sessionId);
+        tombstoned.add(message.sessionId);
+        redactionPending.delete(message.sessionId);
+        redactionStarted.delete(message.sessionId);
+        rewritePending.delete(message.sessionId);
+        livePriority.delete(message.sessionId);
+        failures.delete(message.sessionId);
+        state.tombstone(message.sessionId);
+        scheduleUploadProgress();
+    });
+    await reportUploadProgress(true);
+    /**
+     * @param {any[]} changed
+     * @param {object} [options]
+     * @param {(sessionId: string) => number} [options.batchLimitFor]
+     * @param {(sessionId: string) => boolean} [options.shouldYieldFor]
+     */
+    const processChanged = async (changed, { batchLimitFor = (_sessionId) => Number.POSITIVE_INFINITY, shouldYieldFor = (_sessionId) => false, } = {}) => {
+        for (const [index, descriptor] of changed.entries()) {
+            const sessionId = stableNativeSessionId(machine, descriptor.harness, descriptor.sourcePath);
+            const fingerprint = fingerprints.get(sessionId) || nativeDescriptorFingerprint(descriptor);
+            let cursor = cursors.get(sessionId);
+            if (!cursor) {
+                cursor = {};
+                cursors.set(sessionId, cursor);
+            }
+            let result;
+            let failure;
+            for (let attempt = 0; attempt <= MAX_SOCKET_RETRIES; attempt += 1) {
+                try {
+                    if (rewritePending.has(sessionId) || (redactionPending.has(sessionId) && !redactionStarted.has(sessionId))) {
+                        const redactionUpgrade = redactionPending.has(sessionId);
+                        await rpc.request({ type: 'session.reset', sessionId, redactionVersion: REDACTION_VERSION });
+                        resolvedPaths.forget(sessionId);
+                        rewritePending.delete(sessionId);
+                        if (redactionUpgrade)
+                            redactionStarted.add(sessionId);
+                        cursor = {};
+                        cursors.set(sessionId, cursor);
+                        seen.delete(sessionId);
+                        process.stdout.write(`  ${descriptor.harness} ${descriptor.sourcePath}: reset for ${redactionUpgrade ? 'secret-filtered' : 'full'} replay\n`);
+                    }
+                    result = await uploadNativeSession(rpc, machine, descriptor, cursor, (progress) => {
+                        // Persist an explicitly incomplete fingerprint while a long replay
+                        // is in flight. A daemon restart can resume from this byte cursor,
+                        // but the empty fingerprint still schedules the unfinished tail.
+                        state.set(sessionId, '', cursor, REDACTION_VERSION);
+                        scheduleUploadProgress();
+                        process.stdout.write(`  ${index + 1}/${changed.length} ${descriptor.harness}: ` +
+                            `${progress.nextRow}/${progress.total} rows` +
+                            `${progress.archived ? ' · archived' : ''}\n`);
+                    }, redactor, {
+                        maxBatches: batchLimitFor(sessionId),
+                        shouldYield: () => shouldYieldFor(sessionId),
+                        onPathCandidates: (uploadSessionId, workingDirectory, candidates) => {
+                            void resolvedPaths.enqueue(uploadSessionId, workingDirectory, candidates);
+                        },
+                    });
+                    break;
+                }
+                catch (error) {
+                    if (!isSocketError(error) || attempt === MAX_SOCKET_RETRIES) {
+                        failure = error;
+                        break;
+                    }
+                    if (rpc instanceof SharedUploaderConnection) {
+                        // The shared transport already performed bounded reconnection for
+                        // every concurrent consumer. Leave this session pending for the
+                        // next scheduler sweep rather than replacing the shared object.
+                        failure = error;
+                        break;
+                    }
+                    process.stderr.write(`  ${index + 1}/${changed.length} ${descriptor.harness}: ${error.message}; ` +
+                        `reconnecting (${attempt + 1}/${MAX_SOCKET_RETRIES})\n`);
+                    rpc.close();
+                    await wait(reconnectDelay(attempt));
+                    rpc = await connectUploader(options, machine, true);
+                }
+            }
+            if (!failure && result) {
+                if (result.tombstoned) {
+                    tombstoned.add(sessionId);
+                    redactionPending.delete(sessionId);
+                    redactionStarted.delete(sessionId);
+                    rewritePending.delete(sessionId);
+                    livePriority.delete(sessionId);
+                    failures.delete(sessionId);
+                    state.tombstone(sessionId);
+                    totals.current += 1;
+                    process.stdout.write(`  ${index + 1}/${changed.length} ${descriptor.harness}: deleted on turns.dev\n`);
+                    scheduleUploadProgress();
+                    continue;
+                }
+                if (result.partial) {
+                    state.set(sessionId, '', cursor, REDACTION_VERSION);
+                    totals.rows += result.sent;
+                    scheduleUploadProgress();
+                    continue;
+                }
+                seen.set(sessionId, fingerprint);
+                state.set(sessionId, fingerprint, cursor, REDACTION_VERSION);
+                redactionPending.delete(sessionId);
+                redactionStarted.delete(sessionId);
+                livePriority.delete(sessionId);
+                failures.delete(sessionId);
+                if (result.empty)
+                    totals.empty += 1;
+                else if (result.skipped)
+                    totals.current += 1;
+                else {
+                    totals.uploaded += 1;
+                    totals.rows += result.sent;
+                }
+                if (!result.skipped || (index + 1) % 50 === 0 || index + 1 === changed.length) {
+                    process.stdout.write(`  ${index + 1}/${changed.length} ${descriptor.harness} ${descriptor.sourcePath}: ` +
+                        `${result.empty ? 'no conversation rows' : result.skipped ? `current (${result.rows} rows)` : `${result.sent} rows uploaded`}\n`);
+                }
+                scheduleUploadProgress();
+            }
+            else {
+                const error = failure || new Error('Upload ended without a result.');
+                const attempts = Number(failures.get(sessionId)?.attempts || 0) + 1;
+                failures.set(sessionId, {
+                    harness: descriptor.harness,
+                    sourcePath: descriptor.sourcePath,
+                    error: error?.message || String(error),
+                    attempts,
+                    retryAt: Date.now() + nativeFailureRetryDelay(attempts),
+                });
+                process.stderr.write(`  ${index + 1}/${changed.length} ${descriptor.harness} ${descriptor.sourcePath}: ${error?.message || error}\n`);
+                scheduleUploadProgress();
+            }
+        }
+    };
+    const changedSessions = () => descriptorRegistry.sessions.filter((descriptor) => {
+        const sessionId = stableNativeSessionId(machine, descriptor.harness, descriptor.sourcePath);
+        if (tombstoned.has(sessionId))
+            return false;
+        return (rewritePending.has(sessionId) ||
+            redactionPending.has(sessionId) ||
+            seen.get(sessionId) !== fingerprints.get(sessionId));
+    });
+    if (!options.watch) {
+        let settlePass = 0;
+        for (;;) {
+            const changed = changedSessions();
+            await processChanged(changed);
+            if (!changed.length)
+                break;
+            settlePass += 1;
+            if (settlePass >= MAX_NATIVE_SETTLE_PASSES) {
+                const sessions = await nativeInventory(options, machine);
+                rememberInventory(sessions);
+                const unsettled = changedSessions();
+                if (unsettled.length) {
+                    process.stderr.write(`${unsettled.length} native sessions kept changing; use --watch to follow them continuously.\n`);
+                }
+                break;
+            }
+            await wait(250);
+            const sessions = await nativeInventory(options, machine);
+            rememberInventory(sessions);
+        }
+        state.close();
+        if (uploadProgressTimer) {
+            clearTimeout(uploadProgressTimer);
+            uploadProgressTimer = null;
+        }
+        await reportUploadProgress(true);
+        rpc.close();
+        totals.failed = failures.size;
+        process.stdout.write(`Native upload complete: ${JSON.stringify(totals)}\n`);
+        if (failures.size) {
+            process.stderr.write(`${JSON.stringify({ failures: [...failures.values()] }, null, 2)}\n`);
+            process.exitCode = 1;
+        }
+        return;
+    }
+    let wake = null;
+    let sweepPending = true;
+    let discoveryPending = false;
+    let discoveryDebounce = null;
+    const pendingMetadataDirectories = new Set();
+    const fileDebounces = new Map();
+    const requestSweep = () => {
+        sweepPending = true;
+        if (wake) {
+            const resolve = wake;
+            wake = null;
+            resolve();
+        }
+    };
+    const waitForSweep = () => sweepPending
+        ? Promise.resolve()
+        : new Promise((resolve) => {
+            wake = resolve;
+        });
+    const waitForSweepOrTimeout = (milliseconds) => sweepPending
+        ? Promise.resolve()
+        : new Promise((resolve) => {
+            let timer;
+            const resume = () => {
+                clearTimeout(timer);
+                if (wake === resume)
+                    wake = null;
+                resolve();
+            };
+            timer = setTimeout(resume, milliseconds);
+            timer.unref?.();
+            wake = resume;
+        });
+    const scheduleDiscovery = (changedPath) => {
+        if (changedPath)
+            pendingMetadataDirectories.add(path.dirname(path.resolve(changedPath)));
+        if (discoveryDebounce)
+            return;
+        discoveryDebounce = setTimeout(() => {
+            discoveryDebounce = null;
+            discoveryPending = true;
+            requestSweep();
+        }, NATIVE_DISCOVERY_DEBOUNCE_MS);
+        discoveryDebounce.unref?.();
+    };
+    const refreshDescriptor = (sessionId) => {
+        const descriptor = descriptorBySession.get(sessionId);
+        if (!descriptor)
+            return;
+        let stat;
+        try {
+            stat = fs.statSync(descriptor.file);
+        }
+        catch {
+            return;
+        }
+        if (!stat.isFile())
+            return;
+        const previous = physicalStats.get(sessionId);
+        if (previous && stat.size === previous.size && stat.mtimeMs === previous.mtimeMs)
+            return;
+        physicalStats.set(sessionId, { size: stat.size, mtimeMs: stat.mtimeMs });
+        failures.delete(sessionId);
+        descriptor.size = stat.size;
+        descriptor.mtimeMs = stat.mtimeMs;
+        let fingerprint = '';
+        try {
+            const previousFingerprint = JSON.parse(fingerprints.get(sessionId) || 'null');
+            const workingDirectory = String(previousFingerprint?.[2] || '');
+            if (workingDirectory) {
+                fingerprint = JSON.stringify([
+                    stat.size,
+                    stat.mtimeMs,
+                    workingDirectory,
+                    String(descriptor.parentSessionId || ''),
+                    NATIVE_DESCRIPTOR_VERSION,
+                    String(previousFingerprint?.[5] || nativeDescriptorMetadataFingerprint(descriptor)),
+                ]);
+            }
+        }
+        catch { }
+        // Once discovered, cwd is immutable for a native session. Sessions whose
+        // cwd has not appeared yet retain the bounded metadata probe on append.
+        fingerprints.set(sessionId, fingerprint || nativeDescriptorFingerprint(descriptor));
+        livePriority.add(sessionId);
+        requestSweep();
+    };
+    const refreshDescriptorFile = (changedFile) => {
+        const sessionId = sessionByFile.get(path.resolve(changedFile));
+        if (!sessionId) {
+            scheduleDiscovery(changedFile);
+            return;
+        }
+        if (fileDebounces.has(sessionId))
+            return;
+        const timer = setTimeout(() => {
+            fileDebounces.delete(sessionId);
+            refreshDescriptor(sessionId);
+        }, NATIVE_CHANGE_DEBOUNCE_MS);
+        timer.unref?.();
+        fileDebounces.set(sessionId, timer);
+    };
+    nativeMonitor = watchNativeSessionDirectories({
+        roots: nativeSessionWatchRoots(),
+        shallowRoots: nativeSessionShallowWatchRoots(),
+        files: descriptorRegistry.sessions.map((descriptor) => descriptor.file),
+        onFile: refreshDescriptorFile,
+        onDirectory: (directory) => scheduleDiscovery(path.join(directory, '.directory')),
+    });
+    const pollTimer = setInterval(() => {
+        for (const descriptor of descriptorRegistry.sessions) {
+            // Database projections are refreshed from their authoritative store by
+            // discovery. Polling the projection's synthetic mtime is misleading.
+            if (descriptor.sourcePath.includes('.db#'))
+                continue;
+            const sessionId = stableNativeSessionId(machine, descriptor.harness, descriptor.sourcePath);
+            refreshDescriptor(sessionId);
+        }
+    }, NATIVE_POLL_INTERVAL_MS);
+    pollTimer.unref?.();
+    const discoveryTimer = setInterval(() => {
+        discoveryPending = true;
+        requestSweep();
+    }, NATIVE_DISCOVERY_INTERVAL_MS);
+    discoveryTimer.unref?.();
+    const shutdown = () => {
+        state.close();
+        nativeMonitor.close();
+        clearInterval(pollTimer);
+        clearInterval(discoveryTimer);
+    };
+    process.once('SIGTERM', () => {
+        shutdown();
+        process.exit(0);
+    });
+    process.once('SIGINT', () => {
+        shutdown();
+        process.exit(0);
+    });
+    process.stdout.write(`Watching ${initialSessions.length} native sessions via ${nativeMonitor.count} directories; ` +
+        `polling known files every ${NATIVE_POLL_INTERVAL_MS / 1000}s and auditing every ` +
+        `${NATIVE_DISCOVERY_INTERVAL_MS / 1000}s…\n`);
+    let historicalSessionId = '';
+    for (;;) {
+        await waitForSweep();
+        sweepPending = false;
+        if (discoveryPending) {
+            discoveryPending = false;
+            try {
+                initialSessions = await nativeInventory(options, machine);
+                const forceMetadataDirectories = new Set(pendingMetadataDirectories);
+                pendingMetadataDirectories.clear();
+                rememberInventory(initialSessions, true, forceMetadataDirectories);
+                scheduleUploadProgress();
+            }
+            catch (error) {
+                process.stderr.write(`Native inventory refresh failed: ${error?.message || error}\n`);
+            }
+        }
+        const changed = changedSessions();
+        const active = changed
+            .filter((descriptor) => {
+            const sessionId = stableNativeSessionId(machine, descriptor.harness, descriptor.sourcePath);
+            if (Number(failures.get(sessionId)?.retryAt || 0) > Date.now())
+                return false;
+            return rewritePending.has(sessionId) || livePriority.has(sessionId) || !redactionPending.has(sessionId);
+        })
+            .sort((left, right) => Number(right.mtimeMs || 0) - Number(left.mtimeMs || 0));
+        let processed;
+        if (active.length) {
+            processed = active;
+            await processChanged(active, {
+                batchLimitFor: (sessionId) => redactionPending.has(sessionId) ? ACTIVE_REPLAY_BATCHES_PER_SLICE : Number.POSITIVE_INFINITY,
+                shouldYieldFor: (sessionId) => [...livePriority].some((other) => other !== sessionId),
+            });
+        }
+        else {
+            const historical = changed.filter((descriptor) => {
+                const sessionId = stableNativeSessionId(machine, descriptor.harness, descriptor.sourcePath);
+                return redactionPending.has(sessionId) && Number(failures.get(sessionId)?.retryAt || 0) <= Date.now();
+            });
+            let descriptor = historical.find((candidate) => stableNativeSessionId(machine, candidate.harness, candidate.sourcePath) === historicalSessionId);
+            if (!descriptor)
+                descriptor = historical[0];
+            processed = descriptor ? [descriptor] : [];
+            if (descriptor) {
+                historicalSessionId = stableNativeSessionId(machine, descriptor.harness, descriptor.sourcePath);
+                await processChanged([descriptor], {
+                    batchLimitFor: () => HISTORICAL_REPLAY_BATCHES_PER_SLICE,
+                    shouldYieldFor: () => livePriority.size > 0,
+                });
+                if (!redactionPending.has(historicalSessionId))
+                    historicalSessionId = '';
+            }
+        }
+        // A file may grow while its upload is in flight. Refresh only those files;
+        // filesystem events normally already did this, and the stat is a cheap
+        // correctness fallback.
+        for (const descriptor of processed)
+            refreshDescriptorFile(descriptor.file);
+        if (changedSessions().length) {
+            // The backfill delay is interruptible: a filesystem event sets
+            // sweepPending and wakes this promise immediately, so active sessions do
+            // not inherit the deliberately slow historical cadence.
+            if (!active.length)
+                await waitForSweepOrTimeout(HISTORICAL_REPLAY_DELAY_MS);
+            requestSweep();
+        }
+    }
+}
+export async function runUploader(argv = process.argv.slice(2), { credentialProvider = null } = {}) {
+    const options = argumentsFrom(argv, { allowMissingToken: Boolean(credentialProvider) });
+    options.credentialProvider = credentialProvider;
+    const initialCredentials = credentialProvider ? await credentialProvider.refreshIfDue() : null;
+    if (initialCredentials?.accessToken)
+        options.token = initialCredentials.accessToken;
+    if (!options.dryRun && !options.token && !options.devUser) {
+        throw new Error('Turns authentication did not provide an access token or local DEV_USER.');
+    }
+    const machine = machineId(options.machineIdFile);
+    const filtering = reportingRedactor([options.token, initialCredentials?.refreshToken]);
+    const unsubscribeCredentials = credentialProvider?.onUpdate?.((credentials) => {
+        options.token = credentials.accessToken;
+        filtering.redactor.addLiterals([credentials.accessToken, credentials.refreshToken]);
+    });
+    try {
+        if (options.native) {
+            await uploadNative(options, machine, filtering.redactor);
+            return;
+        }
+        const rpc = await connectUploader(options, machine);
+        const seen = new Map();
+        const sweep = async () => {
+            for (const capture of discover(options.runs, options.only)) {
+                const stat = fs.statSync(capture.file);
+                const fingerprint = `${stat.size}:${stat.mtimeMs}`;
+                if (seen.get(capture.file) === fingerprint)
+                    continue;
+                const result = await uploadFile(rpc, machine, options.runs, capture, filtering.redactor);
+                seen.set(capture.file, fingerprint);
+                if (result.skipped)
+                    process.stdout.write(`  ${capture.relative}: current (${result.rows} rows)\n`);
+            }
+        };
+        await sweep();
+        if (!options.watch) {
+            rpc.close();
+            return;
+        }
+        process.stdout.write('Watching for appended capture rows…\n');
+        for (;;) {
+            await new Promise((resolve) => setTimeout(resolve, 2_000));
+            await sweep();
+        }
+    }
+    finally {
+        unsubscribeCredentials?.();
+        filtering.close();
+    }
+}
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    runUploader().catch((error) => {
+        process.stderr.write(`${error?.stack || error}\n`);
+        process.exitCode = 1;
+    });
+}