@sema-agent/client-core 0.90.0 → 0.92.0

package/dist/adapt/arms.js

@@ -8,9 +8,10 @@ import { projectDiagnosticsFrame } from '../diagnostics.js';
 import { recordEngineToolLabel } from '../engineToolLabelStore.js';
 import { registerSubagentAlias, registerSubagentContentAlias } from '../subagentContentStore.js';
 import { readAsyncLaunchedAgentReceipt } from '../toolResult.js';
-import { isWorkflowAgentTaskId, recordWorkflowAgentTaskId } from '../workflow.js';
+import { 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);
     }
@@ -569,9 +578,7 @@ const taskProgressArm = function* (m, { ctx, cards, panel, inst }) {
     const explicitParentRaw = m.parentToolCallId;
     const explicitParent = typeof explicitParentRaw === 'string' ? explicitParentRaw : undefined;
     const workflowRunId = typeof m.workflowRunId === 'string' ? m.workflowRunId : undefined;
-    if (workflowRunId !== undefined ||
-        isWorkflowAgentTaskId(taskId) ||
-        (explicitParent !== undefined && inst.isWorkflowCard(explicitParent))) {
+    if (workflowRunId !== undefined) {
         recordWorkflowAgentTaskId(taskId);
         if (workflowRunId !== undefined && explicitParent !== undefined && inst.isWorkflowCard(explicitParent))
             noteOwnWorkflowRun(workflowRunId);
@@ -579,19 +586,13 @@ const taskProgressArm = function* (m, { ctx, cards, panel, inst }) {
             t: ctx.now(),
             taskId,
             lane: 'workflow',
-            via: workflowRunId !== undefined
-                ? 'workflowRunId'
-                : isWorkflowAgentTaskId(taskId)
-                    ? 'wa-id'
-                    : 'workflow-card-parent',
+            via: 'workflowRunId',
         }));
         return;
     }
     if (explicitParent !== undefined)
         registerSubagentAlias(explicitParent, taskId);
-    const cardId = explicitParent === undefined && !panel.isBound(taskId) && panel.unboundCandidates() > 1
-        ? undefined
-        : panel.bind(taskId, explicitParent);
+    const cardId = panel.bind(taskId, explicitParent);
     const usage = (m.usage ?? {});
     ctx.probe?.('tick', JSON.stringify({
         t: ctx.now(),

package/dist/adapt/panelTasks.d.ts

@@ -3,9 +3,7 @@ import type { AdapterInstanceLedger } from './instanceLedger.js';
 import type { OpenCardView } from './toolCards.js';
 export interface PanelTaskLedger {
     bind(taskId: string, parentToolCallId?: string): string | undefined;
-    unboundCandidates(): number;
     laneOf(taskId: string): LaneProof;
-    isBound(taskId: string): boolean;
     isLiveBound(taskId: string): boolean;
     isLive(taskId: string): boolean;
     markLive(taskId: string): void;

package/dist/adapt/panelTasks.js

@@ -21,44 +21,24 @@ export function createPanelTaskLedger(ctx, cards, inst) {
     };
     return {
         laneOf,
-        isBound: (taskId) => taskCardBinding.has(taskId),
         isLiveBound: (taskId) => liveBoundPanelTasks.has(taskId),
         bind(taskId, parentToolCallId) {
             const existing = taskCardBinding.get(taskId);
             if (existing !== undefined)
                 return existing;
-            let target;
-            if (parentToolCallId !== undefined) {
-                const named = cards.peek(parentToolCallId);
-                if (named !== undefined && !SUBAGENT_TOOL_NAMES.has(named.name))
-                    return undefined;
-                target = parentToolCallId;
-            }
-            else {
-                for (const [id, p] of cards.entries()) {
-                    if (!boundToolCalls.has(id) && SUBAGENT_TOOL_NAMES.has(p.name)) {
-                        target = id;
-                        break;
-                    }
-                }
-            }
-            if (target === undefined)
+            if (parentToolCallId === undefined)
                 return undefined;
+            const named = cards.peek(parentToolCallId);
+            if (named !== undefined && !SUBAGENT_TOOL_NAMES.has(named.name))
+                return undefined;
+            const target = parentToolCallId;
             taskCardBinding.set(taskId, target);
             boundToolCalls.add(target);
             if (cards.has(target))
                 liveBoundPanelTasks.add(taskId);
-            ctx.probe?.('bind', `bind ${taskId} -> ${target} via=${parentToolCallId !== undefined ? 'explicit' : 'fifo'}`);
+            ctx.probe?.('bind', `bind ${taskId} -> ${target} via=explicit`);
             return target;
         },
-        unboundCandidates() {
-            let n = 0;
-            for (const [id, p] of cards.entries()) {
-                if (!boundToolCalls.has(id) && SUBAGENT_TOOL_NAMES.has(p.name))
-                    n++;
-            }
-            return n;
-        },
         isLive: (taskId) => livePanelTasks.has(taskId),
         markLive: (taskId) => {
             livePanelTasks.add(taskId);

package/dist/adapt.js

@@ -107,10 +107,10 @@ export const ADAPTER_DIVERGENCES = [
         '(0.81.0–0.82.x 曾与 CC 内部转录面驼峰 `toolUseResult` 同引用并铸,0.83.0 删驼峰);cli 侧仍带驼峰 —— 所钉的本包' +
         '旧版本两键同铸,升级后在转录入口从 `tool_use_result` 同值起别名。守卫在两键同在场且同引用时略过驼峰键、' +
         '按 snake 比(两侧对称);cli 侧不再带驼峰后本条自然零触发 ⇒ 自退役。',
-    'DIVERGENCE-11(0.83.0,C-R103):system 转录行的到达时戳 —— 本包只给 user / assistant 行补 `timestamp`' +
+    'DIVERGENCE-11(0.83.0):system 转录行的到达时戳 —— 本包只给 user / assistant 行补 `timestamp`' +
         '(agent-types 只在这两臂声明),system 行不补(入参自带的照旧原样过境);壳的接收口给每条转录行补到达时刻(只补缺席)。' +
         '守卫在逐字比对前只从壳侧 system 行上去掉这一位;本包侧 system 行若带 `timestamp`,照样判不等。',
-    'DIVERGENCE-12(0.83.0,C-R103):记忆写入 —— 本包发 chrome `memory_saved` 臂(`notes` = 笔记原文,`id` 由这次写入的 wire ' +
+    'DIVERGENCE-12(0.83.0):记忆写入 —— 本包发 chrome `memory_saved` 臂(`notes` = 笔记原文,`id` 由这次写入的 wire ' +
         '稳定键派生),转录面零行;壳侧是一条 system/memory_saved 转录行(`writtenPaths` 装同一份笔记)。守卫把壳侧这类行移出逐字比对,' +
         '改比:事件 `notes` ⇔ 行 `writtenPaths` 逐项相等、位置相等(之前已覆盖转录行的条数);`id` 不与旧行 uuid 比(本版不承诺相等)。',
 ];

package/dist/adapter/activeRunSelfHeal.d.ts

@@ -192,8 +192,6 @@ export interface SelfHealFollowDeclaration {
 }
 export declare function readCancelRequested(body: unknown): boolean | undefined;
 export declare function atMostOnceFailureClass(e: unknown): 'rejected' | 'unknown';
-export declare function readSteerDelivery(receipt: unknown): string | null;
-export declare function readSteerReceiptStatus(receipt: unknown): string | null;
 export declare function clearRunningChoiceOffer(taskId: string, sessionId?: string): void;
 export declare function __resetRunningChoiceLedgerForTests(): void;
 export interface ClaimReleaseVerdict {

package/dist/adapter/activeRunSelfHeal.js

@@ -1,6 +1,7 @@
 import { abortableSleep } from '../abortableSleep.js';
 import { corruptStoredRowContent, corruptStoredRowWhere, effectiveWireErrorCode } from '../wireErrorTriage.js';
-import { steeringRefusedBeforeEngine, steeringStatusIs4xx } from '../controlRouter.js';
+import { steerBodyOf, steeringRefusedBeforeEngine, steeringStatusIs4xx, UNOBSERVED_STEER_PRIORITY } from '../controlRouter.js';
+import { readSteerReceipt } from '../steerReceipt.js';
 export const PLAN_REVIEW_GATE_KIND = 'plan_review';
 export const PLAN_REVIEW_GATE_KINDS = Object.freeze([PLAN_REVIEW_GATE_KIND, 'dry_run_review']);
 export const ASK_PARK_GATE_KINDS = Object.freeze(['human', 'irreversible_ask', 'policy_ask', 'tool_approval']);
@@ -265,28 +266,6 @@ export function atMostOnceFailureClass(e) {
         return 'rejected';
     return typeof e === 'object' && e !== null && steeringRefusedBeforeEngine(e) !== undefined ? 'rejected' : 'unknown';
 }
-export function readSteerDelivery(receipt) {
-    try {
-        if (typeof receipt !== 'object' || receipt === null || !('delivery' in receipt))
-            return null;
-        const d = receipt.delivery;
-        return typeof d === 'string' && d.length > 0 ? d : null;
-    }
-    catch {
-        return null;
-    }
-}
-export function readSteerReceiptStatus(receipt) {
-    try {
-        if (typeof receipt !== 'object' || receipt === null || !('status' in receipt))
-            return null;
-        const s = receipt.status;
-        return typeof s === 'string' && s.length > 0 ? s : null;
-    }
-    catch {
-        return null;
-    }
-}
 const CANCEL_RELEASE_WAIT_MS = 10_000;
 const RUNNING_LIVENESS_RECHECK_TIMEOUT_MS = 4_000;
 const runningChoiceDeclined = new Set();
@@ -772,9 +751,8 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
     }
     if (choice === 'steer' && canSteer && runs?.steer !== undefined) {
         try {
-            const receipt = await runs.steer(taskId, { text }, sessionOpts(deps));
-            const delivery = readSteerDelivery(receipt);
-            const receiptStatus = readSteerReceiptStatus(receipt);
+            const receipt = await runs.steer(taskId, steerBodyOf({ text }, UNOBSERVED_STEER_PRIORITY), sessionOpts(deps));
+            const { delivery, status: receiptStatus } = readSteerReceipt(receipt);
             if (delivery === 'queued') {
                 const verdict = receiptStatus !== null && PLAN_REVIEW_STATES.includes(receiptStatus)
                     ? await planVerdict(taskId, deps)
@@ -1071,7 +1049,7 @@ function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false, ke
         }
         case 'running-steer-failed':
             if (outcome.delivery === 'rejected') {
-                return (`The engine rejected handing your message to the running run (run ${outcome.taskId}): ${outcome.detail}. ` +
+                return (`Handing your message to the running run (run ${outcome.taskId}) was refused: ${outcome.detail}. ` +
                     `sema did NOT retry it (a steer is not safe to send twice) and it did NOT cancel that run. ` +
                     `Your message was NOT sent; send it again if you still want it.`);
             }

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/terminalToSdkResult.js

@@ -7,8 +7,15 @@ import { isReviewPark, readRunTerminal, runTerminalCode, runTerminalGateToolName
 import { toCcModelUsage } from './turnUsageToModelUsage.js';
 import { LIMITS_MAX_COST_EXCEEDED, LIMITS_MAX_TOKENS_EXCEEDED, LIMITS_MAX_TURNS_EXCEEDED, LIMITS_MAX_WALLTIME_EXCEEDED, OUTPUT_INVALID, isCorruptSessionCode, isRewindFamilyCode, } from '../../engineErrorCodes.js';
 import { corruptSessionContent } from '../../corruptSessionCopy.js';
-function withSessionUnreadableNote(text, code) {
-    return isCorruptSessionCode(code) ? `${text}\n${corruptSessionContent()}` : text;
+import { abortCauseNoteOf, readAbortCause } from '../../runCancelContext.js';
+function withTerminalNote(text, code, frame) {
+    const withCorrupt = isCorruptSessionCode(code) ? `${text}\n${corruptSessionContent()}` : text;
+    const abortNote = abortCauseNoteOf(frame);
+    return abortNote === undefined ? withCorrupt : `${withCorrupt}\n${abortNote}`;
+}
+function abortCauseWordOf(frame) {
+    const r = readAbortCause(frame);
+    return r === undefined ? undefined : r.kind === 'known' ? r.cause : r.word;
 }
 function finiteOr0(v) {
     return typeof v === 'number' && Number.isFinite(v) ? v : 0;
@@ -500,6 +507,7 @@ function errorResult(ctx, parts) {
         ...(parts.salvagedResult !== undefined ? { _sema_salvaged_result: parts.salvagedResult } : {}),
         ...(parts.outcomeUnknown === true ? { _sema_outcome: 'unknown' } : {}),
         ...(parts.parkFailedReason !== undefined ? { _sema_park_failed_reason: washCredentials(parts.parkFailedReason) } : {}),
+        ...(parts.abortCause !== undefined ? { _sema_abort_cause: parts.abortCause } : {}),
     });
 }
 export function doneToSdkResult(ev, ctx, observed) {
@@ -516,7 +524,7 @@ export function doneToSdkResult(ev, ctx, observed) {
     const degraded = degradedOf(r);
     const parkFailedRaw = ev._sema_park_failed_reason;
     const parkFailedReason = typeof parkFailedRaw === 'string' && parkFailedRaw.length > 0 ? parkFailedRaw : undefined;
-    const errorBase = { durationMs, stats, model: r.model, errorCode, degraded, observed, facts: effectiveFactParts(rec), parkFailedReason };
+    const errorBase = { durationMs, stats, model: r.model, errorCode, degraded, observed, facts: effectiveFactParts(rec), parkFailedReason, abortCause: abortCauseWordOf(ev) };
     if (terminal?.kind === 'failed') {
         const failedCode = terminal.code;
         const failedMessage = terminal.message;
@@ -534,9 +542,9 @@ export function doneToSdkResult(ev, ctx, observed) {
             ...errorBase,
             subtype: failedSubtype,
             errors: [
-                withSessionUnreadableNote(isRewindFamilyCode(failedCode) && failedMessage
+                withTerminalNote(isRewindFamilyCode(failedCode) && failedMessage
                     ? `${failedMessage} (${failedCode})`
-                    : (failedMessage ?? 'run failed'), failedCode),
+                    : (failedMessage ?? 'run failed'), failedCode, ev),
             ],
         });
     }
@@ -625,10 +633,11 @@ export function failedToSdkResult(ev, ctx, observed) {
         observed,
         durationMs: elapsedMs(ctx),
         errorCode: ev.errorCode,
+        abortCause: abortCauseWordOf(ev),
         errors: [
-            withSessionUnreadableNote(isRewindFamilyCode(ev.errorCode) && ev.errorMessage
+            withTerminalNote(isRewindFamilyCode(ev.errorCode) && ev.errorMessage
                 ? `${ev.errorMessage} (${ev.errorCode})`
-                : (ev.errorMessage ?? ev.errorCode ?? 'run failed'), ev.errorCode),
+                : (ev.errorMessage ?? ev.errorCode ?? 'run failed'), ev.errorCode, ev),
         ],
     });
 }

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.js

@@ -5,8 +5,10 @@ import { readRunCostFacts, terminalToSdkResult, TOOL_INPUT_JOIN_MAX_CALLS } from
 import { coerceOutput, publishSubagentContentEvent } from '../subagentContentStore.js';
 import { ACTIVE_RUN_BUSY_ERROR_CODE, OUTPUT_INVALID, isCorruptSessionCode, isLimitsExceededCode } from '../engineErrorCodes.js';
 import { corruptSessionContent } from '../corruptSessionCopy.js';
+import { abortCauseNoteOf } from '../runCancelContext.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 +123,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 +132,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) {
@@ -264,41 +267,52 @@ export function toolHistoryErrorCarrierOf(terminalOrResult) {
         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) {
-    const empty = () => mintToolHistoryCarrier(undefined, undefined, undefined);
+    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 (facts.errText === null || facts.busy.busy || facts.governance || isModelOutputErrorText(facts.errText))
-            return empty();
+        if (terminalRowArmOf(facts) !== 'apiError')
+            return none();
         if (type === 'failed')
-            return mintToolHistoryCarrier(nonEmptyStr(ownDataBit(x, 'errorCode')), undefined, nonEmptyStr(ownDataBit(x, 'errorMessage')));
+            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 empty();
+            return none();
         const snap = ownTerminalSnapshot(result);
         if (snap === undefined)
-            return empty();
+            return none();
         const read = readRunTerminal(snap);
         if (read === null || read.kind !== 'failed')
-            return empty();
+            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 mintToolHistoryCarrier(nonEmptyStr(ownDataBit(read, 'code')), status, nonEmptyStr(ownDataBit(read, 'message')));
+        return {
+            carrier: mintToolHistoryCarrier(nonEmptyStr(ownDataBit(read, 'code')), status, nonEmptyStr(ownDataBit(read, 'message'))),
+            detail: detail,
+        };
     }
     catch {
-        return empty();
+        return none();
     }
 }
-function toolHistoryCarrierOfRowFrame(ev, facts) {
+function apiErrorTerminalOfRowFrame(ev, facts) {
     try {
         const x = plainObjectOf(ev);
-        return x === undefined ? mintToolHistoryCarrier(undefined, undefined, undefined) : toolHistoryCarrierFromFacts(x, facts);
+        return x === undefined ? { carrier: mintToolHistoryCarrier(undefined, undefined, undefined), detail: undefined } : apiErrorTerminalFromFacts(x, facts);
     }
     catch {
-        return mintToolHistoryCarrier(undefined, undefined, undefined);
+        return { carrier: mintToolHistoryCarrier(undefined, undefined, undefined), detail: undefined };
     }
 }
 const reportedDroppedTypes = new Set();
@@ -631,23 +645,25 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 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 = rowFacts.governance;
                 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 = classifyToolHistoryMismatch(toolHistoryCarrierOfRowFrame(ev, rowFacts));
+                const abortNote = abortCauseNoteOf(ev);
+                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,
@@ -657,10 +673,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}${abortNote !== undefined ? `\n${abortNote}` : ''}${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,13 @@
+import { type AutomaticAnswerRoad, type AutomaticAnswerUnknownWhy } from './hitl/automaticAnswerVerdict.js';
+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" | "requires_user_interaction" | "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 road?: AutomaticAnswerRoad;
+} | {
+    readonly kind: 'may_answer';
+} | {
+    readonly kind: 'unknown';
+    readonly why?: AutomaticAnswerUnknownWhy;
+};
+export declare function askSurvivesStandingAnswer(card: object | null | undefined): StandingAnswerVerdict;

package/dist/askSurvivesStandingAnswer.js

@@ -0,0 +1,53 @@
+import { CORE_MODE_ARBITRATION } from './generated/engineFactTables.js';
+import { automaticAnswerVerdict } from './hitl/automaticAnswerVerdict.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) {
+    const old = legacyStandingAnswerVerdict(card);
+    const neu = automaticAnswerVerdict(card, 'standing_rule');
+    if (old.kind === 'must_ask' || neu.kind === 'must_ask') {
+        const by = old.kind === 'must_ask' ? old.by : neu.kind === 'must_ask' ? (neu.askClass ?? neu.road) : 'mandated';
+        const road = neu.kind === 'must_ask' ? neu.road : by === 'mandated' ? 'mandated' : 'ask_class';
+        return Object.freeze({ kind: 'must_ask', by, road });
+    }
+    if (old.kind === 'unknown' || neu.kind === 'unknown')
+        return neu.kind === 'unknown' ? Object.freeze({ kind: 'unknown', why: neu.why }) : UNKNOWN;
+    return MAY_ANSWER;
+}
+function legacyStandingAnswerVerdict(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

@@ -28,3 +28,12 @@ export declare class AttachmentsSpecRefused extends TypeError {
     });
 }
 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;