@sema-agent/client-core 0.97.0 → 0.98.0

package/dist/adapt/textStream.js

@@ -1,4 +1,4 @@
-import { chrome, mainLane, transcript, messageIdentityOf } from './ids.js';
+import { chrome, mainLane, segmentRowId, transcript, messageIdentityOf } from './ids.js';
 import { estimateCjkTokens, FLUSH_INTERVAL_MS } from './wireShapes.js';
 import { resolveTextSegmentAuthority } from './textSegmentAuthority.js';
 export const SEMA_SEGMENT_ID_KEY = '_sema_segment_id';
@@ -44,14 +44,15 @@ export function createTextStream(ctx, idOf) {
         : FLUSH_INTERVAL_MS;
     let segmentAnchor = null;
     let thinkingAnchor = null;
+    let segmentLast = null;
+    let thinkingLast = null;
     let committedThinking = [];
     let thinkingSettled = false;
     let segmentWindowAnchor = null;
-    let segmentWindowSerial = 0;
     let segmentIdCache = null;
     const segmentIdNow = () => {
         if (segmentIdCache === null)
-            segmentIdCache = idOf(segmentWindowAnchor ?? {}, `segment${segmentWindowSerial}`);
+            segmentIdCache = idOf(segmentWindowAnchor ?? {}, 'segment');
         return segmentIdCache;
     };
     function* takeThinking() {
@@ -61,7 +62,7 @@ export function createTextStream(ctx, idOf) {
         const msg = {
             type: 'assistant',
             message: { role: 'assistant', content: [{ type: 'thinking', thinking }], ...messageIdentityOf(anchor, ctx) },
-            uuid: idOf(anchor, 'thinking'),
+            uuid: segmentRowId(idOf, anchor, thinkingLast, 'thinking'),
             session_id: ctx.sessionId,
             parent_tool_use_id: null,
         };
@@ -70,6 +71,7 @@ export function createTextStream(ctx, idOf) {
         thinkingSettled = false;
         thinking = '';
         thinkingAnchor = null;
+        thinkingLast = null;
         thinkingBlockOpen = false;
         yield chrome({ kind: 'thinking_activity', laneProof: mainLane(), active: false });
         yield transcript(msg, ctx.now());
@@ -82,7 +84,7 @@ export function createTextStream(ctx, idOf) {
         const msg = {
             type: 'assistant',
             message: { role: 'assistant', content: [{ type: 'text', text: body }], ...messageIdentityOf(anchor, ctx) },
-            uuid: idOf(anchor, 'text'),
+            uuid: segmentRowId(idOf, anchor, segmentLast, 'text'),
             session_id: ctx.sessionId,
             parent_tool_use_id: null,
         };
@@ -94,6 +96,7 @@ export function createTextStream(ctx, idOf) {
         segmentSealed = '';
         answerSegment = '';
         segmentAnchor = null;
+        segmentLast = null;
         emittedAssistantText = true;
         textBlockOpen = false;
         yield transcript(msg, ctx.now());
@@ -158,6 +161,7 @@ export function createTextStream(ctx, idOf) {
             }
             if (answerSegment.length === 0 && segmentSealed.length === 0)
                 segmentAnchor = frame;
+            segmentLast = frame;
             if (segmentWindowAnchor === null)
                 segmentWindowAnchor = frame;
             answer += delta;
@@ -176,6 +180,7 @@ export function createTextStream(ctx, idOf) {
                     thinkingSettled = false;
                 }
             }
+            thinkingLast = frame;
             if (thinking.length === 0) {
                 thinkingAnchor = frame;
                 yield chrome({ kind: 'thinking_activity', laneProof: mainLane(), active: true });
@@ -283,6 +288,8 @@ export function createTextStream(ctx, idOf) {
             }
             else {
                 segmentSealed += verdict.tail;
+                if (diverged && anchor !== undefined)
+                    segmentLast = anchor;
             }
             answerSegment = '';
             if (answer.endsWith(liveSegment)) {
@@ -290,6 +297,8 @@ export function createTextStream(ctx, idOf) {
             }
             if (segmentAnchor === null && anchor !== undefined)
                 segmentAnchor = anchor;
+            if (segmentLast === null && anchor !== undefined)
+                segmentLast = anchor;
             segmentCommitted = '';
             previousSegmentCommitted = '';
             idleFlushUsedInSegment = false;
@@ -314,7 +323,7 @@ export function createTextStream(ctx, idOf) {
             if (typeof committed === 'string')
                 committedText += committed;
         },
-        replaceThinkingSegment: (content) => {
+        replaceThinkingSegment: (content, anchor) => {
             const rows = committedThinking;
             committedThinking = [];
             const prefix = rows.map((r) => r.text).join('');
@@ -330,6 +339,8 @@ export function createTextStream(ctx, idOf) {
                 thinkingPending = content.startsWith(emitted) ? content.slice(emitted.length) : '';
                 thinking = content;
                 thinkingSettled = content.length > 0;
+                if (diverged && anchor !== undefined)
+                    thinkingLast = anchor;
                 return { diverged, committedPrefixLen: 0, committedPrefixDiverged: false, committedUuids: [] };
             }
             const committedPrefixDiverged = !content.startsWith(prefix);
@@ -340,19 +351,25 @@ export function createTextStream(ctx, idOf) {
                     thinkingPending = tail.startsWith(emitted) ? tail.slice(emitted.length) : '';
                     thinking = tail;
                     thinkingSettled = tail.length > 0;
+                    if (diverged && anchor !== undefined)
+                        thinkingLast = anchor;
                 }
                 return { diverged, committedPrefixLen: prefix.length, committedPrefixDiverged: false, ...(last !== undefined ? { committedUuid: last } : {}), committedUuids: uuids };
             }
             thinking = '';
             thinkingPending = '';
             thinkingAnchor = null;
+            thinkingLast = null;
             thinkingSettled = false;
             return { diverged: true, committedPrefixLen: prefix.length, committedPrefixDiverged: true, ...(last !== undefined ? { committedUuid: last } : {}), committedUuids: uuids };
         },
         segmentId: segmentIdNow,
+        anchorWindow: (frame) => {
+            if (segmentWindowAnchor === null)
+                segmentWindowAnchor = frame;
+        },
         rotateSegmentIdentity: (anchor) => {
             committedTextRows = [];
-            segmentWindowSerial += 1;
             segmentWindowAnchor = anchor;
             segmentIdCache = null;
         },

package/dist/adapt/toolCards.d.ts

@@ -1,25 +1,44 @@
 import type { AdapterContext, AdapterOutput } from '../seam.js';
-import { structuredToToolUseResult, type ToolResultBody } from '../toolResult.js';
+import { structuredToToolUseResult, type ToolKillCause, type ToolResultBody } from '../toolResult.js';
 import { type Frame, type IdOf } from './ids.js';
+import type { EngineRowRef } from '../engineRowRef.js';
+import { type GateOutcomeView } from '../gateOutcome.js';
 type RichToolUseResult = NonNullable<ReturnType<typeof structuredToToolUseResult>>;
 export interface ToolResultOutcome {
     readonly body: ToolResultBody;
     readonly rich: RichToolUseResult | null;
 }
 export type ToolResultOwner = 'leader' | 'subagent';
-export declare function toolResultOutcomeOf(toolName: string, end: ToolEndPayload | undefined, rawInput: PendingToolUse['rawInput'], owner: ToolResultOwner, ledgerTier?: (isError: boolean) => RichToolUseResult | null): ToolResultOutcome;
+export declare function toolResultOutcomeOf(toolName: string, end: ToolEndPayload | undefined, rawInput: PendingToolUse['rawInput'], owner: ToolResultOwner, ledgerTier?: (isError: boolean) => RichToolUseResult | null, killCauseOf?: () => ToolKillCause | undefined): ToolResultOutcome;
 export interface ToolResultEnvelopeKeys {
     readonly tool_use_result?: ToolResultBody['toolUseResult'];
     readonly _sema_degraded?: ToolResultBody['degraded'];
 }
 export declare function toolResultEnvelopeParts(o: ToolResultOutcome): ToolResultEnvelopeKeys;
-interface PendingToolUse {
+export interface PendingToolUse {
     id: string;
     name: string;
-    rawInput: unknown;
+    rawInput: {} | null | undefined;
     eventId?: string;
     parentToolCallId?: string;
+    engineRef?: EngineRowRef | undefined;
+    rowUuid?: string | undefined;
 }
+export declare function toolResultRowIdentity(sources: readonly {
+    readonly eventId?: string | undefined;
+    readonly engineRef?: EngineRowRef | undefined;
+}[], toolCallId: string, ctx: Pick<AdapterContext, 'uuid'>): {
+    readonly uuid: string;
+    readonly engineRef?: EngineRowRef;
+};
+export interface ToolResultRowFlagParts {
+    readonly _sema_not_executed?: true;
+    readonly _sema_collateral_abort?: true;
+    readonly _sema_interrupted_never_started?: true;
+    readonly _sema_approval_window_expired?: true;
+    readonly _sema_denial_limit_window_expired?: true;
+}
+export declare function toolResultRowFlagParts(arm: object | null | undefined): ToolResultRowFlagParts;
 interface ToolEndPayload {
     output?: unknown;
     structured?: unknown;
@@ -28,7 +47,9 @@ interface ToolEndPayload {
     eventId?: string | undefined;
     parentToolCallId?: string | undefined;
     denialKind?: string | undefined;
-    notExecuted?: boolean | undefined;
+    closeArm?: object | undefined;
+    engineRef?: EngineRowRef | undefined;
+    gate?: GateOutcomeView | undefined;
 }
 export interface OpenCardView {
     has(id: string): boolean;
@@ -37,6 +58,7 @@ export interface OpenCardView {
 }
 export interface ToolCardLedger extends OpenCardView {
     open(p: PendingToolUse): void;
+    detach(id: string): PendingToolUse | undefined;
     close(p: PendingToolUse, end?: ToolEndPayload): Generator<AdapterOutput>;
     sweep(): Generator<AdapterOutput>;
     mintResponseId(frame: Frame): string;

package/dist/adapt/toolCards.js

@@ -5,14 +5,17 @@ import { flattenWireOutput } from './wireShapes.js';
 import { toolResultBlocksOf } from '../toolResultContent.js';
 import { bashExitOf, bashExitReadingFailed } from '../bashExitReading.js';
 import { isCcToolDenialKind } from '../gateVocabulary.js';
+import { guardedRead, readFrameStringKey, readFrameTrueMark } from '../ownKey.js';
+import { gateOutcomeOf, isApprovalWindowExpiredGate, isDenialLimitAutoDeniedGate } from '../gateOutcome.js';
+import { TOOL_END_INTERRUPTED_NEVER_STARTED } from '../engineErrorCodes.js';
 function toolUseResultParts(v) {
     return v !== undefined ? { tool_use_result: v } : {};
 }
-export function toolResultOutcomeOf(toolName, end, rawInput, owner, ledgerTier) {
+export function toolResultOutcomeOf(toolName, end, rawInput, owner, ledgerTier, killCauseOf) {
     const isError = end?.isError ?? false;
     const leaderLedger = owner === 'leader';
     const body = end && end.output !== undefined
-        ? wireOutputToBody(toolName, end.output, isError, end.truncated === true, flattenWireOutput, end.structured, leaderLedger)
+        ? wireOutputToBody(toolName, end.output, isError, end.truncated === true, flattenWireOutput, end.structured, leaderLedger, killCauseOf)
         : degradedToolResultBody(isError);
     let rich = end?.structured !== undefined
         ? structuredToToolUseResult(end.structured, end.output !== undefined ? flattenWireOutput(end.output) : undefined, leaderLedger)
@@ -40,6 +43,27 @@ export function toolResultEnvelopeParts(o) {
         ...(o.body.degraded !== undefined ? { _sema_degraded: o.body.degraded } : {}),
     };
 }
+export function toolResultRowIdentity(sources, toolCallId, ctx) {
+    for (const src of sources) {
+        if (typeof src.eventId === 'string' && src.eventId.length > 0) {
+            const ref = src.engineRef;
+            return { uuid: src.eventId, ...(ref !== undefined && ref.eventId === src.eventId ? { engineRef: ref } : {}) };
+        }
+    }
+    return { uuid: deriveTranscriptId({ toolCallId }, ctx) };
+}
+export function toolResultRowFlagParts(arm) {
+    if (arm === null || arm === undefined)
+        return {};
+    const gate = guardedRead(() => gateOutcomeOf(arm));
+    return {
+        ...(readFrameTrueMark(arm, 'notExecuted') ? { _sema_not_executed: true } : {}),
+        ...(readFrameTrueMark(arm, '_sema_collateral_abort') ? { _sema_collateral_abort: true } : {}),
+        ...(readFrameStringKey(arm, 'errorCode') === TOOL_END_INTERRUPTED_NEVER_STARTED ? { _sema_interrupted_never_started: true } : {}),
+        ...(isApprovalWindowExpiredGate(gate) ? { _sema_approval_window_expired: true } : {}),
+        ...(isDenialLimitAutoDeniedGate(gate) ? { _sema_denial_limit_window_expired: true } : {}),
+    };
+}
 export function createToolCardLedger(ctx, idOf) {
     const pending = new Map();
     let assistantResponseId = null;
@@ -63,9 +87,9 @@ export function createToolCardLedger(ctx, idOf) {
                 return null;
             lastLiveTodos = todo.newTodos;
             return { toolUseResult: todo.toolUseResult, isError: todo.isError };
-        });
+        }, () => ctx.toolKillCause?.({ toolCallId: p.id, toolName: p.name }));
         const { body } = outcome;
-        const eventId = end?.eventId ?? p.eventId;
+        const ident = toolResultRowIdentity([{ eventId: end?.eventId, engineRef: end?.engineRef }, { eventId: p.eventId, engineRef: p.engineRef }], p.id, ctx);
         yield transcript({
             type: 'user',
             message: {
@@ -79,12 +103,13 @@ export function createToolCardLedger(ctx, idOf) {
                     },
                 ],
             },
-            uuid: eventId ?? deriveTranscriptId({ toolCallId: p.id }, ctx),
+            uuid: idOf.adopt(ident.uuid, ident.engineRef),
             session_id: ctx.sessionId,
             ...(parentToolCallId !== undefined ? { parent_tool_use_id: parentToolCallId } : {}),
             ...toolResultEnvelopeParts(outcome),
             ...(isCcToolDenialKind(end?.denialKind) ? { _sema_denial_kind: end.denialKind } : {}),
-            ...(end?.notExecuted === true ? { _sema_not_executed: true } : {}),
+            ...(end?.gate !== undefined ? { _sema_gate: end.gate } : {}),
+            ...toolResultRowFlagParts(end?.closeArm),
         }, ctx.now());
     }
     function* closeCard(p, end) {
@@ -99,6 +124,14 @@ export function createToolCardLedger(ctx, idOf) {
         open: (p) => {
             pending.set(p.id, p);
         },
+        detach: (id) => {
+            const p = pending.get(id);
+            if (p === undefined)
+                return undefined;
+            pending.delete(id);
+            assistantResponseId = null;
+            return p;
+        },
         close: closeCard,
         *sweep() {
             for (const [, p] of pending) {

package/dist/adapt/wireShapes.js

@@ -1,8 +1,13 @@
 import { frozenSet } from '../frozenSet.js';
+import { CORE_BUILTIN_SUBAGENT_TYPES } from '../generated/engineFactTables.js';
 import { stripToolUseSideChannels } from '../adapter/types.js';
 import { toolEndOutputText } from '../toolResultContent.js';
 export const FLUSH_INTERVAL_MS = 100;
 export const IDLE_FLUSH_MS = 1500;
+const SHELL_ROLE_SUBAGENT_TYPE = 'worker';
+function isHonouredSubagentType(word) {
+    return word === SHELL_ROLE_SUBAGENT_TYPE || CORE_BUILTIN_SUBAGENT_TYPES.includes(word);
+}
 export const SUBAGENT_TOOL_NAMES = frozenSet(['Task', 'Agent', 'Fork']);
 export const WORKFLOW_TOOL_NAMES = frozenSet(['Workflow', 'RunWorkflow', 'run_workflow']);
 export const TASK_TOOL_NAMES = new Set(['TodoWrite', 'TaskCreate', 'TaskUpdate']);
@@ -61,8 +66,7 @@ export function sanitizeToolUseBlock(block) {
     }
     if (SUBAGENT_TOOL_NAMES.has(out.name) && out.input && typeof out.input === 'object') {
         const inp = out.input;
-        if (typeof inp.subagent_type === 'string' &&
-            !['fork', 'general-purpose', 'worker'].includes(inp.subagent_type)) {
+        if (typeof inp.subagent_type === 'string' && !isHonouredSubagentType(inp.subagent_type)) {
             delete inp.subagent_type;
         }
     }

package/dist/adapt.d.ts

@@ -1,10 +1,12 @@
 import type { AdapterContext, AdapterOutput, WireToCcAdapter } from './seam.js';
 export { CANCEL_MESSAGE, estimateCjkTokens, flattenWireOutput, FLUSH_INTERVAL_MS, IDLE_FLUSH_MS, REJECT_MESSAGE, sanitizeToolUseBlock, SUBAGENT_TOOL_NAMES, WORKFLOW_TOOL_NAMES, } from './adapt/wireShapes.js';
+import { type ParkedToolRowSnapshot } from './adapt/instanceLedger.js';
 export interface AdapterLedgerState {
     version: 1;
     renderedNotifications: string[];
     notifiedRuns: string[];
     cardEnqueuedRuns: string[];
+    parkedToolRows?: ParkedToolRowSnapshot[];
 }
 export declare const ADAPTER_COVERAGE: {
     readonly frames: readonly ["assistant", "user", "stream_event", "turn_usage", "result", "system", "task_notification", "workflow_complete", "diagnostics", "steering_injected", "workspace_changed", "human_input", "message_committed", "engine_notice", "text_end", "prompt_suggestions", "retry_status", "task_progress", "tool_end_result(label 补位 + 关卡 settle + response-id 复位 + 开卡台账出栈 + 经 cards.close 铸 tool_result)"];

package/dist/adapt.js

@@ -1,7 +1,7 @@
 import { isEngineWorkflowNotified, isWorkflowCompletionCardEnqueued, listNotifiedRuns, listWorkflowCompletionCardsEnqueued, markEngineWorkflowNotified, noteWorkflowCompletionCardEnqueued, parseTranscriptNotificationSeeds, } from './notifications.js';
 export { CANCEL_MESSAGE, estimateCjkTokens, flattenWireOutput, FLUSH_INTERVAL_MS, IDLE_FLUSH_MS, REJECT_MESSAGE, sanitizeToolUseBlock, SUBAGENT_TOOL_NAMES, WORKFLOW_TOOL_NAMES, } from './adapt/wireShapes.js';
 import { IDLE_FLUSH_MS } from './adapt/wireShapes.js';
-import { chrome, mainLane, makeIdOf } from './adapt/ids.js';
+import { carryRowSidecars, chrome, mainLane, makeIdOf } from './adapt/ids.js';
 import { createTextStream } from './adapt/textStream.js';
 import { createToolCardLedger } from './adapt/toolCards.js';
 import { createPanelTaskLedger } from './adapt/panelTasks.js';
@@ -122,6 +122,7 @@ class WireToCcAdapterImpl {
             renderedNotifications: this.ledger.listRenderedNotifications(),
             notifiedRuns: listNotifiedRuns(),
             cardEnqueuedRuns: listWorkflowCompletionCardsEnqueued(),
+            ...((rows) => (rows.length > 0 ? { parkedToolRows: rows } : {}))(this.ledger.listParkedToolRows()),
         };
     }
     importLedger(state) {
@@ -142,6 +143,7 @@ class WireToCcAdapterImpl {
             n += this.ledger.takeRenderedNotifications(rendered);
         takeModule(s.notifiedRuns, isEngineWorkflowNotified, markEngineWorkflowNotified);
         takeModule(s.cardEnqueuedRuns, isWorkflowCompletionCardEnqueued, noteWorkflowCompletionCardEnqueued);
+        n += this.ledger.takeParkedToolRows(s.parkedToolRows);
         return n;
     }
     importLedgerFromTranscript(messages) {
@@ -159,19 +161,22 @@ class WireToCcAdapterImpl {
     async *adapt(frames, ctx) {
         const slot = {};
         for await (const out of this.adaptUnstamped(frames, ctx, slot)) {
-            yield slot.text === undefined ? out : slot.text.stampSegmentIdentity(out);
+            const segmented = slot.text === undefined ? out : slot.text.stampSegmentIdentity(out);
+            yield slot.idOf === undefined ? segmented : carryRowSidecars(segmented, slot.idOf);
         }
     }
     async *adaptUnstamped(frames, ctx, slot) {
         const inst = this.ledger;
         const turnStartAt = ctx.now();
         const idOf = makeIdOf(ctx);
+        slot.idOf = idOf;
         const text = createTextStream(ctx, idOf);
         slot.text = text;
         const cards = createToolCardLedger(ctx, idOf);
         const panel = createPanelTaskLedger(ctx, cards, inst);
         const flags = createTurnFlags(ctx, turnStartAt);
-        const deps = { ctx, idOf, text, cards, panel, flags, inst };
+        const pass = inst.beginPass();
+        const deps = { ctx, idOf, text, cards, panel, flags, inst, pass };
         yield chrome({ kind: 'retry_status', laneProof: mainLane(), status: null });
         yield chrome({ kind: 'prompt_suggestions', laneProof: mainLane(), suggestions: null });
         yield chrome({ kind: 'thinking_activity', laneProof: mainLane(), active: false });

package/dist/adapter/activeRunSelfHeal.d.ts

@@ -99,6 +99,7 @@ export type SelfHealOutcome = {
     taskId: string;
     status: string;
     alreadyOffered?: true;
+    pendingGateKind?: string | null;
 } | {
     kind: 'running-not-found';
     taskId: string;
@@ -159,6 +160,10 @@ export type SelfHealOutcome = {
 } | {
     kind: 'ask-run-not-found';
     taskId: string;
+} | {
+    kind: 'ask-run-settled';
+    taskId: string;
+    status: string;
 } | {
     kind: 'stale-park-cancelled';
     taskId: string;

package/dist/adapter/activeRunSelfHeal.js

@@ -1,10 +1,11 @@
 import { abortableSleep } from '../abortableSleep.js';
 import { corruptStoredRowContent, corruptStoredRowWhere, effectiveWireErrorCode } from '../wireErrorTriage.js';
+import { readThrownStatusSlot } from '../wireFailureShape.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';
+import { isSdkRunParked, isSdkRunTerminal, SDK_RUN_LIVE_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';
 const APPROVAL_LEG_GATE_KINDS = SDK_APPROVAL_DECIDE_GATE_KINDS;
@@ -40,7 +41,7 @@ export function askParkForeignGateKind(row) {
 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_HELD_STATES = Object.freeze(['running', ...SDK_PARKED_RUN_STATUSES]);
+export const CLAIM_HELD_STATES = SDK_RUN_LIVE_STATUSES;
 export function selfHealSubmissionDisposition(outcome) {
     switch (outcome.kind) {
         case 'decision-pending':
@@ -76,16 +77,6 @@ function sessionOpts(deps) {
     const sessionId = deps?.sessionId;
     return typeof sessionId === 'string' && sessionId.length > 0 ? { session: sessionId } : {};
 }
-function errorSlot(e, key) {
-    if (e === null || e === undefined)
-        return undefined;
-    try {
-        return e[key];
-    }
-    catch {
-        return undefined;
-    }
-}
 function describeFailure(e) {
     const where = corruptStoredRowWhere(e);
     const rowNote = where === undefined ? '' : ` — ${corruptStoredRowContent(where)}`;
@@ -452,6 +443,7 @@ export async function attemptActiveRunSelfHeal(signal, runs, deps) {
     if (gateLeg === 'approval')
         return askParkArm(taskId, signal, runs, deps);
     let status = signal.activeTaskStatus;
+    const statusFresh = status === null;
     if (status === null) {
         if (typeof runs?.get !== 'function') {
             return { kind: 'state-unknown', taskId, detail: 'this client exposes no durable run verbs' };
@@ -468,8 +460,11 @@ export async function attemptActiveRunSelfHeal(signal, runs, deps) {
     if (status === null) {
         return { kind: 'state-unknown', taskId, detail: 'the engine reported no status for that run' };
     }
+    if (isSdkRunTerminal(status))
+        return { kind: 'running-settled', taskId, status };
+    const triageGate = signal.pendingGate && !statusFresh ? { pendingGateKind: signal.pendingGate.kind ?? null } : {};
     if (gateKind !== null)
-        return { kind: 'not-parked', taskId, status };
+        return { kind: 'not-parked', taskId, status, ...triageGate };
     if (PLAN_REVIEW_STATES.includes(status))
         return planReviewArm(taskId, signal, deps);
     if (ASK_PARK_STATES.includes(status))
@@ -477,7 +472,7 @@ export async function attemptActiveRunSelfHeal(signal, runs, deps) {
     if (RUNNING_STATES.includes(status)) {
         return runningChoiceArm(taskId, status, signal, signal.activeTaskStatus !== null, runs, deps);
     }
-    return { kind: 'not-parked', taskId, status };
+    return { kind: 'not-parked', taskId, status, ...triageGate };
 }
 async function planVerdict(taskId, deps) {
     try {
@@ -576,7 +571,7 @@ async function probeRunStatusOnce(taskId, durable, durableGet, deps) {
         answered = true;
     }
     catch (e) {
-        if (errorSlot(e, 'status') === 404)
+        if (typeof e === 'object' && e !== null && readThrownStatusSlot(e) === 404)
             ghost = true;
         else
             errorCode = failureWireCode(e);
@@ -619,6 +614,8 @@ async function staleParkArm(taskId, busy, runs, deps) {
         return runningChoiceArm(taskId, fresh, busy, false, runs, deps);
     if (PLAN_REVIEW_STATES.includes(fresh))
         return planReviewArm(taskId, busy, deps);
+    if (isSdkRunTerminal(fresh))
+        return { kind: 'ask-run-settled', taskId, status: fresh };
     if (!ASK_PARK_STATES.includes(fresh))
         return reopenFailed;
     const offer = deps?.offerStaleParkChoice;
@@ -656,6 +653,10 @@ async function staleParkArm(taskId, busy, runs, deps) {
     if (afterCard.status === null)
         return withFailureCode(reopenFailedAfterCard, afterCard.errorCode);
     if (!ASK_PARK_STATES.includes(afterCard.status)) {
+        if (isSdkRunTerminal(afterCard.status))
+            return { kind: 'ask-run-settled', taskId, status: afterCard.status };
+        if (RUNNING_STATES.includes(afterCard.status))
+            return { kind: 'not-parked', taskId, status: afterCard.status };
         return !CLAIM_HELD_STATES.includes(afterCard.status) ? reopenFailed : reopenFailedAfterCard;
     }
     const recheck = await readOwnedPendingCount(recheckOwnedPending, deps);
@@ -737,14 +738,10 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
             return { kind: 'running-not-found', taskId };
         if (probeCallerAborted())
             return notParked;
-        if (fresh !== null && !RUNNING_STATES.includes(fresh)) {
-            if (PLAN_REVIEW_STATES.includes(fresh))
-                return planReviewArm(taskId, busy, deps);
-            if (ASK_PARK_STATES.includes(fresh))
-                return askParkArm(taskId, busy, runs, deps);
-            if (isSdkRunTerminal(fresh))
-                return { kind: 'running-settled', taskId, status: fresh };
-            return { kind: 'not-parked', taskId, status: fresh };
+        if (fresh !== null) {
+            const routed = await routeFreshNonRunning(fresh, taskId, busy, runs, deps);
+            if (routed !== undefined)
+                return routed;
         }
     }
     const declineKey = runningChoiceDeclineKey(deps?.sessionId, taskId);
@@ -795,6 +792,16 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
         }
     }
     if (choice === 'cancel' && canCancel && runs?.cancel !== undefined && runs.get !== undefined) {
+        if (probeCallerAborted())
+            return notParked;
+        const preFire = await probeRunStatusOnce(taskId, runs, runs.get, deps);
+        if (preFire.ghost)
+            return { kind: 'running-not-found', taskId };
+        if (probeCallerAborted() || preFire.status === null)
+            return notParked;
+        const rerouted = await routeFreshNonRunning(preFire.status, taskId, busy, runs, deps);
+        if (rerouted !== undefined)
+            return rerouted;
         const verdict = await cancelAndConfirmRelease(taskId, runs, runs.get, deps);
         if (verdict.outcome === 'released') {
             return { kind: 'running-cancelled', taskId, ...(verdict.engineStatedRelease ? { releaseConfirmedByEngine: true } : {}) };
@@ -814,6 +821,17 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
         return { kind: 'running-attach', taskId };
     return notParked;
 }
+async function routeFreshNonRunning(fresh, taskId, busy, runs, deps) {
+    if (RUNNING_STATES.includes(fresh))
+        return undefined;
+    if (PLAN_REVIEW_STATES.includes(fresh))
+        return planReviewArm(taskId, busy, deps);
+    if (ASK_PARK_STATES.includes(fresh))
+        return askParkArm(taskId, busy, runs, deps);
+    if (isSdkRunTerminal(fresh))
+        return { kind: 'running-settled', taskId, status: fresh };
+    return { kind: 'not-parked', taskId, status: fresh };
+}
 export const INTERACTIVE_WAY_OUT = 'run /clear to keep working in a fresh session';
 const DEFAULT_WAY_OUT = INTERACTIVE_WAY_OUT;
 const DEFAULT_FRESH_SESSION = 'start a new session (drop --resume/--continue)';
@@ -853,11 +871,11 @@ export function activeRunSelfHealRow(outcome, signal, copy, origin, follow) {
         (outcome.kind !== 'plan-review-reopen-failed' || outcome.dismissedByUser !== true)
         ? keepSessionWayOutOf(copy)
         : null;
-    const base = activeRunSelfHealBaseRow(outcome, signal, copy?.wayOut ?? DEFAULT_WAY_OUT, following, keep, engineDecide);
+    const base = activeRunSelfHealBaseRow(outcome, copy?.wayOut ?? DEFAULT_WAY_OUT, following, keep, engineDecide);
     const viaEngine = engineDecide ? decidePathClause(signal) : '';
     switch (outcome.kind) {
         case 'not-parked':
-            return base + lastActivityClause(signal) + viaEngine + governanceOriginClause(signal);
+            return base + lastActivityClause(signal) + (outcome.pendingGateKind !== undefined ? viaEngine + governanceOriginClause(signal) : '');
         case 'state-unknown':
             return base + viaEngine + governanceOriginClause(signal);
         default:
@@ -961,7 +979,7 @@ function keepSessionWayOutOf(copy) {
         return null;
     }
 }
-function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false, keepSessionWayOut = null, engineDecide = true) {
+function activeRunSelfHealBaseRow(outcome, wayOut, following = false, keepSessionWayOut = null, engineDecide = true) {
     switch (outcome.kind) {
         case 'decision-pending':
             return (`This session is held by an earlier turn${outcome.taskId ? ` (run ${outcome.taskId})` : ''} that ` +
@@ -1129,6 +1147,10 @@ function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false, ke
                 `not-found — a lookup that cannot separate a run that is really gone from one this session is simply ` +
                 `not allowed to read. Either way sema has nothing it can act on here, so it did NOT cancel anything. ` +
                 `Your message was NOT sent; send it again (if the session really is free it will just run), or ${wayOut}.`);
+        case 'ask-run-settled':
+            return (`The previous turn was recorded as parked on a decision (run ${outcome.taskId}), but that run has already finished ` +
+                `(status ${outcome.status}) — there is nothing left to answer and nothing to cancel, so sema did NOT cancel anything. ` +
+                `Your message was NOT sent; send it again (once that run has let go of the session it will just run), or ${wayOut}.`);
         case 'stale-park-cancelled':
             if (outcome.releaseConfirmedByEngine === true) {
                 return (`Run ${outcome.taskId} was parked on an approval that no longer exists on the engine, so there was ` +
@@ -1196,9 +1218,10 @@ function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false, ke
                     `Your message was NOT sent; wait for that run, cancel it on the engine ` +
                     `(POST /v1/runs/${outcome.taskId}/cancel), or ${wayOut}.`);
             }
-            if (signal?.pendingGate) {
+            const parkedOn = outcome.pendingGateKind !== undefined ? gateKindPhrase(outcome.pendingGateKind) : isSdkRunParked(outcome.status) ? gateKindPhrase(null) : undefined;
+            if (parkedOn !== undefined) {
                 return (`This session is held by an earlier run (run ${outcome.taskId}, status ${outcome.status}) that is ` +
-                    `waiting on ${gateKindPhrase(signal.pendingGate.kind)} — it will not finish on its own. sema did ` +
+                    `waiting on ${parkedOn} — it will not finish on its own. sema did ` +
                     `NOT cancel it, because cancelling would decide that item for you. Your message was NOT sent; ` +
                     `${wayOut} if you no longer want it.`);
             }

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

@@ -2,6 +2,7 @@ import type { AgentEvent, CheckpointGate, TaskResult } from '@sema-agent/sdk';
 import { type WiringManifestView } from './wiringManifestView.js';
 import { type SDKMessage, type EmitContext, type ModelUsage } from '../types.js';
 import { type McpLivenessView } from '../../mcpLiveness.js';
+import { type ContextUsageSectionRow } from '../../ownKey.js';
 export declare const INTERNAL_SDK_ARM_TYPES: ReadonlySet<string>;
 export type EventProjectionNoneReason = 'usage_only' | 'terminal_delegated' | 'hitl_out_of_slice' | 'not_in_slice' | 'empty_payload';
 export type EventProjectionDropReason = 'malformed' | 'unknown_arm' | 'unsupported_arm';
@@ -66,11 +67,7 @@ export interface WiringManifestLspSeamView {
     mounted: boolean;
     lane?: string;
 }
-export interface ContextUsageSectionView {
-    id: string;
-    tokens: number;
-    kind?: string;
-}
+export type ContextUsageSectionView = ContextUsageSectionRow;
 export interface PromptManifestSectionView {
     id: string;
     chars: number;