@sema-agent/client-core 0.97.0 → 0.98.0

package/dist/subagent/engineCompactWire.js

@@ -1,6 +1,7 @@
 import { hostLog, hostTimersFor } from '../host.js';
 import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
-import { COMPACT_NOT_RUNNING, isUnavailableFaceCode } from '../engineErrorCodes.js';
+import { COMPACT_NOT_RUNNING } from '../engineErrorCodes.js';
+import { refusalDeliveryOf } from '../hitl/decisionRefusal.js';
 import { surfaceCompactNotRunning } from '../hitl/hitlHostSurface.js';
 import { wireFailureShapeOf, wireFailureTextsOf } from '../wireFailureShape.js';
 import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, noAnswerDetailFrom, settleInjected, } from '../engineWireFor.js';
@@ -30,7 +31,6 @@ function probeManualCompactCapability(wire) {
         return;
     kickEngineCapsProbe(base, () => client.capabilities());
 }
-export function resetManualCompactCapability() { }
 export function __resetEngineCompactArmForTests() {
     pendingCompactKeys.clear();
     pendingCompactSinks.clear();
@@ -86,9 +86,11 @@ function compactFailureOutcomeOf(e) {
     const status = typeof shape.status === 'number' && Number.isFinite(shape.status) ? shape.status : undefined;
     const code = shape.errorCode !== undefined && shape.errorCode !== '' ? shape.errorCode : undefined;
     if (status !== undefined) {
-        if ((status >= 400 && status < 500) || isUnavailableFaceCode(code)) {
-            return { kind: 'refused', status, ...(code !== undefined ? { errorCode: code } : {}) };
-        }
+        const d = refusalDeliveryOf(e, { route: 'compact' });
+        if (d.delivery === 'refused')
+            return { kind: 'refused', status: d.status ?? status, ...(code !== undefined ? { errorCode: code } : {}) };
+        if (d.delivery === 'ambiguous')
+            return { kind: 'failed', status: d.status ?? status, detail: wireFailureTextsOf(e).reason, unconfirmed: true };
         return { kind: 'failed', status, detail: wireFailureTextsOf(e).reason };
     }
     const noAnswer = typeof e === 'object' && e !== null ? noAnswerDetailFrom(e) : null;

package/dist/subagent/engineTaskHandleWire.js

@@ -2,7 +2,6 @@ import { TaskStopConflictError } from '@sema-agent/sdk';
 import { hostLog } from '../host.js';
 import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, noAnswerDetailFrom, sendOnce, settleInjected } from '../engineWireFor.js';
 import { engineWireDebugEnabled } from '../engineWireTarget.js';
-import { engineCapTrue } from '../engineCapsCache.js';
 import { engineSessionParamFor } from '../engineSessionParam.js';
 import { resolveOwnerContext } from './engineSubagentResume.js';
 import { engineTaskHandlesCapable } from './engineRowStopGate.js';
@@ -15,7 +14,7 @@ function usableTaskStopClient(client) {
 }
 const CAPS_KEY_REQUIRED_DETAIL = 'capability evidence for taskHandles is not available under the key the host named (capsBaseUrl) — nothing sent';
 import { spoolMarkerOf } from '../toolResult.js';
-import { STOP_CONFLICT_CODES, STOP_NOT_LANDED, STOP_NOT_LOCAL, STOP_PARKED, STOP_PARK_ARBITER_UNREACHABLE, STOP_PARK_RESUME_WON, } from '../engineErrorCodes.js';
+import { STOP_NOT_LANDED, STOP_NOT_LOCAL, STOP_PARKED, STOP_PARK_ARBITER_UNREACHABLE, STOP_PARK_RESUME_WON, } from '../engineErrorCodes.js';
 function resolveHostRun(handle) {
     const runId = resolveOwnerContext(handle).runId;
     if (!runId) {
@@ -38,7 +37,7 @@ export async function fetchEngineTaskOutput(handle, opts) {
     if (wire.kind === 'no-target' || wire.kind === 'injected-unusable')
         return null;
     if (wire.kind === 'injected') {
-        if (!engineCapTrue(wire.capsBaseUrl, 'taskHandles')) {
+        if (wire.capsBaseUrl === undefined || !engineTaskHandlesCapable(owner.key, wire.capsBaseUrl)) {
             hostLog('debug', `[task-handle] output ${handle}: ${CAPS_KEY_REQUIRED_DETAIL}`);
             return null;
         }
@@ -115,9 +114,7 @@ function terminalOutputHint(output) {
 export function classifyTaskStopConflict(e) {
     const detail = e instanceof Error ? e.message : String(e);
     const raw = e?.errorCode;
-    const code = typeof raw === 'string'
-        ? raw
-        : (STOP_CONFLICT_CODES.find(c => detail.includes(c)) ?? '');
+    const code = typeof raw === 'string' ? raw : '';
     switch (code) {
         case STOP_NOT_LOCAL:
             return { ok: false, reason: 'not_local', detail };
@@ -139,7 +136,7 @@ export async function stopEngineTask(handle, opts) {
     if (wire.kind === 'no-target' || wire.kind === 'injected-unusable')
         return { ok: false, reason: 'unavailable' };
     if (wire.kind === 'injected') {
-        if (!engineCapTrue(wire.capsBaseUrl, 'taskHandles'))
+        if (wire.capsBaseUrl === undefined || !engineTaskHandlesCapable(owner.key, wire.capsBaseUrl))
             return { ok: false, reason: 'unavailable', detail: CAPS_KEY_REQUIRED_DETAIL };
     }
     else if (!engineTaskHandlesCapable(owner.key)) {

package/dist/subagentContentStore.js

@@ -1,17 +1,7 @@
 import { DEFAULT_SESSION_KEY } from './sessionSlot.js';
 import { toolEndOutputText } from './toolResultContent.js';
 export function coerceOutput(v) {
-    if (v === undefined || v === null)
-        return undefined;
-    const text = toolEndOutputText(v);
-    if (text !== undefined)
-        return text;
-    try {
-        return JSON.stringify(v);
-    }
-    catch {
-        return String(v);
-    }
+    return toolEndOutputText(v);
 }
 const MAX_ITEMS_PER_TASK = 200;
 const MAX_TASKS = 32;

package/dist/submitReopen.d.ts

@@ -0,0 +1,24 @@
+import { type AgentClient, type AgentEvent, type TaskRequest } from '@sema-agent/sdk';
+type TasksStreamOptions = Parameters<AgentClient['tasks']['stream']>[1];
+export type SubmitStreamOptions = Omit<TasksStreamOptions, 'idempotencyKey'>;
+export interface SubmitStreamReopenDeps {
+    readonly client: {
+        readonly tasks: {
+            stream(request: TaskRequest, options: TasksStreamOptions): AsyncGenerator<AgentEvent>;
+        };
+    };
+    readonly request: TaskRequest;
+    readonly options: SubmitStreamOptions;
+}
+export interface SubmitStreamReading {
+    readonly idempotencyKey: string;
+    readonly attempts: 0 | 1 | 2;
+    readonly reopened: boolean;
+    readonly replay: boolean;
+}
+export interface BoundedSubmitStream {
+    readonly frames: AsyncGenerator<AgentEvent>;
+    reading(): SubmitStreamReading;
+}
+export declare function submitStreamWithBoundedReopen(deps: SubmitStreamReopenDeps): BoundedSubmitStream;
+export {};

package/dist/submitReopen.js

@@ -0,0 +1,75 @@
+import { newIdempotencyKey } from '@sema-agent/sdk';
+import { transportFailureScene } from './engineWireFor.js';
+import { isReplayedTerminal } from './replayBody.js';
+function boundByResponse(res) {
+    try {
+        const id = res.headers.get('x-task-id');
+        return typeof id === 'string' && id.length > 0;
+    }
+    catch {
+        return true;
+    }
+}
+function callerAborted(signal) {
+    try {
+        return signal !== null && signal !== undefined && signal.aborted === true;
+    }
+    catch {
+        return true;
+    }
+}
+function lostConnectionWithoutAnswer(error) {
+    const scene = transportFailureScene(error);
+    return scene.status === undefined && scene.end !== 'unreadable' && scene.noAnswer === 'connection-lost';
+}
+export function submitStreamWithBoundedReopen(deps) {
+    const idempotencyKey = newIdempotencyKey();
+    let attempts = 0;
+    let replay = false;
+    let consumerStopped = false;
+    async function* run() {
+        for (const attempt of [1, 2]) {
+            attempts = attempt;
+            let bound = false;
+            try {
+                const source = deps.client.tasks.stream(deps.request, {
+                    ...deps.options,
+                    idempotencyKey,
+                    onResponse: (res) => {
+                        if (boundByResponse(res))
+                            bound = true;
+                        deps.options.onResponse?.(res);
+                    },
+                });
+                for await (const frame of source) {
+                    bound = true;
+                    if (isReplayedTerminal(frame))
+                        replay = true;
+                    yield frame;
+                }
+                return;
+            }
+            catch (error) {
+                if (attempt === 2 || bound || !lostConnectionWithoutAnswer(error))
+                    throw error;
+                if (consumerStopped || callerAborted(deps.options.signal))
+                    throw error;
+            }
+        }
+    }
+    const frames = run();
+    const innerReturn = frames.return.bind(frames);
+    const innerThrow = frames.throw.bind(frames);
+    frames.return = (value) => {
+        consumerStopped = true;
+        return innerReturn(value);
+    };
+    frames.throw = (error) => {
+        consumerStopped = true;
+        return innerThrow(error);
+    };
+    return {
+        frames,
+        reading: () => Object.freeze({ idempotencyKey, attempts, reopened: attempts === 2, replay }),
+    };
+}

package/dist/terminalStatuses.d.ts

@@ -9,6 +9,9 @@ export declare function isSdkRunTerminal(status: unknown): status is SdkRunTermi
 export declare function isSdkRunTerminalNotSuccess(status: unknown): status is Exclude<SdkRunTerminalStatus, 'completed'>;
 export declare const SDK_PARKED_RUN_STATUSES: readonly ["suspended", "needs_review"];
 export declare function isSdkRunParked(status: unknown): status is (typeof SDK_PARKED_RUN_STATUSES)[number];
+export declare const SDK_RUN_LIVE_STATUSES: readonly ["running", "suspended", "needs_review"];
+export type SdkRunLiveStatus = (typeof SDK_RUN_LIVE_STATUSES)[number];
+export declare function isSdkRunLive(status: string): status is SdkRunLiveStatus;
 export declare function isSdkRunFrameSynthesizable(status: unknown): boolean;
 export declare const SDK_FLEET_TASK_TERMINAL_STATUSES: readonly ["completed", "failed", "killed"];
 export type SdkFleetTaskTerminalStatus = (typeof SDK_FLEET_TASK_TERMINAL_STATUSES)[number];

package/dist/terminalStatuses.js

@@ -1,4 +1,4 @@
-import { CORE_TERMINAL_CAUSE_KINDS } from './generated/engineFactTables.js';
+import { CORE_TERMINAL_CAUSE_KINDS, CORE_TASK_NOTIFICATION_TERMINAL_STATUSES as GENERATED_TASK_NOTIFICATION_TERMINAL_STATUSES } from './generated/engineFactTables.js';
 function memberOf(table, word) {
     return typeof word === 'string' && table.includes(word);
 }
@@ -20,6 +20,14 @@ export const SDK_PARKED_RUN_STATUSES = Object.freeze(['suspended', 'needs_review
 export function isSdkRunParked(status) {
     return memberOf(SDK_PARKED_RUN_STATUSES, status);
 }
+export const SDK_RUN_LIVE_STATUSES = Object.freeze(['running', ...SDK_PARKED_RUN_STATUSES]);
+const _runLiveCoversPartition = true;
+const _partitionCoversRunLive = true;
+void _runLiveCoversPartition;
+void _partitionCoversRunLive;
+export function isSdkRunLive(status) {
+    return memberOf(SDK_RUN_LIVE_STATUSES, status);
+}
 export function isSdkRunFrameSynthesizable(status) {
     return isSdkRunTerminal(status) || isSdkRunParked(status);
 }
@@ -30,7 +38,7 @@ export function isSdkFleetTaskTerminal(status) {
 export function isSdkFleetTaskTerminalNotSuccess(status) {
     return terminalNotSuccessOf(SDK_FLEET_TASK_TERMINAL_STATUSES, status);
 }
-export const CORE_TASK_NOTIFICATION_TERMINAL_STATUSES = Object.freeze(['completed', 'failed', 'killed', 'cancelled']);
+export const CORE_TASK_NOTIFICATION_TERMINAL_STATUSES = GENERATED_TASK_NOTIFICATION_TERMINAL_STATUSES;
 export function isCoreTaskNotificationTerminal(status) {
     return memberOf(CORE_TASK_NOTIFICATION_TERMINAL_STATUSES, status);
 }

package/dist/toolResult.d.ts

@@ -1,5 +1,6 @@
 import type { TaskResult, TaskStats } from '@sema-agent/sdk';
 import { type ModelFallbackReason } from './engineErrorCodes.js';
+import type { toolKillCauseAcrossEngineIdentity } from './engineIdentity.js';
 export declare const STRUCTURED_DETAIL_TYPES: ReadonlySet<string>;
 export declare function structuredDetailType(structured: unknown): string | undefined;
 export declare const PROTOCOL_MARKERS: {
@@ -103,7 +104,15 @@ export type ToolCardOutcomeReading = {
     readonly kind: 'unreadable';
 };
 export declare function readToolCardOutcome(record: object | null | undefined): ToolCardOutcomeReading;
-export declare function wireOutputToBody(toolName: string, output: unknown, isError: boolean, truncated: boolean, flatten: FlattenWireOutput, structured?: unknown, leaderLedger?: boolean): ToolResultBody;
+export interface ToolResultRowFlags {
+    readonly collateralAbort: boolean;
+    readonly interruptedNeverStarted: boolean;
+    readonly approvalWindowExpired: boolean;
+    readonly denialLimitWindowExpired: boolean;
+}
+export declare function toolResultRowFlagsOf(row: object | null | undefined): ToolResultRowFlags;
+export type ToolKillCause = NonNullable<ReturnType<typeof toolKillCauseAcrossEngineIdentity>> | 'memory_pressure';
+export declare function wireOutputToBody(toolName: string, output: unknown, isError: boolean, truncated: boolean, flatten: FlattenWireOutput, structured?: unknown, leaderLedger?: boolean, killCauseOf?: () => ToolKillCause | undefined): ToolResultBody;
 export declare function structuredToToolUseResult(structured: unknown, modelText?: string, leaderLedger?: boolean): {
     toolUseResult: unknown;
     isError?: boolean;

package/dist/toolResult.js

@@ -4,7 +4,7 @@ import { parseWorkflowPollEnvelope, projectWorkflowTaskOutput } from './workflow
 import { asModelFallbackReason } from './engineErrorCodes.js';
 import { frozenSet } from './frozenSet.js';
 import { bashExitOf, bashExitReadingFailed } from './bashExitReading.js';
-import { readFrameTrueMark } from './ownKey.js';
+import { readFrameTrueMark, readFrameTrueMarkReading } from './ownKey.js';
 import { isCoreSemaTaskTerminal } from './terminalStatuses.js';
 import { CORE_ENGINE_CARD_TYPES } from './generated/engineFactTables.js';
 export const STRUCTURED_DETAIL_TYPES = frozenSet(CORE_ENGINE_CARD_TYPES);
@@ -314,7 +314,10 @@ export function readToolCardOutcome(record) {
         const block = toolResultBlockOf(record);
         if (block === undefined)
             return { kind: 'unreadable' };
-        if (readFrameTrueMark(record, '_sema_not_executed'))
+        const notExecuted = readFrameTrueMarkReading(record, '_sema_not_executed');
+        if (notExecuted === 'unreadable')
+            return { kind: 'unreadable' };
+        if (notExecuted === 'marked')
             return cardDegraded('not-executed');
         const markerDesc = Object.getOwnPropertyDescriptor(record, '_sema_degraded');
         if (markerDesc === undefined)
@@ -329,7 +332,31 @@ export function readToolCardOutcome(record) {
         return { kind: 'unreadable' };
     }
 }
-export function wireOutputToBody(toolName, output, isError, truncated, flatten, structured, leaderLedger = true) {
+export function toolResultRowFlagsOf(row) {
+    return Object.freeze({
+        collateralAbort: readFrameTrueMark(row, '_sema_collateral_abort'),
+        interruptedNeverStarted: readFrameTrueMark(row, '_sema_interrupted_never_started'),
+        approvalWindowExpired: readFrameTrueMark(row, '_sema_approval_window_expired'),
+        denialLimitWindowExpired: readFrameTrueMark(row, '_sema_denial_limit_window_expired'),
+    });
+}
+const TOOL_KILL_TEXT = {
+    engine_restarted: 'Command was killed when the engine restarted (exit 137)',
+    memory_pressure: 'Command was killed (exit 137 — the system ran out of memory; consider lowering build parallelism e.g. make -j2)',
+    unknown: 'Command was killed by signal 9 (exit 137)',
+};
+const isToolKillCause = (v) => v === 'engine_restarted' || v === 'memory_pressure';
+const killedBySignalSentence = (killCauseOf) => {
+    let cause;
+    try {
+        cause = killCauseOf?.();
+    }
+    catch {
+        cause = undefined;
+    }
+    return TOOL_KILL_TEXT[isToolKillCause(cause) ? cause : 'unknown'];
+};
+export function wireOutputToBody(toolName, output, isError, truncated, flatten, structured, leaderLedger = true, killCauseOf) {
     const text = flatten(output);
     const name = (toolName || '').toLowerCase();
     const sType = structuredDetailType(structured);
@@ -380,7 +407,7 @@ export function wireOutputToBody(toolName, output, isError, truncated, flatten,
                 const reason = slots.stderr.length > 0 ? slots.stderr : slots.stdout;
                 let body = slots.exitCode != null ? `Exit code ${slots.exitCode}\n${reason}` : reason;
                 if (slots.exitCode === 137) {
-                    body += `\nCommand was killed (exit 137 — possibly out-of-memory; consider lowering build parallelism e.g. make -j2)`;
+                    body += `\n${killedBySignalSentence(killCauseOf)}`;
                 }
                 if (body.trim() === '' && text.trim() !== '')
                     body = text;
@@ -400,8 +427,9 @@ export function wireOutputToBody(toolName, output, isError, truncated, flatten,
             };
         }
         const stdout = truncated ? `${text}\n…(truncated)` : text;
-        if (isError || bashExitReadingFailed(exit))
-            return { content: stdout, isError: true };
+        if (isError || bashExitReadingFailed(exit)) {
+            return { content: exit.exitCode === 137 ? `${stdout}\n${killedBySignalSentence(killCauseOf)}` : stdout, isError: true };
+        }
         return { content: stdout, isError, toolUseResult: { stdout, stderr: '', interrupted: false } };
     }
     if (name === 'taskoutput' || name === 'task_output') {

package/dist/toolRoster.d.ts

@@ -12,7 +12,6 @@ export interface ToolRosterRenderHintsView {
     activity?: string;
     summaryParams?: readonly string[];
     resultCards?: readonly string[];
-    approvalCard?: string;
 }
 export interface ToolRosterEntryView {
     name: string;
@@ -87,7 +86,6 @@ export interface ToolShim {
     family?: string;
     userFacingName?: string;
     activity?: string;
-    approvalCard?: string;
     summaryParams?: readonly string[];
     effect?: string;
     egress?: boolean;

package/dist/toolRoster.js

@@ -77,7 +77,6 @@ function readEntry(raw) {
                     ...(str(hintsRaw.activity) !== undefined ? { activity: str(hintsRaw.activity) } : {}),
                     ...(strArr(hintsRaw.summaryParams) !== undefined ? { summaryParams: strArr(hintsRaw.summaryParams) } : {}),
                     ...(strArr(hintsRaw.resultCards) !== undefined ? { resultCards: strArr(hintsRaw.resultCards) } : {}),
-                    ...(str(hintsRaw.approvalCard) !== undefined ? { approvalCard: str(hintsRaw.approvalCard) } : {}),
                 },
             }
             : {}),
@@ -208,7 +207,6 @@ export function toolShimFromRoster(entry) {
         ...(e.family !== undefined ? { family: e.family } : {}),
         ...(e.renderHints?.userFacingName !== undefined ? { userFacingName: e.renderHints.userFacingName } : {}),
         ...(e.renderHints?.activity !== undefined ? { activity: e.renderHints.activity } : {}),
-        ...(e.renderHints?.approvalCard !== undefined ? { approvalCard: e.renderHints.approvalCard } : {}),
         ...(e.renderHints?.summaryParams !== undefined ? { summaryParams: e.renderHints.summaryParams } : {}),
         ...(e.effect !== undefined ? { effect: e.effect } : {}),
         ...(e.egress !== undefined ? { egress: e.egress } : {}),

package/dist/turnFailurePresentation.d.ts

@@ -0,0 +1,28 @@
+import { type TurnWireErrorVerdict } from './wireErrorTriage.js';
+export type TurnFailureCategory = 'auth' | 'billing' | 'rate_limited' | 'invalid_request' | 'capability_unavailable' | 'timeout' | 'server_error' | 'connection_lost' | 'parked' | 'internal';
+export declare const TURN_FAILURE_CATEGORIES: readonly TurnFailureCategory[];
+export interface TurnFailureRetry {
+    readonly offer: boolean;
+    readonly basis: 'wire' | 'category';
+}
+export interface TurnFailurePresentation {
+    readonly category: TurnFailureCategory;
+    readonly kind: TurnWireErrorVerdict['kind'];
+    readonly status?: number;
+    readonly errorCode?: string;
+    readonly detail: string;
+    readonly headline?: string;
+    readonly name?: string;
+    readonly retry: TurnFailureRetry;
+    readonly waitSec?: number;
+}
+export declare function turnFailurePresentation(err: {} | null | undefined, evidence?: {
+    readonly bound?: boolean;
+    readonly reopened?: boolean;
+}): TurnFailurePresentation;
+export type SeatTurnFailure = Pick<TurnFailurePresentation, 'category' | 'retry' | 'waitSec' | 'headline' | 'errorCode'>;
+export declare function seatTurnFailureOf(err: {} | null | undefined, evidence?: {
+    readonly bound?: boolean;
+    readonly reopened?: boolean;
+}): SeatTurnFailure;
+export declare function readSeatTurnFailure(event: {} | null | undefined): SeatTurnFailure | undefined;

package/dist/turnFailurePresentation.js

@@ -0,0 +1,205 @@
+import { classifyTurnWireError, effectiveWireErrorCode, isPreStreamDrainingReject } from './wireErrorTriage.js';
+import { isSseIdleError } from './sseIdleTriage.js';
+import { isCodeClassifiedGateFailure } from './gateFailureCodes.js';
+import { CORRUPT_ROW_ERROR_CODE, CORRUPT_SESSION_ERROR_CODE, MEMORY_CONTROL_PLANE_CORRUPT, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
+import { toolDeclarationRefusalFromError } from './wireRefusalCopy.js';
+import { THROWN_SLOT_UNREADABLE, readErrorNumber, readThrownSlot, wireFailureTextsOf } from './wireFailureShape.js';
+import { provablyNotSent } from './engineWireFor.js';
+const CATEGORY_TABLE = Object.freeze({
+    auth: true,
+    billing: true,
+    rate_limited: true,
+    invalid_request: true,
+    capability_unavailable: true,
+    timeout: true,
+    server_error: true,
+    connection_lost: true,
+    parked: true,
+    internal: true,
+});
+export const TURN_FAILURE_CATEGORIES = Object.freeze(Object.keys(CATEGORY_TABLE));
+const TURN_FAILURE_HEADLINES = Object.freeze({
+    connection_lost_not_sent: 'The engine is unreachable — your message did not run. Check that the engine is up, then send it again.',
+    connection_lost: 'The connection to the engine was lost — it is not known whether your message ran. Check the run’s status, or reattach to it, before sending it again.',
+    timeout: 'The event stream went silent — the run may still be going on the engine. Check its status before sending again.',
+    parked: 'The event stream ended while the run had not reached a terminal state — the run is likely parked waiting for a decision, not crashed. Check its status and decide anything pending; the turn did not complete here.',
+    internal: 'This client hit an internal error — it is a bug in the client, not an engine outage, and the turn did not complete.',
+});
+function waitSecOf(err) {
+    const ms = readThrownSlot(err, 'retryAfterMs', 'data');
+    if (typeof ms === 'number' && Number.isFinite(ms) && ms > 0)
+        return Math.max(1, Math.ceil(ms / 1000));
+    if (typeof err === 'object' && err !== null) {
+        const bodySec = readErrorNumber(err, 'retryAfterSec');
+        if (typeof bodySec === 'number' && Number.isFinite(bodySec) && bodySec > 0)
+            return Math.max(1, Math.ceil(bodySec));
+        const detail = readThrownSlot(err, 'detail', 'data');
+        if (typeof detail === 'object' && detail !== null) {
+            const sec = readThrownSlot(detail, 'retryAfterSec', 'data');
+            if (typeof sec === 'number' && Number.isFinite(sec) && sec > 0)
+                return Math.max(1, Math.ceil(sec));
+        }
+    }
+    return undefined;
+}
+function isIdleWatchdog(err) {
+    try {
+        return isSseIdleError(err);
+    }
+    catch {
+        return false;
+    }
+}
+const DETERMINISTIC_SERVER_CODES = new Set([CORRUPT_SESSION_ERROR_CODE, CORRUPT_ROW_ERROR_CODE, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, MEMORY_CONTROL_PLANE_CORRUPT]);
+const BROWSER_FETCH_FAILURE = /\bfailed to fetch\b|\bnetworkerror\b|\bnetwork error\b|\bload failed\b/i;
+function httpShapeOf(err, verdict) {
+    const status = verdict.status;
+    const code = effectiveWireErrorCode(err) ?? verdict.errorCode;
+    if (verdict.sessionUnreadable === true || verdict.storedRowWhere !== undefined)
+        return { category: 'server_error', offer: false };
+    if (toolDeclarationRefusalFromError(err) !== null)
+        return { category: 'invalid_request', offer: false };
+    if (code !== undefined && DETERMINISTIC_SERVER_CODES.has(code))
+        return { category: 'server_error', offer: false };
+    if (code === 'quota_exhausted')
+        return { category: 'rate_limited', offer: false };
+    if (code === 'budget.precall' || code === 'budget.exceeded')
+        return { category: 'billing', offer: false };
+    if (code === 'draining' || verdict.leaseUnavailable === true || isPreStreamDrainingReject(err))
+        return { category: 'server_error', offer: true };
+    if (status === 501 || (code !== undefined && code.startsWith('capability.')))
+        return { category: 'capability_unavailable', offer: false };
+    if (status === 401 || status === 403)
+        return { category: 'auth', offer: false };
+    if (status === 402)
+        return { category: 'billing', offer: false };
+    if (status === 408)
+        return { category: 'timeout', offer: true };
+    if (status === 429)
+        return { category: 'rate_limited', offer: true };
+    if (status >= 500)
+        return { category: 'server_error', offer: true };
+    if (status >= 400)
+        return { category: 'invalid_request', offer: false };
+    return { category: 'internal', offer: false };
+}
+function connectionLostBeforeSend(err, evidence) {
+    if (readThrownSlot(evidence, 'bound', 'data') === true || readThrownSlot(evidence, 'reopened', 'data') === true)
+        return false;
+    return typeof err === 'object' && err !== null && provablyNotSent(err);
+}
+export function turnFailurePresentation(err, evidence) {
+    const verdict = classifyTurnWireError(err);
+    let shape;
+    let headline;
+    let detail;
+    let name;
+    if (verdict.kind === 'http') {
+        shape = httpShapeOf(err, verdict);
+        detail = verdict.message;
+        if (shape.category === 'internal')
+            headline = TURN_FAILURE_HEADLINES.internal;
+    }
+    else if (verdict.kind === 'stream-ended-without-terminal') {
+        shape = { category: 'parked', offer: false };
+        headline = TURN_FAILURE_HEADLINES.parked;
+        detail = wireFailureTextsOf(err).reason;
+    }
+    else if (verdict.kind === 'transport') {
+        const notSent = connectionLostBeforeSend(err, evidence);
+        shape = { category: 'connection_lost', offer: notSent };
+        headline = notSent ? TURN_FAILURE_HEADLINES.connection_lost_not_sent : TURN_FAILURE_HEADLINES.connection_lost;
+        detail = verdict.detail;
+    }
+    else if (isIdleWatchdog(err)) {
+        shape = { category: 'timeout', offer: true };
+        headline = TURN_FAILURE_HEADLINES.timeout;
+        detail = verdict.detail;
+    }
+    else if (BROWSER_FETCH_FAILURE.test(verdict.detail)) {
+        const notSent = connectionLostBeforeSend(err, evidence);
+        shape = { category: 'connection_lost', offer: notSent };
+        headline = notSent ? TURN_FAILURE_HEADLINES.connection_lost_not_sent : TURN_FAILURE_HEADLINES.connection_lost;
+        detail = verdict.detail;
+    }
+    else {
+        shape = { category: 'internal', offer: false };
+        headline = TURN_FAILURE_HEADLINES.internal;
+        detail = verdict.detail;
+        name = verdict.name;
+    }
+    const status = verdict.kind === 'http' ? verdict.status : undefined;
+    const errorCode = verdict.kind === 'http' ? (effectiveWireErrorCode(err) ?? verdict.errorCode) : undefined;
+    const wireRetriable = readThrownSlot(err, 'retriable', 'data') === true && !isCodeClassifiedGateFailure(errorCode, true);
+    const retry = wireRetriable && shape.category !== 'parked' ? { offer: true, basis: 'wire' } : { offer: shape.offer, basis: 'category' };
+    const waitSec = waitSecOf(err);
+    return Object.freeze({
+        category: shape.category,
+        kind: verdict.kind,
+        ...(status !== undefined ? { status } : {}),
+        ...(errorCode !== undefined ? { errorCode } : {}),
+        detail,
+        ...(headline !== undefined ? { headline } : {}),
+        ...(name !== undefined ? { name } : {}),
+        retry: Object.freeze(retry),
+        ...(waitSec !== undefined ? { waitSec } : {}),
+    });
+}
+export function seatTurnFailureOf(err, evidence) {
+    const p = turnFailurePresentation(err, evidence);
+    return {
+        category: p.category,
+        retry: { offer: p.retry.offer, basis: p.retry.basis },
+        ...(p.waitSec !== undefined ? { waitSec: p.waitSec } : {}),
+        ...(p.headline !== undefined ? { headline: p.headline } : {}),
+        ...(p.errorCode !== undefined ? { errorCode: p.errorCode } : {}),
+    };
+}
+function seatDataField(o, key) {
+    const v = readThrownSlot(o, key, 'data');
+    return v === THROWN_SLOT_UNREADABLE ? SEAT_UNREADABLE : v;
+}
+const SEAT_UNREADABLE = Symbol('seat-unreadable');
+export function readSeatTurnFailure(event) {
+    try {
+        return seatTurnFailureShapeOf(event);
+    }
+    catch {
+        return undefined;
+    }
+}
+function seatTurnFailureShapeOf(event) {
+    if (event === null || event === undefined || typeof event !== 'object' || Array.isArray(event))
+        return undefined;
+    if (seatDataField(event, 'type') !== 'error')
+        return undefined;
+    const raw = seatDataField(event, '_sema_turnFailure');
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+        return undefined;
+    const category = seatDataField(raw, 'category');
+    if (!TURN_FAILURE_CATEGORIES.includes(category))
+        return undefined;
+    const retry = seatDataField(raw, 'retry');
+    if (retry === null || typeof retry !== 'object' || Array.isArray(retry))
+        return undefined;
+    const offer = seatDataField(retry, 'offer');
+    const basis = seatDataField(retry, 'basis');
+    if (typeof offer !== 'boolean' || (basis !== 'wire' && basis !== 'category'))
+        return undefined;
+    const waitSec = seatDataField(raw, 'waitSec');
+    if (waitSec !== undefined && !(typeof waitSec === 'number' && Number.isInteger(waitSec) && waitSec >= 1))
+        return undefined;
+    const headline = seatDataField(raw, 'headline');
+    if (headline !== undefined && !(typeof headline === 'string' && headline.length > 0))
+        return undefined;
+    const errorCode = seatDataField(raw, 'errorCode');
+    if (errorCode !== undefined && !(typeof errorCode === 'string' && errorCode.length > 0))
+        return undefined;
+    return Object.freeze({
+        category: category,
+        retry: Object.freeze({ offer, basis }),
+        ...(waitSec !== undefined ? { waitSec } : {}),
+        ...(headline !== undefined ? { headline } : {}),
+        ...(errorCode !== undefined ? { errorCode } : {}),
+    });
+}

package/dist/userInvokedSkillsCapability.d.ts

@@ -10,9 +10,6 @@ export type UserInvokedSkillsReading = {
     kind: 'present';
 };
 export declare function projectUserInvokedSkillsCapability(caps: unknown): UserInvokedSkillsReading | undefined;
-export declare function noteEngineCapsForUserInvokedSkills(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 export declare function observedUserInvokedSkills(baseUrl?: string | undefined): UserInvokedSkillsReading;
 export declare function userInvokedSkillsAvailable(reading: UserInvokedSkillsReading): 'yes' | 'no' | 'unknown';
 export declare function userInvokedSkillsDoctorDetail(reading: UserInvokedSkillsReading): string;

package/dist/userInvokedSkillsCapability.js

@@ -20,9 +20,6 @@ const reader = createEngineCapReader({
     name: 'userInvokedSkills',
     project: projectUserInvokedSkillsCapability,
 });
-export function noteEngineCapsForUserInvokedSkills(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedUserInvokedSkills(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }

package/dist/webSearchBackendCapability.d.ts

@@ -15,9 +15,5 @@ export type WebSearchBackendReading = {
     view: WebSearchBackendCapabilityView;
 };
 export declare function projectWebSearchBackendCapability(caps: unknown): WebSearchBackendReading | undefined;
-export declare function noteEngineCapsForWebSearchBackend(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 export declare function observedWebSearchBackend(baseUrl?: string | undefined): WebSearchBackendReading;
 export declare function webSearchBackendDoctorDetail(reading: WebSearchBackendReading): string;
-export declare function __resetWebSearchBackendReadingsForTests(): void;

package/dist/webSearchBackendCapability.js

@@ -29,9 +29,6 @@ const reader = createEngineCapReader({
     name: 'webSearch.backend',
     project: projectWebSearchBackendCapability,
 });
-export function noteEngineCapsForWebSearchBackend(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedWebSearchBackend(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -56,6 +53,3 @@ export function webSearchBackendDoctorDetail(reading) {
                 '(per-request overrides are not echoed here)');
     }
 }
-export function __resetWebSearchBackendReadingsForTests() {
-    reader.__resetForTests();
-}