@sema-agent/client-core 0.99.0 → 0.101.0

package/dist/adapt/arms.js

@@ -1,7 +1,8 @@
 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 { dropQueuedNotificationsForRun, freezeTaskNotificationFields, isEngineWorkflowNotified, isWorkflowCompletionCardEnqueued, markEngineWorkflowNotified, noteOwnWorkflowRun, normalizeTaskNotification, noteWorkflowCompletionCardEnqueued, renderTaskNotificationXml, taskNotificationDedupKey } from '../notifications.js';
 import { retryStatusFromArm } from '../retryStatus.js';
 import { steeringInjectedToAttachments } from '../steering.js';
 import { projectDiagnosticsFrame } from '../diagnostics.js';
@@ -11,39 +12,21 @@ import { readAsyncLaunchedAgentReceipt } from '../toolResult.js';
 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 { isMintedRowCcError, readProviderRejectionResendKey } from '../providerRejection.js';
+import { rowKindOf } from '../rowKind.js';
+import { terminalCodedDetailOf } from '../runTerminal.js';
+import { contextUsageReadingOf, guardedRead, humanInputAttachmentsOf, ownSnapshotRecord, ownSnapshotWhenTyped, readOwnDataValue, 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 { fleetRowAgentType } from '../fleet/fleetRowAgentType.js';
+import { cycleSeqValue } from '../cycleOrder.js';
+import { fleetRowAgentType, recordFleetRowAgentType } from '../fleet/fleetRowAgentType.js';
 import { chrome, mainLane, transcript, messageIdentityOf } from './ids.js';
 import { engineRefOf } from '../engineRowRef.js';
 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 +40,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,15 +52,42 @@ function claimParkedCard(m, callId, toolName, deps) {
 function laneOfCard(p) {
     return p.parentToolCallId !== undefined && p.parentToolCallId !== '' ? { lane: 'subagent', parentToolCallId: p.parentToolCallId } : mainLane();
 }
+function isMintedSyntheticRow(m) {
+    return readFrameTrueMark(m, '_sema_api_error_message');
+}
+function terminalOwnerCarry(m) {
+    if (!isMintedSyntheticRow(m))
+        return {};
+    const owner = terminalOwnerOf(m);
+    return owner === undefined ? {} : { _sema_terminal_owner: owner };
+}
+function rowKindCarry(m) {
+    if (!isMintedSyntheticRow(m))
+        return {};
+    const kind = rowKindOf(m);
+    const code = readFrameStringKey(m, '_sema_api_error_code');
+    const err = guardedRead(() => readOwnDataValue(m, 'error'));
+    return {
+        ...(kind !== undefined ? { _sema_row_kind: kind } : {}),
+        ...(code !== undefined ? { _sema_api_error_code: code } : {}),
+        ...(isMintedRowCcError(err) ? { error: err } : {}),
+    };
+}
+function codedDetailCarry(m, relayedRowKind) {
+    if (!isMintedSyntheticRow(m) || relayedRowKind !== 'api_error')
+        return {};
+    const body = terminalCodedDetailOf(m);
+    return body === undefined ? {} : { _sema_coded_detail: body };
+}
 function toolHistoryKeyCarry(m) {
-    if (m._sema_api_error_message !== true)
+    if (!isMintedSyntheticRow(m))
         return {};
     const raw = m._sema_tool_history_mismatch;
     const key = readToolHistoryMismatchKey(typeof raw === 'object' && raw !== null ? raw : undefined);
     return key === undefined ? {} : { _sema_tool_history_mismatch: key };
 }
 function providerResendKeyCarry(m) {
-    if (m._sema_api_error_message !== true)
+    if (!isMintedSyntheticRow(m))
         return {};
     const raw = m._sema_provider_rejection_resend;
     const key = readProviderRejectionResendKey(typeof raw === 'object' && raw !== null ? raw : undefined);
@@ -189,10 +198,11 @@ 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;
+        const rowText = isMintedSyntheticRow(m) ? washCredentials(textBlock.text) : textBlock.text;
+        const relayedKind = rowKindCarry(m);
         text.appendAnswer(rowText);
         text.beginAssistantMessage();
         yield* text.takeThinking();
@@ -202,9 +212,12 @@ const assistantArm = function* (m, deps) {
             uuid: idOf(m),
             session_id: ctx.sessionId,
             parent_tool_use_id: null,
-            ...(m._sema_api_error_message === true ? { _sema_api_error_message: true } : {}),
+            ...(isMintedSyntheticRow(m) ? { _sema_api_error_message: true } : {}),
             ...toolHistoryKeyCarry(m),
             ...providerResendKeyCarry(m),
+            ...terminalOwnerCarry(m),
+            ...relayedKind,
+            ...codedDetailCarry(m, relayedKind._sema_row_kind),
         }, ctx.now());
         text.markEmittedText(rowText);
     }
@@ -457,12 +470,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 } : {}),
     });
 };
@@ -491,6 +533,8 @@ const taskStartedArm = function* (m) {
     const agentType = str(m.agentType);
     const startedAt = num(m.startedAt);
     const eventId = str(idSnap.eventId);
+    if (agentType !== undefined && workflowRunId === undefined)
+        recordFleetRowAgentType(taskId, agentType);
     yield chrome({
         kind: 'subagent_started',
         laneProof,
@@ -533,14 +577,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 +605,7 @@ const promptAssembledArm = function* (m) {
         ...(blocks !== undefined ? { blocks } : {}),
         ...(sections !== undefined ? { sections } : {}),
         ...(tools !== undefined ? { tools } : {}),
+        ...(promptIdentity !== undefined ? { identity: promptIdentity } : {}),
         ...(eventId !== undefined ? { eventId } : {}),
     });
 };
@@ -576,6 +615,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 +631,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))
@@ -627,8 +667,9 @@ const toolEndResultArm = function* (m, deps) {
     const { idOf, cards, panel, ctx, inst, pass } = deps;
     const callId = typeof m.toolCallId === 'string' ? m.toolCallId : undefined;
     recordEngineToolLabel(callId, m.label);
+    const structured = ownSnapshotWhenTyped(m.structured, 'task-output');
     if (callId !== undefined) {
-        const launched = readAsyncLaunchedAgentReceipt(m.structured);
+        const launched = readAsyncLaunchedAgentReceipt(structured);
         if (launched !== null)
             registerSubagentContentAlias(callId, launched.taskId);
     }
@@ -653,7 +694,6 @@ const toolEndResultArm = function* (m, deps) {
     }
     if (p === undefined || callId === undefined)
         return;
-    const structured = m.structured;
     const closeEventIdRaw = m.eventId;
     const closeParentRaw = m.parentToolCallId;
     const closeEventId = typeof closeEventIdRaw === 'string' ? closeEventIdRaw : undefined;
@@ -769,10 +809,19 @@ const taskProgressArm = function* (m, { ctx, cards, panel, inst }) {
             : undefined;
     const identity = resolveEnginePanelTaskId(taskId);
     if (!panel.isLive(taskId)) {
-        yield* panel.start(taskId, fleetRowAgentType(identity.taskId));
+        yield* panel.start(taskId, fleetRowAgentType(taskId) ?? fleetRowAgentType(identity.taskId));
     }
     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 +837,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 }) {
@@ -891,7 +942,7 @@ const resultArm = function* (m, { ctx, idOf, text, cards, panel, flags }) {
         yield chrome({ kind: 'result_replayed', laneProof: mainLane(), text: RESULT_REPLAYED_TEXT });
 };
 const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
-    const n = (m.notification ?? {});
+    const n = ownSnapshotRecord(guardedRead(() => readOwnDataValue(m, 'notification'))) ?? {};
     const fields = normalizeTaskNotification(n);
     if (fields === null)
         return;
@@ -938,6 +989,7 @@ const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
         return;
     if (peerFrame === null && n.task_type !== 'external')
         markEngineWorkflowNotified(taskId);
+    const fact = peerFrame === null ? freezeTaskNotificationFields(fields) : undefined;
     yield transcript({
         type: 'user',
         message: {
@@ -945,15 +997,19 @@ const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
             content: [
                 {
                     type: 'text',
-                    text: peerFrame !== null ? renderPeerFrameTranscriptText(peerFrame) : renderTaskNotificationXml(fields),
+                    text: peerFrame !== null ? renderPeerFrameTranscriptText(peerFrame) : renderTaskNotificationXml(fact ?? fields),
                 },
             ],
         },
         uuid: idOf(m),
         session_id: ctx.sessionId,
+        ...(fact !== undefined ? { _sema_task_notification: fact } : {}),
     }, ctx.now());
 };
-const workflowCompleteArm = function* (m) {
+const workflowCompleteArm = function* (frame) {
+    const m = ownSnapshotRecord(frame);
+    if (m === undefined)
+        return;
     const runId = typeof m.runId === 'string' ? m.runId : undefined;
     if (runId === undefined)
         return;
@@ -963,13 +1019,15 @@ const workflowCompleteArm = function* (m) {
     const wfStatus = m.status === 'failed' ? 'failed' : 'completed';
     const wfSummary = typeof m.summary === 'string' ? m.summary : '';
     noteWorkflowCompletionCardEnqueued(runId);
+    const notification = freezeTaskNotificationFields({ taskId: runId, taskType: 'workflow', status: wfStatus, summary: wfSummary });
     yield chrome({
         kind: 'workflow_notification_enqueue',
         laneProof: mainLane(),
         runId,
         status: wfStatus,
         summary: wfSummary,
-        message: renderTaskNotificationXml({ taskId: runId, status: wfStatus, summary: wfSummary }),
+        message: renderTaskNotificationXml(notification),
+        notification,
     });
 };
 const retryStatusArm = function* (m, { ctx, flags }) {
@@ -1028,6 +1086,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

@@ -1,6 +1,7 @@
 import { chrome, mainLane, segmentRowId, transcript, messageIdentityOf } from './ids.js';
 import { estimateCjkTokens, FLUSH_INTERVAL_MS } from './wireShapes.js';
 import { resolveTextSegmentAuthority } from './textSegmentAuthority.js';
+import { carriesAnswerText } from '../ownKey.js';
 export const SEMA_SEGMENT_ID_KEY = '_sema_segment_id';
 const SENTENCE_END_CHARS = new Set(['。', '！', '？', '…', '.', '!', '?']);
 const SENTENCE_CLOSING_CHARS = new Set([
@@ -38,7 +39,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 +55,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 +96,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 +111,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 +127,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 +168,22 @@ export function createTextStream(ctx, idOf) {
     }
     return {
         *feedText(delta, frame) {
-            if (segmentWindowCloseArmed) {
-                segmentWindowCloseArmed = false;
-                previousSegmentCommitted = '';
-                segmentCommitted = '';
-                committedTextRows = [];
-            }
+            if (delta.length === 0 && segmentWindowCloseArmed && previousSegmentCommitted + segmentCommitted !== '')
+                return;
+            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 +225,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
                 ? {
@@ -241,11 +254,11 @@ export function createTextStream(ctx, idOf) {
                             committedText = txt;
                             currentTouched = true;
                         }
-                        if (txt.length > 0)
+                        if (carriesAnswerText(txt))
                             lastNonEmpty = txt;
                     }
                     if (!currentTouched && committedText.length > 0) { }
-                    if (committedText.length === 0 && lastNonEmpty.length > 0)
+                    if (!carriesAnswerText(committedText) && lastNonEmpty.length > 0)
                         previousCommittedText = lastNonEmpty;
                     booksSynced = true;
                 }
@@ -287,11 +300,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 +319,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 +378,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,12 +406,17 @@ 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;
         },
         beginAssistantMessage: () => {
             messageSerial += 1;
-            if (committedText.length > 0)
+            if (carriesAnswerText(committedText))
                 previousCommittedText = committedText;
             committedText = '';
             previousSegmentCommitted += segmentCommitted;
@@ -403,7 +429,7 @@ export function createTextStream(ctx, idOf) {
             return committedText;
         },
         get lastCommittedAnswerText() {
-            return committedText.length > 0 ? committedText : previousCommittedText;
+            return carriesAnswerText(committedText) ? committedText : previousCommittedText;
         },
         get emittedAssistantText() {
             return emittedAssistantText;