@sema-agent/client-core 0.89.0 → 0.91.0

package/dist/adapt/arms.js

@@ -11,6 +11,7 @@ import { readAsyncLaunchedAgentReceipt } from '../toolResult.js';
 import { isWorkflowAgentTaskId, recordWorkflowAgentTaskId } from '../workflow.js';
 import { isTerminalStatus } from '../runTerminal.js';
 import { readToolHistoryMismatchKey } from '../toolHistoryMismatch.js';
+import { readProviderRejectionResendKey } from '../providerRejection.js';
 import { resolveEnginePanelTaskId } from '../engineAgentPanelStore.js';
 import { fleetRowAgentType } from '../fleet/fleetRowAgentType.js';
 import { chrome, mainLane, transcript, messageIdentityOf } from './ids.js';
@@ -23,6 +24,13 @@ function toolHistoryKeyCarry(m) {
     const key = readToolHistoryMismatchKey(typeof raw === 'object' && raw !== null ? raw : undefined);
     return key === undefined ? {} : { _sema_tool_history_mismatch: key };
 }
+function providerResendKeyCarry(m) {
+    if (m._sema_api_error_message !== true)
+        return {};
+    const raw = m._sema_provider_rejection_resend;
+    const key = readProviderRejectionResendKey(typeof raw === 'object' && raw !== null ? raw : undefined);
+    return key === undefined ? {} : { _sema_provider_rejection_resend: key };
+}
 const assistantArm = function* (m, { ctx, idOf, text, cards, inst }) {
     const message = m.message;
     const blocks = Array.isArray(message?.content)
@@ -129,6 +137,7 @@ const assistantArm = function* (m, { ctx, idOf, text, cards, inst }) {
             parent_tool_use_id: null,
             ...(m._sema_api_error_message === true ? { _sema_api_error_message: true } : {}),
             ...toolHistoryKeyCarry(m),
+            ...providerResendKeyCarry(m),
         }, ctx.now());
         text.markEmittedText(textBlock.text);
     }

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -1,4 +1,4 @@
-import { readInstructionsSegment, wiringManifestViewOf } from './wiringManifestView.js';
+import { readFleetSegment, readInstructionsSegment, wiringManifestViewOf } from './wiringManifestView.js';
 import { stamp, snapshotSegmentIdentity, } from '../types.js';
 import { turnUsageToModelUsage } from './turnUsageToModelUsage.js';
 import { ccToolDenialKindForToolEnd, gateOutcomeOf } from '../../gateOutcome.js';
@@ -551,7 +551,8 @@ function wiringManifestSupersetBody(ev) {
     const hands = projectHandsSection(ev);
     const fileHistory = projectFileHistorySection(ev);
     const instructions = readInstructionsSegment(ev, 'instructions');
-    if (modelGate === undefined && autoMode === undefined && mcp === undefined && tools === undefined && hooks === undefined && lsp === undefined && writeProtection === undefined && autoConsolidation === undefined && readDeny === undefined && hands === undefined && fileHistory === undefined && instructions === undefined)
+    const fleet = readFleetSegment(ev, 'fleet');
+    if (modelGate === undefined && autoMode === undefined && mcp === undefined && tools === undefined && hooks === undefined && lsp === undefined && writeProtection === undefined && autoConsolidation === undefined && readDeny === undefined && hands === undefined && fileHistory === undefined && instructions === undefined && fleet === undefined)
         return undefined;
     return {
         ...(modelGate !== undefined ? { _sema_modelGate: modelGate } : {}),
@@ -566,6 +567,7 @@ function wiringManifestSupersetBody(ev) {
         ...(hands !== undefined ? { _sema_hands: hands } : {}),
         ...(fileHistory !== undefined ? { _sema_fileHistory: fileHistory } : {}),
         ...(instructions !== undefined ? { _sema_instructions: instructions } : {}),
+        ...(fleet !== undefined ? { _sema_fleet: fleet } : {}),
     };
 }
 function projectFileHistorySection(holder) {

package/dist/adapter/downstream/wiringManifestView.d.ts

@@ -15,8 +15,12 @@ export type WiringManifestSections = {
     _sema_instructions?: {
         readonly selected: readonly string[];
     };
+    _sema_fleet?: WiringManifestFleetView;
     eventId?: string;
 };
+export interface WiringManifestFleetView {
+    readonly subagentTranscripts: string;
+}
 export interface WiringManifestView {
     modelGate?: WiringManifestModelGate;
     autoMode?: WiringManifestAutoMode;
@@ -32,9 +36,11 @@ export interface WiringManifestView {
     instructions?: {
         readonly selected: readonly string[];
     };
+    fleet?: WiringManifestFleetView;
     eventId?: string;
 }
 export declare function readInstructionsSegment(holder: object, key: 'instructions' | '_sema_instructions'): {
     readonly selected: readonly string[];
 } | undefined;
+export declare function readFleetSegment(holder: object, key: 'fleet' | '_sema_fleet'): WiringManifestFleetView | undefined;
 export declare function wiringManifestViewOf(s: WiringManifestSections): WiringManifestView | undefined;

package/dist/adapter/downstream/wiringManifestView.js

@@ -27,9 +27,24 @@ export function readInstructionsSegment(holder, key) {
         return undefined;
     }
 }
+export function readFleetSegment(holder, key) {
+    try {
+        if (!Object.hasOwn(holder, key))
+            return undefined;
+        const raw = holder[key];
+        if (typeof raw !== 'object' || raw === null || Array.isArray(raw) || !Object.hasOwn(raw, 'subagentTranscripts'))
+            return undefined;
+        const tier = raw.subagentTranscripts;
+        return typeof tier === 'string' && tier.length > 0 ? Object.freeze({ subagentTranscripts: tier }) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 export function wiringManifestViewOf(s) {
     const instructions = readInstructionsSegment(s, '_sema_instructions');
+    const fleet = readFleetSegment(s, '_sema_fleet');
     const view = {
         ...(isObj(s._sema_modelGate) ? { modelGate: s._sema_modelGate } : {}),
         ...(isObj(s._sema_autoMode) ? { autoMode: s._sema_autoMode } : {}),
@@ -43,6 +58,7 @@ export function wiringManifestViewOf(s) {
         ...(isObj(s._sema_hands) && typeof s._sema_hands.mounted === 'boolean' ? { hands: s._sema_hands } : {}),
         ...(typeof s._sema_fileHistory === 'string' && s._sema_fileHistory.length > 0 ? { fileHistory: s._sema_fileHistory } : {}),
         ...(instructions !== undefined ? { instructions } : {}),
+        ...(fleet !== undefined ? { fleet } : {}),
     };
     if (Object.keys(view).length === 0)
         return undefined;

package/dist/adapter/runStream.d.ts

@@ -1,6 +1,7 @@
 import type { AgentEvent } from '@sema-agent/sdk';
 import { type SDKMessage, type EmitContext, type ModelUsage } from './types.js';
 import { type EngineTurnUsage } from './downstream/turnUsageToModelUsage.js';
+import { type ToolHistoryErrorCarrier } from '../toolHistoryMismatch.js';
 export interface ActiveRunPendingGate {
     readonly kind: string | null;
     readonly decidePath: string | null;
@@ -27,6 +28,7 @@ export declare function isGovernanceTerminal(input: {
     status: string | undefined;
     errorCode: string | undefined;
 }): boolean;
+export declare function toolHistoryErrorCarrierOf(terminalOrResult: object | null | undefined): ToolHistoryErrorCarrier;
 export declare function droppedWhySentence(why: string): string;
 export declare function _resetDroppedFrameReportForTest(): void;
 export declare function _droppedFrameMemoSizeForTest(): number;

package/dist/adapter/runStream.js

@@ -7,6 +7,7 @@ import { ACTIVE_RUN_BUSY_ERROR_CODE, OUTPUT_INVALID, isCorruptSessionCode, isLim
 import { corruptSessionContent } from '../corruptSessionCopy.js';
 import { classifyToolHistoryMismatch, noteToolHistoryTerminal, openToolHistoryGeneration, TOOL_HISTORY_REWIND_SENTENCE, toolHistoryMismatchRowKey, toolHistoryRepeatSentence, toolHistoryRewindOffered, } from '../toolHistoryMismatch.js';
 import { isReviewPark, readRunTerminal, runTerminalCode } from '../runTerminal.js';
+import { providerRejectionResend } from '../providerRejection.js';
 import { washCredentials } from '../displayUntrusted.js';
 import { ccToolDenialKindForToolEnd, gateDeniedBy, gateOutcomeOf } from '../gateOutcome.js';
 import { resumeReopenContent, resumeReopenFromError, suspendedReopenOf } from '../hitl/suspendedReopen.js';
@@ -121,7 +122,7 @@ export function isModelOutputErrorRowText(text) {
     return text.trimStart().startsWith(`${MODEL_OUTPUT_ERROR_PREFIX}:`);
 }
 export const OUTCOME_UNKNOWN_ROW_PREFIX = 'Outcome unknown';
-function syntheticTerminalRow(ctx, text, historyKey) {
+function syntheticTerminalRow(ctx, text, historyKey, resend) {
     return stamp(ctx, {
         uuid: undefined,
         session_id: undefined,
@@ -130,6 +131,7 @@ function syntheticTerminalRow(ctx, text, historyKey) {
         parent_tool_use_id: null,
         _sema_api_error_message: true,
         ...(historyKey !== undefined ? { _sema_tool_history_mismatch: historyKey } : {}),
+        ...(resend !== undefined ? { _sema_provider_rejection_resend: { resend: resend.resend, text: resend.text } } : {}),
     });
 }
 function engineRunIdOf(result) {
@@ -140,11 +142,6 @@ function engineSessionIdOf(result) {
     const v = result?.sessionId;
     return typeof v === 'string' && v.length > 0 ? v : undefined;
 }
-function providerFailureStatusOf(result) {
-    const af = result?.apiFailure;
-    const status = typeof af === 'object' && af !== null ? af.status : undefined;
-    return typeof status === 'number' && Number.isFinite(status) ? status : undefined;
-}
 export function isOutcomeUnknownRowText(text) {
     return text.trimStart().startsWith(`${OUTCOME_UNKNOWN_ROW_PREFIX}:`);
 }
@@ -155,6 +152,168 @@ export function isGovernanceTerminal(input) {
         return true;
     return input.errorCode === OUTPUT_INVALID;
 }
+function terminalRowFacts(ev) {
+    const doneTerminal = ev.type === 'done' ? readRunTerminal(ev.result) : null;
+    const errTextRaw = ev.type === 'failed'
+        ? (ev.errorMessage ?? ev.errorCode ?? 'run failed')
+        : doneTerminal?.kind === 'failed'
+            ? (doneTerminal.message ?? doneTerminal.code ?? 'run failed')
+            : doneTerminal?.kind === 'blocked'
+                ? (doneTerminal.reason
+                    ? `Run blocked: ${doneTerminal.reason}`
+                    : 'Run blocked (the agent reported it cannot proceed)')
+                : null;
+    const errText = errTextRaw === '' ? null : errTextRaw;
+    if (errText === null)
+        return { doneTerminal, errText, activeTaskId: undefined, busy: { busy: false, handle: null }, governance: false };
+    const activeTaskId = (ev.type === 'done' ? ev.result?.activeTaskId : undefined) ??
+        (ev.type === 'failed' ? ev.activeTaskId : undefined);
+    const busy = classifyActiveRunBusy({
+        errorCode: ev.type === 'failed' ? ev.errorCode : runTerminalCode(doneTerminal),
+        activeTaskId,
+    });
+    const governance = isGovernanceTerminal({
+        status: ev.type === 'failed' ? undefined : doneTerminal?.kind === 'blocked' ? 'blocked' : undefined,
+        errorCode: ev.type === 'failed' ? ev.errorCode : runTerminalCode(doneTerminal),
+    });
+    return { doneTerminal, errText, activeTaskId, busy, governance };
+}
+const PROVIDER_REJECTED_DETAIL = 'provider_rejected';
+function ownDataBit(o, k) {
+    try {
+        const d = Object.getOwnPropertyDescriptor(o, k);
+        return d !== undefined && Object.prototype.hasOwnProperty.call(d, 'value') ? d.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function plainObjectOf(v) {
+    if (typeof v !== 'object' || v === null)
+        return undefined;
+    try {
+        return Array.isArray(v) ? undefined : v;
+    }
+    catch {
+        return undefined;
+    }
+}
+function ownDataCopy(o, keys) {
+    const out = Object.create(null);
+    for (const k of keys) {
+        const v = ownDataBit(o, k);
+        if (v !== undefined)
+            out[k] = v;
+    }
+    return out;
+}
+function ownTerminalSnapshot(result) {
+    let causePlane;
+    try {
+        causePlane = 'terminal' in result;
+    }
+    catch {
+        return undefined;
+    }
+    const snap = ownDataCopy(result, ['status', 'errorCode', 'errorMessage']);
+    if (!causePlane)
+        return snap;
+    let d;
+    try {
+        d = Object.getOwnPropertyDescriptor(result, 'terminal');
+    }
+    catch {
+        return undefined;
+    }
+    if (d === undefined || !Object.prototype.hasOwnProperty.call(d, 'value'))
+        return undefined;
+    const t = plainObjectOf(d.value);
+    if (t === undefined) {
+        snap.terminal = null;
+        return snap;
+    }
+    const ts = ownDataCopy(t, ['kind', 'code', 'message']);
+    const detail = plainObjectOf(ownDataBit(t, 'detail'));
+    if (detail !== undefined)
+        ts.detail = ownDataCopy(detail, ['kind', 'status', 'code']);
+    snap.terminal = ts;
+    return snap;
+}
+function nonEmptyStr(v) {
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+function mintToolHistoryCarrier(code, status, message) {
+    const out = Object.create(null);
+    if (code !== undefined)
+        out.code = code;
+    if (status !== undefined)
+        out.status = status;
+    if (message !== undefined)
+        out.message = message;
+    return Object.freeze(out);
+}
+export function toolHistoryErrorCarrierOf(terminalOrResult) {
+    const empty = () => mintToolHistoryCarrier(undefined, undefined, undefined);
+    try {
+        const x = plainObjectOf(terminalOrResult);
+        if (x === undefined)
+            return empty();
+        const type = ownDataBit(x, 'type');
+        const frame = (type === 'done' || type === 'failed' ? x : { type: 'done', result: x });
+        return toolHistoryCarrierFromFacts(x, terminalRowFacts(frame));
+    }
+    catch {
+        return empty();
+    }
+}
+function terminalRowArmOf(facts) {
+    if (facts.errText === null)
+        return null;
+    return facts.busy.busy ? 'busy' : facts.governance ? 'governance' : isModelOutputErrorText(facts.errText) ? 'modelOutput' : 'apiError';
+}
+function toolHistoryCarrierFromFacts(x, facts) {
+    return apiErrorTerminalFromFacts(x, facts).carrier;
+}
+function apiErrorTerminalFromFacts(x, facts) {
+    const none = () => ({ carrier: mintToolHistoryCarrier(undefined, undefined, undefined), detail: undefined });
+    try {
+        const type = ownDataBit(x, 'type');
+        if (terminalRowArmOf(facts) !== 'apiError')
+            return none();
+        if (type === 'failed')
+            return { carrier: mintToolHistoryCarrier(nonEmptyStr(ownDataBit(x, 'errorCode')), undefined, nonEmptyStr(ownDataBit(x, 'errorMessage'))), detail: undefined };
+        const result = type === 'done' ? plainObjectOf(ownDataBit(x, 'result')) : x;
+        if (result === undefined)
+            return none();
+        const snap = ownTerminalSnapshot(result);
+        if (snap === undefined)
+            return none();
+        const read = readRunTerminal(snap);
+        if (read === null || read.kind !== 'failed')
+            return none();
+        const detail = plainObjectOf(ownDataBit(read, 'detail'));
+        const detailStatus = detail !== undefined && ownDataBit(detail, 'kind') === PROVIDER_REJECTED_DETAIL ? ownDataBit(detail, 'status') : undefined;
+        const apiFailure = plainObjectOf(ownDataBit(result, 'apiFailure'));
+        const apiStatus = apiFailure === undefined ? undefined : ownDataBit(apiFailure, 'status');
+        const status = typeof apiStatus === 'number' && Number.isFinite(apiStatus) ? apiStatus : typeof detailStatus === 'number' ? detailStatus : undefined;
+        return {
+            carrier: mintToolHistoryCarrier(nonEmptyStr(ownDataBit(read, 'code')), status, nonEmptyStr(ownDataBit(read, 'message'))),
+            detail: detail,
+        };
+    }
+    catch {
+        return none();
+    }
+}
+function apiErrorTerminalOfRowFrame(ev, facts) {
+    try {
+        const x = plainObjectOf(ev);
+        return x === undefined ? { carrier: mintToolHistoryCarrier(undefined, undefined, undefined), detail: undefined } : apiErrorTerminalFromFacts(x, facts);
+    }
+    catch {
+        return { carrier: mintToolHistoryCarrier(undefined, undefined, undefined), detail: undefined };
+    }
+}
 const reportedDroppedTypes = new Set();
 const DROPPED_TYPE_MEMO_CAP = 64;
 const DROPPED_TYPE_DISPLAY_CAP = 60;
@@ -477,52 +636,32 @@ async function* runStreamInner(events, ctx, handle = {}) {
             continue;
         }
         if (ev.type === 'done' || ev.type === 'failed') {
-            const doneTerminal = ev.type === 'done' ? readRunTerminal(ev.result) : null;
-            const errText = ev.type === 'failed'
-                ? (ev.errorMessage ?? ev.errorCode ?? 'run failed')
-                : doneTerminal?.kind === 'failed'
-                    ? (doneTerminal.message ?? doneTerminal.code ?? 'run failed')
-                    : doneTerminal?.kind === 'blocked'
-                        ? (doneTerminal.reason
-                            ? `Run blocked: ${doneTerminal.reason}`
-                            : 'Run blocked (the agent reported it cannot proceed)')
-                        : null;
+            const rowFacts = terminalRowFacts(ev);
+            const doneTerminal = rowFacts.doneTerminal;
+            const errText = rowFacts.errText;
             if (errText) {
-                const activeTaskId = (ev.type === 'done' ? ev.result?.activeTaskId : undefined) ??
-                    (ev.type === 'failed' ? ev.activeTaskId : undefined);
-                const busy = classifyActiveRunBusy({
-                    errorCode: ev.type === 'failed' ? ev.errorCode : runTerminalCode(doneTerminal),
-                    activeTaskId,
-                });
+                const busy = rowFacts.busy;
                 const maxTokHint = /max_tokens/i.test(errText)
                     ? '\nyour provider caps max_tokens lower — lower it in /model (press m, or M to type a value)'
                     : '';
-                const governance = isGovernanceTerminal({
-                    status: ev.type === 'failed' ? undefined : doneTerminal?.kind === 'blocked' ? 'blocked' : undefined,
-                    errorCode: ev.type === 'failed' ? ev.errorCode : runTerminalCode(doneTerminal),
-                });
                 const busyHandle = busy.handle;
-                const rowText = busy.busy
+                const arm = terminalRowArmOf(rowFacts);
+                const rowText = arm === 'busy'
                     ? `This session is locked by an earlier run${busyHandle ? ` (run ${busyHandle})` : ''} that ` +
                         `has not been released, so this message was NOT sent. Nothing releases it on its own — ` +
                         `cancel that run (POST /v1/runs/${busyHandle ?? '<id>'}/cancel), or start a new session.`
-                    : governance
+                    : arm === 'governance'
                         ?
                             `${isGovernanceStopRowText(errText) ? errText : `${RUN_STOPPED_MESSAGE_PREFIX}: ${errText}`}${maxTokHint}`
-                        : isModelOutputErrorText(errText)
+                        : arm === 'modelOutput'
                             ?
                                 `${MODEL_OUTPUT_ERROR_PREFIX}: ${errText}${maxTokHint}`
                             : `API Error: ${errText}${maxTokHint}`;
                 const sessionUnreadable = ev.type === 'failed'
                     ? isCorruptSessionCode(ev.errorCode)
                     : doneTerminal?.kind === 'failed' && isCorruptSessionCode(doneTerminal.code);
-                const historyMismatch = !busy.busy && !governance && !isModelOutputErrorText(errText)
-                    ? classifyToolHistoryMismatch({
-                        code: ev.type === 'failed' ? ev.errorCode : runTerminalCode(doneTerminal),
-                        status: ev.type === 'done' ? providerFailureStatusOf(ev.result) : undefined,
-                        message: errText,
-                    })
-                    : null;
+                const historyTerminal = apiErrorTerminalOfRowFrame(ev, rowFacts);
+                const historyMismatch = classifyToolHistoryMismatch(historyTerminal.carrier);
                 const historyEchoedSid = ev.type === 'done' ? engineSessionIdOf(ev.result) : undefined;
                 const historyRepeat = noteToolHistoryTerminal({
                     sessionId: historyEchoedSid ?? ctx.sessionId,
@@ -532,10 +671,13 @@ async function* runStreamInner(events, ctx, handle = {}) {
                     replay: ev.type === 'done' && ev.replay === true,
                     mismatch: historyMismatch,
                 });
-                const rewindLine = historyMismatch !== null && ctx.lane !== 'print' && ctx.lane !== 'utility' && toolHistoryRewindOffered(ctx.offersRewind)
+                const rewindOffered = historyMismatch !== null && ctx.lane !== 'print' && ctx.lane !== 'utility' && toolHistoryRewindOffered(ctx.offersRewind);
+                const rewindLine = rewindOffered
                     ? `\n${TOOL_HISTORY_REWIND_SENTENCE}${historyRepeat !== undefined && historyRepeat >= 2 ? ` ${toolHistoryRepeatSentence(historyRepeat)}` : ''}`
                     : '';
-                yield syntheticTerminalRow(ctx, `${sessionUnreadable ? `${rowText}\n${corruptSessionContent()}` : rowText}${rewindLine}`, historyMismatch === null ? undefined : toolHistoryMismatchRowKey(historyMismatch, historyRepeat));
+                const resend = historyTerminal.detail !== undefined ? providerRejectionResend(historyTerminal.detail, historyTerminal.carrier) : undefined;
+                const resendLine = resend !== undefined ? `\n${resend.text}` : '';
+                yield syntheticTerminalRow(ctx, `${sessionUnreadable ? `${rowText}\n${corruptSessionContent()}` : rowText}${rewindLine}${resendLine}`, historyMismatch === null ? undefined : toolHistoryMismatchRowKey(historyMismatch, historyRepeat, rewindOffered), resend);
             }
             else {
                 const echoedSid = ev.type === 'done' ? engineSessionIdOf(ev.result) : undefined;

package/dist/askSurvivesStandingAnswer.d.ts

@@ -0,0 +1,10 @@
+export declare const MODE_ARBITRATION: Readonly<Record<"hook" | "write_protection" | "mode" | "rule_unreadable" | "content_question" | "ancestor" | "unverifiable_delete" | "transcript_write" | "org_rule" | "governance_unavailable" | "ask_rule" | "denial_limit_fallback" | "operator_forced" | "shell_floor" | "write_protection_unresolved" | "probe" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "unstated" | "ordinary", import("./generated/engineFactTables.js").CoreModeArbitrationRow>>;
+export type StandingAnswerVerdict = {
+    readonly kind: 'must_ask';
+    readonly by: string;
+} | {
+    readonly kind: 'may_answer';
+} | {
+    readonly kind: 'unknown';
+};
+export declare function askSurvivesStandingAnswer(card: object | null | undefined): StandingAnswerVerdict;

package/dist/askSurvivesStandingAnswer.js

@@ -0,0 +1,40 @@
+import { CORE_MODE_ARBITRATION } from './generated/engineFactTables.js';
+export const MODE_ARBITRATION = CORE_MODE_ARBITRATION;
+const MUST_ASK_MANDATED = Object.freeze({ kind: 'must_ask', by: 'mandated' });
+const MAY_ANSWER = Object.freeze({ kind: 'may_answer' });
+const UNKNOWN = Object.freeze({ kind: 'unknown' });
+export function askSurvivesStandingAnswer(card) {
+    try {
+        if (card === null || card === undefined || typeof card !== 'object')
+            return UNKNOWN;
+        if (Object.hasOwn(card, 'mandated') && card.mandated === true)
+            return MUST_ASK_MANDATED;
+        const classes = Object.hasOwn(card, 'classes') ? card.classes : undefined;
+        if (!Array.isArray(classes))
+            return UNKNOWN;
+        const length = classes.length;
+        if (typeof length !== 'number' || !Number.isSafeInteger(length) || length <= 0)
+            return UNKNOWN;
+        const names = [];
+        for (let i = 0; i < length; i += 1) {
+            if (!Object.hasOwn(classes, i))
+                return UNKNOWN;
+            const c = classes[i];
+            if (typeof c !== 'string')
+                return UNKNOWN;
+            names.push(c);
+        }
+        if (classes.length !== length)
+            return UNKNOWN;
+        for (const name of names) {
+            if (!Object.hasOwn(MODE_ARBITRATION, name))
+                return UNKNOWN;
+            if (MODE_ARBITRATION[name]?.ruleMayClear !== true)
+                return Object.freeze({ kind: 'must_ask', by: name });
+        }
+        return MAY_ANSWER;
+    }
+    catch {
+        return UNKNOWN;
+    }
+}

package/dist/attachmentSeatCapability.d.ts

@@ -0,0 +1,11 @@
+export type AttachmentSeatReading = {
+    readonly kind: 'unobserved';
+} | {
+    readonly kind: 'not_reported';
+};
+export declare function noteEngineCapsForAttachmentSeat(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+export declare function observedAttachmentSeat(baseUrl?: string | undefined): AttachmentSeatReading;
+export declare function forgetAttachmentSeatReading(baseUrl: string | undefined): void;
+export declare function __resetAttachmentSeatReadingsForTests(): void;

package/dist/attachmentSeatCapability.js

@@ -0,0 +1,27 @@
+import { engineWireTarget } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+function projectAttachmentSeat(caps) {
+    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+        return undefined;
+    const p = Object.getPrototypeOf(caps);
+    if (p !== Object.prototype && p !== null)
+        return undefined;
+    return { kind: 'not_reported' };
+}
+const reader = createEngineCapReader({
+    name: 'attachmentSeat',
+    project: projectAttachmentSeat,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+export function noteEngineCapsForAttachmentSeat(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+export function observedAttachmentSeat(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+export function forgetAttachmentSeatReading(baseUrl) {
+    reader.forget(baseUrl);
+}
+export function __resetAttachmentSeatReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/attachmentsWireCaps.d.ts

@@ -6,7 +6,6 @@ export interface AttachmentsSpec {
     changedFiles?: true | {
         maxFiles?: number;
     };
-    planModeReminder?: true;
     budgetUsd?: true;
     backgroundTasks?: boolean;
     toolsDelta?: true;
@@ -14,6 +13,27 @@ export interface AttachmentsSpec {
     agentListing?: boolean;
     skillsListing?: boolean;
 }
-export declare const ATTACHMENTS_SPEC_KEYS: readonly ["todoReminder", "todoReminderMode", "changedFiles", "planModeReminder", "budgetUsd", "backgroundTasks", "toolsDelta", "mcpInstructions", "agentListing", "skillsListing"];
+export declare const ATTACHMENTS_SPEC_KEYS: readonly ["todoReminder", "todoReminderMode", "changedFiles", "budgetUsd", "backgroundTasks", "toolsDelta", "mcpInstructions", "agentListing", "skillsListing"];
 export declare const ATTACHMENTS_DEFAULT_ON_KEYS: readonly ["agentListing", "skillsListing", "backgroundTasks"];
+export declare class AttachmentsSpecRefused extends TypeError {
+    readonly token: string;
+    readonly why: string;
+    readonly allowed: readonly string[];
+    readonly key?: string;
+    constructor(message: string, init: {
+        readonly token: string;
+        readonly why: string;
+        readonly allowed: readonly string[];
+        readonly key?: string;
+    });
+}
 export declare function attachmentsForRequest(env?: EnvLike): AttachmentsSpec | undefined;
+export type AttachmentsSubmitVerdict = {
+    readonly ok: true;
+    readonly attachments: AttachmentsSpec;
+} | {
+    readonly ok: false;
+    readonly sentence: string;
+    readonly refusedKey: string | undefined;
+};
+export declare function attachmentsSubmitVerdict(env?: EnvLike): AttachmentsSubmitVerdict;