@turns/dev 0.0.1

package/dist/agent-anchor.js

@@ -0,0 +1,1685 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import readline from 'node:readline';
+import { DatabaseSync } from 'node:sqlite';
+import { fileURLToPath } from 'node:url';
+import { WebSocket } from 'ws';
+import { ACP_PROFILES, PROCESS_HARNESSES, processEventSessionId, processInvocation, RPC_PROFILES, resolveHarnessCommand, rpcFrameSessionIdentity, rpcUiRequestIsInformational, } from "./harness-registry.js";
+const socketIndex = process.argv.indexOf('--socket');
+const socketPath = socketIndex >= 0 ? path.resolve(process.argv[socketIndex + 1] || '') : '';
+if (!socketPath)
+    throw new Error('--socket <path> is required');
+const questionMcpPath = path.join(import.meta.dirname, `question-mcp${path.extname(fileURLToPath(import.meta.url))}`);
+const MAX_EVENTS = 2_000;
+const MAX_EVENT_BYTES = 8 * 1024 * 1024;
+const now = () => new Date().toISOString();
+const pause = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+const errorText = (error) => error?.message || String(error);
+const PERMISSION_MODES = new Set(['auto', 'default', 'acceptEdits', 'plan', 'bypassPermissions']);
+function recordHermesWorkingDirectory(sessionId, cwd) {
+    if (!sessionId || !path.isAbsolute(cwd || ''))
+        return;
+    const file = path.join(process.env.HERMES_HOME || path.join(process.env.HOME || '', '.hermes'), 'state.db');
+    try {
+        const database = new DatabaseSync(file);
+        try {
+            database.prepare("UPDATE sessions SET cwd = ? WHERE id = ? AND (cwd IS NULL OR cwd = '')").run(cwd, sessionId);
+        }
+        finally {
+            database.close();
+        }
+    }
+    catch (error) {
+        // Session operation still succeeds if an older Hermes schema lacks the
+        // column; native discovery will simply omit that transcript as before.
+        process.stderr.write(`Hermes cwd promotion failed: ${errorText(error)}\n`);
+    }
+}
+function requestedPermissionMode(value) {
+    if (value === undefined || value === null || value === '')
+        return 'bypassPermissions';
+    if (!PERMISSION_MODES.has(value))
+        throw new Error(`Invalid permission mode: ${String(value)}`);
+    return value;
+}
+/**
+ * The Promise executor runs synchronously, so both handles are assigned before
+ * this returns. The annotations state that guarantee, which the checker cannot
+ * infer from the assignments alone.
+ * @returns {{ promise: Promise<any>, resolve: (value?: any) => void, reject: (error?: any) => void }}
+ */
+function deferred() {
+    /** @type {(value?: any) => void} */
+    let resolve;
+    /** @type {(error?: any) => void} */
+    let reject;
+    const promise = new Promise((yes, no) => {
+        resolve = yes;
+        reject = no;
+    });
+    return { promise, resolve, reject };
+}
+function writeLine(socket, value) {
+    if (!socket.destroyed && socket.writable)
+        socket.write(`${JSON.stringify(value)}\n`);
+}
+function childResult(child, timeoutMs) {
+    const result = deferred();
+    let settled = false;
+    const finish = (value) => {
+        if (!settled) {
+            settled = true;
+            clearTimeout(timer);
+            result.resolve(value);
+        }
+    };
+    child.once('error', (error) => finish({ exitCode: null, signal: null, timedOut: false, error: { message: errorText(error) } }));
+    child.once('close', (code, signal) => finish({ exitCode: code, signal, timedOut: false, error: null }));
+    const timer = setTimeout(() => {
+        try {
+            process.kill(-child.pid, 'SIGTERM');
+        }
+        catch {
+            try {
+                child.kill('SIGTERM');
+            }
+            catch { }
+        }
+        finish({ exitCode: null, signal: 'SIGTERM', timedOut: true, error: { message: 'Agent turn timed out.' } });
+    }, timeoutMs);
+    timer.unref?.();
+    return result.promise;
+}
+class LineTransport {
+    anchor;
+    harness;
+    nextId;
+    pending;
+    lastEventAt;
+    child;
+    constructor(anchor, harness, command, args, cwd, env = {}) {
+        this.anchor = anchor;
+        this.harness = harness;
+        this.nextId = 1;
+        this.pending = new Map();
+        this.lastEventAt = Date.now();
+        this.child = spawn(command, args, {
+            cwd,
+            env: {
+                ...process.env,
+                ...env,
+                TURNS_QUEUE_WORKER_ID: anchor.workerId,
+                TURNS_QUEUE_SESSION_ID: anchor.sessionId,
+                TURNS_TRANSCRIPT_PATH: anchor.transcriptPath,
+            },
+            stdio: ['pipe', 'pipe', 'pipe'],
+            detached: process.platform !== 'win32',
+        });
+        anchor.child = this.child;
+        readline.createInterface({ input: this.child.stdout }).on('line', (line) => this.receive(line));
+        readline.createInterface({ input: this.child.stderr }).on('line', (line) => anchor.emitLive({
+            event: 'process.line',
+            source: `${harness}.stderr`,
+            raw: line,
+            phase: 'queued',
+        }));
+        this.child.once('close', (code, signal) => {
+            const error = new Error(`${harness} transport exited with ${signal || code}`);
+            for (const waiter of this.pending.values())
+                waiter.reject(error);
+            this.pending.clear();
+            this.onClose?.(error);
+        });
+    }
+    emit(value, meta = {}) {
+        const raw = JSON.stringify(value);
+        this.anchor.emitLive({
+            direction: 'out',
+            source: `${this.harness}.stdin`,
+            raw,
+            json: value,
+            phase: 'queued',
+            ...meta,
+        });
+        this.child.stdin.write(`${raw}\n`);
+    }
+    receive(line) {
+        this.lastEventAt = Date.now();
+        let json = null;
+        try {
+            json = JSON.parse(line);
+        }
+        catch { }
+        this.anchor.emitLive({
+            direction: 'in',
+            source: `${this.harness}.stdout`,
+            raw: line,
+            json,
+            phase: 'queued',
+            method: json?.method,
+        });
+        this.onFrame(json);
+    }
+    // Subclass hooks. The base no-ops keep the contract visible for the transports
+    // that do not need them, and for the call sites that invoke them unconditionally.
+    onFrame(_frame) { }
+    onClose(_error) { }
+    stop() {
+        try {
+            this.child.stdin.end();
+        }
+        catch { }
+        try {
+            process.kill(-this.child.pid, 'SIGTERM');
+        }
+        catch {
+            try {
+                this.child.kill('SIGTERM');
+            }
+            catch { }
+        }
+    }
+}
+class ClaudeTransport extends LineTransport {
+    sessionId;
+    permissionMode;
+    turnWaiter;
+    control;
+    constructor(anchor, createSession) {
+        const profile = { command: 'claude' };
+        const nativePermissionMode = anchor.permissionMode === 'default' ? 'manual' : anchor.permissionMode;
+        const args = [
+            '-p',
+            '--input-format',
+            'stream-json',
+            '--output-format',
+            'stream-json',
+            '--verbose',
+            '--include-partial-messages',
+            '--permission-mode',
+            nativePermissionMode,
+            ...(anchor.permissionMode === 'bypassPermissions' ? [] : ['--permission-prompt-tool', 'stdio']),
+            '--mcp-config',
+            JSON.stringify({
+                mcpServers: {
+                    turns: { command: process.execPath, args: [questionMcpPath], env: { TURNS_AGENT_ANCHOR_SOCKET: socketPath } },
+                },
+            }),
+            ...(anchor.model && anchor.model !== 'auto' ? ['--model', anchor.model] : []),
+            ...(anchor.thinkingLevel ? ['--effort', anchor.thinkingLevel] : []),
+            ...(createSession ? ['--session-id', anchor.agentSessionId] : ['--resume', anchor.agentSessionId]),
+        ];
+        super(anchor, 'claude', resolveHarnessCommand('claude', profile), args, anchor.cwd, {
+            CLAUDE_CODE_ENTRYPOINT: 'turns-agent-anchor',
+        });
+        this.sessionId = anchor.agentSessionId;
+        this.permissionMode = anchor.permissionMode;
+        this.turnWaiter = null;
+        this.control = new Map();
+    }
+    onFrame(frame) {
+        if (!frame || typeof frame !== 'object')
+            return;
+        if (frame.type === 'system' && frame.subtype === 'init' && frame.session_id) {
+            this.sessionId = String(frame.session_id);
+            if (this.sessionId !== this.anchor.agentSessionId)
+                this.anchor.updateIdentity(this.sessionId);
+            return;
+        }
+        if (frame.type === 'result' && this.turnWaiter) {
+            const waiter = this.turnWaiter;
+            this.turnWaiter = null;
+            frame.is_error
+                ? waiter.reject(new Error(frame.result || frame.subtype || 'Claude turn failed.'))
+                : waiter.resolve(frame);
+            return;
+        }
+        if (frame.type === 'control_response') {
+            const requestId = frame.response?.request_id;
+            const waiter = this.control.get(requestId);
+            if (!waiter)
+                return;
+            this.control.delete(requestId);
+            frame.response?.subtype === 'error'
+                ? waiter.reject(new Error(frame.response.error || 'Claude control request failed.'))
+                : waiter.resolve(frame.response?.response ?? frame.response);
+            return;
+        }
+        if (frame.type === 'control_request')
+            void this.answerReverse(frame);
+    }
+    onClose(error) {
+        if (this.turnWaiter) {
+            this.turnWaiter.reject(error);
+            this.turnWaiter = null;
+        }
+        for (const waiter of this.control.values())
+            waiter.reject(error);
+        this.control.clear();
+    }
+    controlRequest(subtype, extra = {}, timeoutMs = 20_000) {
+        const requestId = `turns_${subtype}_${crypto.randomUUID()}`;
+        const waiter = deferred();
+        this.control.set(requestId, waiter);
+        this.emit({ type: 'control_request', request_id: requestId, request: { subtype, ...extra } });
+        const timer = setTimeout(() => {
+            if (this.control.delete(requestId))
+                waiter.reject(new Error(`Claude control request timed out: ${subtype}`));
+        }, timeoutMs);
+        timer.unref?.();
+        return waiter.promise.finally(() => clearTimeout(timer));
+    }
+    async open() {
+        await this.controlRequest('initialize', { hooks: {} }).catch(() => { });
+    }
+    async answerReverse(frame) {
+        const request = frame.request || {};
+        let response;
+        if (request.subtype === 'hook_callback')
+            response = {
+                behavior: 'allow',
+                updatedInput: request.input,
+                hookSpecificOutput: { hookEventName: 'PreToolUse', updatedInput: request.input },
+            };
+        else if (request.subtype === 'mcp_message')
+            response = { jsonrpc: '2.0', id: request.message?.id, result: {} };
+        else {
+            try {
+                response = await this.anchor.askInteraction(frame);
+            }
+            catch {
+                return;
+            }
+        }
+        this.emit({ type: 'control_response', response: { subtype: 'success', request_id: frame.request_id, response } });
+    }
+    prompt(text, timeoutMs) {
+        if (this.turnWaiter)
+            throw new Error('Claude already has an active turn.');
+        const waiter = deferred();
+        this.turnWaiter = waiter;
+        this.emit({
+            type: 'user',
+            session_id: this.sessionId,
+            message: { role: 'user', content: [{ type: 'text', text }] },
+            parent_tool_use_id: null,
+        });
+        const timer = setTimeout(() => {
+            if (this.turnWaiter === waiter)
+                this.turnWaiter = null;
+            waiter.reject(new Error('Claude turn timed out.'));
+        }, timeoutMs);
+        timer.unref?.();
+        return waiter.promise.finally(() => clearTimeout(timer));
+    }
+    async interrupt() {
+        try {
+            await this.controlRequest('interrupt');
+        }
+        catch (error) {
+            try {
+                process.kill(-this.child.pid, 'SIGINT');
+            }
+            catch {
+                try {
+                    this.child.kill('SIGINT');
+                }
+                catch { }
+            }
+            throw error;
+        }
+    }
+}
+class CodexAppServerTransport extends LineTransport {
+    threadId;
+    permissionMode;
+    turnId;
+    turnIdWaiter;
+    turnWaiter;
+    constructor(anchor) {
+        const profile = { command: 'codex' };
+        const mcp = `mcp_servers.turns={command=${JSON.stringify(process.execPath)},args=[${JSON.stringify(questionMcpPath)}],env={TURNS_AGENT_ANCHOR_SOCKET=${JSON.stringify(socketPath)}}}`;
+        super(anchor, 'app-server', resolveHarnessCommand('codex', profile), ['-c', mcp, 'app-server', '--listen', 'stdio://'], anchor.cwd);
+        this.threadId = anchor.agentSessionId;
+        this.permissionMode = anchor.permissionMode;
+        this.turnId = null;
+        this.turnIdWaiter = null;
+        this.turnWaiter = null;
+    }
+    setTurnId(turnId) {
+        if (!turnId)
+            return;
+        this.turnId = String(turnId);
+        this.turnIdWaiter?.resolve(this.turnId);
+    }
+    onFrame(frame) {
+        if (!frame || typeof frame !== 'object')
+            return;
+        if (frame.id !== undefined && frame.method === undefined) {
+            const waiter = this.pending.get(String(frame.id));
+            if (!waiter)
+                return;
+            this.pending.delete(String(frame.id));
+            frame.error
+                ? waiter.reject(new Error(frame.error.message || JSON.stringify(frame.error)))
+                : waiter.resolve(frame.result);
+            return;
+        }
+        if (frame.id !== undefined && frame.method) {
+            void this.answerReverse(frame);
+            return;
+        }
+        const ours = !frame.params?.threadId || frame.params.threadId === this.threadId;
+        if (frame.method === 'turn/started' && ours)
+            this.setTurnId(frame.params?.turnId || frame.params?.turn?.id);
+        if (['turn/completed', 'turn/failed', 'turn/aborted'].includes(frame.method) && ours && this.turnWaiter) {
+            const waiter = this.turnWaiter;
+            this.turnWaiter = null;
+            this.turnId = null;
+            this.turnIdWaiter?.resolve('');
+            this.turnIdWaiter = null;
+            frame.method === 'turn/failed'
+                ? waiter.reject(new Error(frame.params?.error?.message || 'Codex turn failed.'))
+                : waiter.resolve(frame);
+        }
+    }
+    async answerReverse(frame) {
+        let result;
+        try {
+            result = await this.anchor.askInteraction(frame);
+        }
+        catch {
+            return;
+        }
+        this.emit({ jsonrpc: '2.0', id: frame.id, result }, { method: frame.method });
+    }
+    onClose(error) {
+        this.turnIdWaiter?.resolve('');
+        this.turnIdWaiter = null;
+        if (this.turnWaiter) {
+            this.turnWaiter.reject(error);
+            this.turnWaiter = null;
+        }
+    }
+    request(method, params, timeoutMs = 60_000) {
+        const id = String(this.nextId++);
+        const waiter = deferred();
+        this.pending.set(id, waiter);
+        this.emit({ jsonrpc: '2.0', id, method, params }, { method });
+        const timer = setTimeout(() => {
+            if (this.pending.delete(id))
+                waiter.reject(new Error(`Codex app-server timeout: ${method}`));
+        }, timeoutMs);
+        timer.unref?.();
+        return waiter.promise.finally(() => clearTimeout(timer));
+    }
+    notify(method, params) {
+        this.emit({ jsonrpc: '2.0', method, params }, { method });
+    }
+    async open(createSession) {
+        await this.request('initialize', {
+            clientInfo: { name: 'turns.dev', version: '1' },
+            capabilities: { experimentalApi: true },
+        });
+        this.notify('initialized', {});
+        const configuration = {
+            cwd: this.anchor.cwd,
+            sandbox: this.anchor.permissionMode === 'bypassPermissions'
+                ? 'danger-full-access'
+                : this.anchor.permissionMode === 'plan'
+                    ? 'read-only'
+                    : 'workspace-write',
+            approvalPolicy: this.anchor.permissionMode === 'bypassPermissions' ? 'never' : 'on-request',
+        };
+        const opened = createSession
+            ? await this.request('thread/start', {
+                ...configuration,
+                ...(this.anchor.model && this.anchor.model !== 'auto' ? { model: this.anchor.model } : {}),
+                ...(this.anchor.thinkingLevel ? { effort: this.anchor.thinkingLevel } : {}),
+                ...(this.anchor.codexHistoryMode === 'paginated' ? { historyMode: 'paginated' } : {}),
+            }, 90_000)
+            : await this.request('thread/resume', {
+                threadId: this.threadId,
+                ...configuration,
+                ...(this.anchor.model && this.anchor.model !== 'auto' ? { model: this.anchor.model } : {}),
+                ...(this.anchor.thinkingLevel ? { effort: this.anchor.thinkingLevel } : {}),
+            }, 90_000);
+        const threadId = String(opened?.thread?.id || opened?.threadId || opened?.id || '');
+        if (!threadId)
+            throw new Error(`Codex ${createSession ? 'thread/start' : 'thread/resume'} returned no thread id.`);
+        if (!createSession && threadId !== this.threadId)
+            throw new Error(`Codex thread/resume returned ${threadId}, expected ${this.threadId}.`);
+        this.threadId = threadId;
+        if (threadId !== this.anchor.agentSessionId)
+            this.anchor.updateIdentity(threadId);
+    }
+    async prompt(text, timeoutMs) {
+        if (this.turnWaiter)
+            throw new Error('Codex already has an active turn.');
+        const waiter = deferred();
+        this.turnId = null;
+        this.turnIdWaiter = deferred();
+        this.turnWaiter = waiter;
+        const started = await this.request('turn/start', { threadId: this.threadId, input: [{ type: 'text', text }] }, timeoutMs).catch((error) => {
+            if (this.turnWaiter === waiter)
+                this.turnWaiter = null;
+            this.turnIdWaiter?.resolve('');
+            this.turnIdWaiter = null;
+            waiter.reject(error);
+            throw error;
+        });
+        this.setTurnId(started?.turn?.id || started?.turnId);
+        const timer = setTimeout(() => {
+            if (this.turnWaiter === waiter)
+                this.turnWaiter = null;
+            this.turnId = null;
+            this.turnIdWaiter?.resolve('');
+            this.turnIdWaiter = null;
+            waiter.reject(new Error('Codex turn timed out.'));
+        }, timeoutMs);
+        timer.unref?.();
+        return waiter.promise.finally(() => clearTimeout(timer));
+    }
+    interrupt() {
+        if (!this.turnId)
+            throw new Error('Codex has not reported an active turn id.');
+        return this.request('turn/interrupt', { threadId: this.threadId, turnId: this.turnId }, 30_000);
+    }
+    async steer(text, messageId = '') {
+        const deadline = Date.now() + 30_000;
+        while (!this.turnId && !this.turnIdWaiter && Date.now() < deadline)
+            await pause(10);
+        const turnId = this.turnId || (await this.turnIdWaiter?.promise);
+        if (!turnId)
+            throw new Error('Codex has not reported an active turn id.');
+        return this.request('turn/steer', {
+            threadId: this.threadId,
+            expectedTurnId: turnId,
+            input: [{ type: 'text', text }],
+            ...(messageId ? { clientUserMessageId: messageId } : {}),
+        }, 30_000);
+    }
+    async compact(timeoutMs) {
+        if (this.turnWaiter)
+            throw new Error('Codex already has an active turn.');
+        const waiter = deferred();
+        this.turnWaiter = waiter;
+        const timer = setTimeout(() => {
+            if (this.turnWaiter === waiter)
+                this.turnWaiter = null;
+            waiter.reject(new Error('Codex compaction timed out.'));
+        }, timeoutMs);
+        timer.unref?.();
+        try {
+            const [response] = await Promise.all([
+                this.request('thread/compact/start', { threadId: this.threadId }, timeoutMs),
+                waiter.promise,
+            ]);
+            return response;
+        }
+        finally {
+            if (this.turnWaiter === waiter)
+                this.turnWaiter = null;
+            clearTimeout(timer);
+        }
+    }
+}
+class AcpTransport extends LineTransport {
+    profile;
+    sessionId;
+    permissionMode;
+    ready;
+    activeRunId;
+    constructor(anchor, harness, profile) {
+        const command = resolveHarnessCommand(harness, profile);
+        const configuredProfile = {
+            ...profile,
+            args: typeof profile.args === 'function' ? profile.args(anchor.permissionMode) : profile.args,
+            mode: typeof profile.mode === 'function' ? profile.mode(anchor.permissionMode) : profile.mode,
+            options: typeof profile.options === 'function' ? profile.options(anchor.permissionMode) : profile.options,
+            env: typeof profile.env === 'function' ? profile.env(anchor.permissionMode, anchor.cwd) : profile.env,
+        };
+        super(anchor, harness, command, configuredProfile.args, anchor.cwd, configuredProfile.env);
+        this.profile = configuredProfile;
+        this.sessionId = anchor.agentSessionId;
+        this.permissionMode = anchor.permissionMode;
+        this.ready = false;
+        this.activeRunId = '';
+    }
+    onFrame(frame) {
+        if (!frame || typeof frame !== 'object')
+            return;
+        const gooseRunId = frame.params?.update?._meta?.goose?.activeRunId;
+        if (this.harness === 'goose' && gooseRunId !== undefined) {
+            this.activeRunId = typeof gooseRunId === 'string' ? gooseRunId : '';
+        }
+        if (frame.id !== undefined && frame.method === undefined) {
+            const waiter = this.pending.get(frame.id);
+            if (!waiter)
+                return;
+            this.pending.delete(frame.id);
+            frame.error
+                ? waiter.reject(new Error(frame.error.message || JSON.stringify(frame.error)))
+                : waiter.resolve(frame.result);
+            return;
+        }
+        if (frame.id !== undefined && frame.method)
+            void this.answerReverse(frame);
+    }
+    async answerReverse(frame) {
+        // Qwen uses this extension as an internal turn-boundary callback. It is
+        // protocol plumbing rather than a request for the user, and historical
+        // Qwen captures establish the empty object as the successful response.
+        if (frame.method === 'craft/drainMidTurnQueue') {
+            this.emit({ jsonrpc: '2.0', id: frame.id, result: {} }, { method: frame.method });
+            return;
+        }
+        let result;
+        try {
+            result = await this.anchor.askInteraction(frame, {
+                onExpire: () => this.emit({ jsonrpc: '2.0', id: frame.id, result: { outcome: { outcome: 'cancelled' } } }, { method: frame.method }),
+            });
+        }
+        catch {
+            return;
+        }
+        this.emit({ jsonrpc: '2.0', id: frame.id, result }, { method: frame.method });
+    }
+    request(method, params, timeoutMs = 120_000) {
+        const id = this.nextId++;
+        const waiter = deferred();
+        this.pending.set(id, waiter);
+        this.emit({ jsonrpc: '2.0', id, method, params }, { method });
+        const timer = setTimeout(() => {
+            if (this.pending.delete(id))
+                waiter.reject(new Error(`ACP request timed out: ${method}`));
+        }, timeoutMs);
+        timer.unref?.();
+        return waiter.promise.finally(() => clearTimeout(timer));
+    }
+    notify(method, params) {
+        this.emit({ jsonrpc: '2.0', method, params }, { method });
+    }
+    async open(createSession) {
+        await this.request('initialize', {
+            protocolVersion: 1,
+            clientCapabilities: {},
+            clientInfo: { name: 'turns.dev', version: '1' },
+        }, 90_000);
+        const mcpServers = this.profile.mcp
+            ? [
+                {
+                    name: 'turns',
+                    command: process.execPath,
+                    args: [questionMcpPath],
+                    env: [{ name: 'TURNS_AGENT_ANCHOR_SOCKET', value: socketPath }],
+                },
+            ]
+            : [];
+        let opened;
+        let openedFresh = Boolean(createSession);
+        const grokPermissionMeta = this.harness === 'grok'
+            ? {
+                _meta: {
+                    // An explicit false is important: otherwise Grok inherits the
+                    // interactive user's persisted always-approve setting.
+                    yoloMode: this.anchor.permissionMode === 'bypassPermissions',
+                    autoMode: this.anchor.permissionMode === 'auto',
+                },
+            }
+            : {};
+        if (!createSession) {
+            let lastError;
+            for (const method of this.profile.resumeMethods || ['session/resume', 'session/load']) {
+                try {
+                    opened = await this.request(method, { sessionId: this.sessionId, cwd: this.anchor.cwd, mcpServers, ...grokPermissionMeta }, 90_000);
+                    lastError = null;
+                    break;
+                }
+                catch (error) {
+                    lastError = error;
+                }
+            }
+            if (lastError && this.profile.resumeFallbackToNew) {
+                opened = await this.request('session/new', {
+                    cwd: this.anchor.cwd,
+                    mcpServers,
+                    ...grokPermissionMeta,
+                }, 120_000);
+                openedFresh = true;
+                lastError = null;
+            }
+            if (lastError)
+                throw new Error(`${this.harness} could not resume native session ${this.sessionId}: ${errorText(lastError)}`);
+        }
+        else {
+            opened = await this.request('session/new', {
+                cwd: this.anchor.cwd,
+                mcpServers,
+                ...grokPermissionMeta,
+            }, 120_000);
+        }
+        if (openedFresh) {
+            this.sessionId = String(opened?.sessionId || opened?.session?.id || opened?.id || '');
+            if (!this.sessionId)
+                throw new Error(`${this.harness} session/new returned no session id.`);
+            this.anchor.updateIdentity(this.sessionId);
+        }
+        if (this.harness === 'hermes')
+            recordHermesWorkingDirectory(this.sessionId, this.anchor.cwd);
+        for (const option of this.profile.options || []) {
+            await this.request('session/set_config_option', { sessionId: this.sessionId, configId: option.id, value: option.value }, 30_000).catch(() => { });
+        }
+        if (this.profile.mode) {
+            const availableModes = opened?.modes?.availableModes || opened?.availableModes || [];
+            const availableIds = availableModes.map((mode) => String(mode?.id ?? mode?.modeId ?? mode));
+            if (availableIds.length && !availableIds.includes(this.profile.mode)) {
+                throw new Error(`${this.harness} does not advertise permission mode "${this.profile.mode}" (available: ${availableIds.join(', ')}).`);
+            }
+            await this.request('session/set_mode', { sessionId: this.sessionId, modeId: this.profile.mode }, 30_000);
+        }
+        const model = this.anchor.model && this.anchor.model !== 'auto' ? this.anchor.model : this.profile.model;
+        if (model)
+            await this.request('session/set_model', { sessionId: this.sessionId, modelId: model }, 30_000).catch(() => { });
+        this.ready = true;
+    }
+    prompt(text, timeoutMs) {
+        return this.request('session/prompt', { sessionId: this.sessionId, prompt: [{ type: 'text', text }] }, timeoutMs);
+    }
+    interrupt() {
+        this.notify('session/cancel', { sessionId: this.sessionId });
+    }
+    steer(text) {
+        if (this.harness === 'goose') {
+            if (!this.activeRunId)
+                throw new Error('Goose did not advertise an active run for steering.');
+            return this.request('_goose/unstable/session/steer', {
+                sessionId: this.sessionId,
+                expectedRunId: this.activeRunId,
+                prompt: [{ type: 'text', text }],
+            });
+        }
+        return this.prompt(`/steer ${text}`, 12 * 60 * 60_000);
+    }
+}
+class RpcTransport extends LineTransport {
+    permissionMode;
+    responses;
+    events;
+    constructor(anchor, harness, profile, createSession = false) {
+        super(anchor, harness, resolveHarnessCommand(harness, profile), profile.args(anchor, createSession), anchor.cwd);
+        this.permissionMode = anchor.permissionMode;
+        this.responses = new Map();
+        this.events = 0;
+    }
+    onFrame(frame) {
+        if (!frame)
+            return;
+        if (frame.type === 'response' && frame.id !== undefined) {
+            const identity = rpcFrameSessionIdentity(frame);
+            if (identity.sessionId &&
+                (identity.sessionId !== this.anchor.agentSessionId ||
+                    (identity.transcriptPath && path.resolve(identity.transcriptPath) !== this.anchor.transcriptPath))) {
+                this.anchor.updateIdentity(identity.sessionId, identity.transcriptPath);
+            }
+            const waiter = this.pending.get(String(frame.id));
+            if (waiter) {
+                this.pending.delete(String(frame.id));
+                frame.success === false || frame.error
+                    ? waiter.reject(new Error(frame.error || `${frame.command || 'RPC'} failed`))
+                    : waiter.resolve(frame);
+            }
+            return;
+        }
+        if (frame.type === 'extension_ui_request') {
+            void this.answerUiQuestion(frame);
+            return;
+        }
+        this.events += 1;
+    }
+    async answerUiQuestion(frame) {
+        if (rpcUiRequestIsInformational(frame)) {
+            this.emit({ type: 'extension_ui_response', id: frame.id, ok: true });
+            return;
+        }
+        let response;
+        try {
+            response = await this.anchor.askInteraction(frame);
+        }
+        catch {
+            return;
+        }
+        const fields = response && typeof response === 'object' && !Array.isArray(response) ? response : { value: response };
+        this.emit({ type: 'extension_ui_response', id: frame.id, ...fields });
+    }
+    request(type, payload = {}, timeoutMs = 60_000) {
+        const id = String(this.nextId++);
+        const waiter = deferred();
+        this.pending.set(id, waiter);
+        this.emit({ type, id, ...payload });
+        const timer = setTimeout(() => {
+            if (this.pending.delete(id))
+                waiter.reject(new Error(`${this.harness} RPC timeout: ${type}`));
+        }, timeoutMs);
+        timer.unref?.();
+        return waiter.promise.finally(() => clearTimeout(timer));
+    }
+    async prompt(text, timeoutMs) {
+        this.events = 0;
+        await this.request('prompt', { message: text, streamingBehavior: 'steer' }, 60_000);
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            await new Promise((resolve) => setTimeout(resolve, 1_000));
+            if (this.events === 0 || Date.now() - this.lastEventAt < 2_500)
+                continue;
+            const state = await this.request('get_state', {}, 20_000).catch(() => null);
+            const data = state?.data || state?.state || {};
+            const running = [
+                data.running,
+                data.isRunning,
+                data.busy,
+                data.isBusy,
+                data.active,
+                data.isStreaming,
+                data.isCompacting,
+                data.turnActive,
+            ].some(Boolean) ||
+                (typeof data.status === 'string' && !/idle|ready|done|needs_input/i.test(data.status));
+            if (!running)
+                return { stopReason: 'completed' };
+        }
+        throw new Error(`${this.harness} turn timed out.`);
+    }
+    interrupt() {
+        return this.request('abort', {}, 30_000);
+    }
+    steer(text) {
+        return this.request('steer', { message: text }, 30_000);
+    }
+    compact(timeoutMs) {
+        return this.request('compact', { customInstructions: 'Keep the automated phase markers.' }, timeoutMs);
+    }
+}
+class OmpRpcTransport extends RpcTransport {
+    readyWaiter;
+    openTurns;
+    eventsSincePrompt;
+    constructor(anchor, profile, createSession = false) {
+        super(anchor, 'omp', { ...profile, args: (value) => profile.args(value, createSession) });
+        this.readyWaiter = deferred();
+        this.openTurns = 0;
+        this.eventsSincePrompt = 0;
+    }
+    onFrame(frame) {
+        if (!frame || typeof frame !== 'object')
+            return;
+        if (frame.type === 'ready') {
+            this.readyWaiter?.resolve(frame);
+            return;
+        }
+        if (frame.type === 'turn_start') {
+            this.openTurns += 1;
+            this.eventsSincePrompt += 1;
+            return;
+        }
+        if (frame.type === 'turn_end') {
+            this.openTurns = Math.max(0, this.openTurns - 1);
+            this.eventsSincePrompt += 1;
+            return;
+        }
+        if (frame.type === 'message_update' ||
+            frame.type === 'tool_execution_update' ||
+            frame.type === 'host_tool_call' ||
+            String(frame.type || '').includes('subagent'))
+            this.eventsSincePrompt += 1;
+        if (frame.type === 'host_tool_call') {
+            if (String(frame.name ?? frame.toolName ?? '') === 'turns_ask_user_question')
+                void this.answerHostQuestion(frame);
+            else
+                this.answerHostEcho(frame);
+            return;
+        }
+        super.onFrame(frame);
+    }
+    async answerHostQuestion(frame) {
+        let result;
+        try {
+            result = await this.anchor.askInteraction(frame);
+        }
+        catch {
+            return;
+        }
+        this.emit({
+            type: 'host_tool_result',
+            id: frame.id,
+            result,
+            isError: false,
+        });
+    }
+    answerHostEcho(frame) {
+        const args = frame.arguments || frame.parameters || frame.input || {};
+        this.emit({
+            type: 'host_tool_result',
+            id: frame.id,
+            result: { content: [{ type: 'text', text: String(args.text || '') }], details: {} },
+            isError: false,
+        });
+    }
+    async open() {
+        const timer = setTimeout(() => this.readyWaiter.reject(new Error('OMP did not emit a ready frame within 60s.')), 60_000);
+        timer.unref?.();
+        try {
+            await this.readyWaiter.promise;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        await this.request('get_state', {}, 30_000).catch(() => null);
+        await this.request('set_host_tools', {
+            tools: [
+                {
+                    name: 'turns_echo',
+                    label: 'Turns Echo',
+                    description: 'Echo text back to the agent for end-to-end tool verification.',
+                    parameters: {
+                        type: 'object',
+                        properties: { text: { type: 'string' } },
+                        required: ['text'],
+                    },
+                },
+                {
+                    name: 'turns_ask_user_question',
+                    label: 'Ask Turns Viewer',
+                    description: 'Ask the viewer a multiple-choice question and return the answer.',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            question: { type: 'string' },
+                            header: { type: 'string' },
+                            options: { type: 'array', items: { type: 'object' } },
+                        },
+                        required: ['question'],
+                    },
+                },
+            ],
+        }, 30_000);
+        await this.request('set_subagent_subscription', { level: 'events' }, 20_000).catch(() => null);
+    }
+    async prompt(text, timeoutMs) {
+        this.openTurns = 0;
+        this.eventsSincePrompt = 0;
+        await this.request('prompt', { message: text }, 60_000);
+        const startedAt = Date.now();
+        const deadline = startedAt + timeoutMs;
+        this.lastEventAt = Date.now();
+        while (Date.now() < deadline) {
+            await new Promise((resolve) => setTimeout(resolve, 2_000));
+            if (Date.now() - this.lastEventAt < 6_000 || this.openTurns > 0)
+                continue;
+            if (this.eventsSincePrompt === 0 && Date.now() - startedAt < 45_000)
+                continue;
+            const state = await this.request('get_state', {}, 20_000).catch(() => null);
+            const data = state?.data || state?.state || {};
+            const running = [data.running, data.isRunning, data.busy, data.isBusy, data.active, data.turnActive].some(Boolean) ||
+                (typeof (data.status || data.agentStatus || data.state) === 'string' &&
+                    !/idle|ready|done/i.test(data.status || data.agentStatus || data.state));
+            if (!running)
+                return { stopReason: 'completed' };
+        }
+        throw new Error('OMP turn timed out.');
+    }
+}
+class DeepseekTransport {
+    anchor;
+    sessionId;
+    waiter;
+    socket;
+    base;
+    constructor(anchor) {
+        this.anchor = anchor;
+        this.sessionId = anchor.agentSessionId;
+        this.waiter = null;
+        this.socket = null;
+    }
+    async open(createSession = false) {
+        const base = String(process.env.TURNS_DEEPSEEK_URL || 'http://127.0.0.1:3080').replace(/\/$/, '');
+        this.base = base;
+        this.socket = new WebSocket(`${base.replace(/^http/, 'ws')}/api/events.mux`);
+        this.socket.on('message', (bytes) => this.receive(String(bytes)));
+        await new Promise((resolve, reject) => {
+            this.socket.once('open', resolve);
+            this.socket.once('error', reject);
+        });
+        if (createSession) {
+            const opened = await this.rpc('session.create', { cwd: this.anchor.cwd });
+            const sessionId = String(opened?.sessionId || '');
+            if (!sessionId)
+                throw new Error('DeepSeek session.create returned no session id.');
+            this.sessionId = sessionId;
+            this.anchor.updateIdentity(sessionId);
+        }
+    }
+    receive(raw) {
+        let frame;
+        try {
+            frame = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if (String(frame?.payload?.sessionId || '') !== this.sessionId)
+            return;
+        this.anchor.emitLive({
+            direction: 'in',
+            source: 'deepseek.websocket',
+            raw,
+            json: frame,
+            phase: 'queued',
+            method: frame.method,
+        });
+        if (frame.method === 'question/requested') {
+            void this.answerQuestion(frame);
+            return;
+        }
+        // DSH emits the underlying ask_user_question tool call as a normal
+        // session/event before its authoritative question/requested frame. Treating
+        // both as interactions creates two different local IDs and leaves the
+        // tool-call-shaped copy waiting forever after the real question is answered.
+        if (frame.method === 'session/event' && frame.payload?.event?.type === 'turn/end' && this.waiter) {
+            const waiter = this.waiter;
+            this.waiter = null;
+            waiter.resolve({ stopReason: frame.payload.event.data?.reason?.kind || 'completed' });
+        }
+    }
+    async answerQuestion(frame) {
+        let result;
+        try {
+            result = await this.anchor.askInteraction(frame);
+        }
+        catch {
+            return;
+        }
+        const body = { type: 'client-response', rpcId: frame.rpcId, result };
+        this.anchor.emitLive({
+            direction: 'out',
+            source: 'deepseek.http',
+            raw: JSON.stringify(body),
+            json: body,
+            phase: 'queued',
+            method: 'respond',
+        });
+        await fetch(`${this.base}/api/respond`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+    }
+    async rpc(method, payload) {
+        const value = { type: 'client-request', rpcId: crypto.randomUUID(), method, payload };
+        this.anchor.emitLive({
+            direction: 'out',
+            source: 'deepseek.http',
+            raw: JSON.stringify(value),
+            json: value,
+            phase: 'queued',
+            method,
+        });
+        const response = await fetch(`${this.base}/api/${method}`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(value),
+        });
+        const json = (await response.json());
+        if (!response.ok || !json?.result?.ok)
+            throw new Error(`${method}: ${json?.result?.error?.message || response.status}`);
+        return json.result.value;
+    }
+    async prompt(text, timeoutMs) {
+        const waiter = deferred();
+        this.waiter = waiter;
+        await this.rpc('session.prompt', { sessionId: this.sessionId, mode: 'queue', content: [{ type: 'text', text }] });
+        const timer = setTimeout(() => waiter.reject(new Error('DeepSeek turn timed out.')), timeoutMs);
+        timer.unref?.();
+        return waiter.promise.finally(() => clearTimeout(timer));
+    }
+    interrupt() {
+        return this.rpc('session.cancel', { sessionId: this.sessionId });
+    }
+    steer(text) {
+        return this.rpc('session.prompt', { sessionId: this.sessionId, mode: 'steer', content: [{ type: 'text', text }] });
+    }
+    stop() {
+        this.socket?.close();
+    }
+}
+/**
+ * Whichever transport the anchor's harness needs. They share the frame plumbing,
+ * but not their extras: only some can steer a running turn, only some need an
+ * explicit open handshake, and DeepseekTransport talks over a socket instead of a
+ * child process. The optional members are the ones guarded at runtime by
+ * `instanceof` checks that the checker cannot correlate with a later access.
+ * @typedef {(LineTransport | DeepseekTransport) &
+ *   Partial<{
+ *     harness: string;
+ *     child: import('node:child_process').ChildProcessWithoutNullStreams;
+ *     ready: boolean;
+ *     sessionId: string;
+ *     permissionMode: string;
+ *     steer: (text: string) => any;
+ *     open: (createSession?: any) => Promise<void>;
+ *     interrupt: () => any;
+ *     compact: (timeoutMs: number) => Promise<any>;
+ *     prompt: (text: string, timeoutMs?: number) => Promise<any>;
+ *     stop: () => void;
+ *   }>} AnchorTransport
+ */
+class Anchor {
+    clients;
+    status;
+    source;
+    sessionId;
+    agentSessionId;
+    cwd;
+    transcriptPath;
+    workerId;
+    model;
+    thinkingLevel;
+    permissionMode;
+    codexHistoryMode;
+    currentTurn;
+    transport;
+    child;
+    events;
+    eventBytes;
+    sequence;
+    pendingInteractions;
+    startedAt;
+    lastActivityAt;
+    idleTimeoutMs;
+    turnTimeoutMs;
+    idleTimer;
+    constructor() {
+        this.clients = new Set();
+        this.status = 'idle';
+        this.source = '';
+        this.sessionId = '';
+        this.agentSessionId = '';
+        this.cwd = '';
+        this.transcriptPath = '';
+        this.workerId = '';
+        this.model = '';
+        this.thinkingLevel = '';
+        this.permissionMode = 'bypassPermissions';
+        this.codexHistoryMode = '';
+        this.currentTurn = null;
+        /** @type {AnchorTransport | null} */
+        this.transport = null;
+        this.child = null;
+        this.events = [];
+        this.eventBytes = 0;
+        this.sequence = 0;
+        this.pendingInteractions = new Map();
+        this.startedAt = now();
+        this.lastActivityAt = this.startedAt;
+        this.idleTimeoutMs = 300_000;
+        this.turnTimeoutMs = 12 * 60 * 60_000;
+        this.idleTimer = null;
+    }
+    snapshot() {
+        return {
+            protocol: 'turns.agent-anchor.v1',
+            owner: 'turns.dev',
+            capabilities: [
+                'interrupt',
+                'shutdown',
+                'answer_interaction',
+                ...(this.transport?.steer ? ['steer'] : []),
+                ...(this.transport?.compact ? ['compact'] : []),
+            ],
+            pid: process.pid,
+            socketPath,
+            source: this.source,
+            sessionId: this.sessionId,
+            agentSessionId: this.agentSessionId,
+            cwd: this.cwd,
+            transcriptPath: this.transcriptPath,
+            workerId: this.workerId,
+            model: this.model,
+            thinkingLevel: this.thinkingLevel,
+            permissionMode: this.permissionMode,
+            codexHistoryMode: this.codexHistoryMode,
+            status: this.status,
+            startedAt: this.startedAt,
+            lastActivityAt: this.lastActivityAt,
+            currentTurn: this.currentTurn ? { ...this.currentTurn } : null,
+            pendingInteractions: [...this.pendingInteractions.values()].map((item) => item.interaction),
+            lastEventSequence: this.sequence,
+            liveEvents: this.events.map((event) => ({ ...event })),
+        };
+    }
+    broadcast(value) {
+        for (const client of this.clients) {
+            if (client.destroyed || !client.writable)
+                this.clients.delete(client);
+            else
+                writeLine(client, value);
+        }
+    }
+    setStatus(status) {
+        this.status = status;
+        this.lastActivityAt = now();
+        this.broadcast({
+            type: 'session_status',
+            sessionId: this.sessionId,
+            agentSessionId: this.agentSessionId,
+            messageId: this.currentTurn?.messageId || '',
+            status,
+        });
+    }
+    emitLive(event) {
+        const entry = { capturedAt: now(), ...event, anchorEventSequence: ++this.sequence };
+        const bytes = Buffer.byteLength(JSON.stringify(entry));
+        this.events.push(entry);
+        this.eventBytes += bytes;
+        while (this.events.length > MAX_EVENTS || this.eventBytes > MAX_EVENT_BYTES)
+            this.eventBytes -= Buffer.byteLength(JSON.stringify(this.events.shift()));
+        this.broadcast({
+            type: 'live_event',
+            sessionId: this.sessionId,
+            agentSessionId: this.agentSessionId,
+            messageId: this.currentTurn?.messageId || '',
+            event: entry,
+        });
+    }
+    updateIdentity(agentSessionId, transcriptPath = '') {
+        this.agentSessionId = agentSessionId;
+        if (transcriptPath)
+            this.transcriptPath = path.resolve(transcriptPath);
+        this.broadcast({
+            type: 'session_identity',
+            sessionId: this.sessionId,
+            agentSessionId,
+            transcriptPath: this.transcriptPath,
+            messageId: this.currentTurn?.messageId || '',
+        });
+    }
+    askInteraction(request, options = {}) {
+        const interaction = {
+            id: crypto.randomUUID(),
+            harness: this.source,
+            request,
+        };
+        const waiter = deferred();
+        clearTimeout(this.idleTimer);
+        this.pendingInteractions.set(interaction.id, { interaction, waiter, onExpire: options.onExpire });
+        this.emitLive({ event: 'user.interaction', agent: this.source, phase: 'queued', interaction });
+        return waiter.promise;
+    }
+    answerInteraction(interactionId, response) {
+        const pending = this.pendingInteractions.get(interactionId);
+        if (!pending)
+            throw new Error('The interaction is no longer waiting in this harness.');
+        this.pendingInteractions.delete(interactionId);
+        this.emitLive({
+            event: 'user.interaction_answer',
+            agent: this.source,
+            phase: 'queued',
+            interaction: pending.interaction,
+            response,
+        });
+        pending.waiter.resolve(response);
+        if (this.status === 'idle')
+            this.scheduleExit();
+        return { answered: true, interactionId };
+    }
+    expirePendingInteractions(reason) {
+        const error = new Error(reason);
+        for (const [interactionId, pending] of this.pendingInteractions) {
+            this.pendingInteractions.delete(interactionId);
+            this.emitLive({
+                event: 'user.interaction_expired',
+                agent: this.source,
+                phase: 'queued',
+                interaction: pending.interaction,
+                reason,
+            });
+            try {
+                pending.onExpire?.();
+            }
+            catch { }
+            pending.waiter.reject(error);
+        }
+    }
+    scheduleExit() {
+        clearTimeout(this.idleTimer);
+        if (this.pendingInteractions.size) {
+            this.idleTimer = null;
+            return;
+        }
+        this.idleTimer = setTimeout(() => this.close(), this.idleTimeoutMs);
+        this.idleTimer.unref?.();
+    }
+    async start(request) {
+        const messageId = String(request.messageId || '');
+        const claimToken = String(request.claimToken || '');
+        const sameMessage = this.currentTurn?.messageId === messageId;
+        const sameClaim = sameMessage && this.currentTurn?.claimToken === claimToken;
+        // send_message crosses a local socket after the queue claim crosses a
+        // WebSocket, so either acknowledgement can be lost after the agent has
+        // already accepted the turn. A replacement claim for the same prompt must
+        // adopt a running/successful turn instead of executing it again. Failed or
+        // interrupted turns remain retryable when the server issues a new claim.
+        if (sameClaim || (sameMessage && ['running', 'completed'].includes(this.currentTurn?.status))) {
+            if (claimToken && claimToken !== this.currentTurn.claimToken) {
+                this.currentTurn = { ...this.currentTurn, claimToken };
+            }
+            return {
+                accepted: true,
+                messageId,
+                pid: process.pid,
+                adopted: true,
+                status: this.currentTurn.status,
+            };
+        }
+        if (this.status === 'running')
+            throw new Error('The anchored agent is already running a turn.');
+        if (this.pendingInteractions.size)
+            throw new Error('The anchored agent is awaiting user input.');
+        for (const key of ['source', 'sessionId', 'agentSessionId', 'messageId'])
+            if (!request[key])
+                throw new Error(`${key} is required.`);
+        const codexHistoryMode = String(request.codexHistoryMode || '');
+        if (codexHistoryMode && (request.source !== 'codex' || codexHistoryMode !== 'paginated'))
+            throw new Error('Paginated history mode is supported only by Codex.');
+        clearTimeout(this.idleTimer);
+        Object.assign(this, {
+            source: String(request.source),
+            sessionId: String(request.sessionId),
+            agentSessionId: String(request.agentSessionId),
+            cwd: path.resolve(request.cwd),
+            transcriptPath: path.resolve(request.transcriptPath),
+            workerId: String(request.workerId || ''),
+            model: String(request.model || ''),
+            thinkingLevel: String(request.thinkingLevel || ''),
+            permissionMode: requestedPermissionMode(request.permissionMode),
+            codexHistoryMode,
+            idleTimeoutMs: Math.max(1_000, Number(request.idleTimeoutMs) || 300_000),
+            turnTimeoutMs: Math.max(60_000, Number(request.timeoutMs) || 12 * 60 * 60_000),
+        });
+        this.events = [];
+        this.eventBytes = 0;
+        this.sequence = 0;
+        this.currentTurn = {
+            messageId,
+            claimToken,
+            prompt: String(request.prompt || ''),
+            expectedText: String(request.expectedText || request.prompt || ''),
+            status: 'running',
+            accepted: true,
+            startedAt: now(),
+            completedAt: null,
+            result: null,
+        };
+        this.setStatus('running');
+        void this.run(Boolean(request.createSession), this.turnTimeoutMs).then((result) => this.finish(result), (error) => this.finish({ exitCode: 1, signal: null, timedOut: false, error: { message: errorText(error) } }));
+        return { accepted: true, messageId: this.currentTurn.messageId, pid: process.pid };
+    }
+    async run(createSession, timeoutMs) {
+        this.emitLive({
+            event: 'turn.start',
+            agent: this.source,
+            phase: 'queued',
+            messageId: this.currentTurn.messageId,
+            displayPrompt: this.currentTurn.expectedText,
+            prompt: this.currentTurn.prompt,
+        });
+        const interruptedBeforePrompt = () => this.currentTurn?.interruptRequestedAt
+            ? { exitCode: 0, signal: null, timedOut: false, error: null, interrupted: true }
+            : null;
+        if (interruptedBeforePrompt())
+            return interruptedBeforePrompt();
+        if (this.source === 'claude') {
+            if (!(this.transport instanceof ClaudeTransport) ||
+                this.transport.child.exitCode !== null ||
+                this.transport.sessionId !== this.agentSessionId ||
+                this.transport.permissionMode !== this.permissionMode) {
+                this.transport?.stop?.();
+                this.transport = new ClaudeTransport(this, createSession);
+                await this.transport.open();
+            }
+            if (interruptedBeforePrompt())
+                return interruptedBeforePrompt();
+            const result = await 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.threadId !== this.agentSessionId ||
+                this.transport.permissionMode !== this.permissionMode) {
+                this.transport?.stop?.();
+                this.transport = new CodexAppServerTransport(this);
+                await this.transport.open(createSession);
+            }
+            if (interruptedBeforePrompt())
+                return interruptedBeforePrompt();
+            const result = await this.transport.prompt(this.currentTurn.prompt, timeoutMs);
+            return {
+                exitCode: 0,
+                signal: null,
+                timedOut: false,
+                error: null,
+                stopReason: result?.method || 'turn/completed',
+            };
+        }
+        if (PROCESS_HARNESSES.has(this.source)) {
+            const invocation = processInvocation({
+                harness: this.source,
+                sessionId: this.agentSessionId,
+                transcriptPath: this.transcriptPath,
+                cwd: this.cwd,
+                prompt: this.currentTurn.prompt,
+                createSession,
+                model: this.model,
+                thinkingLevel: this.thinkingLevel,
+                timeoutMs,
+            });
+            const child = spawn(invocation.command, invocation.args, {
+                cwd: this.cwd,
+                env: {
+                    ...process.env,
+                    TURNS_QUEUE_WORKER_ID: this.workerId,
+                    TURNS_QUEUE_SESSION_ID: this.sessionId,
+                    TURNS_TRANSCRIPT_PATH: this.transcriptPath,
+                },
+                stdio: [invocation.stdin ? 'pipe' : 'ignore', 'pipe', 'pipe'],
+                detached: process.platform !== 'win32',
+            });
+            this.child = child;
+            if (invocation.stdin)
+                child.stdin.end(`${invocation.stdin}\n`);
+            for (const [stream, source] of [
+                [child.stdout, `${this.source}.stdout`],
+                [child.stderr, `${this.source}.stderr`],
+            ])
+                readline.createInterface({ input: stream }).on('line', (line) => {
+                    let json;
+                    try {
+                        json = JSON.parse(line);
+                    }
+                    catch { }
+                    const processSessionId = processEventSessionId(this.source, json);
+                    if (processSessionId && processSessionId !== this.agentSessionId)
+                        this.updateIdentity(processSessionId);
+                    this.emitLive({ event: 'process.line', source, raw: line, json, phase: 'queued' });
+                });
+            return childResult(child, timeoutMs);
+        }
+        if (ACP_PROFILES[this.source]) {
+            if (!(this.transport instanceof AcpTransport) ||
+                this.transport.harness !== this.source ||
+                !this.transport.child ||
+                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);
+            }
+            if (interruptedBeforePrompt())
+                return interruptedBeforePrompt();
+            const result = await this.transport.prompt(this.currentTurn.prompt, timeoutMs);
+            return { exitCode: 0, signal: null, timedOut: false, error: null, stopReason: result?.stopReason };
+        }
+        if (RPC_PROFILES[this.source]) {
+            const specializedOmp = this.source === 'omp';
+            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) {
+                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();
+            }
+            if (interruptedBeforePrompt())
+                return interruptedBeforePrompt();
+            await 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);
+            }
+            if (interruptedBeforePrompt())
+                return interruptedBeforePrompt();
+            await 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}".`);
+    }
+    finish(result) {
+        if (!this.currentTurn || this.currentTurn.status !== 'running')
+            return;
+        const interrupted = Boolean(result?.interrupted || this.currentTurn.interruptRequestedAt);
+        if (interrupted) {
+            result = { ...result, exitCode: 0, signal: null, timedOut: false, error: null, interrupted: true };
+        }
+        const failed = !interrupted && Boolean(result?.error || result?.timedOut || result?.exitCode);
+        // Some ACP servers reject the pending prompt on session/cancel but leave
+        // their native turn alive. Reusing that connection makes the next Turns
+        // prompt a harness-internal queued turn instead of a new active turn. A
+        // reconnect is the portable cancellation boundary; the next prompt resumes
+        // the same durable native session through session/load. Gemini is the
+        // exception: its ACP server settles cancellation on the existing
+        // connection, but an interrupted session is not yet discoverable by
+        // session/load, so reconnecting strands every later queued prompt.
+        if (interrupted && this.transport instanceof AcpTransport && this.source !== 'gemini') {
+            this.transport.stop?.();
+            this.transport = null;
+        }
+        if (interrupted || failed)
+            this.expirePendingInteractions(interrupted
+                ? 'The turn was interrupted before this interaction was answered.'
+                : 'The turn ended before this interaction was answered.');
+        this.currentTurn = {
+            ...this.currentTurn,
+            status: interrupted ? 'interrupted' : failed ? 'error' : 'completed',
+            completedAt: now(),
+            result,
+        };
+        this.emitLive({
+            event: 'turn.complete',
+            agent: this.source,
+            phase: 'queued',
+            messageId: this.currentTurn.messageId,
+            result,
+        });
+        this.setStatus('idle');
+        this.broadcast({
+            type: failed ? 'turn_error' : 'turn_complete',
+            sessionId: this.sessionId,
+            agentSessionId: this.agentSessionId,
+            messageId: this.currentTurn.messageId,
+            result,
+        });
+        this.scheduleExit();
+    }
+    async interrupt(messageId) {
+        if (this.status !== 'running' || (messageId && messageId !== this.currentTurn?.messageId))
+            throw new Error('No matching turn is running.');
+        this.currentTurn.interruptRequestedAt = now();
+        // A reverse request can block an ACP server from consuming session/cancel.
+        // Resolve every pending interaction as cancelled first so interruption is a
+        // complete, protocol-independent boundary even when the user never answers.
+        this.expirePendingInteractions('The turn was interrupted before this interaction was answered.');
+        try {
+            if (this.transport?.interrupt)
+                await this.transport.interrupt();
+            else if (this.child) {
+                try {
+                    process.kill(-this.child.pid, 'SIGINT');
+                }
+                catch {
+                    this.child.kill('SIGINT');
+                }
+            }
+        }
+        finally {
+            this.emitLive({
+                event: 'interrupt.issued',
+                agent: this.source,
+                phase: 'queued',
+                messageId: this.currentTurn.messageId,
+            });
+        }
+        return { interrupted: true, messageId: this.currentTurn.messageId };
+    }
+    async steer(prompt, messageId = '') {
+        if (this.status !== 'running')
+            throw new Error('No turn is running.');
+        // A harness without an in-turn steering primitive still honours the
+        // correction rather than rejecting it: interrupt the running turn so the
+        // queue can dispatch this prompt as the very next turn. The prompt stays
+        // queued on the server, so nothing is emitted for it here.
+        if (!this.transport?.steer) {
+            await this.interrupt(String(this.currentTurn?.messageId || ''));
+            return { steered: true, mode: 'interrupt' };
+        }
+        await this.transport.steer(prompt, messageId);
+        this.emitLive({
+            event: 'turn.steer',
+            agent: this.source,
+            phase: 'queued',
+            messageId,
+            displayPrompt: prompt,
+            prompt,
+        });
+        return { steered: true, mode: 'steer' };
+    }
+    async compact() {
+        if (this.status === 'running')
+            throw new Error('The anchored agent is already running a turn.');
+        if (this.pendingInteractions.size) {
+            throw new Error('The anchored agent is awaiting user input.');
+        }
+        if (!this.transport?.compact)
+            throw new Error(`${this.source} does not support programmatic compaction.`);
+        clearTimeout(this.idleTimer);
+        this.setStatus('running');
+        this.emitLive({ event: 'compaction.started', agent: this.source, phase: 'queued' });
+        try {
+            const result = await this.transport.compact(this.turnTimeoutMs);
+            this.emitLive({ event: 'compaction.complete', agent: this.source, phase: 'queued' });
+            return { compacted: true, result };
+        }
+        catch (error) {
+            this.emitLive({
+                event: 'compaction.failed',
+                agent: this.source,
+                phase: 'queued',
+                error: { message: errorText(error) },
+            });
+            throw error;
+        }
+        finally {
+            this.setStatus('idle');
+            this.scheduleExit();
+        }
+    }
+    close() {
+        clearTimeout(this.idleTimer);
+        const error = new Error('The agent anchor closed.');
+        for (const pending of this.pendingInteractions.values())
+            pending.waiter.reject(error);
+        this.pendingInteractions.clear();
+        this.transport?.stop?.();
+        if (this.child?.exitCode === null) {
+            try {
+                process.kill(-this.child.pid, 'SIGTERM');
+            }
+            catch { }
+        }
+        for (const client of this.clients)
+            client.destroy();
+        server.close(() => {
+            try {
+                fs.unlinkSync(socketPath);
+            }
+            catch { }
+            process.exit(0);
+        });
+    }
+}
+const anchor = new Anchor();
+try {
+    fs.unlinkSync(socketPath);
+}
+catch { }
+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() });
+    const lines = readline.createInterface({ input: socket });
+    const detach = () => {
+        anchor.clients.delete(socket);
+        try {
+            lines.close();
+        }
+        catch { }
+    };
+    // A daemon or diagnostic client may disappear between two live events. Both
+    // the socket and readline interface surface that reset; consume it locally
+    // so one observer cannot take down the detached agent it was observing.
+    socket.on('error', detach);
+    socket.on('close', detach);
+    lines.on('error', detach);
+    lines.on('line', (line) => {
+        let request;
+        try {
+            request = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        const respond = (ok, result) => writeLine(socket, ok ? { id: request.id, ok, result } : { id: request.id, ok, error: errorText(result) });
+        Promise.resolve()
+            .then(async () => {
+            if (request.type === 'snapshot')
+                return anchor.snapshot();
+            if (request.type === 'send_message')
+                return anchor.start(request);
+            if (request.type === 'interrupt')
+                return anchor.interrupt(String(request.messageId || ''));
+            if (request.type === 'steer')
+                return anchor.steer(String(request.prompt || ''), String(request.messageId || ''));
+            if (request.type === 'compact')
+                return anchor.compact();
+            if (request.type === 'ask_interaction')
+                return anchor.askInteraction({
+                    type: 'turns_mcp_tool_call',
+                    toolName: String(request.toolName || 'turns_ask_user_question'),
+                    input: request.input || {},
+                });
+            if (request.type === 'answer_interaction')
+                return anchor.answerInteraction(String(request.interactionId || ''), request.response);
+            if (request.type === 'shutdown') {
+                setImmediate(() => anchor.close());
+                return { closing: true };
+            }
+            throw new Error(`Unknown anchor request: ${request.type}`);
+        })
+            .then((result) => respond(true, result), (error) => respond(false, error));
+    });
+});
+server.listen(socketPath);
+process.on('SIGTERM', () => anchor.close());
+process.on('SIGINT', () => anchor.close());