@sema-agent/client-core 0.94.0 → 0.96.0

package/dist/adapt/arms.js

@@ -9,10 +9,10 @@ import { recordEngineToolLabel } from '../engineToolLabelStore.js';
 import { registerSubagentAlias, registerSubagentContentAlias } from '../subagentContentStore.js';
 import { readAsyncLaunchedAgentReceipt } from '../toolResult.js';
 import { recordWorkflowAgentTaskId } from '../workflow.js';
-import { isTerminalStatus } from '../runTerminal.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
@@ -572,7 +576,6 @@ const toolEndResultArm = function* (m, { idOf, cards, panel }) {
         });
     }
 };
-const TERMINAL_TICK_STATUSES = new Set(['completed', 'failed']);
 const taskProgressArm = function* (m, { ctx, cards, panel, inst }) {
     const taskIdRaw = m.taskId;
     const taskId = typeof taskIdRaw === 'string' ? taskIdRaw : undefined;
@@ -661,9 +664,9 @@ const taskProgressArm = function* (m, { ctx, cards, panel, inst }) {
             totalTokens: typeof usage.totalTokens === 'number' ? usage.totalTokens : 0,
         },
     });
-    if (typeof m.status === 'string' && TERMINAL_TICK_STATUSES.has(m.status) && !panel.isLiveBound(taskId)) {
+    if (isCoreTaskProgressTerminal(m.status) && !panel.isLiveBound(taskId)) {
         ctx.probe?.('tick', JSON.stringify({ t: ctx.now(), taskId, lane: 'foreground', settle: m.status }));
-        yield* panel.settleFromTerminalTick(taskId, m.status === 'failed');
+        yield* panel.settleFromTerminalTick(taskId, isCoreTaskProgressTerminalNotSuccess(m.status));
     }
 };
 const streamEventArm = function* (m, { text }) {
@@ -766,7 +769,7 @@ const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
         return;
     const taskId = fields.taskId;
     const rawStatus = fields.status;
-    const terminal = isTerminalStatus(rawStatus);
+    const terminal = isCoreTaskNotificationTerminal(rawStatus);
     const settleAllowed = n.task_type === undefined || n.task_type === 'background_bash' || n.task_type === 'monitor';
     if (settleAllowed && terminal) {
         yield chrome({
@@ -798,7 +801,7 @@ const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
         });
         dropQueuedNotificationsForRun(taskId);
         if (n.task_type !== 'background_bash' && n.task_type !== 'monitor') {
-            yield* panel.settleFromNotification(taskId, rawStatus !== 'completed');
+            yield* panel.settleFromNotification(taskId, isCoreTaskNotificationTerminalNotSuccess(rawStatus));
         }
     }
     const peerFrame = classifyPeerNotification(n);
@@ -855,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/panelTasks.js

@@ -1,9 +1,9 @@
 import { clearEnginePanelTaskResident, clearEnginePanelTaskResidentByWire, markEnginePanelTaskResident } from '../engineAgentPanelStore.js';
+import { panelEndFact } from '../panelReduce.js';
 import { chrome, mainLane } from './ids.js';
 import { SUBAGENT_TOOL_NAMES } from './wireShapes.js';
 export function createPanelTaskLedger(ctx, cards, inst) {
     const taskCardBinding = new Map();
-    const boundToolCalls = new Set();
     const livePanelTasks = new Set();
     const endedPanelTasks = new Set();
     const liveBoundPanelTasks = new Set();
@@ -33,7 +33,6 @@ export function createPanelTaskLedger(ctx, cards, inst) {
                 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=explicit`);
@@ -85,12 +84,7 @@ export function createPanelTaskLedger(ctx, cards, inst) {
                 yield chrome({
                     kind: 'panel_task',
                     laneProof: mintLane(),
-                    event: {
-                        kind: 'end',
-                        taskId,
-                        isError,
-                        ...(cardId !== null && report !== undefined ? { report } : {}),
-                    },
+                    event: panelEndFact(taskId, isError, cardId !== null && report !== undefined ? { report } : undefined),
                 });
             }
         },
@@ -102,7 +96,7 @@ export function createPanelTaskLedger(ctx, cards, inst) {
             yield chrome({
                 kind: 'panel_task',
                 laneProof: mainLane(),
-                event: { kind: 'end', taskId, isError },
+                event: panelEndFact(taskId, isError),
             });
             if (inst.hasFiredSubagentStart(taskId)) {
                 yield chrome({
@@ -144,7 +138,7 @@ export function createPanelTaskLedger(ctx, cards, inst) {
             yield chrome({
                 kind: 'panel_task',
                 laneProof: mintLane(),
-                event: { kind: 'end', taskId, isError },
+                event: panelEndFact(taskId, isError),
             });
         },
     };

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 {
@@ -34,15 +46,15 @@ export function createToolCardLedger(ctx, idOf) {
     let lastLiveTodos = [];
     function* buildToolResult(p, end) {
         const isError = end?.isError ?? false;
+        const parentToolCallId = end?.parentToolCallId ?? p.parentToolCallId;
         if ((p.name === 'Bash' || p.name === 'Monitor') && !isError) {
             const outputText = end?.output !== undefined ? flattenWireOutput(end.output) : undefined;
             const reg = detectEngineBgShellDetach(p.name, p.rawInput, end?.structured, outputText) ??
                 detectEngineBgShellReceipt(p.name, p.rawInput, outputText, end?.structured);
             if (reg !== null) {
-                yield chrome({ kind: 'bgshell_register', laneProof: mainLane(), taskId: reg.taskId, registration: reg });
+                yield chrome({ kind: 'bgshell_register', laneProof: parentToolCallId === undefined ? mainLane() : { lane: 'subagent', parentToolCallId }, taskId: reg.taskId, registration: reg });
             }
         }
-        const parentToolCallId = end?.parentToolCallId ?? p.parentToolCallId;
         const outcome = toolResultOutcomeOf(p.name, end, p.rawInput, parentToolCallId === undefined ? 'leader' : 'subagent', (err) => {
             if (p.name !== 'TodoWrite')
                 return null;
@@ -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,4 +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']);
@@ -23,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();
@@ -47,14 +34,8 @@ export function shortTaskLabel(task) {
     return label || 'subagent';
 }
 export function sanitizeToolUseBlock(block) {
-    const out = { ...block };
-    const rawInput = out.input;
-    const eventId = typeof out.eventId === 'string' ? out.eventId : undefined;
-    const parentToolCallId = typeof out.parentToolCallId === 'string' ? out.parentToolCallId : undefined;
-    const label = typeof out.label === 'string' ? out.label : undefined;
-    delete out.label;
-    delete out.eventId;
-    delete out.parentToolCallId;
+    const rawInput = block.input;
+    const { block: out, eventId, parentToolCallId, label } = stripToolUseSideChannels(block);
     if (out.input && typeof out.input === 'object') {
         const cleaned = {};
         for (const [k, val] of Object.entries(out.input)) {

package/dist/adapter/activeRunSelfHeal.d.ts

@@ -1,15 +1,19 @@
 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;
 export declare const PLAN_REVIEW_STATES: readonly string[];
 export declare const ASK_PARK_STATES: readonly string[];
 export declare const RUNNING_STATES: readonly string[];
-export declare const CLAIM_RELEASED_STATES: readonly string[];
 export declare const CLAIM_HELD_STATES: readonly string[];
 export interface DurableRunRecordView {
     readonly status?: unknown;
@@ -47,6 +51,7 @@ export interface RunningChoiceRequest {
     status: string;
     canSteer: boolean;
     canCancel: boolean;
+    canAttach?: true;
 }
 export interface StaleParkChoiceRequest {
     taskId: string;
@@ -62,7 +67,8 @@ export interface ActiveRunSelfHealDeps {
         trigger?: PlanReviewReopenTrigger;
     }) => ReopenCardVerdict | Promise<ReopenCardVerdict>;
     reopenAskPark?: (taskId: string) => Promise<ReopenCardVerdict>;
-    offerRunningChoice?: (req: RunningChoiceRequest) => Promise<'steer' | 'cancel' | 'wait'>;
+    offerRunningChoice?: (req: RunningChoiceRequest) => Promise<'steer' | 'cancel' | 'wait' | 'attach'>;
+    canAttachRunning?: boolean;
     offerStaleParkChoice?: (req: StaleParkChoiceRequest) => Promise<'cancel' | 'wait'>;
     deniedMessage?: string;
     signal?: AbortSignal;
@@ -134,6 +140,9 @@ export type SelfHealOutcome = {
     taskId: string;
     detail: string;
     delivery: 'rejected' | 'unknown';
+} | {
+    kind: 'running-attach';
+    taskId: string;
 } | {
     kind: 'running-cancelled';
     taskId: string;
@@ -191,7 +200,7 @@ export interface SelfHealFollowDeclaration {
     following?: boolean;
 }
 export declare function readCancelRequested(body: unknown): boolean | undefined;
-export declare function atMostOnceFailureClass(e: unknown): 'rejected' | 'unknown';
+export { atMostOnceFailureClass };
 export declare function clearRunningChoiceOffer(taskId: string, sessionId?: string): void;
 export declare function __resetRunningChoiceLedgerForTests(): void;
 export interface ClaimReleaseVerdict {

package/dist/adapter/activeRunSelfHeal.js

@@ -1,19 +1,47 @@
 import { abortableSleep } from '../abortableSleep.js';
 import { corruptStoredRowContent, corruptStoredRowWhere, effectiveWireErrorCode } from '../wireErrorTriage.js';
-import { steerBodyOf, steeringRefusedBeforeEngine, steeringStatusIs4xx, UNOBSERVED_STEER_PRIORITY } from '../controlRouter.js';
+import { steerBodyOf, UNOBSERVED_STEER_PRIORITY } from '../controlRouter.js';
+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';
 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 = ['human', 'irreversible_ask'];
+const PLAN_LEG_GATE_KINDS = ['plan_review'];
+const CORE_GATE_KINDS = ['human', 'irreversible_ask', 'resource_limit', 'needs_review', 'plan_review', 'task_done'];
+const _durableDecideLegPins = [true, true, true, true, true, true];
+void _durableDecideLegPins;
+export const PLAN_REVIEW_GATE_KINDS = Object.freeze([...PLAN_LEG_GATE_KINDS]);
+export const ASK_PARK_GATE_KINDS = Object.freeze([...APPROVAL_LEG_GATE_KINDS]);
+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']);
 export const RUNNING_STATES = Object.freeze(['running']);
-export const CLAIM_RELEASED_STATES = Object.freeze(['completed', 'failed', 'blocked', 'timeout']);
-export const CLAIM_HELD_STATES = Object.freeze(['running', 'suspended', 'needs_review']);
+export const CLAIM_HELD_STATES = Object.freeze(['running', ...SDK_PARKED_RUN_STATUSES]);
 export function selfHealSubmissionDisposition(outcome) {
     switch (outcome.kind) {
         case 'decision-pending':
@@ -29,6 +57,8 @@ export function selfHealSubmissionDisposition(outcome) {
             return 'not-delivered';
         case 'running-steered':
             return 'handed-off';
+        case 'running-attach':
+            return 'not-delivered';
         default:
             return 'not-delivered';
     }
@@ -261,11 +291,7 @@ function reopenedOfOutcome(outcome) {
         return null;
     }
 }
-export function atMostOnceFailureClass(e) {
-    if (typeof e === 'object' && e !== null && steeringStatusIs4xx(e))
-        return 'rejected';
-    return typeof e === 'object' && e !== null && steeringRefusedBeforeEngine(e) !== undefined ? 'rejected' : 'unknown';
-}
+export { atMostOnceFailureClass };
 const CANCEL_RELEASE_WAIT_MS = 10_000;
 const RUNNING_LIVENESS_RECHECK_TIMEOUT_MS = 4_000;
 const runningChoiceDeclined = new Set();
@@ -365,7 +391,7 @@ export async function waitForClaimRelease(taskId, deps) {
         if (holder === 'released') {
             return { released: true, waitedMs: waited(), aborted: false, lastStatus: status, lastHolder: holder };
         }
-        if (status !== null && CLAIM_RELEASED_STATES.includes(status)) {
+        if (isSdkRunTerminal(status)) {
             return { released: true, waitedMs: waited(), aborted: false, lastStatus: status, lastHolder: holder };
         }
     }
@@ -698,7 +724,8 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
     const text = typeof deps?.deniedMessage === 'string' ? deps.deniedMessage : '';
     const canSteer = typeof runs?.steer === 'function' && text.length > 0;
     const canCancel = typeof runs?.cancel === 'function' && typeof runs?.get === 'function';
-    if (!canSteer && !canCancel)
+    const canAttach = runningAttachOffered(deps?.canAttachRunning);
+    if (!canSteer && !canCancel && !canAttach)
         return notParked;
     if (injected && !canSteer)
         return notParked;
@@ -715,7 +742,7 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
                 return planReviewArm(taskId, busy, deps);
             if (ASK_PARK_STATES.includes(fresh))
                 return askParkArm(taskId, busy, runs, deps);
-            if (CLAIM_RELEASED_STATES.includes(fresh))
+            if (isSdkRunTerminal(fresh))
                 return { kind: 'running-settled', taskId, status: fresh };
             return { kind: 'not-parked', taskId, status: fresh };
         }
@@ -733,7 +760,7 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
     }
     else if (typeof offer === 'function') {
         try {
-            choice = (await offer({ taskId, status, canSteer, canCancel })) ?? 'wait';
+            choice = (await offer({ taskId, status, canSteer, canCancel, ...(canAttach ? { canAttach: true } : {}) })) ?? 'wait';
             offerDelivered = true;
         }
         catch {
@@ -783,6 +810,8 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
             confirmedHeld: verdict.confirmedHeld,
         };
     }
+    if (choice === 'attach' && canAttach)
+        return { kind: 'running-attach', taskId };
     return notParked;
 }
 export const INTERACTIVE_WAY_OUT = 'run /clear to keep working in a fresh session';
@@ -841,6 +870,9 @@ const NO_CARD_VIEW_ATTACHED = 'this session has no view attached that can show d
 function injectedSubmissionRow(outcome, following = false) {
     const lead = INJECTED_LEAD;
     const id = 'taskId' in outcome && outcome.taskId ? ` (id ${outcome.taskId})` : '';
+    if (outcome.kind === 'running-attach') {
+        return `${lead} was not delivered: you chose to watch the reply already in progress${id} instead, and sema is replaying that reply here, so the part already shown above will appear again below. sema did not retry, so the model has not seen it.`;
+    }
     if (outcome.kind === 'running-steer-failed') {
         return outcome.delivery === 'unknown'
             ? `${lead} was passed to the reply already in progress${id}, but its delivery could not be confirmed ` +
@@ -1057,6 +1089,8 @@ function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false, ke
                 `to it (${outcome.detail}). A steer is not safe to send twice, so sema did NOT retry it, and it did NOT ` +
                 `cancel that run. That run may or may not have received your message — watch what it does next ` +
                 `before sending it again.`);
+        case 'running-attach':
+            return (`${resumeAttachReplayDisclosure(outcome.taskId)} Your message was NOT sent; send it again once that run has finished.`);
         case 'running-cancelled':
             return outcome.releaseConfirmedByEngine === true
                 ? `You chose to cancel run ${outcome.taskId}. The engine confirmed it is no longer holding this session, ` +

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -5,8 +5,10 @@ import { ccToolDenialKindForToolEnd, gateOutcomeOf } from '../../gateOutcome.js'
 import { projectToolRoster, projectToolRosterDelta } from '../../toolRoster.js';
 import { projectHandsSection } from '../../handsSeam.js';
 import { readMcpLiveness } from '../../mcpLiveness.js';
-import { SEGMENT_END_IDENTITY_KEYS } from '../types.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';
 function armBody(body) {
     return body;
 }
@@ -38,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;
@@ -51,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) {
@@ -104,13 +107,13 @@ export function eventToSdkMessage(ev, ctx) {
             if (typeof ev.runId !== 'string' || ev.runId.length === 0) {
                 return dropped('malformed', 'workflow_complete');
             }
-            if (ev.status !== 'completed' && ev.status !== 'failed') {
+            if (!isCoreWorkflowRunTerminal(ev.status)) {
                 return dropped('malformed', 'workflow_complete');
             }
             return projected(stamp(ctx, armBody({
                 type: 'workflow_complete',
                 runId: ev.runId,
-                status: ev.status === 'failed' ? 'failed' : 'completed',
+                status: ev.status,
                 summary: typeof ev.summary === 'string' ? ev.summary : '',
             })));
         }
@@ -126,20 +129,21 @@ export function eventToSdkMessage(ev, ctx) {
                 delta: ev.delta,
                 ...(ev.parentToolCallId !== undefined ? { parentToolCallId: ev.parentToolCallId } : {}),
             }));
-        case 'tool_start':
-            return projected(assistantArm(ctx, [
-                {
-                    type: 'tool_use',
-                    id: ev.toolCallId,
-                    name: ev.toolName,
-                    input: ev.args,
-                    ...(typeof ev.label === 'string' && ev.label.length > 0 ? { label: ev.label } : {}),
-                    ...(ev.eventId !== undefined ? { eventId: ev.eventId } : {}),
-                    ...(ev.parentToolCallId !== undefined
-                        ? { parentToolCallId: ev.parentToolCallId }
-                        : {}),
-                },
-            ], ev.eventId, ev.parentToolCallId));
+        case 'tool_start': {
+            const toolUse = {
+                type: 'tool_use',
+                id: ev.toolCallId,
+                name: ev.toolName,
+                input: ev.args,
+                ...(typeof ev.label === 'string' && ev.label.length > 0 ? { label: ev.label } : {}),
+                ...(ev.eventId !== undefined ? { eventId: ev.eventId } : {}),
+                ...(ev.parentToolCallId !== undefined
+                    ? { parentToolCallId: ev.parentToolCallId }
+                    : {}),
+            };
+            const outBlock = ctx.lane === 'print' ? stripToolUseSideChannels(toolUse).block : toolUse;
+            return projected(assistantArm(ctx, [outBlock], ev.eventId, ev.parentToolCallId, readFrameTrueMark(ev, 'recovered')));
+        }
         case 'compacted': {
             const raw = ev;
             const freedTokens = typeof raw.freedTokens === 'number' && Number.isFinite(raw.freedTokens) && raw.freedTokens >= 0 ? raw.freedTokens : undefined;
@@ -175,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,
@@ -197,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 }
@@ -214,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,
@@ -227,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 } : {}),
             })));
@@ -470,12 +481,15 @@ export function projectMcpSection(raw) {
     if (!Array.isArray(raw))
         return undefined;
     const rows = [];
+    const droppedNamed = new Map();
     for (const e of raw) {
         if (typeof e !== 'object' || e === null || Array.isArray(e))
             continue;
         const r = e;
         const name = typeof r.name === 'string' && r.name.length > 0 ? r.name : undefined;
         const status = typeof r.status === 'string' && r.status.length > 0 ? r.status : undefined;
+        if (name !== undefined && status === undefined)
+            droppedNamed.set(name, (droppedNamed.get(name) ?? 0) + 1);
         if (name === undefined || status === undefined)
             continue;
         rows.push({
@@ -491,6 +505,7 @@ export function projectMcpSection(raw) {
     }
     if (raw.length > 0 && rows.length === 0)
         return undefined;
+    markMcpSectionDroppedNamedRows(rows, droppedNamed);
     return rows;
 }
 function projectModelGateSection(raw) {