dsh-agy-cli 0.0.0-stage → 0.12.0

package/lib/agy/persistent-transport.js

@@ -0,0 +1,753 @@
+/**
+ * Productized persistent transport for AGY 1.1.15 stream-json.
+ * Input: {event:"user",message:{role:"user",content:[{type:"text",text}]}} per NDJSON line.
+ * Output: {event:"init"} -> {event:"step_update"}* -> {event:"result"} per turn.
+ * One AGY process per DSH session, single active turn, idle TTL, before-accept fallback.
+ * See findings.md 2026-08-20 V8-M1 and .tmp/v8-m1/three-turn.log.
+ */
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { encodeAgyUserMessage } from './stream-protocol.js';
+import { buildWindowsNoConsoleLaunch } from './windows-launcher.js';
+import { isAgyReasoningEffort } from './process.js';
+export class PersistentTransportError extends Error {
+    code;
+    constructor(message, code, options) {
+        super(message, options);
+        this.code = code;
+        this.name = 'PersistentTransportError';
+    }
+}
+const DEFAULT_MAX_WORKERS = 8;
+const DEFAULT_MAX_FRAME_BYTES = 256 * 1024;
+const DEFAULT_MAX_OUTPUT_BYTES = 8 * 1024 * 1024;
+const DEFAULT_MAX_STDERR_BYTES = 64 * 1024;
+const DEFAULT_IDLE_TTL_MS = 30_000;
+const DEFAULT_READY_TIMEOUT_MS = 5_000;
+const DEFAULT_SHUTDOWN_TIMEOUT_MS = 1_000;
+const DEFAULT_REQUEST_TIMEOUT_MS = 120_000;
+function delay(milliseconds) {
+    return new Promise(resolve => setTimeout(resolve, milliseconds));
+}
+function validateInteger(name, value, minimum, maximum) {
+    if (!Number.isInteger(value) || value < minimum || value > maximum) {
+        throw new RangeError(`${name} must be an integer between ${minimum} and ${maximum}`);
+    }
+    return value;
+}
+function normalizeOptions(options) {
+    if (options.executable.trim().length === 0) {
+        throw new RangeError('executable must not be empty');
+    }
+    return {
+        executable: options.executable,
+        args: options.args ?? [],
+        cwd: options.cwd,
+        env: options.env,
+        maxWorkers: validateInteger('maxWorkers', options.maxWorkers ?? DEFAULT_MAX_WORKERS, 1, 64),
+        maxFrameBytes: validateInteger('maxFrameBytes', options.maxFrameBytes ?? DEFAULT_MAX_FRAME_BYTES, 128, 16 * 1024 * 1024),
+        maxOutputBytes: validateInteger('maxOutputBytes', options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES, 1, 64 * 1024 * 1024),
+        maxStderrBytes: validateInteger('maxStderrBytes', options.maxStderrBytes ?? DEFAULT_MAX_STDERR_BYTES, 1, 8 * 1024 * 1024),
+        idleTtlMs: validateInteger('idleTtlMs', options.idleTtlMs ?? DEFAULT_IDLE_TTL_MS, 0, 3_600_000),
+        readyTimeoutMs: validateInteger('readyTimeoutMs', options.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS, 1, 60_000),
+        shutdownTimeoutMs: validateInteger('shutdownTimeoutMs', options.shutdownTimeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS, 1, 60_000),
+        defaultRequestTimeoutMs: validateInteger('defaultRequestTimeoutMs', options.defaultRequestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS, 1, 3_600_000),
+    };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function byteLength(value) {
+    return Buffer.byteLength(value, 'utf8');
+}
+/**
+ * Route args for one worker. AGY reads --agent/--model/--effort/--conversation
+ * once at process start, so these must be known before spawning; the rest of
+ * the argv comes from the transport options.
+ */
+function routeArgs(input) {
+    if (input.reasoningEffort !== undefined && !isAgyReasoningEffort(input.reasoningEffort)) {
+        throw new TypeError('Persistent AGY reasoning effort must be one of: low, medium, high');
+    }
+    return [
+        ...(input.agent === undefined ? [] : ['--agent', input.agent]),
+        ...(input.model === undefined ? [] : ['--model', input.model]),
+        ...(input.conversation === undefined ? [] : ['--conversation', input.conversation]),
+        ...(input.reasoningEffort === undefined ? [] : ['--effort', input.reasoningEffort]),
+        ...(input.extraArgs ?? []),
+    ];
+}
+/**
+ * Worker pool key. The session alone is not enough: a session that switches
+ * model, or that must continue a different AGY conversation, needs its own
+ * process. See PersistentTransportRequest.agent/model/reasoningEffort.
+ */
+function workerKeyOf(input) {
+    const route = [
+        input.agent ?? '',
+        input.model ?? '',
+        input.reasoningEffort ?? '',
+        input.conversation ?? '',
+        (input.extraArgs ?? []).join('\u0000'),
+    ].join('\u0001');
+    return `${input.sessionId}\u0002${route}`;
+}
+/** Encode one bounded NDJSON frame, including its trailing newline. */
+export function encodePersistentFrame(frame, maxFrameBytes) {
+    const line = JSON.stringify(frame);
+    if (line === undefined) {
+        throw new PersistentTransportError('Persistent transport frame could not be encoded', 'PROTOCOL_ERROR');
+    }
+    const encoded = `${line}\n`;
+    if (byteLength(encoded) > maxFrameBytes) {
+        throw new PersistentTransportError('Persistent transport input frame exceeds the configured limit', 'FRAME_TOO_LARGE');
+    }
+    return encoded;
+}
+/** Parse and validate the small protocol envelope; payload remains opaque. */
+export function parsePersistentFrame(line) {
+    if (line.trim().length === 0) {
+        throw new PersistentTransportError('Persistent transport emitted an empty frame', 'PROTOCOL_ERROR');
+    }
+    let value;
+    try {
+        value = JSON.parse(line);
+    }
+    catch (error) {
+        throw new PersistentTransportError('Persistent transport emitted malformed JSON', 'PROTOCOL_ERROR', {
+            cause: error,
+        });
+    }
+    if (!isRecord(value) || typeof value.kind !== 'string'
+        || !['ready', 'event', 'complete', 'error'].includes(value.kind)) {
+        throw new PersistentTransportError('Persistent transport emitted an invalid frame envelope', 'PROTOCOL_ERROR');
+    }
+    if (value.requestId !== undefined && typeof value.requestId !== 'string') {
+        throw new PersistentTransportError('Persistent transport frame requestId is invalid', 'PROTOCOL_ERROR');
+    }
+    if (value.sessionId !== undefined && typeof value.sessionId !== 'string') {
+        throw new PersistentTransportError('Persistent transport frame sessionId is invalid', 'PROTOCOL_ERROR');
+    }
+    return {
+        kind: value.kind,
+        ...(value.requestId === undefined ? {} : { requestId: value.requestId }),
+        ...(value.sessionId === undefined ? {} : { sessionId: value.sessionId }),
+        ...(Object.hasOwn(value, 'payload') ? { payload: value.payload } : {}),
+        ...(value.message === undefined ? {} : { message: String(value.message).slice(0, 256) }),
+    };
+}
+/** Real AGY 1.1.15 output envelope: init | step_update | result */
+function parseAgyOutputLine(line) {
+    if (line.trim().length === 0) {
+        throw new PersistentTransportError('Persistent AGY emitted an empty line', 'PROTOCOL_ERROR');
+    }
+    let value;
+    try {
+        value = JSON.parse(line);
+    }
+    catch (error) {
+        throw new PersistentTransportError('Persistent AGY emitted malformed JSON', 'PROTOCOL_ERROR', { cause: error });
+    }
+    if (!isRecord(value) || typeof value.event !== 'string') {
+        throw new PersistentTransportError('Persistent AGY output missing event field', 'PROTOCOL_ERROR');
+    }
+    return { event: value.event, raw: value };
+}
+function terminateWorkerTree(child) {
+    const pid = child.pid;
+    if (pid === undefined) {
+        child.kill();
+        return;
+    }
+    if (process.platform === 'win32') {
+        const killer = spawn('taskkill', ['/pid', String(pid), '/t', '/f'], {
+            shell: false,
+            windowsHide: true,
+            stdio: 'ignore',
+        });
+        const fallback = setTimeout(() => {
+            try {
+                child.kill();
+            }
+            catch {
+                // The child may have exited while taskkill was traversing the tree.
+            }
+        }, 250);
+        try {
+            // Ask the direct child to close immediately so the parent can finish
+            // its lifecycle without waiting for taskkill's process to exit.
+            child.kill();
+        }
+        catch {
+            // taskkill remains responsible for descendants and the close handler
+            // still completes the worker state transition.
+        }
+        killer.once('error', () => {
+            clearTimeout(fallback);
+            try {
+                child.kill();
+            }
+            catch {
+                // The child may already be closed.
+            }
+        });
+        killer.once('close', () => clearTimeout(fallback));
+        return;
+    }
+    try {
+        process.kill(-pid, 'SIGKILL');
+    }
+    catch {
+        child.kill('SIGKILL');
+    }
+}
+function errorFromUnknown(error, fallbackCode, fallbackMessage) {
+    if (error instanceof PersistentTransportError)
+        return error;
+    return new PersistentTransportError(fallbackMessage, fallbackCode, {
+        cause: error instanceof Error ? error : new Error(String(error)),
+    });
+}
+class PersistentAgyWorker {
+    options;
+    sessionId;
+    workerKey;
+    /** Route args fixed at spawn time; a different route needs a new process. */
+    routeArgs;
+    /** Conversation this worker was asked to continue, if any. */
+    seedConversation;
+    onStopped;
+    state = 'starting';
+    child;
+    active;
+    conversationId;
+    idleTimer;
+    startPromise;
+    closePromise = Promise.resolve();
+    closeResolve;
+    closed = true;
+    notifiedStopped = false;
+    stdoutBuffer = '';
+    stderrBytes = 0;
+    readyResolve;
+    readyReject;
+    readySettled = false;
+    constructor(sessionId, workerKey, input, options, onStopped) {
+        this.sessionId = sessionId;
+        this.workerKey = workerKey;
+        this.routeArgs = routeArgs(input);
+        this.seedConversation = input.conversation;
+        this.options = options;
+        this.onStopped = onStopped;
+    }
+    /** The pool key this worker was created for; see workerKeyOf(). */
+    getWorkerKey() {
+        return this.workerKey;
+    }
+    /** True when this worker already exists and can serve the given route. */
+    matchesRoute(input) {
+        return workerKeyOf(input) === this.workerKey;
+    }
+    getState() {
+        return this.state;
+    }
+    async start() {
+        if (this.state === 'stopped' || this.state === 'stopping') {
+            throw new PersistentTransportError('Persistent AGY worker is stopped', 'WORKER_STOPPED');
+        }
+        if (this.state === 'idle' || this.state === 'busy')
+            return;
+        if (this.startPromise !== undefined)
+            return this.startPromise;
+        this.startPromise = this.spawnAndWaitForReady();
+        try {
+            await this.startPromise;
+        }
+        finally {
+            this.startPromise = undefined;
+        }
+    }
+    async request(input) {
+        await this.start();
+        if (this.state !== 'idle') {
+            throw new PersistentTransportError('Persistent AGY worker already has an active request', 'WORKER_BUSY');
+        }
+        if (input.signal?.aborted) {
+            await this.stop('reset');
+            throw new PersistentTransportError('Persistent AGY request aborted before write', 'ABORTED');
+        }
+        const timeoutMs = input.timeoutMs ?? this.options.defaultRequestTimeoutMs;
+        validateInteger('timeoutMs', timeoutMs, 1, 3_600_000);
+        const idleTimeoutMs = input.idleTimeoutMs ?? timeoutMs;
+        validateInteger('idleTimeoutMs', idleTimeoutMs, 1, 3_600_000);
+        const maxOutputBytes = Math.min(input.maxOutputBytes ?? this.options.maxOutputBytes, this.options.maxOutputBytes);
+        validateInteger('maxOutputBytes', maxOutputBytes, 1, this.options.maxOutputBytes);
+        this.clearIdleTimer();
+        this.state = 'busy';
+        return new Promise((resolve, reject) => {
+            const active = {
+                requestId: randomUUID(),
+                sessionId: this.sessionId,
+                startedAt: Date.now(),
+                maxOutputBytes,
+                events: [],
+                onEvent: input.onEvent,
+                signal: input.signal,
+                resolve,
+                reject,
+                outputBytes: 0,
+                firstEventAt: undefined,
+                timer: undefined,
+                idleTimer: undefined,
+                idleTimeoutMs,
+                abortListener: undefined,
+            };
+            this.active = active;
+            active.abortListener = () => this.failActiveAndReset(new PersistentTransportError('Persistent AGY request aborted', 'ABORTED'));
+            input.signal?.addEventListener('abort', active.abortListener, { once: true });
+            // Two independent clocks: the wall clock is a hard ceiling, the idle clock
+            // is re-armed by every frame so a long thinking or tool pause is not a kill.
+            const wallClock = setTimeout(() => this.failActiveAndReset(new PersistentTransportError('Persistent AGY request exceeded its wall-clock timeout', 'TIMEOUT')), timeoutMs);
+            active.timer = wallClock;
+            this.touchActive(active);
+            void this.sendRequest(active, input.text);
+        });
+    }
+    async stop(reason = 'dispose') {
+        if (this.state === 'stopped')
+            return;
+        if (this.state === 'stopping') {
+            await this.closePromise;
+            return;
+        }
+        this.clearIdleTimer();
+        if (this.state === 'starting') {
+            this.rejectReady(reason === 'dispose'
+                ? new PersistentTransportError('Persistent AGY transport was disposed during worker startup', 'DISPOSED')
+                : new PersistentTransportError('Persistent AGY worker stopped before startup completed', 'WORKER_STOPPED'));
+        }
+        if (this.active !== undefined) {
+            this.settleActiveError(new PersistentTransportError(reason === 'dispose'
+                ? 'Persistent AGY transport was disposed'
+                : 'Persistent AGY worker was stopped before request completion', reason === 'dispose' ? 'DISPOSED' : 'WORKER_STOPPED'));
+        }
+        this.state = 'stopping';
+        const child = this.child;
+        if (child === undefined || this.closed) {
+            this.state = 'stopped';
+            this.notifyStopped();
+            return;
+        }
+        if (reason === 'dispose' || reason === 'idle') {
+            try {
+                child.stdin.end();
+            }
+            catch {
+                // The close handler below still performs the final state transition.
+            }
+            await Promise.race([this.closePromise, delay(this.options.shutdownTimeoutMs)]);
+        }
+        if (!this.closed)
+            terminateWorkerTree(child);
+        await this.closePromise;
+    }
+    async spawnAndWaitForReady() {
+        this.state = 'starting';
+        this.closed = false;
+        this.stdoutBuffer = '';
+        this.stderrBytes = 0;
+        this.readySettled = false;
+        this.closePromise = new Promise(resolve => { this.closeResolve = resolve; });
+        const readyPromise = new Promise((resolve, reject) => {
+            this.readyResolve = resolve;
+            this.readyReject = reject;
+        });
+        try {
+            const args = [...this.options.args, ...this.routeArgs];
+            const launch = process.platform === 'win32'
+                ? buildWindowsNoConsoleLaunch(this.options.executable, args)
+                : { executable: this.options.executable, args };
+            const child = spawn(launch.executable, [...launch.args], {
+                cwd: this.options.cwd,
+                env: {
+                    ...process.env,
+                    ...this.options.env,
+                    DSH_AGY_EXPERIMENTAL_SESSION: this.sessionId,
+                },
+                shell: false,
+                detached: process.platform !== 'win32',
+                windowsHide: true,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            this.child = child;
+            this.attachChild(child);
+            const timeout = setTimeout(() => {
+                this.rejectReady(new PersistentTransportError('Persistent AGY worker did not become ready in time', 'WORKER_START_FAILED'));
+            }, this.options.readyTimeoutMs);
+            try {
+                await readyPromise;
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+            const stateAfterReady = this.getState();
+            if (stateAfterReady === 'stopped' || stateAfterReady === 'stopping') {
+                throw new PersistentTransportError('Persistent AGY worker stopped during startup', 'WORKER_START_FAILED');
+            }
+            this.state = 'idle';
+            this.armIdleTimer();
+        }
+        catch (error) {
+            const mapped = errorFromUnknown(error, 'WORKER_START_FAILED', 'Persistent AGY worker failed to start');
+            await this.stop('reset');
+            throw mapped;
+        }
+        finally {
+            this.readyResolve = undefined;
+            this.readyReject = undefined;
+        }
+    }
+    attachChild(child) {
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => this.handleStdout(chunk));
+        child.stderr.on('data', (chunk) => {
+            this.stderrBytes += byteLength(chunk);
+            if (this.stderrBytes > this.options.maxStderrBytes) {
+                this.failActiveAndReset(new PersistentTransportError('Persistent AGY worker stderr exceeded its capture limit', 'OUTPUT_LIMIT'));
+            }
+        });
+        child.once('error', error => {
+            const code = this.state === 'starting'
+                ? 'WORKER_START_FAILED'
+                : 'WORKER_CRASHED';
+            const mapped = new PersistentTransportError(code === 'WORKER_START_FAILED'
+                ? 'Persistent AGY worker could not be started'
+                : 'Persistent AGY worker process failed', code, { cause: error });
+            this.rejectReady(mapped);
+            if (this.active !== undefined)
+                this.settleActiveError(mapped);
+        });
+        child.once('close', (exitCode, signal) => {
+            this.closed = true;
+            this.clearIdleTimer();
+            if (!this.readySettled) {
+                this.rejectReady(new PersistentTransportError('Persistent AGY worker exited before ready', 'WORKER_START_FAILED'));
+            }
+            if (this.active !== undefined) {
+                this.settleActiveError(new PersistentTransportError(`Persistent AGY worker exited before request completion (${exitCode ?? 'signal'})`, 'WORKER_CRASHED', { cause: signal === null ? undefined : new Error(signal) }));
+            }
+            this.state = 'stopped';
+            this.closeResolve?.();
+            this.closeResolve = undefined;
+            this.notifyStopped();
+        });
+    }
+    handleStdout(chunk) {
+        this.stdoutBuffer += chunk;
+        // A runaway child can emit one endless line with no newline; without this
+        // check the un-split buffer grows past maxOutputBytes unchecked (the byte
+        // valve only runs on completed lines).
+        if (this.stdoutBuffer.length > this.options.maxFrameBytes) {
+            this.failActiveAndReset(new PersistentTransportError('Persistent AGY emitted a stdout line beyond the frame limit', 'OUTPUT_LIMIT'));
+            this.stdoutBuffer = '';
+            return;
+        }
+        let newlineIndex = this.stdoutBuffer.indexOf('\n');
+        while (newlineIndex >= 0) {
+            const rawLine = this.stdoutBuffer.slice(0, newlineIndex);
+            this.stdoutBuffer = this.stdoutBuffer.slice(newlineIndex + 1);
+            this.handleLine(rawLine.endsWith('\r') ? rawLine.slice(0, -1) : rawLine);
+            newlineIndex = this.stdoutBuffer.indexOf('\n');
+        }
+    }
+    handleLine(line) {
+        let parsed;
+        try {
+            parsed = parseAgyOutputLine(line);
+        }
+        catch (error) {
+            this.failActiveAndReset(errorFromUnknown(error, 'PROTOCOL_ERROR', 'Persistent AGY worker emitted an invalid frame'));
+            return;
+        }
+        const event = parsed.event;
+        const raw = parsed.raw;
+        // init is the ready signal (emitted once at worker start)
+        if (event === 'init') {
+            const convId = typeof raw.conversation_id === 'string' ? raw.conversation_id : undefined;
+            if (convId !== undefined)
+                this.conversationId = convId;
+            // A worker asked to continue conversation X that comes up as Y would
+            // answer the turn with no history at all while looking healthy. Fail the
+            // request before any delta so the caller can resend full history.
+            if (this.seedConversation !== undefined && convId !== undefined && convId !== this.seedConversation) {
+                this.rejectReady(new PersistentTransportError(`Persistent AGY worker was asked to continue conversation ${this.seedConversation} but started ${convId}`, 'CONVERSATION_MISMATCH'));
+                return;
+            }
+            this.resolveReady();
+            return;
+        }
+        const active = this.active;
+        if (active === undefined) {
+            // No active request: ignore stray step_update/result that belong to previous turn already settled
+            // But if we get a result without active, treat as protocol error and reset
+            if (event === 'result') {
+                this.failActiveAndReset(new PersistentTransportError('Persistent AGY worker emitted a result without an active request', 'PROTOCOL_ERROR'));
+            }
+            return;
+        }
+        // Track output size
+        active.outputBytes += byteLength(`${line}\n`);
+        if (active.outputBytes > active.maxOutputBytes) {
+            this.failActiveAndReset(new PersistentTransportError('Persistent AGY worker response exceeded its capture limit', 'OUTPUT_LIMIT'));
+            return;
+        }
+        // A line arrived: the worker is alive, so the inactivity clock restarts.
+        this.touchActive(active);
+        // Verify conversation_id correlation when present
+        const resultConv = raw.result?.conversation_id
+            ?? raw.step_update?.conversation_id;
+        if (typeof resultConv === 'string' && this.conversationId !== undefined && resultConv !== this.conversationId) {
+            this.failActiveAndReset(new PersistentTransportError('Persistent AGY worker conversation_id mismatch', 'PROTOCOL_ERROR'));
+            return;
+        }
+        if (event === 'step_update') {
+            active.firstEventAt ??= Date.now();
+            active.events.push(raw);
+            try {
+                active.onEvent?.(raw);
+            }
+            catch (error) {
+                this.failActiveAndReset(new PersistentTransportError('Persistent AGY worker event handler failed', 'EVENT_HANDLER_FAILED', { cause: error instanceof Error ? error : new Error(String(error)) }));
+            }
+            return;
+        }
+        if (event === 'result') {
+            const result = raw.result;
+            const status = typeof result?.status === 'string' ? result.status : undefined;
+            if (status !== 'SUCCESS') {
+                const errMsg = typeof result?.error === 'string' ? result.error : 'AGY result status ' + status;
+                this.failActiveAndReset(new PersistentTransportError('Persistent AGY worker returned error result: ' + errMsg.slice(0, 256), 'WORKER_ERROR'));
+                return;
+            }
+            active.firstEventAt ??= Date.now();
+            active.events.push(raw);
+            try {
+                active.onEvent?.(raw);
+            }
+            catch (error) {
+                this.failActiveAndReset(new PersistentTransportError('Persistent AGY worker event handler failed', 'EVENT_HANDLER_FAILED', { cause: error instanceof Error ? error : new Error(String(error)) }));
+                return;
+            }
+            this.settleActiveSuccess();
+            return;
+        }
+        // Unknown event: treat as protocol error
+        this.failActiveAndReset(new PersistentTransportError('Persistent AGY worker emitted unknown event: ' + event, 'PROTOCOL_ERROR'));
+    }
+    async sendRequest(active, text) {
+        try {
+            const frame = encodeAgyUserMessage(text, this.options.maxFrameBytes);
+            await this.writeFrame(frame);
+        }
+        catch (error) {
+            if (this.active !== active)
+                return;
+            this.failActiveAndReset(errorFromUnknown(error, 'PROTOCOL_ERROR', 'Persistent AGY request could not be written'));
+        }
+    }
+    async writeFrame(frame) {
+        const stdin = this.child?.stdin;
+        if (stdin === undefined || !stdin.writable) {
+            throw new PersistentTransportError('Persistent AGY worker stdin is closed', 'WORKER_STOPPED');
+        }
+        if (stdin.write(frame))
+            return;
+        await new Promise((resolve, reject) => {
+            const onDrain = () => {
+                cleanup();
+                resolve();
+            };
+            const onError = (error) => {
+                cleanup();
+                reject(error);
+            };
+            // A worker torn down mid-drain ends stdin; Node never emits 'drain' on
+            // an ended stream, so without a close listener this promise would hang
+            // forever and leak its callers.
+            const onClose = () => {
+                cleanup();
+                reject(new PersistentTransportError('Persistent AGY worker stdin closed during write', 'WORKER_STOPPED'));
+            };
+            const cleanup = () => {
+                stdin.removeListener('drain', onDrain);
+                stdin.removeListener('error', onError);
+                stdin.removeListener('close', onClose);
+            };
+            stdin.once('drain', onDrain);
+            stdin.once('error', onError);
+            stdin.once('close', onClose);
+        });
+    }
+    settleActiveSuccess() {
+        const active = this.active;
+        if (active === undefined)
+            return;
+        this.active = undefined;
+        this.clearActive(active);
+        this.state = 'idle';
+        this.armIdleTimer();
+        active.resolve({
+            requestId: active.requestId,
+            sessionId: active.sessionId,
+            events: [...active.events],
+            durationMs: Date.now() - active.startedAt,
+            ...(active.firstEventAt === undefined ? {} : { firstEventMs: active.firstEventAt - active.startedAt }),
+        });
+    }
+    settleActiveError(error) {
+        const active = this.active;
+        if (active === undefined)
+            return;
+        this.active = undefined;
+        this.clearActive(active);
+        active.reject(error);
+    }
+    clearActive(active) {
+        if (active.timer !== undefined)
+            clearTimeout(active.timer);
+        if (active.idleTimer !== undefined)
+            clearTimeout(active.idleTimer);
+        if (active.abortListener !== undefined)
+            active.signal?.removeEventListener('abort', active.abortListener);
+        active.abortListener = undefined;
+    }
+    /** Re-arm the inactivity clock; every frame proves the worker is alive. */
+    touchActive(active) {
+        const idleTimeoutMs = active.idleTimeoutMs;
+        if (idleTimeoutMs === undefined)
+            return;
+        if (active.idleTimer !== undefined)
+            clearTimeout(active.idleTimer);
+        active.idleTimer = setTimeout(() => this.failActiveAndReset(new PersistentTransportError(`Persistent AGY request produced no output for ${idleTimeoutMs} ms`, 'TIMEOUT')), idleTimeoutMs);
+    }
+    failActiveAndReset(error) {
+        this.settleActiveError(error);
+        void this.stop('reset');
+    }
+    resolveReady() {
+        if (this.readySettled)
+            return;
+        this.readySettled = true;
+        this.readyResolve?.();
+    }
+    rejectReady(error) {
+        if (this.readySettled)
+            return;
+        this.readySettled = true;
+        this.readyReject?.(error);
+    }
+    armIdleTimer() {
+        this.clearIdleTimer();
+        if (this.options.idleTtlMs === 0 || this.state !== 'idle')
+            return;
+        this.idleTimer = setTimeout(() => { void this.stop('idle'); }, this.options.idleTtlMs);
+    }
+    clearIdleTimer() {
+        if (this.idleTimer !== undefined)
+            clearTimeout(this.idleTimer);
+        this.idleTimer = undefined;
+    }
+    notifyStopped() {
+        if (this.notifiedStopped)
+            return;
+        this.notifiedStopped = true;
+        this.onStopped(this);
+    }
+}
+/**
+ * Worker-per-route persistent transport. One AGY process per (session, route);
+ * the worker holds a single active turn and is keyed by the route because AGY
+ * fixes --agent/--model/--effort at process start.
+ */
+export class ExperimentalAgyTransport {
+    options;
+    workers = new Map();
+    disposed = false;
+    constructor(options) {
+        this.options = normalizeOptions(options);
+    }
+    async request(input) {
+        if (this.disposed) {
+            throw new PersistentTransportError('Persistent AGY transport is disposed', 'DISPOSED');
+        }
+        if (input.sessionId.trim().length === 0) {
+            throw new RangeError('sessionId must not be empty');
+        }
+        const key = workerKeyOf(input);
+        let worker = this.workers.get(key);
+        if (worker?.getState() === 'stopped') {
+            this.workers.delete(key);
+            worker = undefined;
+        }
+        if (worker === undefined) {
+            if (this.workers.size >= this.options.maxWorkers) {
+                throw new PersistentTransportError('Persistent AGY worker limit reached', 'WORKER_LIMIT');
+            }
+            worker = new PersistentAgyWorker(input.sessionId, key, input, this.options, stoppedWorker => {
+                if (this.workers.get(key) === stoppedWorker)
+                    this.workers.delete(key);
+            });
+            this.workers.set(key, worker);
+        }
+        try {
+            return await worker.request(input);
+        }
+        catch (error) {
+            if (worker.getState() === 'stopped')
+                this.workers.delete(key);
+            throw error;
+        }
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        const workers = [...this.workers.values()];
+        await Promise.all(workers.map(worker => worker.stop('dispose')));
+        this.workers.clear();
+    }
+    getStats() {
+        let startingWorkers = 0;
+        let idleWorkers = 0;
+        let busyWorkers = 0;
+        let stoppingWorkers = 0;
+        for (const worker of this.workers.values()) {
+            switch (worker.getState()) {
+                case 'starting':
+                    startingWorkers += 1;
+                    break;
+                case 'idle':
+                    idleWorkers += 1;
+                    break;
+                case 'busy':
+                    busyWorkers += 1;
+                    break;
+                case 'stopping':
+                    stoppingWorkers += 1;
+                    break;
+                case 'stopped': break;
+            }
+        }
+        return {
+            totalWorkers: this.workers.size,
+            startingWorkers,
+            idleWorkers,
+            busyWorkers,
+            stoppingWorkers,
+            maxWorkers: this.options.maxWorkers,
+            disposed: this.disposed,
+        };
+    }
+}
+//# sourceMappingURL=persistent-transport.js.map