@parall/claude-agent 1.58.2 → 1.60.0

package/dist/process-pump.js

@@ -0,0 +1,436 @@
+import { describeRuntimeTurnTrigger, } from '@parall/agent-core';
+import { ClaudeBusyTracker } from './busy-state.js';
+import { ClaudeRuntimeTurn } from './runtime-turn.js';
+import { classifyClaudeTurn } from './turn-outcome.js';
+/**
+ * Single owner of one Claude subprocess's stdout. Reads every frame the CLI
+ * emits — during dispatches AND between them — and routes it:
+ *
+ * - `command_lifecycle` frames go to the delivery they name (stdin uuid).
+ * - Content frames (thinking / text / tool_call / tool_result / error) go to
+ *   the delivery whose lifecycle is `started` and not yet terminal
+ *   (claude-soft-steer-design.md: the lifecycle terminal, not `result`,
+ *   bounds a delivery); with no started delivery they go to the open
+ *   runtime-initiated turn, opening one if needed. A `queued` delivery never
+ *   owns frames.
+ * - `result` frames attach turn-outcome evidence to the owner and close a
+ *   runtime-initiated turn; a poison `num_turns: 0` resume artifact never
+ *   opens or closes one.
+ * - task frames feed the busy ledger; `runtime_activity` only refreshes
+ *   inactivity deadlines.
+ *
+ * Reading continuously also removes the latent stall where an unread
+ * self-started turn filled the OS pipe and blocked the CLI.
+ */
+export class ClaudeProcessPump {
+    opts;
+    busy;
+    capabilities = new Set(['msg_lifecycle_v1']);
+    sessionId;
+    runtimeTurn = null;
+    closed = false;
+    idleWaiters = [];
+    idleTimer = null;
+    activeDrain = null;
+    now;
+    constructor(opts) {
+        this.opts = opts;
+        this.now = opts.now ?? Date.now;
+        this.busy = new ClaudeBusyTracker(opts.followUpHoldMs);
+    }
+    start() {
+        void this.run();
+    }
+    /** The dispatch generator currently draining `delivery` (owner preference). */
+    setActiveDrain(delivery, noteActivity) {
+        this.activeDrain = delivery;
+        if (noteActivity)
+            delivery.noteActivity = noteActivity;
+    }
+    clearActiveDrain(delivery) {
+        if (this.activeDrain === delivery)
+            this.activeDrain = null;
+    }
+    hasStartedDelivery() {
+        for (const delivery of this.opts.inputs.values())
+            if (isLive(delivery))
+                return true;
+        return false;
+    }
+    /**
+     * The CLI has (or is about to start) work no dispatch asked for: a
+     * runtime-initiated turn is open, or a finished background task's
+     * follow-up hold is pending. Lazy restarts, dispatch aborts and
+     * `whenIdle` all defer to it.
+     */
+    hasOwnWork(now = this.now()) {
+        return this.runtimeTurn !== null || this.busy.holdActive(now);
+    }
+    busyState(now = this.now()) {
+        const outstanding = this.busy.outstanding();
+        const holdUntil = this.busy.activeHoldUntil(now);
+        return {
+            activeTurns: this.hasStartedDelivery() || this.runtimeTurn ? 1 : 0,
+            backgroundWork: outstanding.total - outstanding.ambient,
+            ...(holdUntil !== undefined ? { holdUntil } : {}),
+        };
+    }
+    /** Dispatch abort: fail every live delivery and release its drain. */
+    abortDeliveries(message) {
+        for (const delivery of this.opts.inputs.values()) {
+            if (delivery.terminal)
+                continue;
+            void this.opts.inputs.failBestEffort(delivery, this.opts.log);
+            delivery.sink.push({ kind: 'ended', reason: 'aborted', message });
+        }
+    }
+    /**
+     * The adapter is terminating the process (kill / reset / shutdown): every
+     * drain and the open runtime turn end now, before stdout EOF is observed.
+     */
+    close(reason, message) {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const delivery of this.opts.inputs.values()) {
+            delivery.sink.push({ kind: 'ended', reason, message });
+            delivery.sink.close();
+        }
+        this.closeRuntimeTurn(reason, message);
+        this.busy.reset();
+        this.checkIdle();
+    }
+    /**
+     * Run `cb` once the CLI has nothing left to do on its own: no
+     * runtime-initiated turn open and no follow-up hold pending (a hold that
+     * turns into a follow-up turn is waited for as well). Immediate when
+     * already idle or closed.
+     */
+    whenIdle(cb) {
+        this.idleWaiters.push(cb);
+        this.checkIdle();
+    }
+    checkIdle() {
+        if (this.idleWaiters.length === 0)
+            return;
+        if (this.idleTimer) {
+            clearTimeout(this.idleTimer);
+            this.idleTimer = null;
+        }
+        if (!this.closed) {
+            if (this.runtimeTurn)
+                return; // closeRuntimeTurn re-checks
+            const now = this.now();
+            const holdUntil = this.busy.activeHoldUntil(now);
+            if (holdUntil !== undefined) {
+                this.idleTimer = setTimeout(() => {
+                    this.idleTimer = null;
+                    this.checkIdle();
+                }, holdUntil - now + 1);
+                this.idleTimer.unref?.();
+                return;
+            }
+        }
+        const waiters = this.idleWaiters.splice(0);
+        for (const waiter of waiters)
+            waiter();
+    }
+    closeRuntimeTurn(reason, message) {
+        const turn = this.runtimeTurn;
+        if (!turn)
+            return;
+        this.runtimeTurn = null;
+        turn.sink.push({ kind: 'ended', reason, message });
+        turn.sink.close();
+        this.opts.log?.info?.(`runtime-initiated turn ${turn.groupKey} on ${this.opts.sessionKey} closed (${reason})`);
+        this.opts.hooks.onRuntimeTurnClosed();
+        this.checkIdle();
+    }
+    // --- routing --------------------------------------------------------------
+    async run() {
+        const { parser, log } = this.opts;
+        try {
+            for await (const parsed of parser) {
+                if (this.closed)
+                    break;
+                this.touchAll();
+                await this.route(parsed);
+            }
+        }
+        catch (err) {
+            log?.warn?.(`Claude stdout pump failed for ${this.opts.sessionKey}: ${String(err)}`);
+        }
+        finally {
+            await this.handleEof();
+        }
+    }
+    async route(parsed) {
+        switch (parsed.type) {
+            case 'runtime_activity':
+                return;
+            case 'runtime_init':
+                this.handleInit(parsed);
+                return;
+            case 'command_lifecycle':
+                await this.handleLifecycle(parsed);
+                return;
+            case 'runtime_task':
+                this.handleTask(parsed);
+                return;
+            case 'user_text':
+                // The CLI's own injected notice (task-notification text); the
+                // follow-up turn's content frames carry the consequence.
+                return;
+            case 'turn_end':
+                await this.handleTurnEnd(parsed);
+                return;
+            case 'assistant_error': {
+                const owner = this.ownerFor(true);
+                owner?.evidence.noticeTexts.push(parsed.message);
+                return;
+            }
+            case 'compact_boundary': {
+                // The CLI folded history: a `/compact` command's evidence, or its
+                // own auto-compact mid-turn. Progress only, never a RuntimeEvent.
+                const owner = this.ownerFor(false);
+                if (owner) {
+                    owner.evidence.compactBoundary = {
+                        ...(parsed.preTokens !== undefined ? { preTokens: parsed.preTokens } : {}),
+                    };
+                }
+                return;
+            }
+            case 'runtime_session':
+            case 'turn_outcome':
+                // Never produced by the parser (type guards only).
+                return;
+            default: {
+                const owner = this.ownerFor(true);
+                if (!owner)
+                    return;
+                if (parsed.type === 'error')
+                    owner.evidence.sawError = true;
+                owner.sink.push({ kind: 'runtime', event: parsed });
+                return;
+            }
+        }
+    }
+    touchAll() {
+        for (const delivery of this.opts.inputs.values()) {
+            if (!delivery.terminal)
+                delivery.noteActivity?.();
+        }
+        this.runtimeTurn?.touch();
+    }
+    liveDeliveries() {
+        const live = [];
+        for (const delivery of this.opts.inputs.values())
+            if (isLive(delivery))
+                live.push(delivery);
+        return live;
+    }
+    ownerFor(open) {
+        if (this.activeDrain && isLive(this.activeDrain))
+            return this.activeDrain;
+        for (const delivery of this.opts.inputs.values())
+            if (isLive(delivery))
+                return delivery;
+        if (this.runtimeTurn)
+            return this.runtimeTurn;
+        return open ? this.openRuntimeTurn() : null;
+    }
+    openRuntimeTurn() {
+        const notification = this.busy.takeRecentNotification(this.now());
+        const trigger = notification
+            ? {
+                kind: 'background_task',
+                ...(notification.taskId ? { taskId: notification.taskId } : {}),
+                ...(notification.description ? { description: notification.description } : {}),
+                ...(notification.summary ? { summary: notification.summary } : {}),
+                ...(notification.status ? { status: notification.status } : {}),
+            }
+            : { kind: 'runtime' };
+        const turn = new ClaudeRuntimeTurn(this.opts.sessionKey, trigger, {
+            onDetach: (reason) => this.closeRuntimeTurn('detached', reason),
+            log: this.opts.log,
+        });
+        this.runtimeTurn = turn;
+        this.busy.clearHold();
+        if (this.sessionId) {
+            turn.sink.push({
+                kind: 'runtime',
+                event: {
+                    type: 'runtime_session',
+                    runtimeSessionId: this.sessionId,
+                    runtimeLaneKey: this.opts.sessionKey,
+                },
+            });
+        }
+        this.opts.log?.info?.(`runtime-initiated turn ${turn.groupKey} opened on ${this.opts.sessionKey} (${describeRuntimeTurnTrigger(trigger)})`);
+        this.opts.hooks.onRuntimeTurnOpened(turn);
+        return turn;
+    }
+    handleInit(init) {
+        this.capabilities = new Set(init.capabilities);
+        if (init.sessionId)
+            this.sessionId = init.sessionId;
+        const fatal = this.opts.hooks.onRuntimeInit(init);
+        if (fatal) {
+            this.pushErrorToDeliveries(fatal);
+            this.opts.hooks.onFatal();
+            return;
+        }
+        if (!this.sessionId)
+            return;
+        const announce = {
+            type: 'runtime_session',
+            runtimeSessionId: this.sessionId,
+            runtimeLaneKey: this.opts.sessionKey,
+        };
+        for (const delivery of this.opts.inputs.values()) {
+            if (delivery.terminal || delivery.sessionAnnounced)
+                continue;
+            delivery.sessionAnnounced = true;
+            delivery.sink.push({ kind: 'runtime', event: announce });
+        }
+    }
+    async handleLifecycle(parsed) {
+        if (!this.capabilities.has('msg_lifecycle_v1')) {
+            this.pushErrorToDeliveries('Claude emitted command lifecycle before advertising msg_lifecycle_v1');
+            this.opts.hooks.onFatal();
+            return;
+        }
+        const delivery = this.opts.inputs.getByCommand(parsed.commandUuid);
+        if (!delivery) {
+            this.opts.log?.warn?.(`ignoring lifecycle for unknown Claude command ${parsed.commandUuid}`);
+            return;
+        }
+        if (parsed.state === 'started') {
+            this.busy.clearHold();
+            // A dispatch delivery took over stdout: the runtime-initiated turn's
+            // tail (if the CLI folded the delivery into it) belongs to the
+            // delivery from here on.
+            this.closeRuntimeTurn('absorbed');
+        }
+        try {
+            await this.opts.inputs.apply(delivery, parsed.state);
+        }
+        catch (err) {
+            await this.opts.inputs.failBestEffort(delivery, this.opts.log);
+            delivery.sink.push({
+                kind: 'runtime',
+                event: { type: 'error', message: `Claude input lifecycle update failed: ${String(err)}` },
+            });
+            this.opts.hooks.onFatal();
+            return;
+        }
+        if (parsed.state === 'completed' ||
+            parsed.state === 'cancelled' ||
+            parsed.state === 'discarded') {
+            delivery.sink.push({ kind: 'terminal' });
+        }
+    }
+    handleTask(frame) {
+        const before = this.busy.outstanding().total;
+        this.busy.onTaskFrame(frame, this.now());
+        const log = this.opts.log;
+        switch (frame.subtype) {
+            case 'task_started':
+                log?.info?.(`background task ${frame.taskId ?? '?'} started on ${this.opts.sessionKey}: ${frame.description ?? frame.taskType ?? ''}`.trim());
+                return;
+            case 'task_notification':
+                log?.info?.(`background task ${frame.taskId ?? '?'} ${frame.status ?? 'finished'} on ${this.opts.sessionKey}; holding for its follow-up turn`);
+                return;
+            case 'background_tasks_changed': {
+                const after = this.busy.outstanding();
+                if (after.total !== before) {
+                    log?.info?.(`background tasks on ${this.opts.sessionKey}: ${after.total} live (${after.ambient} ambient)`);
+                }
+                return;
+            }
+            default:
+                return;
+        }
+    }
+    async handleTurnEnd(parsed) {
+        const live = this.liveDeliveries();
+        const owner = this.ownerFor(false);
+        // The poison startup frame (num_turns 0, --resume artifact) is not a
+        // turn boundary: it never overwrites evidence, opens or closes a turn.
+        if (parsed.numTurns !== 0 && owner)
+            owner.evidence.lastResultMeta = parsed.resultMeta;
+        if (parsed.numTurns === 0 && owner)
+            owner.evidence.zeroTurnResultMeta = parsed.resultMeta;
+        if (parsed.isError) {
+            const failed = parsed.userMessageUuid
+                ? this.opts.inputs.getByCommand(parsed.userMessageUuid)
+                : undefined;
+            if (failed) {
+                failed.resultFailed = true;
+                if (settledAsLimit(failed.evidence))
+                    failed.suppressFailReport = true;
+                return;
+            }
+            if (live.length > 0) {
+                // An error result nobody claims while a delivery runs: fail every
+                // input and drop the process (the pre-pump contract).
+                if (owner && settledAsLimit(owner.evidence)) {
+                    for (const delivery of this.opts.inputs.values())
+                        delivery.suppressFailReport = true;
+                }
+                await this.opts.inputs.failAllBestEffort(this.opts.log);
+                for (const delivery of live) {
+                    delivery.sink.push({ kind: 'ended', reason: 'error_result' });
+                }
+                this.opts.hooks.onFatal();
+                return;
+            }
+            if (owner && owner === this.runtimeTurn) {
+                this.closeRuntimeTurn('error_result');
+            }
+            return;
+        }
+        if (parsed.numTurns !== 0 && owner && owner === this.runtimeTurn) {
+            this.closeRuntimeTurn('result');
+        }
+    }
+    pushErrorToDeliveries(message) {
+        for (const delivery of this.opts.inputs.values()) {
+            if (delivery.terminal)
+                continue;
+            delivery.sink.push({ kind: 'runtime', event: { type: 'error', message } });
+        }
+    }
+    async handleEof() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        const { handle, inputs, log } = this.opts;
+        const detail = handle.stderrChunks.join('').trim();
+        const exit = await handle.exitPromise.catch(() => ({ code: null, signal: null }));
+        if (detail)
+            log?.warn?.(`subprocess stderr: ${detail}`);
+        this.opts.hooks.onEof();
+        const message = detail ||
+            `Claude exited with code ${exit.code ?? 'unknown'}${exit.signal ? ` (${exit.signal})` : ''}`;
+        for (const delivery of inputs.values()) {
+            if (!delivery.terminal && settledAsLimit(delivery.evidence))
+                delivery.suppressFailReport = true;
+        }
+        await inputs.failAllBestEffort(log);
+        for (const delivery of inputs.values()) {
+            delivery.sink.push({ kind: 'ended', reason: 'eof', message });
+            delivery.sink.close();
+        }
+        this.closeRuntimeTurn('eof', message);
+        this.busy.reset();
+    }
+}
+/** usage_limit settles via the lane-level deferred complete, never a failed-input report. */
+function settledAsLimit(evidence) {
+    return (classifyClaudeTurn(evidence.lastResultMeta, evidence.noticeTexts).outcome === 'usage_limit');
+}
+/** A delivery that owns stdout: the CLI reported `started` and no terminal state yet. */
+function isLive(delivery) {
+    return delivery.reportedState === 'started' && !delivery.terminal;
+}

package/dist/runtime-turn.d.ts

@@ -0,0 +1,19 @@
+import { type GatewayLogger, type RuntimeEvent, RuntimeTurnBase, type RuntimeTurnTrigger } from '@parall/agent-core';
+import { type ClaudeTurnSink, type TurnEvidence } from './turn-sink.js';
+/**
+ * A turn the Claude CLI started on its own (no dispatch wrote to stdin): the
+ * follow-up it runs after a background task or background subagent finishes,
+ * or any other self-continuation. The pump routes its frames here; the
+ * gateway (main session) or the adapter's log-only fallback drains `events`.
+ */
+export declare class ClaudeRuntimeTurn extends RuntimeTurnBase {
+    readonly sink: ClaudeTurnSink;
+    readonly evidence: TurnEvidence;
+    constructor(sessionKey: string, trigger: RuntimeTurnTrigger, opts: {
+        onDetach: (reason: string) => void;
+        log?: GatewayLogger;
+    });
+    protected drain(): AsyncGenerator<RuntimeEvent>;
+    private finish;
+}
+//# sourceMappingURL=runtime-turn.d.ts.map

package/dist/runtime-turn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-turn.d.ts","sourceRoot":"","sources":["../src/runtime-turn.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAElB,KAAK,YAAY,EACjB,eAAe,EACf,KAAK,kBAAkB,EACxB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAEL,KAAK,cAAc,EAGnB,KAAK,YAAY,EAClB,MAAM,gBAAgB,CAAC;AAExB;;;;;GAKG;AACH,qBAAa,iBAAkB,SAAQ,eAAe;IACpD,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAqB;gBAGlD,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,kBAAkB,EAC3B,IAAI,EAAE;QAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;QAAC,GAAG,CAAC,EAAE,aAAa,CAAA;KAAE;cAMlD,KAAK,IAAI,cAAc,CAAC,YAAY,CAAC;IAetD,OAAO,CAAE,MAAM;CA6BhB"}

package/dist/runtime-turn.js

@@ -0,0 +1,59 @@
+import { projectRuntimeEvent, RuntimeTurnBase, } from '@parall/agent-core';
+import { classifyClaudeTurn } from './turn-outcome.js';
+import { newTurnEvidence, newTurnSink, } from './turn-sink.js';
+/**
+ * A turn the Claude CLI started on its own (no dispatch wrote to stdin): the
+ * follow-up it runs after a background task or background subagent finishes,
+ * or any other self-continuation. The pump routes its frames here; the
+ * gateway (main session) or the adapter's log-only fallback drains `events`.
+ */
+export class ClaudeRuntimeTurn extends RuntimeTurnBase {
+    sink;
+    evidence = newTurnEvidence();
+    constructor(sessionKey, trigger, opts) {
+        super(sessionKey, trigger, opts.onDetach);
+        this.sink = newTurnSink(`runtime-turn ${this.groupKey}`, opts.log);
+    }
+    async *drain() {
+        while (true) {
+            const next = await this.sink.next();
+            if (next.done)
+                return;
+            const envelope = next.value;
+            if (envelope.kind === 'runtime') {
+                yield projectRuntimeEvent(envelope.event, this.groupKey);
+                continue;
+            }
+            if (envelope.kind === 'terminal')
+                continue;
+            yield* this.finish(envelope.reason, envelope.message);
+            return;
+        }
+    }
+    *finish(reason, message) {
+        switch (reason) {
+            case 'absorbed':
+                // A dispatch delivery took over the tail: its drain carries the
+                // result frame and the outcome; nothing to classify here.
+                return;
+            case 'result':
+            case 'error_result':
+                if (this.evidence.lastResultMeta) {
+                    yield classifyClaudeTurn(this.evidence.lastResultMeta, this.evidence.noticeTexts);
+                }
+                return;
+            default:
+                if (!this.evidence.sawError) {
+                    yield {
+                        type: 'error',
+                        message: message ?? `runtime-initiated turn ${reason}`,
+                        groupKey: this.groupKey,
+                    };
+                }
+                // No result frame classifies as runtime_crash (agent-turn-outcome
+                // §4.1); with evidence, classify what the CLI reported.
+                yield classifyClaudeTurn(this.evidence.lastResultMeta, this.evidence.noticeTexts);
+                return;
+        }
+    }
+}

package/dist/session-manager.d.ts

@@ -20,6 +20,7 @@ export declare class ClaudeSessionManager {
     private readonly processes;
     constructor(mainSessionKey: string, stateFilePath: string, logger?: ClaudeSessionManagerLogger | undefined);
     getSessionId(sessionKey: string): string | undefined;
+    isMain(sessionKey: string): boolean;
     getResumeArgs(sessionKey: string): string[];
     recordSessionId(sessionKey: string, sessionId: string): void;
     createForkSession(parentSessionKey: string): ForkSessionHandle | null;

package/dist/session-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-manager.d.ts","sourceRoot":"","sources":["../src/session-manager.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAO5D,KAAK,0BAA0B,GAAG;IAChC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,8BAA8B,CAAC;IACrC,WAAW,EAAE,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,CAAA;KAAE,CAAC,CAAC;IAC7E,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAEF,qBAAa,oBAAoB;IAM7B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IAP1B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6B;IACxD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAA6B;IAChE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0C;gBAGjD,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,EACrB,MAAM,CAAC,EAAE,0BAA0B,YAAA;IAKtD,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIpD,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE;IAU3C,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAQrD,iBAAiB,CAAC,gBAAgB,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI;IAYrE,WAAW,CAAC,UAAU,EAAE,MAAM;IAU9B,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS;IAI/D,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB;IAsB/D,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,mBAAmB;IAO7D,qEAAqE;IACrE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAS;IAE5C,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;YAMpB,WAAW;IAmCzB;;;OAGG;IACH,OAAO,CAAC,eAAe;IAuBvB,OAAO,CAAC,WAAW;IAmBnB,gBAAgB;IAShB,OAAO,CAAC,OAAO;IAgBf,OAAO,CAAC,OAAO;CAoBhB"}
+{"version":3,"file":"session-manager.d.ts","sourceRoot":"","sources":["../src/session-manager.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAO5D,KAAK,0BAA0B,GAAG;IAChC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,8BAA8B,CAAC;IACrC,WAAW,EAAE,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,CAAA;KAAE,CAAC,CAAC;IAC7E,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAEF,qBAAa,oBAAoB;IAM7B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IAP1B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6B;IACxD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAA6B;IAChE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0C;gBAGjD,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,EACrB,MAAM,CAAC,EAAE,0BAA0B,YAAA;IAKtD,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIpD,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAInC,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE;IAU3C,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAQrD,iBAAiB,CAAC,gBAAgB,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI;IAYrE,WAAW,CAAC,UAAU,EAAE,MAAM;IAU9B,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS;IAI/D,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB;IAsB/D,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,mBAAmB;IAO7D,qEAAqE;IACrE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAS;IAE5C,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;YAMpB,WAAW;IAmCzB;;;OAGG;IACH,OAAO,CAAC,eAAe;IAuBvB,OAAO,CAAC,WAAW;IAmBnB,gBAAgB;IAShB,OAAO,CAAC,OAAO;IAgBf,OAAO,CAAC,OAAO;CAoBhB"}

package/dist/session-manager.js

@@ -17,6 +17,9 @@ export class ClaudeSessionManager {
     getSessionId(sessionKey) {
         return this.sessionIds.get(sessionKey);
     }
+    isMain(sessionKey) {
+        return sessionKey === this.mainSessionKey;
+    }
     getResumeArgs(sessionKey) {
         const existing = this.sessionIds.get(sessionKey);
         if (existing)

package/dist/turn-sink.d.ts

@@ -0,0 +1,49 @@
+import type { GatewayLogger, RuntimeEvent } from '@parall/agent-core';
+import { AsyncQueue } from '@parall/agent-core/internal/async-queue';
+import type { ClaudeResultMeta } from './output-parser.js';
+/**
+ * Why a turn ended from the pump's point of view. `result` and
+ * `error_result` are the CLI's own boundary; `absorbed` means a dispatch
+ * delivery started mid runtime-initiated turn and took over the tail; the
+ * rest are bridge-side terminations (process EOF / kill, gateway detach,
+ * dispatch abort).
+ */
+export type ClaudeTurnEndReason = 'result' | 'error_result' | 'absorbed' | 'eof' | 'killed' | 'aborted' | 'detached';
+export type ClaudeTurnEnvelope = {
+    kind: 'runtime';
+    event: RuntimeEvent;
+}
+/** The delivery's lifecycle reached a terminal state (dispatch drains only). */
+ | {
+    kind: 'terminal';
+} | {
+    kind: 'ended';
+    reason: ClaudeTurnEndReason;
+    message?: string;
+};
+/**
+ * Turn-outcome evidence attached to whichever owner (dispatch delivery or
+ * runtime-initiated turn) the pump routes frames to
+ * (agent-turn-outcome-design.md §4.1): the LAST non-poison result frame seen
+ * while the owner held stdout, plus synthetic assistant notices.
+ */
+export type TurnEvidence = {
+    lastResultMeta?: ClaudeResultMeta;
+    /**
+     * The LAST `num_turns: 0` result frame in this owner's window: never turn
+     * evidence (the --resume poison frame looks the same), but a `/compact`
+     * command's own boundary — the idle auto-compact drain reads it.
+     */
+    zeroTurnResultMeta?: ClaudeResultMeta;
+    /** `system/compact_boundary` seen in this owner's window (compact.ts evidence). */
+    compactBoundary?: {
+        preTokens?: number;
+    };
+    noticeTexts: string[];
+    sawError: boolean;
+};
+export declare function newTurnEvidence(): TurnEvidence;
+/** Per-owner envelope queue between the stdout pump and the owner's drain. */
+export type ClaudeTurnSink = AsyncQueue<ClaudeTurnEnvelope>;
+export declare function newTurnSink(label: string, log?: GatewayLogger): ClaudeTurnSink;
+//# sourceMappingURL=turn-sink.d.ts.map

package/dist/turn-sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-sink.d.ts","sourceRoot":"","sources":["../src/turn-sink.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,yCAAyC,CAAC;AACrE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,GAC3B,QAAQ,GACR,cAAc,GACd,UAAU,GACV,KAAK,GACL,QAAQ,GACR,SAAS,GACT,UAAU,CAAC;AAEf,MAAM,MAAM,kBAAkB,GAC1B;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,YAAY,CAAA;CAAE;AAC1C,gFAAgF;GAC9E;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,GACpB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,mBAAmB,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAErE;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,cAAc,CAAC,EAAE,gBAAgB,CAAC;IAClC;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,gBAAgB,CAAC;IACtC,mFAAmF;IACnF,eAAe,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACzC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,wBAAgB,eAAe,IAAI,YAAY,CAE9C;AAED,8EAA8E;AAC9E,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,kBAAkB,CAAC,CAAC;AAE5D,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,aAAa,GAAG,cAAc,CAK9E"}

package/dist/turn-sink.js

@@ -0,0 +1,9 @@
+import { AsyncQueue } from '@parall/agent-core/internal/async-queue';
+export function newTurnEvidence() {
+    return { noticeTexts: [], sawError: false };
+}
+export function newTurnSink(label, log) {
+    return new AsyncQueue({
+        onFirstDrop: () => log?.warn?.(`Claude turn sink ${label} exceeded its parked-frame cap; dropping oldest`),
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parall/claude-agent",
-  "version": "1.58.2",
+  "version": "1.60.0",
   "description": "Claude Code bridge runtime for self-hosted Parall agents",
   "license": "MIT",
   "repository": {
@@ -25,9 +25,9 @@
     "src"
   ],
   "dependencies": {
-    "@parall/agent-core": "1.58.2",
-    "@parall/cli": "1.58.2",
-    "@parall/sdk": "1.58.2"
+    "@parall/agent-core": "1.60.0",
+    "@parall/cli": "1.60.0",
+    "@parall/sdk": "1.60.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",