@excitedjs/agent-runtime-claude-code 0.7.0-alpha.gea3dc096ae44 → 0.7.0-beta.213

package/dist/rpc.js

@@ -1,308 +1,154 @@
+import { randomUUID } from 'node:crypto';
+import { buildCanUseToolAllow, buildControlAck, buildRemoteControlEnable, buildUserMessage, LineBuffer, parseLine, TurnAggregator, } from './stream.js';
+import { completionFromTurnOutcome } from './runtime-session.js';
 /**
- * Claude Code stream-json turn RPC.
- *
- * The supervisor owns the child process. This class owns one in-flight command
- * group, stdout line demux, command drainage, and defensive control replies.
- *
- * One resident CLI execution window can span several submitted commands: a
- * live steer is written while the CLI is already running. How the CLI answers them is
- * not fixed, which is what makes settlement subtle (probed against a live
- * 2.1.231 resident session):
- *
- *  - **Commands fold.** A message that arrives while the in-flight turn is
- *    inside a tool call is absorbed into that turn at the next query-loop
- *    boundary. Several commands then share ONE `result` (3 → 1 observed), and
- *    a folded command's uuid never appears on any `result`.
- *  - **Or they do not.** A command that arrives between turns runs on its own
- *    and gets its own `result`.
- *  - **`result.user_message_uuid` is not a completion ledger.** It is present
- *    only sometimes and is not reliably the first-submitted uuid of a fold. It
- *    is present on the artifact an accepted interrupt produces (measured
- *    against claude 2.1.263), so presence does not mean "this is an answer".
- *  - **`command_lifecycle` is the attribution signal.** Started commands identify
- *    the submissions represented by the next native `result`; terminal states
- *    drain the resident execution window. Its ordering against `result` is not
- *    stable.
- *
- * Every valid `result` is forwarded immediately as its own native completion
- * boundary. Lifecycle terminality only decides when the command group has
- * drained and the resident session may accept a new initial command; it never
- * aggregates several results into one completion.
+ * One resident transport, one association from UUID to unanswered request.
+ * Native results consume requests directly; no aggregate execution window waits
+ * for terminal lifecycle frames. The consumed set also includes native internal
+ * commands so cancellation is scoped to work that actually entered a turn.
  */
-import { randomUUID } from 'node:crypto';
-import { buildUserMessage, LineBuffer, parseLine, TurnAggregator, } from './stream.js';
-import { ClaudeCodeControlRpc } from './control-rpc.js';
-/** Provider-private admission classification; never crosses the neutral API. */
-export class ClaudeSteerAdmissionError extends Error {
-    admission;
-    constructor(admission, message, options) {
-        super(message, options);
-        this.admission = admission;
-        this.name = 'ClaudeSteerAdmissionError';
-    }
-}
 export class ClaudeCodeStreamRpc {
     stdin;
     options;
     lineBuf = new LineBuffer();
-    pending = null;
+    aggregator = new TurnAggregator();
+    requests = new Map();
+    consumed = new Set();
     lifecycleSupported = null;
-    control;
+    timer = null;
+    closed = false;
+    remoteControlRequestId = null;
     constructor(stdin, options) {
         this.stdin = stdin;
         this.options = options;
-        this.control = new ClaudeCodeControlRpc(stdin, options);
     }
-    async submitTurn(prompt, options = {}, commandUuid = randomUUID()) {
-        if (!this.stdin.writable) {
-            return Promise.reject(new Error('claude resident child is not running'));
+    submit(prompt, options = {}, commandUuid = randomUUID()) {
+        if (this.closed || !this.stdin.writable) {
+            return Promise.resolve({ status: 'failed', error: new Error('claude resident child is not running') });
         }
-        if (this.pending !== null) {
-            return Promise.reject(new Error('claude resident session is already mid-turn'));
+        const concurrent = this.requests.size > 0;
+        if (concurrent && this.lifecycleSupported === false) {
+            return Promise.resolve({ status: 'failed', error: lifecycleUnsupportedError() });
         }
-        return new Promise((resolve, reject) => {
-            const pending = {
-                resolve,
-                reject,
-                aggregator: new TurnAggregator(),
-                timer: null,
-                submitted: [commandUuid],
-                terminal: new Set(),
-                startedSinceResult: new Set(),
-                ranAnyCommand: false,
-                sawResult: false,
-                interruptRequested: false,
-                lastAbnormalReason: null,
-                capabilityWaiters: [],
-                writeWaiters: new Map(),
-            };
-            this.pending = pending;
-            // Arm the idle deadline (reset on every inbound stream line in `onLine`).
-            this.armIdleTimer(pending);
-            try {
-                this.stdin.write(`${buildUserMessage(prompt, options, commandUuid)}\n`, (err) => {
-                    if (err != null && this.pending === pending) {
-                        const error = asError(err);
-                        this.settlePending(error)?.reject(error);
+        let settle;
+        const submission = Object.freeze({
+            settled: new Promise((resolve) => { settle = resolve; }),
+        });
+        return new Promise((admit) => {
+            const request = {
+                submission,
+                settle,
+                admit,
+                write: () => {
+                    request.write = null;
+                    this.armIdleTimer();
+                    try {
+                        this.stdin.write(`${buildUserMessage(prompt, options, commandUuid)}\n`, (error) => {
+                            if (error != null)
+                                this.failWrite(commandUuid, request, error);
+                            else
+                                this.acceptRequest(request);
+                        });
                     }
-                });
-            }
-            catch (error) {
-                if (this.pending === pending) {
-                    const failure = asError(error);
-                    this.settlePending(failure)?.reject(failure);
-                }
+                    catch (error) {
+                        this.failWrite(commandUuid, request, asError(error));
+                    }
+                },
+            };
+            // Registration precedes writing: a transport may synchronously acknowledge
+            // or answer this message before write() returns or invokes its callback.
+            this.requests.set(commandUuid, request);
+            if (this.lifecycleSupported === true) {
+                // Reentrant input must not overtake older requests waiting on init.
+                for (const pending of this.requests.values())
+                    pending.write?.();
             }
+            else if (!concurrent)
+                request.write();
         });
     }
-    async steerTurn(prompt, options = {}, commandUuid = randomUUID()) {
-        if (!this.stdin.writable) {
-            return Promise.reject(preAdmissionError('claude resident child is not running'));
-        }
-        if (this.pending === null) {
-            return Promise.reject(preAdmissionError('claude resident session has no active turn'));
-        }
-        const pending = this.pending;
-        if (this.lifecycleSupported === false) {
-            return Promise.reject(lifecycleUnsupportedError());
-        }
-        if (this.lifecycleSupported === null) {
-            return new Promise((resolve, reject) => {
-                pending.capabilityWaiters.push({ prompt, options, commandUuid, resolve, reject });
-            });
-        }
-        return this.writeSteer(pending, prompt, options, commandUuid);
+    acceptRequest(request) {
+        request.admit?.({ status: 'submitted', submission: request.submission });
+        request.admit = null;
     }
-    writeSteer(pending, prompt, options, commandUuid = randomUUID()) {
-        if (this.pending !== pending) {
-            return Promise.reject(capabilityUndecidedTurnEndedError());
-        }
-        if (!this.stdin.writable) {
-            return Promise.reject(preAdmissionError('claude resident child is not running'));
-        }
-        // The steer joins this resident execution window: from here on it cannot drain
-        // until this command has also reached a terminal lifecycle state.
-        pending.submitted.push(commandUuid);
-        return new Promise((resolve, reject) => {
-            pending.writeWaiters.set(commandUuid, { resolve, reject });
-            const fail = (error) => {
-                // A steer whose write failed will never reach the CLI, so no
-                // `command_lifecycle` is coming for it: mark it terminal here or the
-                // turn waits on a signal that cannot arrive. Reject the waiter first,
-                // since marking may settle the turn and settlement rejects surviving
-                // waiters with the generic write-unconfirmed message.
-                this.rejectWriteWaiter(pending, commandUuid, ambiguousWriteError(error));
-                this.markCommandTerminal(pending, commandUuid, 'steer write failed');
-            };
-            try {
-                this.stdin.write(`${buildUserMessage(prompt, options, commandUuid)}\n`, (err) => {
-                    if (err != null) {
-                        fail(err);
-                        return;
-                    }
-                    this.resolveWriteWaiter(pending, commandUuid);
-                });
-            }
-            catch (error) {
-                fail(error);
-            }
-        });
+    failWrite(uuid, request, error) {
+        if (this.requests.get(uuid) !== request || request.admit === null)
+            return;
+        this.requests.delete(uuid);
+        this.consumed.delete(uuid);
+        request.admit({ status: 'ambiguous', error });
+        request.admit = null;
+        request.settle({ kind: 'failed', error });
+        this.clearIdleIfEmpty();
     }
     onStdoutChunk(chunk) {
-        for (const line of this.lineBuf.push(chunk))
+        if (this.closed)
+            return;
+        for (const line of this.lineBuf.push(chunk)) {
+            if (this.closed)
+                break;
             this.onLine(parseLine(line));
+        }
     }
-    failPending(err) {
-        this.settlePending(err)?.reject(err);
+    /** Actual transport loss fails each outstanding request, without a completion. */
+    fail(error) {
+        this.close({ kind: 'failed', error });
     }
-    interruptTurn(reason) {
-        return this.control.interruptTurn(this.pending, reason);
+    /** Explicit teardown stops requests and converges unconfirmed admissions. */
+    stop() {
+        this.close({ kind: 'stopped' });
     }
-    enableRemoteControl() {
-        this.control.enableRemoteControl();
-    }
-    /**
-     * Detach the in-flight turn: clear its deadline timer and null `pending`,
-     * returning it so the caller can resolve or reject it exactly once.
-     */
-    settlePending(failure, interruptOutcome = false) {
-        const pending = this.pending;
-        if (pending === null)
-            return null;
-        if (pending.timer !== null)
-            clearTimeout(pending.timer);
-        this.pending = null;
-        this.control.settleTurn(pending, failure, interruptOutcome);
-        // On an explicit failure (write error, stop, idle reap) both waiter kinds
-        // get the real error. On a clean `result` settlement there is no error:
-        // capability waiters never got a decision, while write waiters were written
-        // but unconfirmed — distinct messages for distinct conditions.
-        this.rejectCapabilityWaiters(pending, failure ?? capabilityUndecidedTurnEndedError());
-        this.rejectWriteWaiters(pending, failure ?? steerWriteUnconfirmedError());
-        return pending;
+    close(settlement) {
+        this.closed = true;
+        const error = settlement.kind === 'failed'
+            ? settlement.error
+            : new Error('claude resident session stopped before write acknowledgement');
+        for (const request of this.requests.values()) {
+            request.admit?.(request.write === null
+                ? { status: 'ambiguous', error }
+                : settlement.kind === 'stopped' ? { status: 'stopped' } : { status: 'failed', error });
+            request.admit = null;
+            request.settle(settlement);
+        }
+        this.requests.clear();
+        this.consumed.clear();
+        this.aggregator.discard();
+        this.clearIdleIfEmpty();
     }
-    /**
-     * End the execution window on the artifact of an accepted interrupt. This is
-     * the only settlement an interrupt has, deliberately: a lifecycle
-     * `cancelled` for the same command arrives *after* the artifact and is then
-     * a no-op, so no path can settle the turn early and leave the artifact to
-     * arrive against an empty `pending` — which the `result` case reads as an
-     * unattributable envelope and answers by reaping the resident child.
-     */
-    settleInterrupted(pending) {
-        if (this.pending !== pending)
+    enableRemoteControl() {
+        if (this.closed || !this.stdin.writable)
             return;
-        this.options.onProtocolEvent?.({ kind: 'interrupted' });
-        this.settlePending(undefined, true)?.resolve();
+        this.remoteControlRequestId = randomUUID();
+        this.stdin.write(`${buildRemoteControlEnable(this.remoteControlRequestId)}\n`);
     }
-    /**
-     * Mark a submitted command as producing nothing further, then re-check
-     * settlement. `abnormalReason` is `null` for the normal ending (`completed`)
-     * and a short phrase for a command that never ran — those are logged,
-     * because the CLI gives no other trace of a command it declined.
-     *
-     * A command ending abnormally never fails the turn by itself: the probe
-     * shows a `cancelled` command coexisting with another that answers normally
-     * (that is exactly what an interrupt looks like), so
-     * rejecting on `cancelled` — as the pre-#342 code did — is wrong.
-     */
-    markCommandTerminal(pending, commandUuid, abnormalReason) {
-        if (!pending.submitted.includes(commandUuid))
-            return;
-        if (!pending.terminal.has(commandUuid)) {
-            pending.terminal.add(commandUuid);
-            if (abnormalReason === null) {
-                pending.ranAnyCommand = true;
-            }
-            else {
-                pending.lastAbnormalReason = abnormalReason;
-                this.options.log?.('warn', `claude command ${commandUuid} ${abnormalReason}; it will not ` +
-                    'produce further output for this turn');
-            }
+    clearIdleIfEmpty() {
+        if (this.requests.size === 0 && this.timer !== null) {
+            clearTimeout(this.timer);
+            this.timer = null;
         }
-        this.settleIfReady(pending);
     }
-    /**
-     * The drainage gate: every submitted command has reached a terminal
-     * lifecycle state AND at least one valid `result` has been seen. Result
-     * identity and settlement have already been forwarded one-by-one.
-     *
-     * Two escapes, both anti-hang:
-     *
-     *  - no lifecycle signal at all (`msg_lifecycle_v1` absent, so no
-     *    `command_lifecycle` will ever arrive) — the `result` is then the only
-     *    terminal event there is, so settle on it;
-     *  - every command terminal, none of them ever ran, and no result — nothing
-     *    can answer this turn, so fail it loudly. The idle deadline is not an
-     *    acceptable backstop here: it reaps the resident child, and any inbound
-     *    line re-arms it, so a healthy session could be killed long after the
-     *    turn became unanswerable.
-     *
-     * When a command *did* run but no result has arrived yet, this waits: the
-     * probe shows terminal lifecycle states arriving both before and after the
-     * result they belong to, so "terminal, therefore no result is coming" is not
-     * a sound inference.
-     */
-    settleIfReady(pending) {
-        if (this.pending !== pending)
-            return;
-        if (pending.sawResult && this.lifecycleSupported !== true) {
-            this.settlePending()?.resolve();
+    /** Outstanding work has a max-idle deadline; pure background work has none. */
+    armIdleTimer() {
+        if (this.requests.size === 0)
             return;
-        }
-        if (pending.startedSinceResult.size > 0)
-            return;
-        for (const commandUuid of pending.submitted) {
-            if (!pending.terminal.has(commandUuid))
-                return;
-        }
-        if (pending.sawResult) {
-            this.settlePending()?.resolve();
-            return;
-        }
-        if (pending.ranAnyCommand)
-            return;
-        const error = new Error('claude turn ended without running any of its commands ' +
-            `(last: ${pending.lastAbnormalReason ?? 'no command reached the CLI'})`);
-        // Pass the cause into `settlePending` so surviving steer waiters get the
-        // real reason instead of the generic write-unconfirmed message.
-        this.settlePending(error)?.reject(error);
-    }
-    /**
-     * (Re)arm the per-turn idle deadline. `turnTimeoutMs` is a *max-idle* window,
-     * not a total-turn cap: any inbound stream line for this turn pushes it out
-     * (see `onLine`). A genuinely wedged child (no stream activity for the whole
-     * window) is still reaped — preserving the #120 anti-hang intent — but a long
-     * but continuously-streaming turn never trips the deadline (#156).
-     */
-    armIdleTimer(pending) {
-        if (pending.timer !== null)
-            clearTimeout(pending.timer);
-        pending.timer = setTimeout(() => {
-            if (this.pending !== pending)
-                return;
-            const error = new Error(`claude resident turn stalled: no stream activity for ${this.options.turnTimeoutMs}ms`);
-            const stalled = this.settlePending(error);
-            if (stalled === null)
-                return;
-            this.options.log?.('error', `claude turn stalled: no stream activity for ${this.options.turnTimeoutMs}ms; reaping resident child`);
-            stalled.reject(error);
-            this.options.reapOnTimeout();
+        if (this.timer !== null)
+            clearTimeout(this.timer);
+        this.timer = setTimeout(() => {
+            const error = new Error(`claude resident requests stalled: no stream activity for ${this.options.turnTimeoutMs}ms`);
+            this.options.log?.('error', `${error.message}; reaping resident child`);
+            this.fail(error);
+            this.options.reapOnTimeout(error);
         }, this.options.turnTimeoutMs);
     }
     onLine(line) {
-        // Idle-timeout reset: any inbound stream line for the pending turn is
-        // activity, so push the deadline out. The terminal `result` clears the
-        // timer via `settlePending` below.
-        if (this.pending !== null)
-            this.armIdleTimer(this.pending);
+        this.armIdleTimer();
         switch (line.kind) {
             case 'init':
+                this.aggregator.accept(line);
                 this.decideLifecycleSupport(line.capabilities.includes('msg_lifecycle_v1'));
-                this.pending?.aggregator.accept(line);
                 break;
             case 'assistant':
-                this.pending?.aggregator.accept(line);
+                this.aggregator.accept(line);
                 this.options.onProtocolEvent?.({ kind: 'stream', line });
                 break;
             case 'user':
@@ -310,178 +156,145 @@ export class ClaudeCodeStreamRpc {
                 this.options.onProtocolEvent?.({ kind: 'stream', line });
                 break;
             case 'command_lifecycle': {
-                const pending = this.pending;
-                if (pending === null || line.commandUuid === null)
+                const { commandUuid, state } = line;
+                if (commandUuid === null || state === null)
                     break;
-                if (line.state !== null) {
-                    this.options.onProtocolEvent?.({
-                        kind: 'command_lifecycle',
-                        commandUuid: line.commandUuid,
-                        state: line.state,
-                    });
-                }
-                if (line.state === 'started')
-                    pending.startedSinceResult.add(line.commandUuid);
-                // `command_lifecycle` does double duty: it coordinates live-steer
-                // admission (writeWaiters) and proves lifecycle capability, and its
-                // terminal states are the drainage gate when the CLI represents several
-                // started commands with one `result`.
-                const newlySupported = this.lifecycleSupported === null;
-                if (newlySupported)
-                    this.lifecycleSupported = true;
-                this.resolveWriteWaiter(pending, line.commandUuid);
-                if (newlySupported && this.pending === pending) {
-                    this.flushCapabilityWaiters(pending);
-                }
-                if (this.pending !== pending)
-                    break;
-                if (line.state === 'completed') {
-                    this.markCommandTerminal(pending, line.commandUuid, null);
-                }
-                else if (line.state === 'cancelled' || line.state === 'discarded' || line.state === 'refused') {
-                    pending.startedSinceResult.delete(line.commandUuid);
-                    this.markCommandTerminal(pending, line.commandUuid, `was ${line.state} by claude`);
+                if (state === 'started')
+                    this.consumed.add(commandUuid);
+                const request = this.requests.get(commandUuid);
+                if (request?.write === null) {
+                    this.acceptRequest(request);
+                    // Consumed commands can report cancelled before their failure result.
+                    // Keep the result's members; lifecycle alone cannot supply its outcome.
+                    if (state === 'discarded' || state === 'refused' ||
+                        (state === 'cancelled' && !this.consumed.has(commandUuid))) {
+                        this.requests.delete(commandUuid);
+                        request.settle({ kind: 'failed', error: new Error(`claude command was ${state}`) });
+                        this.clearIdleIfEmpty();
+                    }
                 }
+                // An unconsumed command's cancellation cannot discard generating text.
+                if (state === 'cancelled' && this.consumed.has(commandUuid))
+                    this.aggregator.discard();
+                this.options.onProtocolEvent?.({ kind: 'command_lifecycle', commandUuid, state });
+                this.decideLifecycleSupport(true);
                 break;
             }
             case 'result': {
-                const pending = this.pending;
-                if (pending === null) {
-                    const error = new Error('claude result envelope arrived without an attributable command group');
-                    this.options.log?.('error', error.message, error);
-                    this.options.reapOnTimeout();
-                    break;
+                this.aggregator.accept(line);
+                const outcome = this.aggregator.takeOutcome();
+                const commandUuids = new Set(this.consumed);
+                this.consumed.clear();
+                const uuid = line.outcome.userMessageUuid;
+                if (uuid !== null)
+                    commandUuids.add(uuid);
+                if (this.lifecycleSupported !== true && uuid === null) {
+                    for (const [id, request] of this.requests) {
+                        if (request.write === null)
+                            commandUuids.add(id);
+                    }
                 }
-                const commandUuid = line.outcome.userMessageUuid;
-                if (commandUuid !== null && !pending.submitted.includes(commandUuid)) {
-                    const error = new Error(`claude result envelope for unsubmitted command ${commandUuid}; ` +
-                        'native completion ownership is ambiguous');
-                    this.options.log?.('error', error.message, error);
-                    this.settlePending(error)?.reject(error);
-                    this.options.reapOnTimeout();
-                    break;
+                const answered = [];
+                const submittedUuids = [];
+                for (const id of commandUuids) {
+                    const request = this.requests.get(id);
+                    if (request === undefined || request.write !== null)
+                        continue;
+                    this.requests.delete(id);
+                    answered.push(request);
+                    submittedUuids.push(id);
                 }
-                // The artifact an accepted interrupt leaves behind is not a native
-                // answer boundary. Measured against claude 2.1.263 (both an interrupted
-                // stream and an interrupted tool call): it is a `result` with subtype
-                // `error_during_execution`, `is_error: true`, no result text, and the
-                // interrupted command's own `user_message_uuid`. Nothing in its shape
-                // separates it from a genuine execution error, so our own accepted
-                // request is the discriminator — an `error_during_execution` nobody
-                // asked for stays a real failure and falls through below.
-                if (pending.interruptRequested &&
-                    line.outcome.subtype === 'error_during_execution') {
-                    this.settleInterrupted(pending);
-                    break;
+                this.clearIdleIfEmpty();
+                const completion = answered.length === 0 ? null : completionFromTurnOutcome(outcome, this.options.sessionId, this.options.outputSchemaEnabled === true);
+                // Remove the answered requests before callbacks can admit or stop work.
+                // Native end is still delivered before these submissions settle.
+                this.options.onProtocolEvent?.({ kind: 'result', outcome, commandUuids: submittedUuids });
+                for (const request of answered) {
+                    this.acceptRequest(request);
+                    request.settle({ kind: 'completion', completion: completion });
                 }
-                // Inherited from #342: an `error_during_execution` carrying neither a
-                // uuid nor result text is nobody's answer and mints no boundary. Its
-                // premise was not reproduced here — a steer sent mid-tool-call did not
-                // abort the turn and produced no artifact at all (claude 2.1.263) —
-                // and the streaming-phase steer was not probed, so it stays as it was
-                // rather than being deleted on one negative observation.
-                if (line.outcome.subtype === 'error_during_execution' &&
-                    line.outcome.userMessageUuid === null &&
-                    line.outcome.text === null) {
-                    this.options.log?.('warn', 'claude interrupt result artifact ignored');
-                    break;
-                }
-                pending.aggregator.accept(line);
-                const outcome = pending.aggregator.takeOutcome();
-                pending.startedSinceResult.clear();
-                pending.sawResult = true;
-                this.options.onProtocolEvent?.({
-                    kind: 'result',
-                    outcome,
-                });
-                this.settleIfReady(pending);
+                if (this.lifecycleSupported !== true)
+                    this.rejectWaitingRequests();
                 break;
             }
             case 'control_request':
-                this.control.onControlRequest(line.requestId, line.subtype, line.request);
+                this.onControlRequest(line.requestId, line.subtype, line.request);
                 break;
             case 'control_response':
-                this.control.onControlResponse(line.requestId, line.ok, line.response, line.error);
+                this.onControlResponse(line.requestId, line.ok, line.response, line.error);
                 break;
             case 'parse_error':
                 this.options.log?.('warn', `claude stream-json parse error: ${line.raw}`);
                 break;
             default:
-                // Every other envelope (`system` notices past `init` and
-                // `compact_boundary`, `stream_event`,
-                // `rate_limit_event`, ...) carries nothing the runtime consumes. It
-                // already counted as activity for the idle deadline above.
                 break;
         }
     }
     decideLifecycleSupport(supported) {
-        if (this.lifecycleSupported !== null)
+        if (this.lifecycleSupported === true)
             return;
-        this.lifecycleSupported = supported;
-        const pending = this.pending;
-        if (pending === null)
+        if (!supported && this.lifecycleSupported !== null)
             return;
-        if (supported) {
-            this.flushCapabilityWaiters(pending);
+        this.lifecycleSupported = supported;
+        if (!supported) {
+            this.rejectWaitingRequests();
             return;
         }
-        this.rejectCapabilityWaiters(pending, lifecycleUnsupportedError());
+        for (const request of this.requests.values())
+            request.write?.();
     }
-    flushCapabilityWaiters(pending) {
-        const waiters = pending.capabilityWaiters.splice(0);
-        for (const waiter of waiters) {
-            void this.writeSteer(pending, waiter.prompt, waiter.options, waiter.commandUuid).then(waiter.resolve, waiter.reject);
+    rejectWaitingRequests() {
+        const error = this.lifecycleSupported === false ? lifecycleUnsupportedError()
+            : new Error('claude result arrived before concurrent-input capability was decided');
+        for (const [uuid, request] of this.requests) {
+            if (request.write === null)
+                continue;
+            this.requests.delete(uuid);
+            request.admit?.({ status: 'failed', error });
+            request.admit = null;
+            request.settle({ kind: 'failed', error });
         }
+        this.clearIdleIfEmpty();
     }
-    rejectCapabilityWaiters(pending, error) {
-        const waiters = pending.capabilityWaiters.splice(0);
-        const failure = error instanceof ClaudeSteerAdmissionError
-            ? error
-            : preAdmissionError(error.message, error);
-        for (const waiter of waiters)
-            waiter.reject(failure);
-    }
-    resolveWriteWaiter(pending, commandUuid) {
-        const waiter = pending.writeWaiters.get(commandUuid);
-        if (waiter === undefined)
+    onControlRequest(requestId, subtype, request) {
+        if (requestId === null || !this.stdin.writable)
             return;
-        pending.writeWaiters.delete(commandUuid);
-        waiter.resolve();
+        // Unattended posture: answer permission callbacks so a turn never wedges
+        // waiting on a human.
+        let reply;
+        if (subtype === 'can_use_tool') {
+            const rawInput = request['input'];
+            const input = typeof rawInput === 'object' &&
+                rawInput !== null &&
+                !Array.isArray(rawInput)
+                ? rawInput
+                : {};
+            reply = buildCanUseToolAllow(requestId, input);
+        }
+        else {
+            reply = buildControlAck(requestId);
+        }
+        this.stdin.write(`${reply}\n`);
     }
-    rejectWriteWaiter(pending, commandUuid, error) {
-        const waiter = pending.writeWaiters.get(commandUuid);
-        if (waiter === undefined)
+    onControlResponse(requestId, ok, response, error) {
+        if (requestId === null || requestId !== this.remoteControlRequestId)
             return;
-        pending.writeWaiters.delete(commandUuid);
-        waiter.reject(error);
-    }
-    rejectWriteWaiters(pending, error) {
-        const failure = error instanceof ClaudeSteerAdmissionError &&
-            error.admission === 'ambiguous'
-            ? error
-            : ambiguousWriteError(error);
-        const waiters = [...pending.writeWaiters.values()];
-        pending.writeWaiters.clear();
-        for (const waiter of waiters)
-            waiter.reject(failure);
+        this.remoteControlRequestId = null;
+        if (ok && response !== null) {
+            const url = response['session_url'] ?? response['connect_url'];
+            if (typeof url === 'string') {
+                this.options.onRemoteControlUrl?.(url);
+            }
+            else {
+                this.options.log?.('warn', 'claude remote control enable succeeded without a URL');
+            }
+            return;
+        }
+        this.options.log?.('warn', `claude remote control enable failed${error !== null ? `: ${error}` : ''}`);
     }
 }
 function lifecycleUnsupportedError() {
-    return preAdmissionError('claude resident session cannot prove live-steer lifecycle: ' +
-        'msg_lifecycle_v1 is unavailable');
-}
-function capabilityUndecidedTurnEndedError() {
-    return preAdmissionError('claude resident turn ended before live-steer capability was decided');
-}
-function steerWriteUnconfirmedError() {
-    return new ClaudeSteerAdmissionError('ambiguous', 'claude resident turn ended before the steer write was confirmed');
-}
-function preAdmissionError(message, cause) {
-    return new ClaudeSteerAdmissionError('failed', message, cause === undefined ? undefined : { cause });
-}
-function ambiguousWriteError(error) {
-    const cause = asError(error);
-    return new ClaudeSteerAdmissionError('ambiguous', cause.message, { cause });
+    return new Error('claude resident session cannot attribute concurrent inputs: msg_lifecycle_v1 is unavailable');
 }
 function asError(error) {
     return error instanceof Error ? error : new Error(String(error));