@sema-agent/client-core 0.98.0 → 0.100.0

package/dist/adapt/arms.js

@@ -1,8 +1,9 @@
 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';
-import { mapBrainStatusToRetry } from '../retryStatus.js';
+import { retryStatusFromArm } from '../retryStatus.js';
 import { steeringInjectedToAttachments } from '../steering.js';
 import { projectDiagnosticsFrame } from '../diagnostics.js';
 import { recordEngineToolLabel } from '../engineToolLabelStore.js';
@@ -12,9 +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, readFrameStringKey, readFrameTrueMark } from '../ownKey.js';
-import { washCredentials } from '../displayUntrusted.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';
@@ -22,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))
@@ -56,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;
@@ -69,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 {};
@@ -188,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;
@@ -204,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);
     }
@@ -310,8 +298,15 @@ const humanInputArm = function* (m) {
         ...(actor !== undefined && Object.keys(actor).length > 0 ? { actor } : {}),
         ...(str(m.entryId) !== undefined ? { entryId: str(m.entryId) } : {}),
         ...(str(m.eventId) !== undefined ? { eventId: str(m.eventId) } : {}),
+        ...humanInputAttachmentsForChrome(m),
     });
 };
+function humanInputAttachmentsForChrome(m) {
+    const rows = humanInputAttachmentsOf(m);
+    if (rows === undefined)
+        return {};
+    return { attachments: rows.map((r) => (r.label !== undefined ? { ...r, label: paintAndCap(r.label, ESCAPE_FACE, CORE_USER_ATTACHMENT_LABEL_MAX) } : r)) };
+}
 const messageCommittedArm = function* (m) {
     if (typeof m.parentToolCallId === 'string')
         return;
@@ -449,12 +444,86 @@ 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 } : {}),
+    });
+};
+const taskStartedArm = function* (m) {
+    const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+    const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : undefined);
+    const taskId = str(m.taskId);
+    if (taskId === undefined)
+        return;
+    const idSnap = snapshotSegmentIdentity(m);
+    if (idSnap === null)
+        return;
+    const parent = str(idSnap.parentToolCallId);
+    const laneProof = parent !== undefined ? { lane: 'subagent', parentToolCallId: parent } : mainLane();
+    const sessionId = str(m.sessionId);
+    const model = str(m.model);
+    const taskType = str(m.taskType);
+    const seq = num(m.seq);
+    const workflowRunId = str(m.workflowRunId);
+    const workflowAgentLabel = str(m.workflowAgentLabel);
+    const parentTaskId = str(m.parentTaskId);
+    const parentSessionId = str(m.parentSessionId);
+    const rootSessionId = str(m.rootSessionId);
+    const name = str(m.name);
+    const spawnName = str(m.spawnName);
+    const agentType = str(m.agentType);
+    const startedAt = num(m.startedAt);
+    const eventId = str(idSnap.eventId);
+    yield chrome({
+        kind: 'subagent_started',
+        laneProof,
+        taskId,
+        ...(sessionId !== undefined ? { sessionId } : {}),
+        ...(model !== undefined ? { model } : {}),
+        ...(taskType !== undefined ? { taskType } : {}),
+        ...(seq !== undefined ? { seq } : {}),
+        ...(workflowRunId !== undefined ? { workflowRunId } : {}),
+        ...(workflowAgentLabel !== undefined ? { workflowAgentLabel } : {}),
+        ...(parentTaskId !== undefined ? { parentTaskId } : {}),
+        ...(parentSessionId !== undefined ? { parentSessionId } : {}),
+        ...(rootSessionId !== undefined ? { rootSessionId } : {}),
+        ...(name !== undefined ? { name } : {}),
+        ...(spawnName !== undefined ? { spawnName } : {}),
+        ...(agentType !== undefined ? { agentType } : {}),
+        ...(startedAt !== undefined ? { startedAt } : {}),
         ...(eventId !== undefined ? { eventId } : {}),
     });
 };
@@ -480,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 };
@@ -514,6 +577,7 @@ const promptAssembledArm = function* (m) {
         ...(blocks !== undefined ? { blocks } : {}),
         ...(sections !== undefined ? { sections } : {}),
         ...(tools !== undefined ? { tools } : {}),
+        ...(promptIdentity !== undefined ? { identity: promptIdentity } : {}),
         ...(eventId !== undefined ? { eventId } : {}),
     });
 };
@@ -523,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({
@@ -538,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))
@@ -720,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),
@@ -735,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 }) {
@@ -876,7 +952,8 @@ const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
         });
         dropQueuedNotificationsForRun(taskId);
         if (n.task_type !== 'background_bash' && n.task_type !== 'monitor') {
-            yield* panel.settleFromNotification(taskId, isCoreTaskNotificationTerminalNotSuccess(rawStatus));
+            const bgSessionId = n.task_type === 'background_agent' && typeof n.sessionId === 'string' && n.sessionId.length > 0 ? n.sessionId : undefined;
+            yield* panel.settleFromNotification(taskId, isCoreTaskNotificationTerminalNotSuccess(rawStatus), bgSessionId);
         }
     }
     const peerFrame = classifyPeerNotification(n);
@@ -919,23 +996,9 @@ const workflowCompleteArm = function* (m) {
     });
 };
 const retryStatusArm = function* (m, { ctx, flags }) {
-    if (typeof m.parentToolCallId === 'string')
+    const status = retryStatusFromArm(m, ctx.now());
+    if (status === undefined)
         return;
-    const status = mapBrainStatusToRetry({
-        phase: typeof m.phase === 'string' ? m.phase : '',
-        ...(typeof m.detail === 'string' ? { detail: m.detail } : {}),
-        ...(typeof m.retryInSec === 'number' ? { retryInSec: m.retryInSec } : {}),
-        ...(typeof m.retryInMs === 'number' ? { retryInMs: m.retryInMs } : {}),
-        ...(typeof m.attempt === 'number' ? { attempt: m.attempt } : {}),
-        ...(typeof m.maxRetries === 'number' ? { maxRetries: m.maxRetries } : {}),
-        ...(typeof m.errClass === 'string' ? { errClass: m.errClass } : {}),
-        ...(typeof m.retryAtMs === 'number' ? { retryAtMs: m.retryAtMs } : {}),
-        ...(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())
             yield chrome({ kind: 'retry_status', laneProof: mainLane(), status: null });
@@ -968,6 +1031,7 @@ export const ARMS = new Map([
     ['user', userArm],
     ['tool_end_result', toolEndResultArm],
     ['task_progress', taskProgressArm],
+    ['task_started', taskStartedArm],
     ['stream_event', streamEventArm],
     ['turn_usage', turnUsageArm],
     ['result', resultArm],
@@ -987,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): Generator<AdapterOutput>;
-    settleFromTerminalTick(taskId: string, isError: boolean): Generator<AdapterOutput>;
+    settleFromNotification(taskId: string, isError: boolean, sessionId?: string): 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({
@@ -88,15 +103,15 @@ export function createPanelTaskLedger(ctx, cards, inst) {
                 });
             }
         },
-        *settleFromNotification(taskId, isError) {
+        *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(),
-                event: panelEndFact(taskId, isError),
+                event: panelEndFact(taskId, isError, sessionId !== undefined ? { sessionId } : undefined),
             });
             if (inst.hasFiredSubagentStart(taskId)) {
                 yield chrome({
@@ -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

@@ -1,3 +1,4 @@
+import type { UiLanguage } from '../env/uiLanguage.js';
 import type { ActiveRunBusySignal } from './runStream.js';
 import type { PlanReviewReopenTrigger } from '../hitl/planReviewWire.js';
 import { atMostOnceFailureClass } from '../atMostOnce.js';
@@ -39,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;
@@ -139,6 +143,8 @@ export type SelfHealOutcome = {
     taskId: string;
     detail: string;
     delivery: 'rejected' | 'unknown';
+    errorCode?: string;
+    runStatus?: string;
 } | {
     kind: 'running-attach';
     taskId: string;
@@ -228,9 +234,11 @@ 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;
 }
-export declare const INTERACTIVE_WAY_OUT = "run /clear to keep working in a fresh session";
-export declare function activeRunSelfHealRow(outcome: SelfHealOutcome, signal?: ActiveRunBusySignal | null, copy?: ActiveRunSelfHealCopy, origin?: RejectedSubmissionOrigin, follow?: SelfHealFollowDeclaration): string;
-export declare function activeRunBusyHeadlessRow(signal: ActiveRunBusySignal, copy?: ActiveRunSelfHealCopy): string;
+export declare const INTERACTIVE_WAY_OUT: string;
+export declare function activeRunSelfHealRow(outcome: SelfHealOutcome, signal?: ActiveRunBusySignal | null, copy?: ActiveRunSelfHealCopy, origin?: RejectedSubmissionOrigin, follow?: SelfHealFollowDeclaration, lang?: UiLanguage): string;
+export declare function activeRunBusyHeadlessRow(signal: ActiveRunBusySignal, copy?: ActiveRunSelfHealCopy, lang?: UiLanguage): string;