@parall/claude-agent 1.59.0 → 1.61.0

package/dist/dispatch.js

@@ -2,9 +2,13 @@ import { execSync, spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import { isRuntimeBusy, projectRuntimeEvent, RuntimeActivityPort } from '@parall/agent-core';
 import { appendPreparedLocalAttachmentRefs, pinLocalAttachmentPaths, } from '@parall/agent-core/internal/attachment-input';
+import { runClaudeCompact } from './compact.js';
+import { aggregateBusyState, DEFAULT_FOLLOW_UP_HOLD_MS } from './busy-state.js';
 import { ClaudeInputRegistry } from './input-lifecycle.js';
-import { parseClaudeStreamJson, } from './output-parser.js';
+import { parseClaudeStreamJson } from './output-parser.js';
+import { ClaudeProcessPump } from './process-pump.js';
 import { buildSpawnEnv } from './spawn-env.js';
 import { classifyClaudeTurn } from './turn-outcome.js';
 export { buildSpawnEnv };
@@ -30,15 +34,19 @@ export class ClaudeCodeAdapter {
     opts;
     inputLifecycleMode = 'explicit';
     processes = new Map();
+    /** Retired by abortDispatch while the CLI still had its own work: busy until idle, then terminated. */
+    retiring = new Set();
     capabilityProbe;
     capabilityProbeHandle;
     shuttingDown = false;
+    activity;
     _model;
     _effortLevel;
     _contextWindow;
     _maxTokens;
     constructor(opts) {
         this.opts = opts;
+        this.activity = new RuntimeActivityPort('ClaudeCodeAdapter');
         this._model = opts.model;
         this._contextWindow = opts.contextWindow;
         this._maxTokens = opts.maxTokens;
@@ -77,6 +85,24 @@ export class ClaudeCodeAdapter {
             state.needsRestart = true;
         }
     }
+    // --- runtime-initiated work -------------------------------------------------
+    subscribeRuntimeActivity(handler) {
+        return this.activity.subscribe(handler);
+    }
+    busyState(now = this.now()) {
+        const states = [];
+        for (const state of this.processes.values()) {
+            if (state.done)
+                continue;
+            states.push(state.pump.busyState(now));
+        }
+        for (const state of this.retiring)
+            states.push(state.pump.busyState(now));
+        return aggregateBusyState(states);
+    }
+    isBusy(now = this.now()) {
+        return isRuntimeBusy(this.busyState(now), now);
+    }
     enqueueDuringDispatch(sessionKey, body, inputLifecycle) {
         // Exact identity is mandatory for soft steer. Without it the later
         // buffered dispatch could only guess which stdout boundary belonged to
@@ -88,7 +114,7 @@ export class ClaudeCodeAdapter {
             return false;
         // A throwaway process already proved the CLI capability before any
         // business process started. The real process revalidates its own init.
-        if (!state.capabilities?.has('msg_lifecycle_v1'))
+        if (!state.pump.capabilities.has('msg_lifecycle_v1'))
             return false;
         const { proc } = state.handle;
         if (proc.exitCode !== null || proc.signalCode !== null || proc.stdin.destroyed)
@@ -113,17 +139,23 @@ export class ClaudeCodeAdapter {
         const state = this.processes.get(sessionKey);
         if (!state || state.done)
             return;
-        for (const delivery of state.inputs.values()) {
-            if (!delivery.terminal)
-                void state.inputs.failBestEffort(delivery);
-        }
+        state.pump.abortDeliveries('dispatch aborted');
         state.done = true;
-        try {
-            state.handle.proc.stdin.end();
-        }
-        catch {
-            /* best-effort */
+        if (state.pump.hasOwnWork()) {
+            // The CLI has (or is about to start) a runtime-initiated turn: retire
+            // the process instead of ending stdin under it. Out of `processes` and
+            // the session manager so the next dispatch's fresh process does not
+            // SIGTERM it as replaced; terminated once the pump reports idle.
+            this.processes.delete(sessionKey);
+            this.opts.sessionManager.clearProcess(sessionKey, state.handle);
+            this.retiring.add(state);
+            state.pump.whenIdle(() => {
+                if (this.retiring.delete(state))
+                    this.terminateHandle(state.handle);
+            });
+            return;
         }
+        this.endStdin(state.handle);
     }
     hasPendingInjections(sessionKey) {
         const state = this.processes.get(sessionKey);
@@ -146,11 +178,7 @@ export class ClaudeCodeAdapter {
         // waiting on. Unlike the consume path's tail, the discarded delivery may
         // still be RUNNING (non-terminal): killing the process now would fail a
         // live input, so the restart also waits for every injection to settle.
-        if (state.needsRestart &&
-            !state.inputs.hasPendingInjections() &&
-            !state.inputs.hasUnsettledInjections()) {
-            this.killProcess(sessionKey, state);
-        }
+        this.maybeApplyRestart(sessionKey, state);
     }
     async *dispatch({ event, bodyForAgent, sessionKey, context, inputLifecycle, noteActivity, }) {
         const deliveryKey = inputLifecycle?.deliveryKey ?? event.dispatchEventId ?? event.messageId;
@@ -166,16 +194,12 @@ export class ClaudeCodeAdapter {
                 injected.drained = true;
                 context.log?.info?.(`consuming steer input ${injected.commandUuid}`);
                 try {
-                    yield* this.consumeDelivery(sessionKey, existingState, injected, context.log, noteActivity);
+                    yield* this.consumeDelivery(sessionKey, existingState, injected, noteActivity);
                 }
                 finally {
                     existingState.inputs.remove(injected);
                 }
-                if (existingState.needsRestart &&
-                    !existingState.inputs.hasPendingInjections() &&
-                    !existingState.inputs.hasUnsettledInjections()) {
-                    this.killProcess(sessionKey, existingState);
-                }
+                this.maybeApplyRestart(sessionKey, existingState);
                 return;
             }
         }
@@ -231,6 +255,12 @@ export class ClaudeCodeAdapter {
             this.killProcess(sessionKey, state);
         }
         this.processes.clear();
+        const retired = [...this.retiring];
+        this.retiring.clear();
+        for (const state of retired) {
+            state.pump.close('killed', 'Claude process terminated by the bridge');
+            this.terminateHandle(state.handle);
+        }
     }
     async shutdown() {
         this.shuttingDown = true;
@@ -241,6 +271,9 @@ export class ClaudeCodeAdapter {
         this.resetProcesses();
         await this.opts.sessionManager.shutdownAll();
     }
+    now() {
+        return (this.opts.now ?? Date.now)();
+    }
     async *runTurn(sessionKey, promptBody, deliveryKey, lifecycle, log, noteActivity) {
         let state;
         try {
@@ -257,7 +290,9 @@ export class ClaudeCodeAdapter {
             yield { type: 'error', message: `Claude spawn failed: ${String(err)}` };
             return;
         }
-        const delivery = state.inputs.register(deliveryKey, lifecycle, false);
+        // Registered BEFORE the stdin write: the pump may route this command's
+        // queued/started frames before the drain below starts.
+        const delivery = state.inputs.register(deliveryKey, lifecycle, false, noteActivity, log);
         try {
             this.writeUserMessage(state.handle, promptBody, delivery.commandUuid);
         }
@@ -269,12 +304,22 @@ export class ClaudeCodeAdapter {
             return;
         }
         try {
-            yield* this.consumeDelivery(sessionKey, state, delivery, log, noteActivity);
+            yield* this.consumeDelivery(sessionKey, state, delivery, noteActivity);
         }
         finally {
             state.inputs.remove(delivery);
         }
     }
+    /** Idle auto-compact (compact.ts): a `/compact` frame into the long-lived process. */
+    compact(opts) {
+        return runClaudeCompact({
+            ensureRuntimeCapability: (log) => this.ensureRuntimeCapability(log),
+            ensureProcess: (sessionKey, log) => this.ensureProcess(sessionKey, log),
+            killProcess: (sessionKey, state) => this.killProcess(sessionKey, state),
+            writeUserMessage: (handle, text, uuid) => this.writeUserMessage(handle, text, uuid),
+            applyPendingRestart: (sessionKey, state) => this.maybeApplyRestart(sessionKey, state),
+        }, opts);
+    }
     ensureRuntimeCapability(log) {
         if (!this.capabilityProbe) {
             const probe = this.probeRuntimeCapability(log);
@@ -331,179 +376,80 @@ export class ClaudeCodeAdapter {
         }
     }
     /**
-     * Drain the shared stdout stream until the exact UUID written for target
-     * reaches a terminal lifecycle state. Other injected inputs may start and
-     * finish while this drain is active; their callbacks advance independently
-     * and their later bookkeeping dispatch becomes a no-op.
+     * Drain the envelopes the pump routed to `target` until its exact stdin
+     * UUID reaches a terminal lifecycle state. Other injected inputs may start
+     * and finish while this drain is active; their callbacks advance in the
+     * pump independently and their later bookkeeping dispatch becomes a no-op.
      */
-    async *consumeDelivery(sessionKey, state, target, log, noteActivity) {
+    async *consumeDelivery(sessionKey, state, target, noteActivity) {
         if (target.terminal)
             return;
         const groupKey = randomUUID();
-        let sawError = false;
-        // Turn-outcome evidence for this dispatch (agent-turn-outcome-design
-        // §4.1). Lifecycle terminals — not turn_end — bound consumption, so the
-        // result frame for the turn that carried this delivery is the LAST
-        // non-poison turn_end observed before the terminal. Poison frames
-        // (num_turns: 0 startup artifacts) never overwrite evidence. At most one
-        // turn_outcome is emitted per dispatch, right before the generator
-        // returns; with no evidence and no crash, nothing is emitted and the
-        // legacy boolean error path stands (refine-only, never guess).
-        let lastResultMeta;
-        const noticeTexts = [];
-        // usage_limit settles via the lane-level deferred complete; a failed-input
-        // report would race it with an immediate redrive into the choked LLM.
-        const settledAsLimit = () => classifyClaudeTurn(lastResultMeta, noticeTexts).outcome === 'usage_limit';
-        while (!target.terminal) {
-            const next = await state.parser.next();
-            if (next.done) {
-                state.done = true;
-                this.processes.delete(sessionKey);
-                const detail = state.handle.stderrChunks.join('').trim();
-                const exit = await state.handle.exitPromise.catch(() => ({ code: null, signal: null }));
-                if (detail) {
-                    log?.warn?.(`subprocess stderr: ${detail}`);
-                }
-                if (settledAsLimit())
-                    target.suppressFailReport = true;
-                await state.inputs.failBestEffort(target, log);
-                if (!sawError) {
-                    yield {
-                        type: 'error',
-                        message: detail ||
-                            `Claude exited with code ${exit.code ?? 'unknown'}${exit.signal ? ` (${exit.signal})` : ''}`,
-                    };
-                }
-                // No evidence at all classifies as runtime_crash (the process died
-                // before any result frame); with evidence, classify what we saw.
-                yield classifyClaudeTurn(lastResultMeta, noticeTexts);
-                return;
-            }
-            const parsed = next.value;
-            // Count every parser-observed CLI progress frame as activity, including
-            // command lifecycle, turn boundaries, and explicit activity markers
-            // for nested subagent frames that must not become RuntimeEvents.
-            noteActivity?.();
-            if (parsed.type === 'runtime_activity')
-                continue;
-            if (parsed.type === 'runtime_init') {
-                state.capabilities = new Set(parsed.capabilities);
-                if (parsed.sessionId) {
-                    this.opts.sessionManager.recordSessionId(sessionKey, parsed.sessionId);
-                    yield {
-                        type: 'runtime_session',
-                        runtimeSessionId: parsed.sessionId,
-                        runtimeLaneKey: sessionKey,
-                    };
-                }
-                if (!state.capabilities.has('msg_lifecycle_v1')) {
-                    await state.inputs.failBestEffort(target, log);
-                    yield {
-                        type: 'error',
-                        message: 'Claude runtime lacks required msg_lifecycle_v1 capability; refusing heuristic input coverage',
-                    };
-                    this.killProcess(sessionKey, state);
-                    return;
-                }
-                continue;
-            }
-            if (parsed.type === 'command_lifecycle') {
-                if (!state.capabilities?.has('msg_lifecycle_v1')) {
-                    await state.inputs.failBestEffort(target, log);
-                    yield {
-                        type: 'error',
-                        message: 'Claude emitted command lifecycle before advertising msg_lifecycle_v1',
-                    };
-                    this.killProcess(sessionKey, state);
+        state.pump.setActiveDrain(target, noteActivity);
+        try {
+            while (true) {
+                const next = await target.sink.next();
+                if (next.done)
                     return;
-                }
-                const delivery = state.inputs.getByCommand(parsed.commandUuid);
-                if (!delivery) {
-                    log?.warn?.(`ignoring lifecycle for unknown Claude command ${parsed.commandUuid}`);
+                const envelope = next.value;
+                if (envelope.kind === 'runtime') {
+                    yield projectRuntimeEvent(envelope.event, groupKey);
                     continue;
                 }
-                try {
-                    await state.inputs.apply(delivery, parsed.state);
-                }
-                catch (err) {
-                    await state.inputs.failBestEffort(delivery, log);
+                if (envelope.kind === 'terminal')
+                    break;
+                // The process is gone (eof / killed), the dispatch was aborted, or
+                // the pump ended this owner's window: surface the error unless the
+                // stream already carried one, then classify what was observed (no
+                // evidence at all is a runtime_crash).
+                if (envelope.reason !== 'error_result' && !target.evidence.sawError) {
                     yield {
                         type: 'error',
-                        message: `Claude input lifecycle update failed: ${String(err)}`,
+                        message: envelope.message ?? `Claude turn ${envelope.reason}`,
                     };
-                    this.killProcess(sessionKey, state);
-                    return;
-                }
-                continue;
-            }
-            if (parsed.type === 'turn_end') {
-                // Evidence capture: the poison startup frame (numTurns === 0) is a
-                // resume artifact, not a turn boundary — never let it overwrite real
-                // evidence.
-                if (parsed.numTurns !== 0) {
-                    lastResultMeta = parsed.resultMeta;
-                }
-                if (parsed.isError) {
-                    const limitSettled = settledAsLimit();
-                    const failedDelivery = parsed.userMessageUuid
-                        ? state.inputs.getByCommand(parsed.userMessageUuid)
-                        : undefined;
-                    if (!failedDelivery) {
-                        if (limitSettled) {
-                            for (const delivery of state.inputs.values()) {
-                                delivery.suppressFailReport = true;
-                            }
-                        }
-                        await state.inputs.failAllBestEffort(log);
-                        yield classifyClaudeTurn(lastResultMeta, noticeTexts);
-                        this.killProcess(sessionKey, state);
-                        return;
-                    }
-                    failedDelivery.resultFailed = true;
-                    if (limitSettled)
-                        failedDelivery.suppressFailReport = true;
                 }
-                // result adjacency is not a consumption boundary: the matching
-                // command_lifecycle(completed) may follow it or interleave with a
-                // different queued/injected command.
-                continue;
-            }
-            if (parsed.type === 'assistant_error') {
-                noticeTexts.push(parsed.message);
-                continue;
-            }
-            if (parsed.type === 'error') {
-                sawError = true;
-                yield parsed;
-                continue;
+                yield classifyClaudeTurn(target.evidence.lastResultMeta, target.evidence.noticeTexts);
+                return;
             }
-            if (parsed.type === 'text') {
-                yield { ...parsed, project: false, groupKey };
-                continue;
+            // Delivery reached a lifecycle terminal. Classify only when a result
+            // frame was observed in this owner's window: a delivery whose frames
+            // were drained by a sibling consumption window has no evidence here,
+            // and guessing would mislabel the turn (refine-only rule, §4.3).
+            if (target.evidence.lastResultMeta) {
+                yield classifyClaudeTurn(target.evidence.lastResultMeta, target.evidence.noticeTexts);
             }
-            if (parsed.type === 'runtime_session') {
-                yield parsed;
-                continue;
-            }
-            if (parsed.type === 'turn_outcome') {
-                // (never produced by the parser — type guard only)
-                continue;
-            }
-            yield { ...parsed, groupKey };
-        }
-        // Delivery reached a lifecycle terminal. Classify only when a result
-        // frame was observed during this drain: a delivery whose frames were
-        // drained by a sibling consumption window has no evidence here, and
-        // guessing would mislabel the turn (refine-only rule, §4.3).
-        if (lastResultMeta) {
-            yield classifyClaudeTurn(lastResultMeta, noticeTexts);
-        }
-        if (state.needsRestart &&
-            !state.inputs.hasPendingInjections() &&
-            !state.inputs.hasUnsettledInjections()) {
-            this.killProcess(sessionKey, state);
+        }
+        finally {
+            state.pump.clearActiveDrain(target);
+            this.maybeApplyRestart(sessionKey, state);
         }
     }
+    /**
+     * Lazy restart: kill the process so the next dispatch respawns it (the
+     * session survives via --resume). Waits for every injection to settle, for
+     * an open runtime-initiated turn and for a follow-up hold — but NOT for
+     * outstanding background tasks (a `make dev` would defer a config change
+     * forever); those die with the process, logged.
+     */
+    maybeApplyRestart(sessionKey, state) {
+        if (!state.needsRestart || state.done)
+            return;
+        if (state.inputs.hasPendingInjections() || state.inputs.hasUnsettledInjections())
+            return;
+        // A dispatch queued behind a runtime-initiated turn is registered but
+        // not started yet; killing now would fail it before the CLI runs it.
+        for (const delivery of state.inputs.values()) {
+            if (!delivery.terminal)
+                return;
+        }
+        if (state.pump.hasOwnWork())
+            return;
+        const outstanding = state.pump.busy.outstanding();
+        if (outstanding.total > 0) {
+            state.log?.warn?.(`restarting ${sessionKey} with ${outstanding.total} live background task(s); they die with the process`);
+        }
+        this.killProcess(sessionKey, state);
+    }
     ensureProcess(sessionKey, log) {
         if (this.shuttingDown) {
             throw new Error('adapter shutting down, refusing new process');
@@ -511,10 +457,15 @@ export class ClaudeCodeAdapter {
         const existing = this.processes.get(sessionKey);
         if (existing && !existing.done) {
             const { proc } = existing.handle;
-            if (existing.needsRestart) {
+            const alive = proc.exitCode === null && proc.signalCode === null && !proc.stdin.destroyed;
+            if (existing.needsRestart && alive) {
+                if (existing.pump.hasOwnWork()) {
+                    log?.info?.(`deferring lazy restart of ${sessionKey}: runtime-initiated turn in progress`);
+                    return existing;
+                }
                 this.killProcess(sessionKey, existing);
             }
-            else if (proc.exitCode === null && proc.signalCode === null && !proc.stdin.destroyed) {
+            else if (alive) {
                 return existing;
             }
             else {
@@ -523,19 +474,52 @@ export class ClaudeCodeAdapter {
         }
         const handle = this.spawnProcess(sessionKey, log);
         const parser = parseClaudeStreamJson(handle.proc.stdout);
+        const inputs = new ClaudeInputRegistry();
         const state = {
             handle,
-            parser,
+            pump: new ClaudeProcessPump({
+                sessionKey,
+                parser,
+                handle,
+                inputs,
+                log,
+                followUpHoldMs: this.opts.followUpHoldMs ?? DEFAULT_FOLLOW_UP_HOLD_MS,
+                now: () => this.now(),
+                hooks: {
+                    onRuntimeInit: (init) => {
+                        if (init.sessionId) {
+                            this.opts.sessionManager.recordSessionId(sessionKey, init.sessionId);
+                        }
+                        if (!init.capabilities.includes('msg_lifecycle_v1')) {
+                            return 'Claude runtime lacks required msg_lifecycle_v1 capability; refusing heuristic input coverage';
+                        }
+                        return undefined;
+                    },
+                    onFatal: () => {
+                        const current = this.processes.get(sessionKey);
+                        if (current === state)
+                            this.killProcess(sessionKey, state);
+                    },
+                    onEof: () => {
+                        state.done = true;
+                        if (this.processes.get(sessionKey) === state)
+                            this.processes.delete(sessionKey);
+                        this.retiring.delete(state);
+                    },
+                    // Main-session turns go to the gateway (steps + session activity);
+                    // fork-session turns only count as busy (fork-scope invariant).
+                    onRuntimeTurnOpened: (turn) => this.activity.surfaceTurn(turn, this.opts.sessionManager.isMain(sessionKey), log),
+                    onRuntimeTurnClosed: () => this.maybeApplyRestart(sessionKey, state),
+                },
+            }),
             done: false,
             needsRestart: false,
-            // A throwaway process already proved the current CLI advertises this
-            // capability. Real 2.1.220 sends queued/started before its own init,
-            // so pre-seed the gate and still verify the real init when it arrives.
-            capabilities: new Set(['msg_lifecycle_v1']),
-            inputs: new ClaudeInputRegistry(),
+            inputs,
+            log,
         };
         this.processes.set(sessionKey, state);
         this.opts.sessionManager.registerProcess(sessionKey, handle);
+        state.pump.start();
         return state;
     }
     spawnProcess(sessionKey, log, resume = true) {
@@ -586,15 +570,19 @@ export class ClaudeCodeAdapter {
         if (current === state) {
             this.processes.delete(sessionKey);
         }
+        state.pump.close('killed', 'Claude process terminated by the bridge');
         this.terminateHandle(state.handle);
     }
-    terminateHandle(handle) {
+    endStdin(handle) {
         try {
             handle.proc.stdin.end();
         }
         catch {
             /* best-effort */
         }
+    }
+    terminateHandle(handle) {
+        this.endStdin(handle);
         if (handle.proc.exitCode === null && handle.proc.signalCode === null) {
             try {
                 if (!IS_WIN32 || !handle.proc.pid || !killWin32Tree(handle.proc.pid)) {

package/dist/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import * as os from 'node:os';
-import { capabilityBinDir, childLogger, clearAllProviderCreds, configureHttpKeepAlive, createLogger, createOtelLogger, createPlatformConfigManager, deriveModelIsPin, identityFromMe, initAgentTelemetry, llmSource, materializeChannelCapabilities, ParallAgentGateway, parseDispatchDeadlineMs, parseForkDeadlineMs, parseProviderConfig, parseShutdownDeadlineMs, resolveRuntimeContextWindow, resolveRuntimeMaxTokens, resolveRuntimeModel, } from '@parall/agent-core';
+import { capabilityBinDir, childLogger, clearAllProviderCreds, configureHttpKeepAlive, createLogger, createOtelLogger, createPlatformConfigManager, deriveModelIsPin, identityFromMe, initAgentTelemetry, llmSource, resolveServiceVersion, materializeChannelCapabilities, ParallAgentGateway, parseDispatchDeadlineMs, parseForkDeadlineMs, parseProviderConfig, parseShutdownDeadlineMs, resolveRuntimeContextWindow, resolveRuntimeMaxTokens, resolveRuntimeModel, } from '@parall/agent-core';
 import { ApiError, ParallClient, ParallWs } from '@parall/sdk';
 import { buildClaudeRuntimeKey, contextFilePathForSession, dispatchContextDirPath, resolveClaudeAgentConfig, resolveWsUrl, sessionStateFilePathForRuntime, stepIdFilePathForSession, } from './config.js';
 import { ClaudeCodeAdapter } from './dispatch.js';
@@ -44,7 +44,11 @@ function resolveProviderEnv() {
 async function main() {
     // Before any fetch: long-lived HTTP connections for every bridge→api call.
     configureHttpKeepAlive();
-    const telemetry = await initAgentTelemetry('parall-claude-agent', 'claude-code');
+    const telemetry = await initAgentTelemetry('parall-claude-agent', 'claude-code', {
+        apiUrl: process.env.PRLL_API_URL,
+        apiKey: process.env.PRLL_API_KEY,
+        serviceVersion: resolveServiceVersion(import.meta.url),
+    });
     activeLog = createOtelLogger('agent', 'claude-agent');
     try {
         const activeLLMSource = resolveProviderEnv();

package/dist/input-lifecycle.d.ts

@@ -1,4 +1,5 @@
 import type { DispatchInputLifecycle, GatewayLogger, RuntimeInputState } from '@parall/agent-core';
+import { type ClaudeTurnSink, type TurnEvidence } from './turn-sink.js';
 export type ClaudeInputDelivery = {
     deliveryKey: string;
     commandUuid: string;
@@ -8,6 +9,14 @@ export type ClaudeInputDelivery = {
     terminal?: 'completed' | 'failed' | 'settled';
     reportedState?: RuntimeInputState;
     resultFailed: boolean;
+    /** Envelopes the stdout pump routed to this delivery; drained by its dispatch. */
+    sink: ClaudeTurnSink;
+    /** Turn-outcome evidence gathered while this delivery owned stdout. */
+    evidence: TurnEvidence;
+    /** Dispatch inactivity signal of the dispatch draining (or about to drain) this delivery. */
+    noteActivity?: () => void;
+    /** runtime_session already pushed to this delivery's sink. */
+    sessionAnnounced: boolean;
     /**
      * The turn settled as usage_limit: the lane-level deferred complete will
      * re-deliver this input at retry_at without burning redrive budget. A
@@ -41,7 +50,7 @@ export declare class ClaudeInputRegistry {
      * would release the member for redrive mid-processing.
      */
     hasUnsettledInjections(): boolean;
-    register(deliveryKey: string, lifecycle: DispatchInputLifecycle | undefined, injected: boolean): ClaudeInputDelivery;
+    register(deliveryKey: string, lifecycle: DispatchInputLifecycle | undefined, injected: boolean, noteActivity?: () => void, log?: GatewayLogger): ClaudeInputDelivery;
     remove(delivery: ClaudeInputDelivery): void;
     /**
      * The buffered copy backing this delivery was discarded without a

package/dist/input-lifecycle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"input-lifecycle.d.ts","sourceRoot":"","sources":["../src/input-lifecycle.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAEnG,MAAM,MAAM,mBAAmB,GAAG;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,sBAAsB,CAAC;IACnC,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAC;IAC9C,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAClC,YAAY,EAAE,OAAO,CAAC;IACtB;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AAEF;;;;GAIG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA0C;IAChE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0C;IAEpE,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS;IAI9D,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS;IAIlE,eAAe,CAAC,gBAAgB,EAAE,MAAM,EAAE,GAAG,mBAAmB,GAAG,SAAS;IAU5E,MAAM,IAAI,gBAAgB,CAAC,mBAAmB,CAAC;IAI/C,oBAAoB,IAAI,OAAO;IAI/B;;;;;;;;;OASG;IACH,sBAAsB,IAAI,OAAO;IAIjC,QAAQ,CACN,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,sBAAsB,GAAG,SAAS,EAC7C,QAAQ,EAAE,OAAO,GAChB,mBAAmB;IAiBtB,MAAM,CAAC,QAAQ,EAAE,mBAAmB,GAAG,IAAI;IAS3C;;;;;;;;OAQG;IACH,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAOvC,KAAK,CACT,QAAQ,EAAE,mBAAmB,EAC7B,KAAK,EAAE,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,WAAW,GAAG,WAAW,GACpE,OAAO,CAAC,IAAI,CAAC;IA0BV,IAAI,CAAC,QAAQ,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBlD,cAAc,CAAC,QAAQ,EAAE,mBAAmB,EAAE,GAAG,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAUjF,iBAAiB,CAAC,GAAG,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;CAO5D"}
+{"version":3,"file":"input-lifecycle.d.ts","sourceRoot":"","sources":["../src/input-lifecycle.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACnG,OAAO,EACL,KAAK,cAAc,EAGnB,KAAK,YAAY,EAClB,MAAM,gBAAgB,CAAC;AAExB,MAAM,MAAM,mBAAmB,GAAG;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,sBAAsB,CAAC;IACnC,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAC;IAC9C,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAClC,YAAY,EAAE,OAAO,CAAC;IACtB,kFAAkF;IAClF,IAAI,EAAE,cAAc,CAAC;IACrB,uEAAuE;IACvE,QAAQ,EAAE,YAAY,CAAC;IACvB,6FAA6F;IAC7F,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;IAC1B,8DAA8D;IAC9D,gBAAgB,EAAE,OAAO,CAAC;IAC1B;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AAEF;;;;GAIG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA0C;IAChE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0C;IAEpE,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS;IAI9D,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS;IAIlE,eAAe,CAAC,gBAAgB,EAAE,MAAM,EAAE,GAAG,mBAAmB,GAAG,SAAS;IAU5E,MAAM,IAAI,gBAAgB,CAAC,mBAAmB,CAAC;IAI/C,oBAAoB,IAAI,OAAO;IAI/B;;;;;;;;;OASG;IACH,sBAAsB,IAAI,OAAO;IAIjC,QAAQ,CACN,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,sBAAsB,GAAG,SAAS,EAC7C,QAAQ,EAAE,OAAO,EACjB,YAAY,CAAC,EAAE,MAAM,IAAI,EACzB,GAAG,CAAC,EAAE,aAAa,GAClB,mBAAmB;IAsBtB,MAAM,CAAC,QAAQ,EAAE,mBAAmB,GAAG,IAAI;IAY3C;;;;;;;;OAQG;IACH,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAOvC,KAAK,CACT,QAAQ,EAAE,mBAAmB,EAC7B,KAAK,EAAE,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,WAAW,GAAG,WAAW,GACpE,OAAO,CAAC,IAAI,CAAC;IA0BV,IAAI,CAAC,QAAQ,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBlD,cAAc,CAAC,QAAQ,EAAE,mBAAmB,EAAE,GAAG,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAUjF,iBAAiB,CAAC,GAAG,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;CAO5D"}

package/dist/input-lifecycle.js

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import { newTurnEvidence, newTurnSink, } from './turn-sink.js';
 /**
  * Per-process registry that maps Parall WorkItem batches to Claude stdin
  * UUIDs. It owns lifecycle transition rules; process/stdout orchestration
@@ -41,17 +42,22 @@ export class ClaudeInputRegistry {
     hasUnsettledInjections() {
         return [...this.byKey.values()].some((delivery) => delivery.injected && !delivery.terminal);
     }
-    register(deliveryKey, lifecycle, injected) {
+    register(deliveryKey, lifecycle, injected, noteActivity, log) {
         if (this.byKey.has(deliveryKey)) {
             throw new Error(`duplicate Claude delivery key ${deliveryKey}`);
         }
+        const commandUuid = randomUUID();
         const delivery = {
             deliveryKey,
-            commandUuid: randomUUID(),
+            commandUuid,
             lifecycle,
             injected,
             drained: !injected,
             resultFailed: false,
+            sink: newTurnSink(`delivery ${deliveryKey}`, log),
+            evidence: newTurnEvidence(),
+            noteActivity,
+            sessionAnnounced: false,
         };
         this.byKey.set(deliveryKey, delivery);
         this.byCommand.set(delivery.commandUuid, delivery);
@@ -64,6 +70,9 @@ export class ClaudeInputRegistry {
         if (this.byCommand.get(delivery.commandUuid) === delivery) {
             this.byCommand.delete(delivery.commandUuid);
         }
+        // The sink stays open: apply() removes a drained delivery at its
+        // terminal BEFORE the pump pushes the terminal envelope its drain is
+        // waiting for. Only the pump closes sinks (process gone).
     }
     /**
      * The buffered copy backing this delivery was discarded without a