@sema-agent/client-core 0.97.1 → 0.99.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,8 +1,8 @@
-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';
-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,13 +12,64 @@ 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 { washCredentials } from '../displayUntrusted.js';
+import { contextUsageReadingOf, guardedRead, humanInputAttachmentsOf, 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 { 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 +84,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 +113,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 +174,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 +208,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',
@@ -249,8 +311,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;
@@ -360,20 +429,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 } : {}),
     });
 };
@@ -404,6 +466,51 @@ const compactionOutcomeArm = function* (m) {
         ...(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 } : {}),
+    });
+};
 const promptManifestRows = (v, pick) => {
     if (!Array.isArray(v))
         return undefined;
@@ -516,7 +623,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 +632,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 +660,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 +668,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 +767,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 +887,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 ?? {});
@@ -801,7 +929,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);
@@ -844,23 +973,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 });
@@ -869,11 +984,31 @@ 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],
+    ['task_started', taskStartedArm],
     ['stream_event', streamEventArm],
     ['turn_usage', turnUsageArm],
     ['result', resultArm],

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;