@sema-agent/client-core 0.97.0 → 0.98.0

package/dist/adapt/arms.d.ts

@@ -15,6 +15,7 @@ export interface ArmDeps extends ProjectionArmDeps {
     readonly panel: PanelTaskLedger;
     readonly flags: TurnFlags;
     readonly inst: AdapterInstanceLedger;
+    readonly pass: number;
 }
 export type ProjectionArmFn = (m: Frame, deps: ProjectionArmDeps) => Generator<AdapterOutput>;
 type ArmFn = (m: Frame, deps: ArmDeps) => Generator<AdapterOutput>;

package/dist/adapt/arms.js

@@ -1,4 +1,4 @@
-import { ccToolDenialKindForToolEnd } from '../gateOutcome.js';
+import { ccToolDenialKindForToolEnd, gateOutcomeOf } from '../gateOutcome.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,13 +12,63 @@ import { recordWorkflowAgentTaskId } from '../workflow.js';
 import { isCoreTaskNotificationTerminal, isCoreTaskNotificationTerminalNotSuccess, isCoreTaskProgressTerminal, isCoreTaskProgressTerminalNotSuccess } from '../terminalStatuses.js';
 import { readToolHistoryMismatchKey } from '../toolHistoryMismatch.js';
 import { readProviderRejectionResendKey } from '../providerRejection.js';
-import { readFrameStringKey, readFrameTrueMark } from '../ownKey.js';
+import { contextUsageReadingOf, guardedRead, readFrameStringKey, readFrameTrueMark } from '../ownKey.js';
 import { washCredentials } from '../displayUntrusted.js';
 import { resolveEnginePanelTaskId } from '../engineAgentPanelStore.js';
 import { fleetRowAgentType } 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))
+        return undefined;
+    const row = inst.parkedToolRowFor(ctx.sessionId, callId);
+    if (row === undefined)
+        return undefined;
+    if (readFrameStringKey(m, 'parentToolCallId') !== row.card.parentToolCallId)
+        return undefined;
+    if (toolName !== undefined && toolName !== row.card.name)
+        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);
+        if (allowed.length > 0 && !allowed.includes(frameRun))
+            return undefined;
+    }
+    if (row.pass !== pass && !continuesParkWitness(ctx, row))
+        return undefined;
+    inst.dropParkedToolRow(row.key);
+    return row.card;
+}
+function laneOfCard(p) {
+    return p.parentToolCallId !== undefined && p.parentToolCallId !== '' ? { lane: 'subagent', parentToolCallId: p.parentToolCallId } : mainLane();
+}
 function toolHistoryKeyCarry(m) {
     if (m._sema_api_error_message !== true)
         return {};
@@ -33,7 +83,8 @@ function providerResendKeyCarry(m) {
     const key = readProviderRejectionResendKey(typeof raw === 'object' && raw !== null ? raw : undefined);
     return key === undefined ? {} : { _sema_provider_rejection_resend: key };
 }
-const assistantArm = function* (m, { ctx, idOf, text, cards, inst }) {
+const assistantArm = function* (m, deps) {
+    const { ctx, idOf, text, cards, inst } = deps;
     const message = m.message;
     const blocks = Array.isArray(message?.content)
         ? message.content
@@ -61,21 +112,27 @@ const assistantArm = function* (m, { ctx, idOf, text, cards, inst }) {
         }
         yield* text.takeAnswerSegment();
         yield* text.takeThinking();
-        text.beginAssistantMessage();
-        const cardIdentity = messageIdentityOf(m, ctx);
-        yield transcript({
-            type: 'assistant',
-            message: {
-                id: cards.mintResponseId(m),
-                role: 'assistant',
-                content: renderBlocks,
-                ...(cardIdentity.model !== undefined ? { model: cardIdentity.model } : {}),
-            },
-            uuid: idOf(m),
-            session_id: ctx.sessionId,
-            parent_tool_use_id: null,
-            ...(readFrameTrueMark(m, '_sema_tool_recovered') ? { _sema_tool_recovered: true } : {}),
-        }, ctx.now());
+        const claimed = claimParkedCard(m, toolUseId, toolName, deps);
+        const startUuid = claimed !== undefined ? claimed.rowUuid : idOf(m);
+        if (claimed === undefined)
+            inst.noteStartRow(ctx.sessionId, toolUseId, startUuid);
+        if (claimed === undefined) {
+            text.beginAssistantMessage();
+            const cardIdentity = messageIdentityOf(m, ctx);
+            yield transcript({
+                type: 'assistant',
+                message: {
+                    id: cards.mintResponseId(m),
+                    role: 'assistant',
+                    content: renderBlocks,
+                    ...(cardIdentity.model !== undefined ? { model: cardIdentity.model } : {}),
+                },
+                uuid: startUuid,
+                session_id: ctx.sessionId,
+                parent_tool_use_id: null,
+                ...(readFrameTrueMark(m, '_sema_tool_recovered') ? { _sema_tool_recovered: true } : {}),
+            }, ctx.now());
+        }
         if (decision === 'reject' || decision === 'cancel') {
             cards.resetResponseId();
             yield transcript({
@@ -116,18 +173,23 @@ const assistantArm = function* (m, { ctx, idOf, text, cards, inst }) {
             }, ctx.now());
             return;
         }
-        cards.open({
+        cards.open(claimed !== undefined ? { ...claimed, rawInput: san.rawInput } : {
             id: toolUseId,
             name: toolName,
             rawInput: san.rawInput,
             ...(san.eventId !== undefined ? { eventId: san.eventId } : {}),
             ...(san.parentToolCallId !== undefined ? { parentToolCallId: san.parentToolCallId } : {}),
+            engineRef: engineRefOf(m),
+            ...(startUuid !== undefined ? { rowUuid: startUuid } : {}),
         });
         if (WORKFLOW_TOOL_NAMES.has(toolName))
             inst.markWorkflowCard(toolUseId);
         return;
     }
     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'))
+        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;
         text.appendAnswer(rowText);
@@ -145,7 +207,6 @@ const assistantArm = function* (m, { ctx, idOf, text, cards, inst }) {
         }, ctx.now());
         text.markEmittedText(rowText);
     }
-    const thinkingBlock = blocks.find(b => b?.type === 'thinking');
     if (thinkingBlock && typeof thinkingBlock.thinking === 'string') {
         yield transcript({
             type: 'assistant',
@@ -360,20 +421,13 @@ const toolRosterDeltaArm = function* (m) {
 const contextUsageArm = function* (m) {
     if (isSubFlowSegmentEnd(m))
         return;
-    const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : undefined);
-    const usedTokens = num(m.usedTokens);
-    const windowTokens = num(m.windowTokens);
-    const compactAtTokens = num(m.compactAtTokens);
-    const sections = Array.isArray(m.sections) ? m.sections : undefined;
-    if (usedTokens === undefined && windowTokens === undefined && compactAtTokens === undefined && sections === undefined)
+    const reading = contextUsageReadingOf(m);
+    if (reading === undefined)
         return;
     yield chrome({
         kind: 'context_usage',
         laneProof: mainLane(),
-        ...(usedTokens !== undefined ? { usedTokens } : {}),
-        ...(windowTokens !== undefined ? { windowTokens } : {}),
-        ...(compactAtTokens !== undefined ? { compactAtTokens } : {}),
-        ...(sections !== undefined ? { sections } : {}),
+        ...reading,
         ...(typeof m.eventId === 'string' && m.eventId.length > 0 ? { eventId: m.eventId } : {}),
     });
 };
@@ -516,7 +570,8 @@ const promptSuggestionsArm = function* (m) {
         yield chrome({ kind: 'prompt_suggestions', laneProof: mainLane(), suggestions: list });
     }
 };
-const toolEndResultArm = function* (m, { idOf, cards, panel }) {
+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);
     if (callId !== undefined) {
@@ -524,10 +579,25 @@ const toolEndResultArm = function* (m, { idOf, cards, panel }) {
         if (launched !== null)
             registerSubagentContentAlias(callId, launched.taskId);
     }
+    if (callId !== undefined && isUnsettledHeldToolEnd(m)) {
+        const held = cards.detach(callId);
+        if (held !== undefined) {
+            inst.parkToolRow({ sessionId: ctx.sessionId, toolCallId: callId, card: held, pass });
+            yield chrome({ kind: 'tool_parked', laneProof: laneOfCard(held), toolUseId: callId, ...(held.rowUuid !== undefined ? { rowUuid: held.rowUuid } : {}) });
+        }
+        return;
+    }
     if (callId !== undefined) {
         yield* panel.settle(callId, m.isError === true, m.output !== undefined ? flattenWireOutput(m.output) : undefined);
     }
-    const p = callId !== undefined ? cards.peek(callId) : undefined;
+    let p = callId !== undefined ? cards.peek(callId) : undefined;
+    if (p === undefined && callId !== undefined) {
+        const claimed = claimParkedCard(m, callId, readFrameStringKey(m, 'toolName'), deps);
+        if (claimed !== undefined) {
+            cards.open(claimed);
+            p = claimed;
+        }
+    }
     if (p === undefined || callId === undefined)
         return;
     const structured = m.structured;
@@ -537,6 +607,7 @@ const toolEndResultArm = function* (m, { idOf, cards, panel }) {
     const closeParent = typeof closeParentRaw === 'string' ? closeParentRaw : undefined;
     const stampedRaw = m._sema_denial_kind;
     const closeDenialKindRaw = typeof stampedRaw === 'string' ? stampedRaw : ccToolDenialKindForToolEnd(m);
+    const closeGate = guardedRead(() => gateOutcomeOf(m));
     yield* cards.close(p, {
         output: m.output,
         structured,
@@ -544,8 +615,10 @@ const toolEndResultArm = function* (m, { idOf, cards, panel }) {
         isError: m.isError === true,
         eventId: closeEventId,
         parentToolCallId: closeParent,
+        engineRef: engineRefOf(m),
         ...(typeof closeDenialKindRaw === 'string' ? { denialKind: closeDenialKindRaw } : {}),
-        ...(readFrameTrueMark(m, 'notExecuted') ? { notExecuted: true } : {}),
+        ...(closeGate !== undefined ? { gate: closeGate } : {}),
+        closeArm: m,
     });
     const s = structured !== undefined && structured !== null && typeof structured === 'object'
         ? structured
@@ -641,7 +714,7 @@ const taskProgressArm = function* (m, { ctx, cards, panel, inst }) {
         : typeof input.task === 'string'
             ? input.task
             : undefined;
-    const identity = resolveEnginePanelTaskId(taskId, explicitParent);
+    const identity = resolveEnginePanelTaskId(taskId);
     if (!panel.isLive(taskId)) {
         yield* panel.start(taskId, fleetRowAgentType(identity.taskId));
     }
@@ -761,6 +834,8 @@ const resultArm = function* (m, { ctx, idOf, text, cards, panel, flags }) {
             resultLength: terminalText.length,
         });
     }
+    if (isReplayMarked(m))
+        yield chrome({ kind: 'result_replayed', laneProof: mainLane(), text: RESULT_REPLAYED_TEXT });
 };
 const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
     const n = (m.notification ?? {});
@@ -869,8 +944,27 @@ const retryStatusArm = function* (m, { ctx, flags }) {
     yield chrome({ kind: 'retry_status', laneProof: mainLane(), status });
     flags.noteRetryOverlay();
 };
+const terminalFactArm = function* (m, { ctx, inst, pass }) {
+    const taskId = readFrameStringKey(m, 'taskId');
+    const paused = guardedRead(() => {
+        const d = Object.getOwnPropertyDescriptor(m, 'paused');
+        return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
+    });
+    if (typeof paused === 'object' && paused !== null) {
+        const heldCallId = readFrameStringKey(paused, 'heldCallId');
+        const checkpointId = readFrameStringKey(paused, 'checkpointId');
+        inst.noteParkedFact(ctx.sessionId, pass, {
+            ...(heldCallId !== undefined ? { heldCallId } : {}),
+            ...(checkpointId !== undefined ? { checkpointId } : {}),
+            ...(taskId !== undefined ? { taskId } : {}),
+        });
+        return;
+    }
+    inst.retireParkedRowsOfRun(ctx.sessionId, pass, taskId);
+};
 export const ARMS = new Map([
     ['assistant', assistantArm],
+    ['terminal_fact', terminalFactArm],
     ['user', userArm],
     ['tool_end_result', toolEndResultArm],
     ['task_progress', taskProgressArm],

package/dist/adapt/ids.d.ts

@@ -1,7 +1,16 @@
 import type { AdapterContext, AdapterOutput, ChromeEvent, LaneProof } from '../seam.js';
+import { type EngineRowRef } from '../engineRowRef.js';
 export type Frame = Record<string, unknown>;
 export declare const mainLane: () => LaneProof;
-export type IdOf = (frame: Frame, suffix?: string) => string;
+export interface RowSidecars {
+    readonly ref?: EngineRowRef;
+    readonly replay?: true;
+}
+export interface IdOf {
+    (frame: Frame, suffix?: string): string;
+    adopt(id: string, ref: EngineRowRef | undefined): string;
+    sidecarsOfId(id: string): RowSidecars | undefined;
+}
 export declare function messageIdentityOf(frame: Frame, ctx: {
     model?: string;
 }): {
@@ -11,3 +20,5 @@ export declare function messageIdentityOf(frame: Frame, ctx: {
 export declare const chrome: (event: ChromeEvent) => AdapterOutput;
 export declare const transcript: (message: Frame, nowMs: number) => AdapterOutput;
 export declare function makeIdOf(ctx: AdapterContext): IdOf;
+export declare function segmentRowId(idOf: IdOf, open: Frame, close: Frame | null, tag: 'text' | 'thinking'): string;
+export declare function carryRowSidecars(out: AdapterOutput, idOf: IdOf): AdapterOutput;

package/dist/adapt/ids.js

@@ -1,4 +1,6 @@
 import { deriveTranscriptId } from '../seam.js';
+import { engineRefOf } from '../engineRowRef.js';
+import { isReplayMarked } from '../replayBody.js';
 export const mainLane = () => ({ lane: 'main' });
 export function messageIdentityOf(frame, ctx) {
     const msg = frame.message;
@@ -24,17 +26,66 @@ export const transcript = (message, nowMs) => {
             : { ...message, timestamp: new Date(nowMs).toISOString() }),
     };
 };
+function frameKeyOf(frame) {
+    if (frame === null)
+        return undefined;
+    return typeof frame.id === 'string' && frame.id.length > 0
+        ? frame.id
+        : typeof frame.uuid === 'string' && frame.uuid.length > 0
+            ? frame.uuid
+            : undefined;
+}
 export function makeIdOf(ctx) {
-    return (frame, suffix) => {
-        const base = typeof frame.id === 'string' && frame.id.length > 0
-            ? frame.id
-            : typeof frame.uuid === 'string' && frame.uuid.length > 0
-                ? frame.uuid
-                : undefined;
-        return deriveTranscriptId({
+    const ledger = new Map();
+    const note = (id, ref, replay) => {
+        if ((ref === undefined && !replay) || ledger.has(id))
+            return;
+        ledger.set(id, { ...(ref !== undefined ? { ref } : {}), ...(replay ? { replay: true } : {}) });
+    };
+    const idOf = (frame, suffix) => {
+        const base = frameKeyOf(frame);
+        const id = deriveTranscriptId({
             ...(base !== undefined ? { id: base } : {}),
-            ...(typeof frame.seq === 'number' ? { seq: frame.seq } : {}),
             ...(typeof frame.toolCallId === 'string' ? { toolCallId: frame.toolCallId } : {}),
         }, ctx, suffix);
+        note(id, engineRefOf(frame), isReplayMarked(frame));
+        return id;
+    };
+    return Object.assign(idOf, {
+        adopt: (id, ref) => {
+            note(id, ref, false);
+            return id;
+        },
+        sidecarsOfId: (id) => {
+            const row = ledger.get(id);
+            if (row === undefined)
+                return undefined;
+            return { ...(row.ref !== undefined ? { ref: { ...row.ref } } : {}), ...(row.replay === true ? { replay: true } : {}) };
+        },
+    });
+}
+export function segmentRowId(idOf, open, close, tag) {
+    const closeKey = frameKeyOf(close);
+    if (closeKey === undefined)
+        return idOf.adopt(idOf({}, tag), engineRefOf(open));
+    return idOf(open, `${tag}~${closeKey}`);
+}
+export function carryRowSidecars(out, idOf) {
+    if (out.plane !== 'transcript')
+        return out;
+    const row = out.message;
+    const uuid = row.uuid;
+    if (typeof uuid !== 'string')
+        return out;
+    const side = idOf.sidecarsOfId(uuid);
+    if (side === undefined)
+        return out;
+    const addRef = side.ref !== undefined && !Object.hasOwn(row, '_sema_engine_ref');
+    const addReplay = side.replay === true && !Object.hasOwn(row, '_sema_replay');
+    if (!addRef && !addReplay)
+        return out;
+    return {
+        plane: 'transcript',
+        message: Object.assign({}, out.message, addRef ? { _sema_engine_ref: side.ref } : {}, addReplay ? { _sema_replay: true } : {}),
     };
 }

package/dist/adapt/instanceLedger.d.ts

@@ -1,3 +1,17 @@
+import type { PendingToolUse } from './toolCards.js';
+import type { EngineRowRef } from '../engineRowRef.js';
+export declare const PARKED_TOOL_ROWS_MAX = 64;
+export declare const LATEST_START_ROWS_MAX = 1024;
+export interface ParkedToolRow {
+    readonly key: string;
+    readonly sessionId: string;
+    readonly toolCallId: string;
+    readonly card: PendingToolUse;
+    readonly pass?: number;
+    readonly seq: number;
+    parkedRun?: string;
+    checkpointId?: string;
+}
 export interface AdapterInstanceLedger {
     hasRenderedNotification(key: string): boolean;
     addRenderedNotification(key: string): void;
@@ -7,5 +21,41 @@ export interface AdapterInstanceLedger {
     markWorkflowCard(toolUseId: string): void;
     hasFiredSubagentStart(taskId: string): boolean;
     markFiredSubagentStart(taskId: string): void;
+    beginPass(): number;
+    parkToolRow(row: ParkToolRowInput): void;
+    parkedToolRowFor(sessionId: string, toolCallId: string): ParkedToolRow | undefined;
+    noteParkedFact(sessionId: string, pass: number, fact: ParkedTerminalFact): void;
+    retireParkedRowsOfRun(sessionId: string, pass: number, taskId: string | undefined): void;
+    dropParkedToolRow(key: string): void;
+    noteStartRow(sessionId: string, toolCallId: string, rowUuid: string | undefined): void;
+    listParkedToolRows(): ParkedToolRowSnapshot[];
+    takeParkedToolRows(rows: {} | null | undefined): number;
+}
+export interface ParkToolRowInput {
+    readonly sessionId: string;
+    readonly toolCallId: string;
+    readonly card: PendingToolUse;
+    readonly pass: number;
+}
+export interface ParkedTerminalFact {
+    readonly heldCallId?: string;
+    readonly checkpointId?: string;
+    readonly taskId?: string;
+}
+export interface ParkedToolCardSnapshot {
+    readonly id: string;
+    readonly name: string;
+    readonly rawInput: {} | null | undefined;
+    readonly eventId?: string;
+    readonly parentToolCallId?: string;
+    readonly rowUuid?: string;
+    readonly engineRef?: EngineRowRef;
+}
+export interface ParkedToolRowSnapshot {
+    readonly sessionId: string;
+    readonly toolCallId: string;
+    readonly parkedRun?: string;
+    readonly checkpointId?: string;
+    readonly card: ParkedToolCardSnapshot;
 }
 export declare function createAdapterInstanceLedger(): AdapterInstanceLedger;

package/dist/adapt/instanceLedger.js

@@ -1,8 +1,155 @@
+export const PARKED_TOOL_ROWS_MAX = 64;
+export const LATEST_START_ROWS_MAX = 1024;
+const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+function ownData(o, key) {
+    try {
+        if (typeof o !== 'object' || o === null)
+            return undefined;
+        const d = Object.getOwnPropertyDescriptor(o, key);
+        return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function createAdapterInstanceLedger() {
     const renderedNotifications = new Set();
     const seenWorkflowToolCallIds = new Set();
     const firedSubagentStartHookTaskIds = new Set();
+    const parkedRows = new Map();
+    let passSeq = 0;
+    let rowSeq = 0;
+    const addParkedRow = (r) => {
+        const seq = ++rowSeq;
+        const key = `${r.sessionId}\u0000${r.parkedRun ?? ''}\u0000${seq}`;
+        parkedRows.set(key, { ...r, key, seq });
+        while (parkedRows.size > PARKED_TOOL_ROWS_MAX) {
+            const oldest = parkedRows.keys().next();
+            if (oldest.done === true)
+                break;
+            parkedRows.delete(oldest.value);
+        }
+    };
+    const latestStartRows = new Map();
+    const callKey = (sessionId, toolCallId) => `${sessionId}\u0000${toolCallId}`;
+    const isClaimable = (r) => r.card.rowUuid !== undefined && latestStartRows.get(callKey(r.sessionId, r.toolCallId)) === r.card.rowUuid;
+    const setLatestStartRow = (key, rowUuid) => {
+        latestStartRows.delete(key);
+        latestStartRows.set(key, rowUuid);
+        if (latestStartRows.size <= LATEST_START_ROWS_MAX)
+            return;
+        const pinned = new Set([...parkedRows.values()].map((r) => callKey(r.sessionId, r.toolCallId)));
+        for (const k of latestStartRows.keys()) {
+            if (latestStartRows.size <= LATEST_START_ROWS_MAX)
+                break;
+            if (!pinned.has(k))
+                latestStartRows.delete(k);
+        }
+    };
+    const latestFor = (sessionId, toolCallId, pass) => {
+        let hit;
+        for (const r of parkedRows.values()) {
+            if (r.sessionId === sessionId && r.toolCallId === toolCallId && (pass === undefined || r.pass === pass))
+                hit = r;
+        }
+        return hit;
+    };
     return {
+        beginPass: () => ++passSeq,
+        parkToolRow: (row) => {
+            addParkedRow({ sessionId: row.sessionId, toolCallId: row.toolCallId, card: row.card, pass: row.pass });
+        },
+        parkedToolRowFor: (sessionId, toolCallId) => {
+            const r = latestFor(sessionId, toolCallId);
+            return r !== undefined && isClaimable(r) ? r : undefined;
+        },
+        noteParkedFact: (sessionId, pass, fact) => {
+            if (fact.heldCallId === undefined)
+                return;
+            const r = latestFor(sessionId, fact.heldCallId, pass);
+            if (r === undefined)
+                return;
+            if (fact.checkpointId !== undefined)
+                r.checkpointId = fact.checkpointId;
+            if (fact.taskId !== undefined)
+                r.parkedRun = fact.taskId;
+        },
+        retireParkedRowsOfRun: (sessionId, pass, taskId) => {
+            for (const [key, r] of parkedRows) {
+                if (r.sessionId !== sessionId)
+                    continue;
+                if (r.parkedRun !== undefined ? r.parkedRun === taskId : r.pass === pass)
+                    parkedRows.delete(key);
+            }
+        },
+        dropParkedToolRow: (key) => {
+            parkedRows.delete(key);
+        },
+        noteStartRow: (sessionId, toolCallId, rowUuid) => {
+            setLatestStartRow(callKey(sessionId, toolCallId), rowUuid ?? null);
+        },
+        listParkedToolRows: () => [...parkedRows.values()].filter(isClaimable).map((r) => ({
+            sessionId: r.sessionId,
+            toolCallId: r.toolCallId,
+            ...(r.parkedRun !== undefined ? { parkedRun: r.parkedRun } : {}),
+            ...(r.checkpointId !== undefined ? { checkpointId: r.checkpointId } : {}),
+            card: {
+                id: r.card.id,
+                name: r.card.name,
+                rawInput: r.card.rawInput,
+                ...(r.card.eventId !== undefined ? { eventId: r.card.eventId } : {}),
+                ...(r.card.parentToolCallId !== undefined ? { parentToolCallId: r.card.parentToolCallId } : {}),
+                ...(r.card.rowUuid !== undefined ? { rowUuid: r.card.rowUuid } : {}),
+                ...(r.card.engineRef !== undefined ? { engineRef: r.card.engineRef } : {}),
+            },
+        })),
+        takeParkedToolRows: (rows) => {
+            let n = 0;
+            let list = [];
+            try {
+                list = Array.isArray(rows) ? [...rows] : [];
+            }
+            catch {
+                list = [];
+            }
+            for (const raw of list) {
+                const sessionId = str(ownData(raw, 'sessionId'));
+                const toolCallId = str(ownData(raw, 'toolCallId'));
+                const card = ownData(raw, 'card');
+                const id = str(ownData(card, 'id'));
+                const name = str(ownData(card, 'name'));
+                if (sessionId === undefined || toolCallId === undefined || id === undefined || id !== toolCallId || name === undefined)
+                    continue;
+                const rowUuid = str(ownData(card, 'rowUuid'));
+                if ([...parkedRows.values()].some((r) => r.sessionId === sessionId && r.toolCallId === toolCallId && r.card.rowUuid === rowUuid))
+                    continue;
+                const eventId = str(ownData(card, 'eventId'));
+                const parentToolCallId = str(ownData(card, 'parentToolCallId'));
+                const engineRef = ownData(card, 'engineRef');
+                const parkedRun = str(ownData(raw, 'parkedRun'));
+                const checkpointId = str(ownData(raw, 'checkpointId'));
+                const ck = callKey(sessionId, toolCallId);
+                if (!latestStartRows.has(ck) && rowUuid !== undefined)
+                    setLatestStartRow(ck, rowUuid);
+                addParkedRow({
+                    sessionId,
+                    toolCallId,
+                    card: {
+                        id,
+                        name,
+                        rawInput: ownData(card, 'rawInput'),
+                        ...(eventId !== undefined ? { eventId } : {}),
+                        ...(parentToolCallId !== undefined ? { parentToolCallId } : {}),
+                        ...(rowUuid !== undefined ? { rowUuid } : {}),
+                        ...(typeof engineRef === 'object' && engineRef !== null ? { engineRef: engineRef } : {}),
+                    },
+                    ...(parkedRun !== undefined ? { parkedRun } : {}),
+                    ...(checkpointId !== undefined ? { checkpointId } : {}),
+                });
+                n++;
+            }
+            return n;
+        },
         hasRenderedNotification: (key) => renderedNotifications.has(key),
         addRenderedNotification: (key) => {
             renderedNotifications.add(key);

package/dist/adapt/textStream.d.ts

@@ -35,6 +35,7 @@ export interface TextStream {
     closeSegmentAuthorityWindowOnNextText(): void;
     replaceThinkingSegment(content: string, anchor?: Frame): ThinkingSegmentReplacement;
     segmentId(): string;
+    anchorWindow(frame: Frame): void;
     rotateSegmentIdentity(anchor: Frame): void;
     stampSegmentIdentity(out: AdapterOutput): AdapterOutput;
     readonly answerLength: number;