@sema-agent/client-core 0.99.0 → 0.100.0

package/dist/adapt/arms.js

@@ -1,4 +1,5 @@
 import { ccToolDenialKindForToolEnd, gateOutcomeOf } from '../gateOutcome.js';
+import { terminalOwnerOf } from '../seam.js';
 import { isSubFlowSegmentEnd, SEGMENT_END_IDENTITY_KEYS, snapshotSegmentIdentity, snapshotIsSubFlow } from '../adapter/types.js';
 import { classifyPeerNotification, renderPeerFrameTranscriptText } from '../peerFrames.js';
 import { dropQueuedNotificationsForRun, isEngineWorkflowNotified, isWorkflowCompletionCardEnqueued, markEngineWorkflowNotified, noteOwnWorkflowRun, normalizeTaskNotification, noteWorkflowCompletionCardEnqueued, renderTaskNotificationXml, taskNotificationDedupKey } from '../notifications.js';
@@ -12,10 +13,11 @@ import { recordWorkflowAgentTaskId } from '../workflow.js';
 import { isCoreTaskNotificationTerminal, isCoreTaskNotificationTerminalNotSuccess, isCoreTaskProgressTerminal, isCoreTaskProgressTerminalNotSuccess } from '../terminalStatuses.js';
 import { readToolHistoryMismatchKey } from '../toolHistoryMismatch.js';
 import { readProviderRejectionResendKey } from '../providerRejection.js';
-import { contextUsageReadingOf, guardedRead, humanInputAttachmentsOf, readFrameStringKey, readFrameTrueMark } from '../ownKey.js';
+import { contextUsageReadingOf, guardedRead, humanInputAttachmentsOf, promptManifestIdentityOfFrame, promptManifestSectionViewOf, readFrameStringKey, readFrameTrueMark } from '../ownKey.js';
 import { CORE_USER_ATTACHMENT_LABEL_MAX } from '../generated/engineFactTables.js';
 import { ESCAPE_FACE, paintAndCap, washCredentials } from '../displayUntrusted.js';
 import { resolveEnginePanelTaskId } from '../engineAgentPanelStore.js';
+import { cycleSeqValue } from '../cycleOrder.js';
 import { fleetRowAgentType } from '../fleet/fleetRowAgentType.js';
 import { chrome, mainLane, transcript, messageIdentityOf } from './ids.js';
 import { engineRefOf } from '../engineRowRef.js';
@@ -23,27 +25,6 @@ import { isReplayMarked, RESULT_REPLAYED_TEXT } from '../replayBody.js';
 import { wiringManifestViewOf } from '../adapter/downstream/wiringManifestView.js';
 import { isUnsettledHeldToolEnd } from '../engineRowRef.js';
 import { CANCEL_MESSAGE, decisionOf, flattenWireOutput, REJECT_MESSAGE, sanitizeToolUseBlock, shortTaskLabel, TASK_TOOL_NAMES, WORKFLOW_TOOL_NAMES, } from './wireShapes.js';
-function hostOwnString(o, key) {
-    return readFrameStringKey(o, key);
-}
-function continuesParkDeclarationOf(ctx) {
-    const decl = guardedRead(() => ctx.continuesPark);
-    return typeof decl === 'object' && decl !== null ? decl : undefined;
-}
-function continuesParkWitness(ctx, row) {
-    const decl = continuesParkDeclarationOf(ctx);
-    if (decl === undefined)
-        return false;
-    if (hostOwnString(decl, 'toolCallId') !== row.toolCallId)
-        return false;
-    const cp = hostOwnString(decl, 'checkpointId');
-    if (cp !== undefined && row.checkpointId !== undefined && cp !== row.checkpointId)
-        return false;
-    const parkedTaskId = hostOwnString(decl, 'parkedTaskId');
-    if (parkedTaskId !== undefined && row.parkedRun !== undefined && parkedTaskId !== row.parkedRun)
-        return false;
-    return true;
-}
 function claimParkedCard(m, callId, toolName, deps) {
     const { ctx, cards, inst, pass } = deps;
     if (cards.has(callId))
@@ -57,12 +38,11 @@ function claimParkedCard(m, callId, toolName, deps) {
         return undefined;
     const frameRun = engineRefOf(m)?.taskId;
     if (frameRun !== undefined) {
-        const decl = continuesParkDeclarationOf(ctx);
-        const allowed = [row.parkedRun, row.card.engineRef?.taskId, readFrameStringKey(decl, 'parkedTaskId'), readFrameStringKey(decl, 'continuationTaskId')].filter((x) => x !== undefined);
+        const allowed = [row.parkedRun, row.card.engineRef?.taskId].filter((x) => x !== undefined);
         if (allowed.length > 0 && !allowed.includes(frameRun))
             return undefined;
     }
-    if (row.pass !== pass && !continuesParkWitness(ctx, row))
+    if (row.pass !== pass)
         return undefined;
     inst.dropParkedToolRow(row.key);
     return row.card;
@@ -70,6 +50,12 @@ function claimParkedCard(m, callId, toolName, deps) {
 function laneOfCard(p) {
     return p.parentToolCallId !== undefined && p.parentToolCallId !== '' ? { lane: 'subagent', parentToolCallId: p.parentToolCallId } : mainLane();
 }
+function terminalOwnerCarry(m) {
+    if (m._sema_api_error_message !== true)
+        return {};
+    const owner = terminalOwnerOf(m);
+    return owner === undefined ? {} : { _sema_terminal_owner: owner };
+}
 function toolHistoryKeyCarry(m) {
     if (m._sema_api_error_message !== true)
         return {};
@@ -189,7 +175,7 @@ const assistantArm = function* (m, deps) {
     }
     const textBlock = blocks.find(b => b?.type === 'text');
     const thinkingBlock = blocks.find(b => b?.type === 'thinking');
-    if ((textBlock && typeof textBlock.text === 'string' && textBlock.text.length > 0) || (thinkingBlock && typeof thinkingBlock.thinking === 'string'))
+    if (textBlock && typeof textBlock.text === 'string' && textBlock.text.length > 0)
         text.anchorWindow(m);
     if (textBlock && typeof textBlock.text === 'string' && textBlock.text.length > 0) {
         const rowText = m._sema_api_error_message === true ? washCredentials(textBlock.text) : textBlock.text;
@@ -205,6 +191,7 @@ const assistantArm = function* (m, deps) {
             ...(m._sema_api_error_message === true ? { _sema_api_error_message: true } : {}),
             ...toolHistoryKeyCarry(m),
             ...providerResendKeyCarry(m),
+            ...terminalOwnerCarry(m),
         }, ctx.now());
         text.markEmittedText(rowText);
     }
@@ -457,12 +444,41 @@ const compactionOutcomeArm = function* (m) {
     const trigger = str(m.trigger);
     const reason = str(m.reason);
     const eventId = str(idSnap.eventId);
+    const pass = str(m.pass);
     yield chrome({
         kind: 'compaction_outcome',
         laneProof,
         outcome,
         ...(trigger !== undefined ? { trigger } : {}),
         ...(reason !== undefined ? { reason } : {}),
+        ...(pass !== undefined ? { pass } : {}),
+        ...(eventId !== undefined ? { eventId } : {}),
+    });
+};
+const compactionStartedArm = function* (m) {
+    const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+    const pass = str(m.pass);
+    const trigger = str(m.trigger);
+    if (pass === undefined || trigger === undefined)
+        return;
+    const idSnap = snapshotSegmentIdentity(m);
+    if (idSnap === null)
+        return;
+    let laneProof = mainLane();
+    if (snapshotIsSubFlow(idSnap)) {
+        const parent = str(idSnap.parentToolCallId);
+        if (parent === undefined)
+            return;
+        laneProof = { lane: 'subagent', parentToolCallId: parent };
+    }
+    const startedAt = typeof m.startedAt === 'number' && Number.isFinite(m.startedAt) ? m.startedAt : undefined;
+    const eventId = str(idSnap.eventId);
+    yield chrome({
+        kind: 'compaction_started',
+        laneProof,
+        pass,
+        trigger,
+        ...(startedAt !== undefined ? { startedAt } : {}),
         ...(eventId !== undefined ? { eventId } : {}),
     });
 };
@@ -533,14 +549,8 @@ const promptAssembledArm = function* (m) {
         const chars = size(o.chars);
         return id === undefined || chars === undefined ? undefined : { id, chars };
     });
-    const sections = promptManifestRows(m.sections, (o) => {
-        const id = str(o.id);
-        const chars = size(o.chars);
-        if (id === undefined || chars === undefined)
-            return undefined;
-        const slot = str(o.slot);
-        return { id, chars, ...(slot !== undefined ? { slot } : {}) };
-    });
+    const sections = promptManifestRows(m.sections, (o) => promptManifestSectionViewOf(o));
+    const promptIdentity = promptManifestIdentityOfFrame(m);
     const tools = promptManifestRows(m.tools, (o) => {
         const wireName = str(o.wireName);
         return wireName === undefined ? undefined : { wireName };
@@ -567,6 +577,7 @@ const promptAssembledArm = function* (m) {
         ...(blocks !== undefined ? { blocks } : {}),
         ...(sections !== undefined ? { sections } : {}),
         ...(tools !== undefined ? { tools } : {}),
+        ...(promptIdentity !== undefined ? { identity: promptIdentity } : {}),
         ...(eventId !== undefined ? { eventId } : {}),
     });
 };
@@ -576,6 +587,7 @@ const textSegmentEndArm = function* (m, { text }) {
     const content = typeof m.content === 'string' ? m.content : '';
     if (content.length === 0)
         return;
+    text.anchorWindow(m);
     const r = text.replaceAnswerSegment(content, m);
     yield* text.drainLive();
     yield chrome({
@@ -591,7 +603,7 @@ const textSegmentEndArm = function* (m, { text }) {
         ...(r.committedRows !== undefined ? { committedRows: r.committedRows } : {}),
         ...(typeof m.eventId === 'string' && m.eventId.length > 0 ? { eventId: m.eventId } : {}),
     });
-    text.rotateSegmentIdentity(m);
+    yield* text.endSegment();
 };
 const thinkingSegmentEndArm = function* (m, { text }) {
     if (isSubFlowSegmentEnd(m))
@@ -773,6 +785,15 @@ const taskProgressArm = function* (m, { ctx, cards, panel, inst }) {
     }
     panel.noteResidency(taskId, identity.taskId);
     panel.markLive(taskId);
+    const cycleSeq = cycleSeqValue(m.seq);
+    panel.noteCycle(taskId, cycleSeq);
+    const finalUsage = {};
+    if (isCoreTaskProgressTerminal(m.status)) {
+        if (typeof usage.totalTokens === 'number' && Number.isFinite(usage.totalTokens))
+            finalUsage.totalTokens = true;
+        if (typeof usage.toolUses === 'number' && Number.isFinite(usage.toolUses))
+            finalUsage.toolUses = true;
+    }
     yield chrome({
         kind: 'panel_task',
         laneProof: panel.laneOf(taskId),
@@ -788,11 +809,13 @@ const taskProgressArm = function* (m, { ctx, cards, panel, inst }) {
             ...(panel.isLiveBound(taskId) ? { cardBound: true } : {}),
             toolUses: typeof usage.toolUses === 'number' ? usage.toolUses : 0,
             totalTokens: typeof usage.totalTokens === 'number' ? usage.totalTokens : 0,
+            ...(cycleSeq !== undefined ? { cycleSeq } : {}),
+            ...(finalUsage.totalTokens === true || finalUsage.toolUses === true ? { final: finalUsage } : {}),
         },
     });
     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, isCoreTaskProgressTerminalNotSuccess(m.status));
+        yield* panel.settleFromTerminalTick(taskId, isCoreTaskProgressTerminalNotSuccess(m.status), cycleSeq);
     }
 };
 const streamEventArm = function* (m, { text }) {
@@ -1028,6 +1051,7 @@ export const ARMS = new Map([
     ['tool_roster_delta', toolRosterDeltaArm],
     ['context_usage', contextUsageArm],
     ['compaction_outcome', compactionOutcomeArm],
+    ['compaction_started', compactionStartedArm],
     ['prompt_assembled', promptAssembledArm],
     ['wiring_manifest', wiringManifestArm],
     ['approval_request', approvalFrameArm('approval_request')],

package/dist/adapt/panelTasks.d.ts

@@ -7,10 +7,11 @@ export interface PanelTaskLedger {
     isLiveBound(taskId: string): boolean;
     isLive(taskId: string): boolean;
     markLive(taskId: string): void;
+    noteCycle(taskId: string, cycleSeq: number | undefined): void;
     noteResidency(taskId: string, residentKey?: string): void;
     start(taskId: string, agentType?: string): Generator<AdapterOutput>;
     settle(cardId: string | null, isError: boolean, report?: string): Generator<AdapterOutput>;
     settleFromNotification(taskId: string, isError: boolean, sessionId?: string): Generator<AdapterOutput>;
-    settleFromTerminalTick(taskId: string, isError: boolean): Generator<AdapterOutput>;
+    settleFromTerminalTick(taskId: string, isError: boolean, cycleSeq?: number): Generator<AdapterOutput>;
 }
 export declare function createPanelTaskLedger(ctx: AdapterContext, cards: OpenCardView, inst: AdapterInstanceLedger): PanelTaskLedger;

package/dist/adapt/panelTasks.js

@@ -5,7 +5,15 @@ import { SUBAGENT_TOOL_NAMES } from './wireShapes.js';
 export function createPanelTaskLedger(ctx, cards, inst) {
     const taskCardBinding = new Map();
     const livePanelTasks = new Set();
-    const endedPanelTasks = new Set();
+    const endedPanelTasks = new Map();
+    const seenCycle = new Map();
+    const currentGenerationEnded = (taskId) => {
+        if (!endedPanelTasks.has(taskId))
+            return false;
+        const prior = endedPanelTasks.get(taskId);
+        const seen = seenCycle.get(taskId);
+        return !(prior !== undefined && seen !== undefined && prior < seen);
+    };
     const liveBoundPanelTasks = new Set();
     const clearResidencyBothKeys = (taskId) => clearEnginePanelTaskResidentByWire(taskId);
     const subagentTypeById = new Map();
@@ -42,6 +50,13 @@ export function createPanelTaskLedger(ctx, cards, inst) {
         markLive: (taskId) => {
             livePanelTasks.add(taskId);
         },
+        noteCycle: (taskId, cycleSeq) => {
+            if (cycleSeq === undefined)
+                return;
+            const seen = seenCycle.get(taskId);
+            if (seen === undefined || cycleSeq > seen)
+                seenCycle.set(taskId, cycleSeq);
+        },
         noteResidency: (taskId, residentKey = taskId) => {
             if (liveBoundPanelTasks.has(taskId))
                 clearEnginePanelTaskResident(residentKey);
@@ -69,9 +84,9 @@ export function createPanelTaskLedger(ctx, cards, inst) {
                     continue;
                 if (cardId === null && !liveBoundPanelTasks.has(taskId))
                     continue;
-                if (endedPanelTasks.has(taskId))
+                if (currentGenerationEnded(taskId))
                     continue;
-                endedPanelTasks.add(taskId);
+                endedPanelTasks.set(taskId, undefined);
                 const mintLane = laneMinterFor(taskId);
                 const agentType = subagentTypeById.get(taskId);
                 yield chrome({
@@ -90,9 +105,9 @@ export function createPanelTaskLedger(ctx, cards, inst) {
         },
         *settleFromNotification(taskId, isError, sessionId) {
             clearResidencyBothKeys(taskId);
-            if (endedPanelTasks.has(taskId))
+            if (currentGenerationEnded(taskId))
                 return;
-            endedPanelTasks.add(taskId);
+            endedPanelTasks.set(taskId, undefined);
             yield chrome({
                 kind: 'panel_task',
                 laneProof: mainLane(),
@@ -108,10 +123,18 @@ export function createPanelTaskLedger(ctx, cards, inst) {
                 });
             }
         },
-        *settleFromTerminalTick(taskId, isError) {
-            if (endedPanelTasks.has(taskId))
+        *settleFromTerminalTick(taskId, isError, cycleSeq) {
+            if (endedPanelTasks.has(taskId)) {
+                const prior = endedPanelTasks.get(taskId);
+                if (cycleSeq === undefined || prior === undefined || cycleSeq <= prior)
+                    return;
+            }
+            const seen = seenCycle.get(taskId);
+            if (cycleSeq !== undefined && seen !== undefined && cycleSeq < seen) {
+                yield chrome({ kind: 'panel_task', laneProof: laneMinterFor(taskId)(), event: panelEndFact(taskId, isError, { cycleSeq }) });
                 return;
-            endedPanelTasks.add(taskId);
+            }
+            endedPanelTasks.set(taskId, cycleSeq);
             clearResidencyBothKeys(taskId);
             const mintLane = laneMinterFor(taskId);
             const card = taskCardBinding.get(taskId);
@@ -138,7 +161,7 @@ export function createPanelTaskLedger(ctx, cards, inst) {
             yield chrome({
                 kind: 'panel_task',
                 laneProof: mintLane(),
-                event: panelEndFact(taskId, isError),
+                event: panelEndFact(taskId, isError, cycleSeq !== undefined ? { cycleSeq } : undefined),
             });
         },
     };

package/dist/adapt/textStream.d.ts

@@ -36,7 +36,7 @@ export interface TextStream {
     replaceThinkingSegment(content: string, anchor?: Frame): ThinkingSegmentReplacement;
     segmentId(): string;
     anchorWindow(frame: Frame): void;
-    rotateSegmentIdentity(anchor: Frame): void;
+    endSegment(): Generator<AdapterOutput>;
     stampSegmentIdentity(out: AdapterOutput): AdapterOutput;
     readonly answerLength: number;
 }

package/dist/adapt/textStream.js

@@ -38,7 +38,6 @@ export function createTextStream(ctx, idOf) {
     let segmentCommitted = '';
     let previousSegmentCommitted = '';
     let segmentWindowCloseArmed = false;
-    let segmentSealed = '';
     const flushEveryMs = typeof ctx.coalesceIntervalMs === 'number' && ctx.coalesceIntervalMs >= 0
         ? ctx.coalesceIntervalMs
         : FLUSH_INTERVAL_MS;
@@ -55,6 +54,25 @@ export function createTextStream(ctx, idOf) {
             segmentIdCache = idOf(segmentWindowAnchor ?? {}, 'segment');
         return segmentIdCache;
     };
+    const openSegmentWindow = (frame) => {
+        if (segmentWindowAnchor !== null)
+            return;
+        segmentWindowAnchor = frame;
+        segmentIdCache = null;
+    };
+    const closeSegmentWindow = () => {
+        committedTextRows = [];
+        segmentWindowAnchor = null;
+        segmentIdCache = null;
+    };
+    const consumeArmedClose = () => {
+        if (!segmentWindowCloseArmed)
+            return;
+        segmentWindowCloseArmed = false;
+        previousSegmentCommitted = '';
+        segmentCommitted = '';
+        closeSegmentWindow();
+    };
     function* takeThinking() {
         if (thinking.length === 0)
             return;
@@ -77,9 +95,11 @@ export function createTextStream(ctx, idOf) {
         yield transcript(msg, ctx.now());
     }
     function* emitAnswerSegment() {
-        const body = segmentSealed + answerSegment;
+        const body = answerSegment;
         if (body.length === 0)
             return;
+        if (segmentAnchor !== null)
+            openSegmentWindow(segmentAnchor);
         const anchor = segmentAnchor ?? {};
         const msg = {
             type: 'assistant',
@@ -90,10 +110,8 @@ export function createTextStream(ctx, idOf) {
         };
         const committedTextBeforeRow = committedText;
         committedText += body;
-        segmentCommitted += answerSegment;
-        if (answerSegment.length > 0)
-            committedTextRows.push({ text: body, uuid: msg.uuid, sealedPrefix: segmentSealed, msgSerial: messageSerial, msgTextBefore: committedTextBeforeRow });
-        segmentSealed = '';
+        segmentCommitted += body;
+        committedTextRows.push({ text: body, uuid: msg.uuid, msgSerial: messageSerial, msgTextBefore: committedTextBeforeRow });
         answerSegment = '';
         segmentAnchor = null;
         segmentLast = null;
@@ -108,7 +126,7 @@ export function createTextStream(ctx, idOf) {
         segmentCommitted = '';
     }
     function* takeAnswerSegmentOnIdle() {
-        const body = segmentSealed + answerSegment;
+        const body = answerSegment;
         if (body.length === 0)
             return;
         if (idleFlushUsedInSegment)
@@ -149,28 +167,20 @@ export function createTextStream(ctx, idOf) {
     }
     return {
         *feedText(delta, frame) {
-            if (segmentWindowCloseArmed) {
-                segmentWindowCloseArmed = false;
-                previousSegmentCommitted = '';
-                segmentCommitted = '';
-                committedTextRows = [];
-            }
+            consumeArmedClose();
             if (thinking.length > 0 || thinkingPending.length > 0) {
                 yield* drainLive();
                 yield* takeThinking();
             }
-            if (answerSegment.length === 0 && segmentSealed.length === 0)
+            if (answerSegment.length === 0)
                 segmentAnchor = frame;
             segmentLast = frame;
-            if (segmentWindowAnchor === null)
-                segmentWindowAnchor = frame;
+            openSegmentWindow(frame);
             answer += delta;
             answerSegment += delta;
             textPending += delta;
         },
         *feedThinking(delta, frame) {
-            if (segmentWindowAnchor === null)
-                segmentWindowAnchor = frame;
             if (thinkingSettled) {
                 if (thinking.length > 0) {
                     yield* drainLive();
@@ -212,7 +222,7 @@ export function createTextStream(ctx, idOf) {
             const rows = uuidsUnique ? rowsAll : [];
             const rowUuids = rows.map((r) => r.uuid);
             const committedRowsOut = committedPrefixDiverged && rows.length > 0
-                ? rows.map((r, i) => ({ uuid: r.uuid, text: i === 0 ? r.sealedPrefix + content : r.sealedPrefix }))
+                ? rows.map((r, i) => ({ uuid: r.uuid, text: i === 0 ? content : '' }))
                 : undefined;
             const attribution = uuidsUnique
                 ? {
@@ -287,11 +297,12 @@ export function createTextStream(ctx, idOf) {
                 }
             }
             else {
-                segmentSealed += verdict.tail;
+                answerSegment = verdict.tail;
                 if (diverged && anchor !== undefined)
                     segmentLast = anchor;
             }
-            answerSegment = '';
+            if (committedPrefixDiverged)
+                answerSegment = '';
             if (answer.endsWith(liveSegment)) {
                 answer = answer.slice(0, answer.length - liveSegment.length) + content;
             }
@@ -305,7 +316,6 @@ export function createTextStream(ctx, idOf) {
             return { diverged, committedPrefixLen, committedPrefixDiverged, ...attribution };
         },
         hasPendingContent: () => thinking.length > 0 ||
-            segmentSealed.length > 0 ||
             answerSegment.length > 0 ||
             thinkingPending.length > 0 ||
             textPending.length > 0,
@@ -365,13 +375,21 @@ export function createTextStream(ctx, idOf) {
         },
         segmentId: segmentIdNow,
         anchorWindow: (frame) => {
-            if (segmentWindowAnchor === null)
-                segmentWindowAnchor = frame;
+            openSegmentWindow(frame);
         },
-        rotateSegmentIdentity: (anchor) => {
-            committedTextRows = [];
-            segmentWindowAnchor = anchor;
-            segmentIdCache = null;
+        *endSegment() {
+            try {
+                yield* emitAnswerSegment();
+            }
+            finally {
+                segmentAnchor = null;
+                segmentLast = null;
+                segmentCommitted = '';
+                previousSegmentCommitted = '';
+                idleFlushUsedInSegment = false;
+                textBlockOpen = false;
+                closeSegmentWindow();
+            }
         },
         stampSegmentIdentity: (out) => {
             if (out.plane !== 'transcript')
@@ -385,6 +403,11 @@ export function createTextStream(ctx, idOf) {
             const last = blocks[blocks.length - 1];
             if (last === undefined || last.type !== 'text' || typeof last.text !== 'string')
                 return out;
+            if (segmentWindowAnchor === null) {
+                const rowUuid = out.message.uuid;
+                openSegmentWindow(typeof rowUuid === 'string' ? { uuid: rowUuid } : {});
+            }
+            ;
             out.message[SEMA_SEGMENT_ID_KEY] = segmentIdNow();
             return out;
         },

package/dist/adapter/activeRunSelfHeal.d.ts

@@ -40,11 +40,14 @@ export type ReopenCardVerdict = {
     dismissedByUser?: true;
     _sema_noPresentationSurface?: true;
     _sema_errorCode?: string;
+    _sema_reopenRefusal?: PlanReviewReopenRefusal;
 } | {
     reopened: true;
     firstSight: boolean;
     presented?: boolean;
 };
+export declare const PLAN_REVIEW_REOPEN_REFUSALS: readonly ["invalid_call", "no_delivery_path", "not_presented", "gate_record_gone", "internal_error"];
+export type PlanReviewReopenRefusal = (typeof PLAN_REVIEW_REOPEN_REFUSALS)[number];
 export interface RunningChoiceRequest {
     taskId: string;
     status: string;
@@ -140,6 +143,8 @@ export type SelfHealOutcome = {
     taskId: string;
     detail: string;
     delivery: 'rejected' | 'unknown';
+    errorCode?: string;
+    runStatus?: string;
 } | {
     kind: 'running-attach';
     taskId: string;
@@ -229,6 +234,8 @@ export interface ActiveRunSelfHealCopy {
     freshSession?: string;
     keepSessionWayOut?: () => string | null;
     engineDecidePath?: boolean;
+    endRun?: string;
+    wakeSession?: string | null;
     rowFor?: (outcome: SelfHealOutcome, signal: ActiveRunBusySignal | null | undefined) => string | undefined;
     headlessRowFor?: (signal: ActiveRunBusySignal) => string | undefined;
 }