@sema-agent/client-core 0.97.1 → 0.99.0

package/dist/subagent/engineSubagentResume.js

@@ -1,5 +1,6 @@
 import { hostLog } from '../host.js';
-import { resumeRetryLaterFromError } from '../wireErrorTriage.js';
+import { isNotFoundFailure, resumeRetryLaterFromError } from '../wireErrorTriage.js';
+import { readThrownSlot, THROWN_SLOT_UNREADABLE } from '../wireFailureShape.js';
 import { RESUME_SESSION_NOT_FOUND } from '../engineErrorCodes.js';
 import { displayUntrusted } from '../displayUntrusted.js';
 import { engineCapTrue } from '../engineCapsCache.js';
@@ -25,15 +26,22 @@ const RETENTION_LAPSED_CODES = new Set([
     RESUME_SESSION_NOT_FOUND,
 ]);
 function shapeOf(e) {
-    const o = (e ?? {});
+    const status = readThrownSlot(e ?? {}, 'status', 'data');
+    const errorCode = readThrownSlot(e ?? {}, 'errorCode', 'data');
+    const message = readThrownSlot(e ?? {}, 'message');
+    if (status === THROWN_SLOT_UNREADABLE || errorCode === THROWN_SLOT_UNREADABLE) {
+        return { message: typeof message === 'string' && message !== '' ? message : String(e), unreadable: true };
+    }
     return {
-        ...(typeof o.status === 'number' ? { status: o.status } : {}),
-        ...(typeof o.errorCode === 'string' ? { errorCode: o.errorCode } : {}),
-        message: typeof o.message === 'string' && o.message !== '' ? o.message : String(e),
+        ...(typeof status === 'number' ? { status } : {}),
+        ...(typeof errorCode === 'string' ? { errorCode } : {}),
+        message: typeof message === 'string' && message !== '' ? message : String(e),
     };
 }
 export function classifySubagentResumeFailure(e) {
-    const { status, errorCode, message } = shapeOf(e);
+    const { status, errorCode, message, unreadable } = shapeOf(e);
+    if (unreadable === true)
+        return { reason: 'error', detail: message };
     if (status === undefined && errorCode === undefined) {
         const noAnswer = typeof e === 'object' ? noAnswerDetailFrom(e) : null;
         if (noAnswer !== null)
@@ -63,12 +71,10 @@ export function classifySubagentResumeFailure(e) {
         return { reason: 'row-contended', detail: message };
     if (errorCode === 'resume.row_gone')
         return { reason: 'row-gone', detail: message };
-    if (errorCode === undefined && status === 404)
+    if (isNotFoundFailure(e) !== false)
         return { reason: 'not-found', detail: message };
     if (errorCode === undefined && status === 400)
         return { reason: 'bad-request', detail: message };
-    if (errorCode?.startsWith('not_found.') === true)
-        return { reason: 'not-found', detail: message };
     return { reason: 'error', detail: message };
 }
 export function resolveOwnerRunId(childTaskId, activeRunId) {

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.d.ts

@@ -33,6 +33,9 @@ export interface SubagentContentEvent {
     isError?: boolean | undefined;
 }
 export declare function coerceOutput(v: unknown): string | undefined;
+export declare function subagentContentEventOf(ev: {
+    readonly type: string;
+}): SubagentContentEvent | undefined;
 export interface SubagentContentStoreConfig {
     maxBytesPerTask: number;
     maxBytesTotal: number;

package/dist/subagentContentStore.js

@@ -1,17 +1,29 @@
 import { DEFAULT_SESSION_KEY } from './sessionSlot.js';
 import { toolEndOutputText } from './toolResultContent.js';
 export function coerceOutput(v) {
-    if (v === undefined || v === null)
+    return toolEndOutputText(v);
+}
+export function subagentContentEventOf(ev) {
+    const t = ev.type;
+    if (t !== 'text_delta' && t !== 'reasoning_delta' && t !== 'text' && t !== 'reasoning' && t !== 'tool_start' && t !== 'tool_end')
         return undefined;
-    const text = toolEndOutputText(v);
-    if (text !== undefined)
-        return text;
-    try {
-        return JSON.stringify(v);
-    }
-    catch {
-        return String(v);
-    }
+    const sub = ev;
+    const parent = sub.parentToolCallId;
+    if (typeof parent !== 'string')
+        return undefined;
+    return {
+        type: sub.type,
+        taskId: sub.taskId ?? parent,
+        parentToolCallId: parent,
+        delta: sub.delta,
+        text: sub.text,
+        eventId: sub.eventId,
+        toolCallId: sub.toolCallId,
+        toolName: sub.toolName,
+        args: sub.args,
+        output: coerceOutput(sub.output),
+        isError: sub.isError,
+    };
 }
 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/toolHistoryMismatch.js

@@ -1,4 +1,5 @@
 import { rewindArchiveReadingAt, rewindConversationAvailability } from './rewindArchiveReading.js';
+import { ownDataField } from './ownKey.js';
 export const TOOL_HISTORY_MISMATCH_KINDS = Object.freeze([
     'tool_use_without_result',
     'orphan_tool_result',
@@ -191,8 +192,8 @@ export function classifyToolHistoryMismatch(err) {
     let status;
     let rawMessage;
     try {
-        code = err.code;
-        status = err.status;
+        code = ownDataField(err, 'code');
+        status = ownDataField(err, 'status');
         rawMessage = err.message;
     }
     catch {

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

@@ -1,3 +1,4 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 export interface ToolRosterPathTargetView {
     param: string;
     access: string;
@@ -12,7 +13,6 @@ export interface ToolRosterRenderHintsView {
     activity?: string;
     summaryParams?: readonly string[];
     resultCards?: readonly string[];
-    approvalCard?: string;
 }
 export interface ToolRosterEntryView {
     name: string;
@@ -78,8 +78,8 @@ export type HandsSeamReading = {
 export declare function handsSeamReadingOf(view: {
     readonly hands?: WiringManifestHandsView;
 } | null | undefined): HandsSeamReading;
-export declare function handsSeamDetail(reading: HandsSeamReading): string;
-export declare function handsMountedDetail(reading: HandsMountedReading): string;
+export declare function handsSeamDetail(reading: HandsSeamReading, lang?: UiLanguage): string;
+export declare function handsMountedDetail(reading: HandsMountedReading, lang?: UiLanguage): string;
 export declare function toolRosterNames(roster: ToolRosterView | undefined): readonly string[];
 export interface ToolShim {
     name: string;
@@ -87,7 +87,6 @@ export interface ToolShim {
     family?: string;
     userFacingName?: string;
     activity?: string;
-    approvalCard?: string;
     summaryParams?: readonly string[];
     effect?: string;
     egress?: boolean;

package/dist/toolRoster.js

@@ -1,4 +1,5 @@
 import { displayUntrusted } from './displayUntrusted.js';
+import { msg, renderMessage } from './i18n/translate.js';
 import { HANDS_REASON_NO_EXECUTION_ENV, projectHandsSection } from './handsSeam.js';
 const str = (v) => typeof v === 'string' && v.length > 0 ? v : undefined;
 const strArr = (v) => Array.isArray(v) ? v.filter((x) => typeof x === 'string') : undefined;
@@ -77,7 +78,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) } : {}),
                 },
             }
             : {}),
@@ -145,55 +145,55 @@ export function handsSeamReadingOf(view) {
         return { kind: 'mounted' };
     return seam.reason !== undefined ? { kind: 'not_mounted', reason: seam.reason } : { kind: 'not_mounted' };
 }
-const HANDS_NONE_STEM = 'this leg of the run was assembled with NO built-in file-and-shell tools';
-const HANDS_NONE_TAIL = "so on this leg the model had no tool of the engine's own for editing files or running commands (tools mounted by other conditions, such as external servers, and sub-runs delegated to other legs are not covered by this reading)";
 const HANDS_REASON_DISPLAY_MAX = 64;
-const HANDS_NOT_REPORTED_SENTENCE = 'whether this leg has built-in file-and-shell tools is not stated here — the engine did not report its hands seam (older engines and servers, and the static half of a manifest, never do); the tool roster may still answer it';
-export function handsSeamDetail(reading) {
+function handsNotReported(lang) {
+    return renderMessage(msg('notice.capability.hands.notReported'), lang);
+}
+export function handsSeamDetail(reading, lang) {
     const kind = typeof reading === 'object' && reading !== null ? reading.kind : undefined;
     switch (kind) {
         case 'mounted':
-            return 'this leg of the run was assembled with its built-in file tools mounted — the engine says so; whether a shell is reachable is answered by the tool roster, not by this statement';
+            return renderMessage(msg('notice.capability.hands.seamMounted'), lang);
         case 'not_mounted': {
             const raw = reading.reason;
             const reason = typeof raw === 'string' && raw.length > 0 ? raw : undefined;
             const why = reason === undefined
-                ? 'the engine states it mounted no hands on this leg (it gave no reason)'
+                ? msg('notice.capability.hands.whyNoReason')
                 : reason === HANDS_REASON_NO_EXECUTION_ENV
-                    ? 'the engine states it mounted no hands on this leg because no execution environment was supplied'
-                    : `the engine states it mounted no hands on this leg (reason: ${displayUntrusted(reason, { max: HANDS_REASON_DISPLAY_MAX })}, a word this build does not know)`;
-            return `${HANDS_NONE_STEM} — ${why}, ${HANDS_NONE_TAIL}`;
+                    ? msg('notice.capability.hands.whyNoExecutionEnv')
+                    : msg('notice.capability.hands.whyUnknownReason', { reason: displayUntrusted(reason, { max: HANDS_REASON_DISPLAY_MAX }) });
+            return renderMessage(msg('notice.capability.hands.noneLine', { stem: msg('notice.capability.hands.noneStem'), why, tail: msg('notice.capability.hands.noneTail') }), lang);
         }
         default:
-            return HANDS_NOT_REPORTED_SENTENCE;
+            return handsNotReported(lang);
     }
 }
-export function handsMountedDetail(reading) {
+export function handsMountedDetail(reading, lang) {
     const r = reading;
     const kind = typeof r === 'object' && r !== null ? r.kind : undefined;
     switch (kind) {
         case 'mounted': {
             const rows = r.rows;
             if (typeof rows === 'number' && Number.isInteger(rows) && rows > 0)
-                return `this run was assembled with file-and-shell tools mounted (${rows} of them)`;
-            return HANDS_NOT_REPORTED_SENTENCE;
+                return renderMessage(msg('notice.capability.hands.rosterMounted', { rows }), lang);
+            return handsNotReported(lang);
         }
         case 'not-mounted':
-            return `${HANDS_NONE_STEM} — the engine reports a roster and not one row was mounted by that condition, ${HANDS_NONE_TAIL}`;
+            return renderMessage(msg('notice.capability.hands.rosterNotMounted', { stem: msg('notice.capability.hands.noneStem'), tail: msg('notice.capability.hands.noneTail') }), lang);
         case 'unknown':
             switch (r.why) {
                 case 'no-manifest':
-                    return 'whether this run has file-and-shell tools is unknown — no assembly manifest was observed for it';
+                    return renderMessage(msg('notice.capability.hands.unknownNoManifest'), lang);
                 case 'no-roster':
-                    return 'whether this run has file-and-shell tools is unknown — the manifest carries no tool roster (the static half never does; only an engine-minted effective manifest reports one)';
+                    return renderMessage(msg('notice.capability.hands.unknownNoRoster'), lang);
                 case 'roster-unreadable':
-                    return 'whether this run has file-and-shell tools is unknown — the tool roster could not be read in the shape this reader knows';
+                    return renderMessage(msg('notice.capability.hands.unknownRosterUnreadable'), lang);
                 case 'mount-condition-absent':
-                    return 'whether this run has file-and-shell tools is unknown — this engine does not report which condition mounted each tool, so an empty count here would be a fact about the reader, not about the run';
+                    return renderMessage(msg('notice.capability.hands.unknownMountConditionAbsent'), lang);
             }
-            return HANDS_NOT_REPORTED_SENTENCE;
+            return handsNotReported(lang);
     }
-    return HANDS_NOT_REPORTED_SENTENCE;
+    return handsNotReported(lang);
 }
 export function toolRosterNames(roster) {
     return roster?.entries.map((e) => e.name) ?? [];
@@ -208,7 +208,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,39 @@
+import type { UiLanguage } from './env/uiLanguage.js';
+import { type TurnWireErrorVerdict } from './wireErrorTriage.js';
+import { type LiveModelCatalog } from './liveModelCatalog.js';
+import type { TaskRequestLike } from './request/taskRequest.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;
+    readonly notes: readonly string[];
+    readonly waitNote?: string;
+}
+export interface TurnFailureNotesContext {
+    readonly requestedScenario?: string;
+    readonly sentRequest?: TaskRequestLike;
+    readonly modelCatalog?: LiveModelCatalog | null;
+    readonly nowMs?: number;
+}
+export declare function turnFailurePresentation(err: {} | null | undefined, evidence?: {
+    readonly bound?: boolean;
+    readonly reopened?: boolean;
+}, notesCtx?: TurnFailureNotesContext, lang?: UiLanguage): 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;