@parall/claude-agent 1.50.1 → 1.52.0

package/dist/input-lifecycle.d.ts

@@ -0,0 +1,39 @@
+import type { DispatchInputLifecycle, GatewayLogger, RuntimeInputState } from '@parall/agent-core';
+export type ClaudeInputDelivery = {
+    deliveryKey: string;
+    commandUuid: string;
+    lifecycle?: DispatchInputLifecycle;
+    injected: boolean;
+    drained: boolean;
+    terminal?: 'completed' | 'failed' | 'settled';
+    reportedState?: RuntimeInputState;
+    resultFailed: 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
+     * failed-input report here would trigger the immediate failed-input
+     * redrive straight back into the still-choked LLM
+     * (agent-turn-outcome-design.md §6).
+     */
+    suppressFailReport?: boolean;
+};
+/**
+ * Per-process registry that maps Parall WorkItem batches to Claude stdin
+ * UUIDs. It owns lifecycle transition rules; process/stdout orchestration
+ * stays in ClaudeCodeAdapter.
+ */
+export declare class ClaudeInputRegistry {
+    private readonly byKey;
+    private readonly byCommand;
+    getByKey(deliveryKey: string): ClaudeInputDelivery | undefined;
+    getByCommand(commandUuid: string): ClaudeInputDelivery | undefined;
+    values(): IterableIterator<ClaudeInputDelivery>;
+    hasPendingInjections(): boolean;
+    register(deliveryKey: string, lifecycle: DispatchInputLifecycle | undefined, injected: boolean): ClaudeInputDelivery;
+    remove(delivery: ClaudeInputDelivery): void;
+    apply(delivery: ClaudeInputDelivery, state: 'queued' | 'started' | 'completed' | 'cancelled' | 'discarded'): Promise<void>;
+    fail(delivery: ClaudeInputDelivery): Promise<void>;
+    failBestEffort(delivery: ClaudeInputDelivery, log?: GatewayLogger): Promise<void>;
+    failAllBestEffort(log?: GatewayLogger): Promise<void>;
+}
+//# sourceMappingURL=input-lifecycle.d.ts.map

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

@@ -0,0 +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,MAAM,IAAI,gBAAgB,CAAC,mBAAmB,CAAC;IAI/C,oBAAoB,IAAI,OAAO;IAI/B,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;IASrC,KAAK,CACT,QAAQ,EAAE,mBAAmB,EAC7B,KAAK,EAAE,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,WAAW,GAAG,WAAW,GACpE,OAAO,CAAC,IAAI,CAAC;IAsBV,IAAI,CAAC,QAAQ,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBlD,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

@@ -0,0 +1,97 @@
+import { randomUUID } from 'node:crypto';
+/**
+ * Per-process registry that maps Parall WorkItem batches to Claude stdin
+ * UUIDs. It owns lifecycle transition rules; process/stdout orchestration
+ * stays in ClaudeCodeAdapter.
+ */
+export class ClaudeInputRegistry {
+    byKey = new Map();
+    byCommand = new Map();
+    getByKey(deliveryKey) {
+        return this.byKey.get(deliveryKey);
+    }
+    getByCommand(commandUuid) {
+        return this.byCommand.get(commandUuid);
+    }
+    values() {
+        return this.byKey.values();
+    }
+    hasPendingInjections() {
+        return [...this.byKey.values()].some((delivery) => delivery.injected && !delivery.drained);
+    }
+    register(deliveryKey, lifecycle, injected) {
+        if (this.byKey.has(deliveryKey)) {
+            throw new Error(`duplicate Claude delivery key ${deliveryKey}`);
+        }
+        const delivery = {
+            deliveryKey,
+            commandUuid: randomUUID(),
+            lifecycle,
+            injected,
+            drained: !injected,
+            resultFailed: false,
+        };
+        this.byKey.set(deliveryKey, delivery);
+        this.byCommand.set(delivery.commandUuid, delivery);
+        return delivery;
+    }
+    remove(delivery) {
+        if (this.byKey.get(delivery.deliveryKey) === delivery) {
+            this.byKey.delete(delivery.deliveryKey);
+        }
+        if (this.byCommand.get(delivery.commandUuid) === delivery) {
+            this.byCommand.delete(delivery.commandUuid);
+        }
+    }
+    async apply(delivery, state) {
+        if (delivery.terminal || state === 'queued')
+            return;
+        if (state === 'started') {
+            if (delivery.reportedState)
+                return;
+            await delivery.lifecycle?.update('started');
+            delivery.reportedState = 'started';
+            return;
+        }
+        if (state === 'cancelled' || state === 'discarded' || delivery.resultFailed) {
+            await this.fail(delivery);
+            return;
+        }
+        if (delivery.reportedState !== 'completed') {
+            await delivery.lifecycle?.update('completed');
+            delivery.reportedState = 'completed';
+        }
+        delivery.terminal = 'completed';
+    }
+    async fail(delivery) {
+        if (delivery.terminal)
+            return;
+        if (delivery.suppressFailReport) {
+            delivery.terminal = 'settled';
+            return;
+        }
+        try {
+            if (delivery.reportedState !== 'failed') {
+                const result = await delivery.lifecycle?.update('failed');
+                delivery.reportedState = 'failed';
+                delivery.terminal = result?.retry === false ? 'settled' : 'failed';
+            }
+        }
+        finally {
+            delivery.terminal ??= 'failed';
+        }
+    }
+    async failBestEffort(delivery, log) {
+        try {
+            await this.fail(delivery);
+        }
+        catch (err) {
+            log?.warn?.(`failed to report Claude input ${delivery.commandUuid} as failed: ${String(err)}`);
+        }
+    }
+    async failAllBestEffort(log) {
+        await Promise.all([...this.byKey.values()]
+            .filter((delivery) => !delivery.terminal)
+            .map((delivery) => this.failBestEffort(delivery, log)));
+    }
+}

package/dist/output-parser.d.ts

@@ -1,13 +1,48 @@
 import type { Readable } from 'node:stream';
 import type { RuntimeEvent } from '@parall/agent-core';
+/**
+ * Structured snapshot of the `result` frame's LLM-layer discriminators and
+ * accounting — the raw material for turn-outcome classification
+ * (agent-turn-outcome-design.md §4.1). Every field is optional: older CLIs
+ * omit some, and classification degrades gracefully.
+ */
+export type ClaudeResultMeta = {
+    subtype?: string;
+    terminalReason?: string;
+    apiErrorStatus?: number;
+    stopReason?: string;
+    /** The frame's `result` text — synthetic failure notices land here. */
+    resultText?: string;
+    isError: boolean;
+    numTurns?: number;
+    durationMs?: number;
+    durationApiMs?: number;
+    totalCostUsd?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheReadTokens?: number;
+    cacheCreationTokens?: number;
+    /** First model key of `modelUsage` — the model the CLI actually used. */
+    model?: string;
+};
 export type ClaudeParsedEvent = RuntimeEvent | {
-    type: 'session_id';
-    sessionId: string;
+    type: 'runtime_init';
+    sessionId?: string;
+    capabilities: string[];
+} | {
+    type: 'command_lifecycle';
+    commandUuid: string;
+    state: 'queued' | 'started' | 'completed' | 'cancelled' | 'discarded';
+} | {
+    type: 'assistant_error';
+    message: string;
 } | {
     type: 'turn_end';
     sessionId?: string;
+    userMessageUuid?: string;
     isError: boolean;
     numTurns?: number;
+    resultMeta?: ClaudeResultMeta;
 };
 export declare function parseClaudeStreamJson(readable: Readable): AsyncGenerator<ClaudeParsedEvent>;
 //# sourceMappingURL=output-parser.d.ts.map

package/dist/output-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"output-parser.d.ts","sourceRoot":"","sources":["../src/output-parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,MAAM,MAAM,iBAAiB,GACzB,YAAY,GACZ;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAkBzC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAgFlF,wBAAuB,qBAAqB,CAC1C,QAAQ,EAAE,QAAQ,GACjB,cAAc,CAAC,iBAAiB,CAAC,CAmInC"}
+{"version":3,"file":"output-parser.d.ts","sourceRoot":"","sources":["../src/output-parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uEAAuE;IACvE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,yEAAyE;IACzE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GACzB,YAAY,GACZ;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,EAAE,CAAA;CAAE,GACpE;IACE,IAAI,EAAE,mBAAmB,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,WAAW,GAAG,WAAW,CAAC;CACvE,GAID;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAqB5C;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,gBAAgB,CAAC;CAC/B,CAAC;AAgFN,wBAAuB,qBAAqB,CAC1C,QAAQ,EAAE,QAAQ,GACjB,cAAc,CAAC,iBAAiB,CAAC,CA4KnC"}

package/dist/output-parser.js

@@ -93,13 +93,46 @@ export async function* parseClaudeStreamJson(readable) {
         const eventRecord = event;
         if (eventRecord.type === 'system' && eventRecord.subtype === 'init') {
             const sessionId = asTrimmedString(eventRecord.session_id);
-            if (sessionId) {
-                yield { type: 'session_id', sessionId };
+            const capabilities = Array.isArray(eventRecord.capabilities)
+                ? eventRecord.capabilities
+                    .map((capability) => asTrimmedString(capability))
+                    .filter((capability) => Boolean(capability))
+                : [];
+            yield {
+                type: 'runtime_init',
+                ...(sessionId ? { sessionId } : {}),
+                capabilities,
+            };
+            continue;
+        }
+        if (eventRecord.type === 'command_lifecycle') {
+            const commandUuid = asTrimmedString(eventRecord.command_uuid);
+            const state = asTrimmedString(eventRecord.state);
+            if (commandUuid &&
+                (state === 'queued' ||
+                    state === 'started' ||
+                    state === 'completed' ||
+                    state === 'cancelled' ||
+                    state === 'discarded')) {
+                yield { type: 'command_lifecycle', commandUuid, state };
             }
             continue;
         }
         if (eventRecord.type === 'assistant') {
-            if (eventRecord.error)
+            if (eventRecord.error) {
+                // Not a model message — surface the notice text for turn-outcome
+                // classification instead of silently dropping the frame.
+                const message = asTrimmedString(eventRecord.error) ??
+                    asTrimmedString(eventRecord.error?.message);
+                if (message)
+                    yield { type: 'assistant_error', message };
+                continue;
+            }
+            // Verbose stream-json includes nested subagent frames. Their final
+            // tool_result returns through the root conversation; projecting their
+            // internal assistant/tool stream here would attribute background work
+            // to whichever root input currently owns stdout.
+            if (asTrimmedString(eventRecord.parent_tool_use_id))
                 continue;
             const message = eventRecord.message;
             const content = message && typeof message === 'object'
@@ -147,6 +180,8 @@ export async function* parseClaudeStreamJson(readable) {
             continue;
         }
         if (eventRecord.type === 'user') {
+            if (asTrimmedString(eventRecord.parent_tool_use_id))
+                continue;
             const message = eventRecord.message;
             const content = message && typeof message === 'object'
                 ? message.content
@@ -191,12 +226,68 @@ export async function* parseClaudeStreamJson(readable) {
             // the map grow unbounded or mislabel durations on id collisions.
             toolUses.clear();
             const numTurns = asFiniteNumber(eventRecord.num_turns);
+            const userMessageUuid = asTrimmedString(eventRecord.user_message_uuid) || asTrimmedString(eventRecord.command_uuid);
             yield {
                 type: 'turn_end',
                 sessionId: asTrimmedString(eventRecord.session_id),
+                ...(userMessageUuid ? { userMessageUuid } : {}),
                 isError,
                 ...(numTurns !== undefined ? { numTurns } : {}),
+                resultMeta: extractResultMeta(eventRecord, isError, numTurns),
             };
         }
     }
 }
+/** Snapshot the result frame's discriminator + usage fields (all optional). */
+function extractResultMeta(frame, isError, numTurns) {
+    const usage = frame.usage && typeof frame.usage === 'object'
+        ? frame.usage
+        : undefined;
+    const modelUsage = frame.modelUsage && typeof frame.modelUsage === 'object'
+        ? Object.keys(frame.modelUsage)
+        : [];
+    const meta = { isError };
+    if (numTurns !== undefined)
+        meta.numTurns = numTurns;
+    const subtype = asTrimmedString(frame.subtype);
+    if (subtype)
+        meta.subtype = subtype;
+    const terminalReason = asTrimmedString(frame.terminal_reason);
+    if (terminalReason)
+        meta.terminalReason = terminalReason;
+    const apiErrorStatus = asFiniteNumber(frame.api_error_status);
+    if (apiErrorStatus !== undefined)
+        meta.apiErrorStatus = apiErrorStatus;
+    const stopReason = asTrimmedString(frame.stop_reason);
+    if (stopReason)
+        meta.stopReason = stopReason;
+    const resultText = asTrimmedString(frame.result);
+    if (resultText)
+        meta.resultText = resultText;
+    const durationMs = asFiniteNumber(frame.duration_ms);
+    if (durationMs !== undefined)
+        meta.durationMs = durationMs;
+    const durationApiMs = asFiniteNumber(frame.duration_api_ms);
+    if (durationApiMs !== undefined)
+        meta.durationApiMs = durationApiMs;
+    const totalCostUsd = asFiniteNumber(frame.total_cost_usd);
+    if (totalCostUsd !== undefined)
+        meta.totalCostUsd = totalCostUsd;
+    if (usage) {
+        const inputTokens = asFiniteNumber(usage.input_tokens);
+        if (inputTokens !== undefined)
+            meta.inputTokens = inputTokens;
+        const outputTokens = asFiniteNumber(usage.output_tokens);
+        if (outputTokens !== undefined)
+            meta.outputTokens = outputTokens;
+        const cacheReadTokens = asFiniteNumber(usage.cache_read_input_tokens);
+        if (cacheReadTokens !== undefined)
+            meta.cacheReadTokens = cacheReadTokens;
+        const cacheCreationTokens = asFiniteNumber(usage.cache_creation_input_tokens);
+        if (cacheCreationTokens !== undefined)
+            meta.cacheCreationTokens = cacheCreationTokens;
+    }
+    if (modelUsage.length > 0)
+        meta.model = modelUsage[0];
+    return meta;
+}

package/dist/turn-outcome.d.ts

@@ -0,0 +1,10 @@
+import type { TurnOutcomeEvent } from '@parall/agent-core';
+import type { ClaudeResultMeta } from './output-parser.js';
+export declare function parseClaudeResetTime(text: string, now: Date): string | undefined;
+/**
+ * Classify one finished Claude turn from its result-frame snapshot plus any
+ * synthetic notice texts observed during the turn (assistant_error frames,
+ * zero-usage assistant text like the session-limit notice).
+ */
+export declare function classifyClaudeTurn(meta: ClaudeResultMeta | undefined, noticeTexts: string[], now?: Date): TurnOutcomeEvent;
+//# sourceMappingURL=turn-outcome.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"turn-outcome.d.ts","sourceRoot":"","sources":["../src/turn-outcome.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAa,MAAM,oBAAoB,CAAC;AACtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAwC3D,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,GAAG,MAAM,GAAG,SAAS,CA8ChF;AAcD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,gBAAgB,GAAG,SAAS,EAClC,WAAW,EAAE,MAAM,EAAE,EACrB,GAAG,GAAE,IAAiB,GACrB,gBAAgB,CAkElB"}

package/dist/turn-outcome.js

@@ -0,0 +1,173 @@
+/**
+ * Claude turn-outcome classifier (agent-turn-outcome-design.md §4.1).
+ *
+ * Detection order is a hard rule: structured fields first
+ * (api_error_status / terminal_reason / is_error), behavioral heuristics
+ * second (zero-usage synthetic turns), message regex last — and regex only
+ * ever refines a classification, so a CLI wording change degrades to the
+ * generic `api_error`, never to a wrong `ok` or a wrong deferral.
+ * Classification uncertainty must never defer: deferring a real message is
+ * costlier than losing one automatic recovery.
+ */
+const LIMIT_TEXT = /you'?ve (hit|reached) your .*limit|usage limit reached|weekly limit/i;
+const AUTH_TEXT = /not logged in|please run \/login|authentication_error|invalid api key|oauth token (has )?expired|\[action required\]/i;
+const CONTEXT_TEXT = /prompt is too long|context (window|length) exceeded|request too large/i;
+const DETAIL_MAX = 500;
+/**
+ * Parse the reset time out of a limit notice like
+ * `You've hit your session limit · resets 1:20am (Asia/Shanghai)` /
+ * `… resets at 11pm (UTC)`. Returns the NEXT occurrence of that wall-clock
+ * time in the given zone as an ISO string, or undefined when the wording
+ * doesn't match — the server then applies its default deferral window.
+ */
+function minutesOfDayInZone(fmt, at) {
+    const parts = Object.fromEntries(fmt
+        .formatToParts(at)
+        .filter((p) => p.type !== 'literal')
+        .map((p) => [p.type, Number(p.value)]));
+    // "24" can appear for midnight under hour12:false on some ICU versions.
+    const hour = parts.hour === 24 ? 0 : parts.hour;
+    return hour * 60 + parts.minute;
+}
+export function parseClaudeResetTime(text, now) {
+    const m = /resets\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\s*\(([^)]+)\)/i.exec(text);
+    if (!m)
+        return undefined;
+    let hour = Number(m[1]);
+    const minute = m[2] ? Number(m[2]) : 0;
+    const meridiem = m[3]?.toLowerCase();
+    const timeZone = m[4].trim();
+    if (!Number.isFinite(hour) || hour > 23 || minute > 59)
+        return undefined;
+    if (meridiem === 'pm' && hour < 12)
+        hour += 12;
+    if (meridiem === 'am' && hour === 12)
+        hour = 0;
+    // Intl throws on unknown zone names — treat that as no parse.
+    let fmt;
+    let nowMinutesOfDay;
+    try {
+        fmt = new Intl.DateTimeFormat('en-US', {
+            timeZone,
+            hour12: false,
+            hour: '2-digit',
+            minute: '2-digit',
+        });
+        nowMinutesOfDay = minutesOfDayInZone(fmt, now);
+    }
+    catch {
+        return undefined;
+    }
+    const targetMinutesOfDay = hour * 60 + minute;
+    let deltaMinutes = targetMinutesOfDay - nowMinutesOfDay;
+    if (deltaMinutes <= 0)
+        deltaMinutes += 24 * 60;
+    // Anchor on the real instant (drop seconds so the result lands exactly on
+    // the notice's minute), advance by the wall-clock delta, then CORRECT for
+    // any DST transition inside the interval: wall-clock minutes ≠ elapsed UTC
+    // minutes across a shift, so re-read the candidate's wall-clock in the
+    // zone and nudge by the difference (two rounds absorb a single transition;
+    // a spring-forward nonexistent time settles within an hour, which the
+    // server-side clamp tolerates).
+    const anchored = now.getTime() - (now.getSeconds() * 1000 + now.getMilliseconds());
+    let target = anchored + deltaMinutes * 60_000;
+    for (let i = 0; i < 2; i++) {
+        let diff = targetMinutesOfDay - minutesOfDayInZone(fmt, new Date(target));
+        if (diff > 720)
+            diff -= 1440;
+        if (diff < -720)
+            diff += 1440;
+        if (diff === 0)
+            break;
+        target += diff * 60_000;
+    }
+    if (target <= now.getTime())
+        target += 24 * 60 * 60_000;
+    return new Date(target).toISOString();
+}
+function usageOf(meta) {
+    const usage = {};
+    if (meta.inputTokens !== undefined)
+        usage.inputTokens = meta.inputTokens;
+    if (meta.outputTokens !== undefined)
+        usage.outputTokens = meta.outputTokens;
+    if (meta.cacheReadTokens !== undefined)
+        usage.cacheReadTokens = meta.cacheReadTokens;
+    if (meta.cacheCreationTokens !== undefined)
+        usage.cacheCreationTokens = meta.cacheCreationTokens;
+    if (meta.totalCostUsd !== undefined)
+        usage.costUsd = meta.totalCostUsd;
+    if (meta.durationMs !== undefined)
+        usage.durationMs = meta.durationMs;
+    if (meta.durationApiMs !== undefined)
+        usage.durationApiMs = meta.durationApiMs;
+    return Object.keys(usage).length > 0 ? usage : undefined;
+}
+/**
+ * Classify one finished Claude turn from its result-frame snapshot plus any
+ * synthetic notice texts observed during the turn (assistant_error frames,
+ * zero-usage assistant text like the session-limit notice).
+ */
+export function classifyClaudeTurn(meta, noticeTexts, now = new Date()) {
+    if (!meta) {
+        // No result frame reached us (subprocess died mid-turn) — the dispatch
+        // layer's own error path reports the crash; classify what we know.
+        return { type: 'turn_outcome', outcome: 'runtime_crash' };
+    }
+    const usage = usageOf(meta);
+    const evidence = [meta.resultText, ...noticeTexts].filter(Boolean).join('\n');
+    const base = {
+        type: 'turn_outcome',
+        ...(usage ? { usage } : {}),
+        ...(meta.model ? { model: meta.model } : {}),
+        raw: {
+            ...(meta.subtype ? { subtype: meta.subtype } : {}),
+            ...(meta.terminalReason ? { terminal_reason: meta.terminalReason } : {}),
+            ...(meta.apiErrorStatus !== undefined ? { api_error_status: meta.apiErrorStatus } : {}),
+            ...(meta.stopReason ? { stop_reason: meta.stopReason } : {}),
+        },
+    };
+    const withDetail = (outcome, retryAt) => ({
+        ...base,
+        outcome,
+        ...(evidence ? { detail: evidence.slice(0, DETAIL_MAX) } : {}),
+        ...(retryAt ? { retryAt } : {}),
+    });
+    // 1) Structured HTTP status.
+    if (meta.apiErrorStatus === 401 || meta.apiErrorStatus === 403)
+        return withDetail('auth');
+    if (meta.apiErrorStatus === 413)
+        return withDetail('context_overflow');
+    if (meta.apiErrorStatus === 429) {
+        return withDetail('usage_limit', evidence ? parseClaudeResetTime(evidence, now) : undefined);
+    }
+    // 2) Text families — refine only; they can never turn a failure into ok.
+    const failed = meta.isError ||
+        // Claude CLI 2.1.220 sets terminal_reason=completed on clean result
+        // frames. Any other terminal reason stays fail-closed.
+        (meta.terminalReason !== undefined && meta.terminalReason !== 'completed') ||
+        (meta.subtype !== undefined && meta.subtype !== 'success');
+    const syntheticQuiet = !failed &&
+        // A "successful" turn that never touched the API and produced no tool
+        // activity is the synthetic-notice shape (limit/auth text emitted
+        // locally by the CLI): zero usage + stop_sequence.
+        meta.stopReason === 'stop_sequence' &&
+        (meta.inputTokens ?? 0) === 0 &&
+        (meta.outputTokens ?? 0) === 0 &&
+        (meta.durationApiMs ?? 0) === 0;
+    if (failed || syntheticQuiet || noticeTexts.length > 0) {
+        if (CONTEXT_TEXT.test(evidence))
+            return withDetail('context_overflow');
+        if (LIMIT_TEXT.test(evidence)) {
+            return withDetail('usage_limit', parseClaudeResetTime(evidence, now));
+        }
+        if (AUTH_TEXT.test(evidence))
+            return withDetail('auth');
+        // Reached only when this block was entered (failed / syntheticQuiet /
+        // a captured synthetic notice) but no text family matched. A CLI wording
+        // change must degrade to api_error — never fall through to `ok` and settle
+        // a refused turn as success (the read-no-reply class this PR closes).
+        return withDetail('api_error');
+    }
+    return { ...base, outcome: 'ok' };
+}

package/package.json

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