@sema-agent/client-core 0.95.0 → 0.97.0

package/dist/adapt/arms.js

@@ -12,7 +12,7 @@ import { recordWorkflowAgentTaskId } from '../workflow.js';
 import { isCoreTaskNotificationTerminal, isCoreTaskNotificationTerminalNotSuccess, isCoreTaskProgressTerminal, isCoreTaskProgressTerminalNotSuccess } from '../terminalStatuses.js';
 import { readToolHistoryMismatchKey } from '../toolHistoryMismatch.js';
 import { readProviderRejectionResendKey } from '../providerRejection.js';
-import { readFrameStringKey } from '../ownKey.js';
+import { readFrameStringKey, readFrameTrueMark } from '../ownKey.js';
 import { washCredentials } from '../displayUntrusted.js';
 import { resolveEnginePanelTaskId } from '../engineAgentPanelStore.js';
 import { fleetRowAgentType } from '../fleet/fleetRowAgentType.js';
@@ -74,6 +74,7 @@ const assistantArm = function* (m, { ctx, idOf, text, cards, inst }) {
             uuid: idOf(m),
             session_id: ctx.sessionId,
             parent_tool_use_id: null,
+            ...(readFrameTrueMark(m, '_sema_tool_recovered') ? { _sema_tool_recovered: true } : {}),
         }, ctx.now());
         if (decision === 'reject' || decision === 'cancel') {
             cards.resetResponseId();
@@ -469,6 +470,7 @@ const textSegmentEndArm = function* (m, { text }) {
     if (content.length === 0)
         return;
     const r = text.replaceAnswerSegment(content, m);
+    yield* text.drainLive();
     yield chrome({
         kind: 'text_segment_end',
         laneProof: mainLane(),
@@ -491,6 +493,7 @@ const thinkingSegmentEndArm = function* (m, { text }) {
     if (content.length === 0)
         return;
     const r = text.replaceThinkingSegment(content, m);
+    yield* text.drainLive();
     yield chrome({
         kind: 'thinking_segment_end',
         laneProof: mainLane(),
@@ -542,6 +545,7 @@ const toolEndResultArm = function* (m, { idOf, cards, panel }) {
         eventId: closeEventId,
         parentToolCallId: closeParent,
         ...(typeof closeDenialKindRaw === 'string' ? { denialKind: closeDenialKindRaw } : {}),
+        ...(readFrameTrueMark(m, 'notExecuted') ? { notExecuted: true } : {}),
     });
     const s = structured !== undefined && structured !== null && typeof structured === 'object'
         ? structured
@@ -854,6 +858,8 @@ const retryStatusArm = function* (m, { ctx, flags }) {
         ...(typeof m.errorStatus === 'number' ? { errorStatus: m.errorStatus } : {}),
         ...(typeof m.elapsedMs === 'number' ? { elapsedMs: m.elapsedMs } : {}),
         ...(typeof m.timeoutMs === 'number' ? { timeoutMs: m.timeoutMs } : {}),
+        ...(typeof m.providerCondition === 'string' && m.providerCondition.length > 0 ? { providerCondition: m.providerCondition } : {}),
+        ...(typeof m.providerConditionSource === 'string' && m.providerConditionSource.length > 0 ? { providerConditionSource: m.providerConditionSource } : {}),
     }, ctx.now());
     if (status === null) {
         if (flags.takeRetryOverlay())

package/dist/adapt/toolCards.d.ts

@@ -28,6 +28,7 @@ interface ToolEndPayload {
     eventId?: string | undefined;
     parentToolCallId?: string | undefined;
     denialKind?: string | undefined;
+    notExecuted?: boolean | undefined;
 }
 export interface OpenCardView {
     has(id: string): boolean;

package/dist/adapt/toolCards.js

@@ -2,6 +2,8 @@ import { deriveTranscriptId } from '../seam.js';
 import { degradedToolResultBody, detectEngineBgShellDetach, detectEngineBgShellReceipt, reportFindingsToolUseResult, structuredToToolUseResult, todoWriteToolUseResult, wireOutputToBody, } from '../toolResult.js';
 import { chrome, mainLane, transcript } from './ids.js';
 import { flattenWireOutput } from './wireShapes.js';
+import { toolResultBlocksOf } from '../toolResultContent.js';
+import { bashExitOf, bashExitReadingFailed } from '../bashExitReading.js';
 import { isCcToolDenialKind } from '../gateVocabulary.js';
 function toolUseResultParts(v) {
     return v !== undefined ? { tool_use_result: v } : {};
@@ -20,7 +22,17 @@ export function toolResultOutcomeOf(toolName, end, rawInput, owner, ledgerTier)
     if (rich === null && !isError && toolName === 'ReportFindings') {
         rich = reportFindingsToolUseResult(end?.structured, rawInput);
     }
-    return { body, rich };
+    const failed = body.isError || rich?.isError === true || bashExitReadingFailed(bashExitOf(end?.structured, () => null));
+    const settled = failed && !body.isError ? { ...body, isError: true } : body;
+    return { body: withContentBlocks(settled, end), rich };
+}
+function withContentBlocks(body, end) {
+    if (body.isError || typeof body.content !== 'string' || end === undefined || end.output === undefined)
+        return body;
+    const blocks = toolResultBlocksOf(end.output, end.truncated === true);
+    if (blocks === undefined)
+        return body;
+    return { ...body, content: blocks, toolUseResult: body.toolUseResult !== undefined ? body.toolUseResult : body.content };
 }
 export function toolResultEnvelopeParts(o) {
     return {
@@ -52,7 +64,7 @@ export function createToolCardLedger(ctx, idOf) {
             lastLiveTodos = todo.newTodos;
             return { toolUseResult: todo.toolUseResult, isError: todo.isError };
         });
-        const { body, rich } = outcome;
+        const { body } = outcome;
         const eventId = end?.eventId ?? p.eventId;
         yield transcript({
             type: 'user',
@@ -63,7 +75,7 @@ export function createToolCardLedger(ctx, idOf) {
                         type: 'tool_result',
                         tool_use_id: p.id,
                         content: body.content,
-                        is_error: rich?.isError === true || body.isError,
+                        is_error: body.isError,
                     },
                 ],
             },
@@ -72,6 +84,7 @@ export function createToolCardLedger(ctx, idOf) {
             ...(parentToolCallId !== undefined ? { parent_tool_use_id: parentToolCallId } : {}),
             ...toolResultEnvelopeParts(outcome),
             ...(isCcToolDenialKind(end?.denialKind) ? { _sema_denial_kind: end.denialKind } : {}),
+            ...(end?.notExecuted === true ? { _sema_not_executed: true } : {}),
         }, ctx.now());
     }
     function* closeCard(p, end) {

package/dist/adapt/wireShapes.js

@@ -1,5 +1,6 @@
 import { frozenSet } from '../frozenSet.js';
 import { stripToolUseSideChannels } from '../adapter/types.js';
+import { toolEndOutputText } from '../toolResultContent.js';
 export const FLUSH_INTERVAL_MS = 100;
 export const IDLE_FLUSH_MS = 1500;
 export const SUBAGENT_TOOL_NAMES = frozenSet(['Task', 'Agent', 'Fork']);
@@ -24,22 +25,7 @@ export function estimateCjkTokens(s) {
     return Math.round(t);
 }
 export function flattenWireOutput(output) {
-    if (typeof output === 'string')
-        return output;
-    if (Array.isArray(output)) {
-        const parts = [];
-        for (const block of output) {
-            if (block && typeof block === 'object') {
-                const b = block;
-                if (b.type === 'text' && typeof b.text === 'string')
-                    parts.push(b.text);
-                else if (b.type === 'image')
-                    parts.push('[image]');
-            }
-        }
-        return parts.join('');
-    }
-    return '';
+    return toolEndOutputText(output) ?? '';
 }
 export function shortTaskLabel(task) {
     const firstLine = (task.split('\n').find(l => l.trim()) ?? task).trim();

package/dist/adapter/activeRunSelfHeal.d.ts

@@ -2,8 +2,10 @@ import type { ActiveRunBusySignal } from './runStream.js';
 import type { PlanReviewReopenTrigger } from '../hitl/planReviewWire.js';
 import { atMostOnceFailureClass } from '../atMostOnce.js';
 export declare const PLAN_REVIEW_GATE_KIND = "plan_review";
-export declare const PLAN_REVIEW_GATE_KINDS: readonly string[];
-export declare const ASK_PARK_GATE_KINDS: readonly string[];
+export type DurableDecideLeg = 'approval' | 'plan_review' | 'other_gate' | 'unreadable' | 'absent';
+export declare function durableDecideLegOf(row: {
+    readonly gateKind?: string | null;
+} | null | undefined): DurableDecideLeg;
 export declare function askParkForeignGateKind(row: {
     gateKind?: string | null;
 }): string | null;

package/dist/adapter/activeRunSelfHeal.js

@@ -5,12 +5,37 @@ import { atMostOnceFailureClass } from '../atMostOnce.js';
 import { readSteerReceipt } from '../steerReceipt.js';
 import { resumeAttachReplayDisclosure, runningAttachOffered } from '../hitl/resumeRunningCard.js';
 import { isSdkRunTerminal, SDK_PARKED_RUN_STATUSES } from '../terminalStatuses.js';
+import { SDK_APPROVAL_DECIDE_GATE_KINDS, SDK_PLAN_REVIEW_GATE_KINDS } from '../generated/sdkFactTables.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']);
+const APPROVAL_LEG_GATE_KINDS = SDK_APPROVAL_DECIDE_GATE_KINDS;
+const PLAN_LEG_GATE_KINDS = SDK_PLAN_REVIEW_GATE_KINDS;
+const CORE_GATE_KINDS = ['human', 'irreversible_ask', 'resource_limit', 'needs_review', 'plan_review', 'task_done'];
+const _durableDecideLegPins = [true, true, true, true, true, true, true, true, true, true];
+void _durableDecideLegPins;
+function gateKindReadingOf(row) {
+    let kind;
+    try {
+        kind = row !== null && typeof row === 'object' ? row.gateKind : undefined;
+    }
+    catch {
+        return { leg: 'unreadable', kind: null };
+    }
+    if (typeof kind !== 'string' || kind === '')
+        return { leg: 'absent', kind: null };
+    if (APPROVAL_LEG_GATE_KINDS.includes(kind))
+        return { leg: 'approval', kind };
+    if (PLAN_LEG_GATE_KINDS.includes(kind))
+        return { leg: 'plan_review', kind };
+    if (CORE_GATE_KINDS.includes(kind))
+        return { leg: 'other_gate', kind };
+    return { leg: 'unreadable', kind };
+}
+export function durableDecideLegOf(row) {
+    return gateKindReadingOf(row).leg;
+}
 export function askParkForeignGateKind(row) {
-    const kind = typeof row.gateKind === 'string' && row.gateKind.length > 0 ? row.gateKind : null;
-    return kind !== null && !ASK_PARK_GATE_KINDS.includes(kind) ? kind : null;
+    const r = gateKindReadingOf(row);
+    return r.leg === 'approval' || r.leg === 'absent' ? null : (r.kind ?? '(unreadable)');
 }
 export const PLAN_REVIEW_STATES = Object.freeze(['needs_review']);
 export const ASK_PARK_STATES = Object.freeze(['suspended']);
@@ -421,9 +446,10 @@ export async function attemptActiveRunSelfHeal(signal, runs, deps) {
         };
     }
     const gateKind = signal.pendingGate?.kind ?? null;
-    if (gateKind !== null && PLAN_REVIEW_GATE_KINDS.includes(gateKind))
+    const gateLeg = gateKind !== null ? durableDecideLegOf({ gateKind }) : 'absent';
+    if (gateLeg === 'plan_review')
         return planReviewArm(taskId, signal, deps);
-    if (gateKind !== null && ASK_PARK_GATE_KINDS.includes(gateKind))
+    if (gateLeg === 'approval')
         return askParkArm(taskId, signal, runs, deps);
     let status = signal.activeTaskStatus;
     if (status === null) {

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -5,7 +5,7 @@ import { ccToolDenialKindForToolEnd, gateOutcomeOf } from '../../gateOutcome.js'
 import { projectToolRoster, projectToolRosterDelta } from '../../toolRoster.js';
 import { projectHandsSection } from '../../handsSeam.js';
 import { readMcpLiveness } from '../../mcpLiveness.js';
-import { markMcpSectionDroppedNamedRows } from '../../ownKey.js';
+import { markMcpSectionDroppedNamedRows, readFrameTrueMark } from '../../ownKey.js';
 import { SEGMENT_END_IDENTITY_KEYS, stripToolUseSideChannels } from '../types.js';
 import { frozenSet } from '../../frozenSet.js';
 import { isCoreWorkflowRunTerminal } from '../../terminalStatuses.js';
@@ -40,7 +40,7 @@ export const INTERNAL_SDK_ARM_TYPES = frozenSet([
     'approval_revoke',
     'message_committed',
 ]);
-function assistantArm(ctx, content, eventId, parentToolCallId) {
+function assistantArm(ctx, content, eventId, parentToolCallId, recovered) {
     const id = typeof eventId === 'string' && eventId.length > 0 ? eventId : undefined;
     const parent = typeof parentToolCallId === 'string' && parentToolCallId.length > 0 ? parentToolCallId : undefined;
     const model = parent === undefined && typeof ctx.model === 'string' && ctx.model.length > 0 ? ctx.model : undefined;
@@ -53,6 +53,7 @@ function assistantArm(ctx, content, eventId, parentToolCallId) {
             ...(model !== undefined ? { model } : {}),
         },
         parent_tool_use_id: parent ?? null,
+        ...(recovered === true ? { _sema_tool_recovered: true } : {}),
     }));
 }
 function streamEventArm(ctx, event) {
@@ -141,7 +142,7 @@ export function eventToSdkMessage(ev, ctx) {
                     : {}),
             };
             const outBlock = ctx.lane === 'print' ? stripToolUseSideChannels(toolUse).block : toolUse;
-            return projected(assistantArm(ctx, [outBlock], ev.eventId, ev.parentToolCallId));
+            return projected(assistantArm(ctx, [outBlock], ev.eventId, ev.parentToolCallId, readFrameTrueMark(ev, 'recovered')));
         }
         case 'compacted': {
             const raw = ev;
@@ -178,6 +179,7 @@ export function eventToSdkMessage(ev, ctx) {
             const collateralAbort = ev._sema_collateral_abort;
             const denialKind = ccToolDenialKindForToolEnd(ev);
             const denialUnclassified = denialKind === undefined && toolEndGate?.disposition.kind === 'denied';
+            const toolEndNotExecuted = readFrameTrueMark(ev, 'notExecuted');
             return projected(stamp(ctx, armBody({
                 type: 'tool_end_result',
                 toolCallId: ev.toolCallId,
@@ -200,6 +202,7 @@ export function eventToSdkMessage(ev, ctx) {
                 ...(collateralAbort === true ? { _sema_collateral_abort: true } : {}),
                 ...(denialKind !== undefined ? { _sema_denial_kind: denialKind } : {}),
                 ...(denialUnclassified ? { _sema_denial_unclassified: true } : {}),
+                ...(toolEndNotExecuted ? { notExecuted: true } : {}),
                 ...(ev.eventId !== undefined ? { eventId: ev.eventId } : {}),
                 ...(ev.parentToolCallId !== undefined
                     ? { parentToolCallId: ev.parentToolCallId }
@@ -217,6 +220,9 @@ export function eventToSdkMessage(ev, ctx) {
             const elapsedMs = num(st2.elapsedMs);
             const timeoutMs = num(st2.timeoutMs);
             const errClass = typeof ev.errClass === 'string' && ev.errClass.length > 0 ? ev.errClass : undefined;
+            const nonEmptyStr = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+            const providerCondition = nonEmptyStr(st2.providerCondition);
+            const providerConditionSource = nonEmptyStr(st2.providerConditionSource);
             return projected(stamp(ctx, armBody({
                 type: 'retry_status',
                 phase: ev.phase,
@@ -230,6 +236,8 @@ export function eventToSdkMessage(ev, ctx) {
                 ...(errorStatus !== undefined ? { errorStatus } : {}),
                 ...(elapsedMs !== undefined ? { elapsedMs } : {}),
                 ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+                ...(providerCondition !== undefined ? { providerCondition } : {}),
+                ...(providerConditionSource !== undefined ? { providerConditionSource } : {}),
                 ...(typeof ev.eventId === 'string' ? { eventId: ev.eventId } : {}),
                 ...(typeof ev.parentToolCallId === 'string' ? { parentToolCallId: ev.parentToolCallId } : {}),
             })));

package/dist/adapter/downstream/terminalToSdkResult.js

@@ -4,12 +4,18 @@ import { putOwnKey, readFrameStringKey } from '../../ownKey.js';
 import { REDACTION_MARKER_PREFIX, washCredentials } from '../../displayUntrusted.js';
 import { readEffectiveReasoning, readEffectiveMemoryScopes } from '../../effectiveFacts.js';
 import { isReviewPark, readRunTerminal, runTerminalCode, runTerminalGateToolName, } from '../../runTerminal.js';
+import { doneResultView } from '../../replayBody.js';
 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 { LIMITS_MAX_COST_EXCEEDED, LIMITS_MAX_TOKENS_EXCEEDED, LIMITS_MAX_TURNS_EXCEEDED, LIMITS_MAX_WALLTIME_EXCEEDED, OUTPUT_INVALID, isCorruptSessionCode, idempotencyPayloadMismatchContent, isIdempotencyPayloadMismatchCode, isRewindFamilyCode, } from '../../engineErrorCodes.js';
 import { corruptSessionContent } from '../../corruptSessionCopy.js';
+import { runBlockedText } from '../../promptBlockedCopy.js';
 import { abortCauseNoteOf, readAbortCause } from '../../runCancelContext.js';
 function withTerminalNote(text, code, frame) {
-    const withCorrupt = isCorruptSessionCode(code) ? `${text}\n${corruptSessionContent()}` : text;
+    const withCorrupt = isCorruptSessionCode(code)
+        ? `${text}\n${corruptSessionContent()}`
+        : isIdempotencyPayloadMismatchCode(code)
+            ? `${text}\n${idempotencyPayloadMismatchContent()}`
+            : text;
     const abortNote = abortCauseNoteOf(frame);
     return abortNote === undefined ? withCorrupt : `${withCorrupt}\n${abortNote}`;
 }
@@ -519,14 +525,16 @@ function errorResult(ctx, parts) {
     });
 }
 export function doneToSdkResult(ev, ctx, observed) {
-    const rRaw = ev.result;
+    const view = doneResultView(ev.result);
+    const rRaw = view.engine;
     const rec = typeof rRaw === 'object' && rRaw !== null ? rRaw : {};
     const r = rec;
     const stats = r.stats;
-    const echoedSid = r.sessionId;
+    const nestedSid = r.sessionId;
+    const echoedSid = typeof nestedSid === 'string' && nestedSid.length > 0 ? nestedSid : view.row?.sessionId;
     if (typeof echoedSid === 'string' && echoedSid.length > 0)
         ctx.sessionId = echoedSid;
-    const terminal = readRunTerminal(rRaw);
+    const terminal = readRunTerminal(ev.result);
     const durationMs = elapsedMs(ctx);
     const errorCode = runTerminalCode(terminal);
     const degraded = degradedOf(r);
@@ -556,15 +564,10 @@ export function doneToSdkResult(ev, ctx, observed) {
         });
     }
     if (terminal?.kind === 'blocked') {
-        const blockedReason = terminal.reason;
         return errorResult(ctx, {
             ...errorBase,
             subtype: 'error_during_execution',
-            errors: [
-                blockedReason !== undefined
-                    ? `Run blocked: ${blockedReason}`
-                    : 'Run blocked (the agent reported it cannot proceed)',
-            ],
+            errors: [runBlockedText(terminal)],
         });
     }
     if (terminal?.kind === 'paused') {

package/dist/adapter/runStream.js

@@ -3,13 +3,15 @@ import { eventToSdkMessage, turnEndUsage } from './downstream/eventToSdkMessage.
 import { turnUsageToModelUsage } from './downstream/turnUsageToModelUsage.js';
 import { readRunCostFacts, terminalToSdkResult, TOOL_INPUT_JOIN_MAX_CALLS } from './downstream/terminalToSdkResult.js';
 import { coerceOutput, publishSubagentContentEvent } from '../subagentContentStore.js';
-import { ACTIVE_RUN_BUSY_ERROR_CODE, OUTPUT_INVALID, isCorruptSessionCode, isLimitsExceededCode } from '../engineErrorCodes.js';
+import { OUTPUT_INVALID, activeRunBusyCarrierOf, classifyActiveRunBusy, isCorruptSessionCode, isLimitsExceededCode } from '../engineErrorCodes.js';
+import { doneResultView } from '../replayBody.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 { PROMPT_BLOCKED_BY_HOOK_ROW_LEAD, runBlockedText } from '../promptBlockedCopy.js';
 import { ccToolDenialKindForToolEnd, gateDeniedBy, gateOutcomeOf } from '../gateOutcome.js';
 import { resumeReopenContent, resumeReopenFromError, suspendedReopenOf } from '../hitl/suspendedReopen.js';
 import { isCcToolDenialKind, isCcToolDenialKindADenial, isGateDeniedByWord } from '../gateVocabulary.js';
@@ -52,31 +54,10 @@ export function pendingGateIsProvablyDifferent(prev, next) {
     return a !== b;
 }
 export function activeRunBusySignal(ev) {
-    if (typeof ev !== 'object' || ev === null || !('type' in ev))
-        return null;
-    const type = ev.type;
-    let carrier;
-    if (type === 'done') {
-        const result = ev.result;
-        if (typeof result !== 'object' || result === null)
-            return null;
-        const status = result.status;
-        if (status !== 'failed' && (status !== undefined || Array.isArray(result)))
-            return null;
-        carrier = result;
-    }
-    else if (type === 'failed') {
-        carrier = ev;
-    }
-    else {
-        return null;
-    }
-    const cls = classifyActiveRunBusy({
-        errorCode: typeof carrier.errorCode === 'string' ? carrier.errorCode : undefined,
-        activeTaskId: carrier.activeTaskId,
-    });
-    if (!cls.busy)
+    const read = busyReadOfFrame(ev);
+    if (read === null || !read.cls.busy)
         return null;
+    const { carrier, cls } = read;
     const status = carrier.activeTaskStatus;
     const rawGate = carrier.pendingGate;
     let pendingGate = null;
@@ -100,19 +81,22 @@ export function activeRunBusySignal(ev) {
         ...(typeof msIdle === 'number' && Number.isFinite(msIdle) && msIdle >= 0 ? { msSinceLastActivity: msIdle } : {}),
     };
 }
-function classifyActiveRunBusy(input) {
-    const handle = typeof input.activeTaskId === 'string' && input.activeTaskId.length > 0 ? input.activeTaskId : null;
-    if (input.errorCode === ACTIVE_RUN_BUSY_ERROR_CODE)
-        return { busy: true, handle };
-    if (typeof input.activeTaskId === 'string')
-        return { busy: true, handle };
-    return { busy: false, handle };
+function busyReadOfFrame(ev, doneTerminal, preReadActiveTaskId) {
+    const carrier = activeRunBusyCarrierOf(ev);
+    if (carrier === null)
+        return null;
+    const isDone = ev.type === 'done';
+    const terminal = isDone ? (doneTerminal !== undefined ? doneTerminal : readRunTerminal(ev.result)) : null;
+    const flatCode = typeof carrier.errorCode === 'string' ? carrier.errorCode : undefined;
+    const activeTaskId = preReadActiveTaskId !== undefined ? preReadActiveTaskId.value : carrier.activeTaskId;
+    const cls = classifyActiveRunBusy({ errorCode: (isDone ? runTerminalCode(terminal) : undefined) ?? flatCode, activeTaskId });
+    return { carrier, cls };
 }
 export const RUN_STOPPED_MESSAGE_PREFIX = 'Run stopped';
 export const RUN_BLOCKED_MESSAGE_PREFIX = 'Run blocked';
 export function isGovernanceStopRowText(text) {
     const t = text.trimStart();
-    return t.startsWith(`${RUN_STOPPED_MESSAGE_PREFIX}:`) || t.startsWith(`${RUN_BLOCKED_MESSAGE_PREFIX}`);
+    return t.startsWith(`${RUN_STOPPED_MESSAGE_PREFIX}:`) || t.startsWith(`${RUN_BLOCKED_MESSAGE_PREFIX}`) || t.startsWith(PROMPT_BLOCKED_BY_HOOK_ROW_LEAD);
 }
 export const MODEL_OUTPUT_ERROR_PREFIX = 'Model output error';
 export function isModelOutputErrorText(text) {
@@ -133,13 +117,17 @@ function syntheticTerminalRow(ctx, text, historyKey, resend) {
         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 } } : {}),
+        ...(resend !== undefined ? { _sema_provider_rejection_resend: { resend: resend.resend, text: resend.text, kind: resend.kind } } : {}),
     });
 }
 function engineRunIdOf(result) {
     const v = result?.runId;
     return typeof v === 'string' && v.length > 0 ? v : undefined;
 }
+function engineResultOf(result) {
+    const v = doneResultView(result);
+    return v.replay ? (v.engine ?? result) : result;
+}
 function engineSessionIdOf(result) {
     const v = result?.sessionId;
     return typeof v === 'string' && v.length > 0 ? v : undefined;
@@ -161,19 +149,14 @@ function terminalRowFacts(ev) {
         : 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)')
+                ? runBlockedText(doneTerminal)
                 : 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 busy = busyReadOfFrame(ev, doneTerminal, { value: activeTaskId })?.cls ?? { busy: false, handle: null };
     const governance = isGovernanceTerminal({
         status: ev.type === 'failed' ? undefined : doneTerminal?.kind === 'blocked' ? 'blocked' : undefined,
         errorCode: ev.type === 'failed' ? ev.errorCode : runTerminalCode(doneTerminal),
@@ -284,7 +267,7 @@ function apiErrorTerminalFromFacts(x, facts) {
             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;
+        const result = type === 'done' ? plainObjectOf(engineResultOf(ownDataBit(x, 'result'))) : x;
         if (result === undefined)
             return none();
         const snap = ownTerminalSnapshot(result);
@@ -667,12 +650,12 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 const abortNote = abortCauseNoteOf(ev);
                 const historyTerminal = apiErrorTerminalOfRowFrame(ev, rowFacts);
                 const historyMismatch = classifyToolHistoryMismatch(historyTerminal.carrier);
-                const historyEchoedSid = ev.type === 'done' ? engineSessionIdOf(ev.result) : undefined;
+                const historyEchoedSid = ev.type === 'done' ? engineSessionIdOf(engineResultOf(ev.result)) : undefined;
                 const historyRepeat = noteToolHistoryTerminal({
                     sessionId: historyEchoedSid ?? ctx.sessionId,
                     sessionEchoed: historyEchoedSid !== undefined,
                     generation: historyGeneration,
-                    runId: ev.type === 'done' ? engineRunIdOf(ev.result) : undefined,
+                    runId: ev.type === 'done' ? engineRunIdOf(engineResultOf(ev.result)) : undefined,
                     replay: ev.type === 'done' && ev.replay === true,
                     mismatch: historyMismatch,
                 });
@@ -685,12 +668,12 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 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;
+                const echoedSid = ev.type === 'done' ? engineSessionIdOf(engineResultOf(ev.result)) : undefined;
                 noteToolHistoryTerminal({
                     sessionId: echoedSid ?? ctx.sessionId,
                     sessionEchoed: echoedSid !== undefined,
                     generation: historyGeneration,
-                    runId: ev.type === 'done' ? engineRunIdOf(ev.result) : undefined,
+                    runId: ev.type === 'done' ? engineRunIdOf(engineResultOf(ev.result)) : undefined,
                     replay: ev.type === 'done' && ev.replay === true,
                     mismatch: null,
                 });
@@ -702,7 +685,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 catch { }
             }
             if (ev.type === 'done' && ctx.emitChrome) {
-                const doneStats = ev.result?.stats;
+                const doneStats = engineResultOf(ev.result)?.stats;
                 const costFacts = readRunCostFacts(doneStats, { usageMissingObserved });
                 if (costFacts !== undefined) {
                     emitChromeFireAndForget(ctx, { kind: 'run_cost_reconciled', laneProof: mainLane(), ...costFacts.reconcile });

package/dist/agentSession/backgroundView.js

@@ -122,7 +122,6 @@ export function createBackgroundView(client, opts) {
     let disposed = false;
     let current = null;
     let lastSerialized = null;
-    let capsApprovals = null;
     const listeners = new Set();
     const abort = new AbortController();
     function notify() {
@@ -137,27 +136,16 @@ export function createBackgroundView(client, opts) {
             }
         }
     }
-    async function probeCaps() {
-        if (capsApprovals !== null)
-            return;
-        try {
-            const caps = await client.capabilities({ signal: abort.signal });
-            capsApprovals = caps.approvals === true;
-        }
-        catch (err) {
-            debugLog(`caps probe unavailable (approvals 判别缺席,保持 ok 口径): ${String(err)}`);
-        }
-    }
     async function pullAssistant() {
         try {
             const { tasks } = await client.assistant.tasks({ signal: abort.signal });
             if (!Array.isArray(tasks))
                 return { health: 'unavailable', tasks: [] };
-            return { health: capsApprovals === false ? 'not-configured' : 'ok', tasks };
+            return { health: 'ok', tasks };
         }
         catch (err) {
             debugLog(`assistant.tasks degrade: ${String(err)}`);
-            const health = capsApprovals === false || isNotImplemented(err)
+            const health = isNotImplemented(err)
                 ? 'not-configured'
                 : isReadCredentialRefusal(err)
                     ? 'unauthorized'
@@ -183,7 +171,6 @@ export function createBackgroundView(client, opts) {
         }
     }
     async function pollOnce() {
-        await probeCaps();
         const [assistant, fleet] = await Promise.all([pullAssistant(), pullFleet()]);
         if (disposed || abort.signal.aborted)
             return;

package/dist/agentSession/engineAgentRegistryRead.js

@@ -1,6 +1,7 @@
 import { errCodes } from '../controlRouter.js';
 import { hostLog } from '../host.js';
 import { isSessionIdPathSegment } from '../sessionIdSegment.js';
+import { ownDataField } from '../ownKey.js';
 const unavailable = (why) => ({
     kind: 'unavailable',
     why,
@@ -58,12 +59,12 @@ export function isEngineAgentRegistryListingSuperseded(listing) {
     return registryListingProvenanceOf(listing)?.superseded === true;
 }
 function listFaceOn(caps) {
-    if (typeof caps !== 'object' || caps === null || !Object.hasOwn(caps, 'background'))
+    if (typeof caps !== 'object' || caps === null)
         return false;
-    const bg = caps.background;
-    if (typeof bg !== 'object' || bg === null || !Object.hasOwn(bg, 'listFace'))
+    const bg = ownDataField(caps, 'background');
+    if (typeof bg !== 'object' || bg === null)
         return false;
-    return bg.listFace === true;
+    return ownDataField(bg, 'listFace') === true;
 }
 function readRow(v) {
     if (typeof v !== 'object' || v === null || Array.isArray(v))

package/dist/agentSession/engineSessionBackgroundStop.js

@@ -1,4 +1,4 @@
-import { engineCapValue } from '../engineCapsCache.js';
+import { engineCapNestedValue } from '../engineCapsCache.js';
 import { isStatusDerivedCoarseCode } from '../engineErrorCodes.js';
 import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, noAnswerDetailFrom, sendOnce, settleInjected } from '../engineWireFor.js';
 import { engineWireDebugEnabled } from '../engineWireTarget.js';
@@ -18,6 +18,8 @@ const DETAIL_NO_TARGET = `no engine connection is installed for this session${NO
 const DETAIL_NO_CLIENT = `an engine client could not be built from the installed connection${NOTHING_SENT}`;
 const DETAIL_CAPS_KEY_REQUIRED = `capability evidence for background.exitFaces is not available under the key the host named (capsBaseUrl)${NOTHING_SENT}`;
 const DETAIL_CAPS_UNOBSERVED = `the engine capabilities have not been read for this connection yet — wait for the capability probe to settle, then call again${NOTHING_SENT}`;
+const DETAIL_CAPS_UNREADABLE = `the engine reported its capabilities in a form this client cannot read, so whether it offers the session background stop is unknown — calling again on this connection will not change that${NOTHING_SENT}`;
+const DETAIL_CAPS_UNKNOWN_GENERIC = `whether the engine offers the session background stop is unknown${NOTHING_SENT}`;
 const DETAIL_NO_EXIT_FACE = `this engine does not offer the session background stop (capabilities.background.exitFaces is not true); background tasks may keep running${NOTHING_SENT}`;
 function refusedDetail(why) {
     switch (why) {
@@ -67,22 +69,27 @@ function unavailable(why, detail) {
 function usableStopClient(client) {
     return clientHasVerbs(client, [['sessions', 'backgroundStop']]);
 }
-function exitFaceGate(capsKey) {
-    try {
-        const v = engineCapValue(capsKey, 'background');
-        if (v.kind === 'unobserved')
-            return { why: 'capability_unknown', detail: DETAIL_CAPS_UNOBSERVED };
-        if (v.kind !== 'value')
-            return { why: 'no_exit_face', detail: DETAIL_NO_EXIT_FACE };
-        const bg = v.value;
-        if (typeof bg !== 'object' || bg === null || !Object.hasOwn(bg, 'exitFaces'))
-            return { why: 'no_exit_face', detail: DETAIL_NO_EXIT_FACE };
-        return bg.exitFaces === true ? null : { why: 'no_exit_face', detail: DETAIL_NO_EXIT_FACE };
-    }
-    catch {
-        return { why: 'capability_unknown', detail: DETAIL_CAPS_UNOBSERVED };
+function capsUnknownDetail(reason) {
+    switch (reason) {
+        case 'unobserved':
+            return DETAIL_CAPS_UNOBSERVED;
+        case 'unreadable':
+            return DETAIL_CAPS_UNREADABLE;
+        default: {
+            const unreachable = reason;
+            void unreachable;
+            return DETAIL_CAPS_UNKNOWN_GENERIC;
+        }
     }
 }
+function exitFaceGate(capsKey) {
+    const v = engineCapNestedValue(capsKey, 'background', 'exitFaces');
+    if (v.kind === 'unobserved')
+        return { why: 'capability_unknown', detail: capsUnknownDetail('unobserved') };
+    if (v.kind === 'unreadable')
+        return { why: 'capability_unknown', detail: capsUnknownDetail('unreadable') };
+    return v.kind === 'value' && v.value === true ? null : { why: 'no_exit_face', detail: DETAIL_NO_EXIT_FACE };
+}
 function readReceipt(v) {
     if (typeof v !== 'object' || v === null || Array.isArray(v))
         return undefined;