@sema-agent/client-core 0.97.1 → 0.99.0

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/panelTasks.d.ts

@@ -10,7 +10,7 @@ export interface PanelTaskLedger {
     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>;
+    settleFromNotification(taskId: string, isError: boolean, sessionId?: string): Generator<AdapterOutput>;
     settleFromTerminalTick(taskId: string, isError: boolean): Generator<AdapterOutput>;
 }
 export declare function createPanelTaskLedger(ctx: AdapterContext, cards: OpenCardView, inst: AdapterInstanceLedger): PanelTaskLedger;

package/dist/adapt/panelTasks.js

@@ -88,7 +88,7 @@ export function createPanelTaskLedger(ctx, cards, inst) {
                 });
             }
         },
-        *settleFromNotification(taskId, isError) {
+        *settleFromNotification(taskId, isError, sessionId) {
             clearResidencyBothKeys(taskId);
             if (endedPanelTasks.has(taskId))
                 return;
@@ -96,7 +96,7 @@ export function createPanelTaskLedger(ctx, cards, inst) {
             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({

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;

package/dist/adapt/textStream.js

@@ -1,4 +1,4 @@
-import { chrome, mainLane, transcript, messageIdentityOf } from './ids.js';
+import { chrome, mainLane, segmentRowId, transcript, messageIdentityOf } from './ids.js';
 import { estimateCjkTokens, FLUSH_INTERVAL_MS } from './wireShapes.js';
 import { resolveTextSegmentAuthority } from './textSegmentAuthority.js';
 export const SEMA_SEGMENT_ID_KEY = '_sema_segment_id';
@@ -44,14 +44,15 @@ export function createTextStream(ctx, idOf) {
         : FLUSH_INTERVAL_MS;
     let segmentAnchor = null;
     let thinkingAnchor = null;
+    let segmentLast = null;
+    let thinkingLast = null;
     let committedThinking = [];
     let thinkingSettled = false;
     let segmentWindowAnchor = null;
-    let segmentWindowSerial = 0;
     let segmentIdCache = null;
     const segmentIdNow = () => {
         if (segmentIdCache === null)
-            segmentIdCache = idOf(segmentWindowAnchor ?? {}, `segment${segmentWindowSerial}`);
+            segmentIdCache = idOf(segmentWindowAnchor ?? {}, 'segment');
         return segmentIdCache;
     };
     function* takeThinking() {
@@ -61,7 +62,7 @@ export function createTextStream(ctx, idOf) {
         const msg = {
             type: 'assistant',
             message: { role: 'assistant', content: [{ type: 'thinking', thinking }], ...messageIdentityOf(anchor, ctx) },
-            uuid: idOf(anchor, 'thinking'),
+            uuid: segmentRowId(idOf, anchor, thinkingLast, 'thinking'),
             session_id: ctx.sessionId,
             parent_tool_use_id: null,
         };
@@ -70,6 +71,7 @@ export function createTextStream(ctx, idOf) {
         thinkingSettled = false;
         thinking = '';
         thinkingAnchor = null;
+        thinkingLast = null;
         thinkingBlockOpen = false;
         yield chrome({ kind: 'thinking_activity', laneProof: mainLane(), active: false });
         yield transcript(msg, ctx.now());
@@ -82,7 +84,7 @@ export function createTextStream(ctx, idOf) {
         const msg = {
             type: 'assistant',
             message: { role: 'assistant', content: [{ type: 'text', text: body }], ...messageIdentityOf(anchor, ctx) },
-            uuid: idOf(anchor, 'text'),
+            uuid: segmentRowId(idOf, anchor, segmentLast, 'text'),
             session_id: ctx.sessionId,
             parent_tool_use_id: null,
         };
@@ -94,6 +96,7 @@ export function createTextStream(ctx, idOf) {
         segmentSealed = '';
         answerSegment = '';
         segmentAnchor = null;
+        segmentLast = null;
         emittedAssistantText = true;
         textBlockOpen = false;
         yield transcript(msg, ctx.now());
@@ -158,6 +161,7 @@ export function createTextStream(ctx, idOf) {
             }
             if (answerSegment.length === 0 && segmentSealed.length === 0)
                 segmentAnchor = frame;
+            segmentLast = frame;
             if (segmentWindowAnchor === null)
                 segmentWindowAnchor = frame;
             answer += delta;
@@ -176,6 +180,7 @@ export function createTextStream(ctx, idOf) {
                     thinkingSettled = false;
                 }
             }
+            thinkingLast = frame;
             if (thinking.length === 0) {
                 thinkingAnchor = frame;
                 yield chrome({ kind: 'thinking_activity', laneProof: mainLane(), active: true });
@@ -283,6 +288,8 @@ export function createTextStream(ctx, idOf) {
             }
             else {
                 segmentSealed += verdict.tail;
+                if (diverged && anchor !== undefined)
+                    segmentLast = anchor;
             }
             answerSegment = '';
             if (answer.endsWith(liveSegment)) {
@@ -290,6 +297,8 @@ export function createTextStream(ctx, idOf) {
             }
             if (segmentAnchor === null && anchor !== undefined)
                 segmentAnchor = anchor;
+            if (segmentLast === null && anchor !== undefined)
+                segmentLast = anchor;
             segmentCommitted = '';
             previousSegmentCommitted = '';
             idleFlushUsedInSegment = false;
@@ -314,7 +323,7 @@ export function createTextStream(ctx, idOf) {
             if (typeof committed === 'string')
                 committedText += committed;
         },
-        replaceThinkingSegment: (content) => {
+        replaceThinkingSegment: (content, anchor) => {
             const rows = committedThinking;
             committedThinking = [];
             const prefix = rows.map((r) => r.text).join('');
@@ -330,6 +339,8 @@ export function createTextStream(ctx, idOf) {
                 thinkingPending = content.startsWith(emitted) ? content.slice(emitted.length) : '';
                 thinking = content;
                 thinkingSettled = content.length > 0;
+                if (diverged && anchor !== undefined)
+                    thinkingLast = anchor;
                 return { diverged, committedPrefixLen: 0, committedPrefixDiverged: false, committedUuids: [] };
             }
             const committedPrefixDiverged = !content.startsWith(prefix);
@@ -340,19 +351,25 @@ export function createTextStream(ctx, idOf) {
                     thinkingPending = tail.startsWith(emitted) ? tail.slice(emitted.length) : '';
                     thinking = tail;
                     thinkingSettled = tail.length > 0;
+                    if (diverged && anchor !== undefined)
+                        thinkingLast = anchor;
                 }
                 return { diverged, committedPrefixLen: prefix.length, committedPrefixDiverged: false, ...(last !== undefined ? { committedUuid: last } : {}), committedUuids: uuids };
             }
             thinking = '';
             thinkingPending = '';
             thinkingAnchor = null;
+            thinkingLast = null;
             thinkingSettled = false;
             return { diverged: true, committedPrefixLen: prefix.length, committedPrefixDiverged: true, ...(last !== undefined ? { committedUuid: last } : {}), committedUuids: uuids };
         },
         segmentId: segmentIdNow,
+        anchorWindow: (frame) => {
+            if (segmentWindowAnchor === null)
+                segmentWindowAnchor = frame;
+        },
         rotateSegmentIdentity: (anchor) => {
             committedTextRows = [];
-            segmentWindowSerial += 1;
             segmentWindowAnchor = anchor;
             segmentIdCache = null;
         },

package/dist/adapt/toolCards.d.ts

@@ -1,25 +1,44 @@
 import type { AdapterContext, AdapterOutput } from '../seam.js';
-import { structuredToToolUseResult, type ToolResultBody } from '../toolResult.js';
+import { structuredToToolUseResult, type ToolKillCause, type ToolResultBody } from '../toolResult.js';
 import { type Frame, type IdOf } from './ids.js';
+import type { EngineRowRef } from '../engineRowRef.js';
+import { type GateOutcomeView } from '../gateOutcome.js';
 type RichToolUseResult = NonNullable<ReturnType<typeof structuredToToolUseResult>>;
 export interface ToolResultOutcome {
     readonly body: ToolResultBody;
     readonly rich: RichToolUseResult | null;
 }
 export type ToolResultOwner = 'leader' | 'subagent';
-export declare function toolResultOutcomeOf(toolName: string, end: ToolEndPayload | undefined, rawInput: PendingToolUse['rawInput'], owner: ToolResultOwner, ledgerTier?: (isError: boolean) => RichToolUseResult | null): ToolResultOutcome;
+export declare function toolResultOutcomeOf(toolName: string, end: ToolEndPayload | undefined, rawInput: PendingToolUse['rawInput'], owner: ToolResultOwner, ledgerTier?: (isError: boolean) => RichToolUseResult | null, killCauseOf?: () => ToolKillCause | undefined): ToolResultOutcome;
 export interface ToolResultEnvelopeKeys {
     readonly tool_use_result?: ToolResultBody['toolUseResult'];
     readonly _sema_degraded?: ToolResultBody['degraded'];
 }
 export declare function toolResultEnvelopeParts(o: ToolResultOutcome): ToolResultEnvelopeKeys;
-interface PendingToolUse {
+export interface PendingToolUse {
     id: string;
     name: string;
-    rawInput: unknown;
+    rawInput: {} | null | undefined;
     eventId?: string;
     parentToolCallId?: string;
+    engineRef?: EngineRowRef | undefined;
+    rowUuid?: string | undefined;
 }
+export declare function toolResultRowIdentity(sources: readonly {
+    readonly eventId?: string | undefined;
+    readonly engineRef?: EngineRowRef | undefined;
+}[], toolCallId: string, ctx: Pick<AdapterContext, 'uuid'>): {
+    readonly uuid: string;
+    readonly engineRef?: EngineRowRef;
+};
+export interface ToolResultRowFlagParts {
+    readonly _sema_not_executed?: true;
+    readonly _sema_collateral_abort?: true;
+    readonly _sema_interrupted_never_started?: true;
+    readonly _sema_approval_window_expired?: true;
+    readonly _sema_denial_limit_window_expired?: true;
+}
+export declare function toolResultRowFlagParts(arm: object | null | undefined): ToolResultRowFlagParts;
 interface ToolEndPayload {
     output?: unknown;
     structured?: unknown;
@@ -28,7 +47,9 @@ interface ToolEndPayload {
     eventId?: string | undefined;
     parentToolCallId?: string | undefined;
     denialKind?: string | undefined;
-    notExecuted?: boolean | undefined;
+    closeArm?: object | undefined;
+    engineRef?: EngineRowRef | undefined;
+    gate?: GateOutcomeView | undefined;
 }
 export interface OpenCardView {
     has(id: string): boolean;
@@ -37,6 +58,7 @@ export interface OpenCardView {
 }
 export interface ToolCardLedger extends OpenCardView {
     open(p: PendingToolUse): void;
+    detach(id: string): PendingToolUse | undefined;
     close(p: PendingToolUse, end?: ToolEndPayload): Generator<AdapterOutput>;
     sweep(): Generator<AdapterOutput>;
     mintResponseId(frame: Frame): string;

package/dist/adapt/toolCards.js

@@ -5,14 +5,17 @@ import { flattenWireOutput } from './wireShapes.js';
 import { toolResultBlocksOf } from '../toolResultContent.js';
 import { bashExitOf, bashExitReadingFailed } from '../bashExitReading.js';
 import { isCcToolDenialKind } from '../gateVocabulary.js';
+import { guardedRead, readFrameStringKey, readFrameTrueMark } from '../ownKey.js';
+import { gateOutcomeOf, isApprovalWindowExpiredGate, isDenialLimitAutoDeniedGate } from '../gateOutcome.js';
+import { TOOL_END_INTERRUPTED_NEVER_STARTED } from '../engineErrorCodes.js';
 function toolUseResultParts(v) {
     return v !== undefined ? { tool_use_result: v } : {};
 }
-export function toolResultOutcomeOf(toolName, end, rawInput, owner, ledgerTier) {
+export function toolResultOutcomeOf(toolName, end, rawInput, owner, ledgerTier, killCauseOf) {
     const isError = end?.isError ?? false;
     const leaderLedger = owner === 'leader';
     const body = end && end.output !== undefined
-        ? wireOutputToBody(toolName, end.output, isError, end.truncated === true, flattenWireOutput, end.structured, leaderLedger)
+        ? wireOutputToBody(toolName, end.output, isError, end.truncated === true, flattenWireOutput, end.structured, leaderLedger, killCauseOf)
         : degradedToolResultBody(isError);
     let rich = end?.structured !== undefined
         ? structuredToToolUseResult(end.structured, end.output !== undefined ? flattenWireOutput(end.output) : undefined, leaderLedger)
@@ -40,6 +43,27 @@ export function toolResultEnvelopeParts(o) {
         ...(o.body.degraded !== undefined ? { _sema_degraded: o.body.degraded } : {}),
     };
 }
+export function toolResultRowIdentity(sources, toolCallId, ctx) {
+    for (const src of sources) {
+        if (typeof src.eventId === 'string' && src.eventId.length > 0) {
+            const ref = src.engineRef;
+            return { uuid: src.eventId, ...(ref !== undefined && ref.eventId === src.eventId ? { engineRef: ref } : {}) };
+        }
+    }
+    return { uuid: deriveTranscriptId({ toolCallId }, ctx) };
+}
+export function toolResultRowFlagParts(arm) {
+    if (arm === null || arm === undefined)
+        return {};
+    const gate = guardedRead(() => gateOutcomeOf(arm));
+    return {
+        ...(readFrameTrueMark(arm, 'notExecuted') ? { _sema_not_executed: true } : {}),
+        ...(readFrameTrueMark(arm, '_sema_collateral_abort') ? { _sema_collateral_abort: true } : {}),
+        ...(readFrameStringKey(arm, 'errorCode') === TOOL_END_INTERRUPTED_NEVER_STARTED ? { _sema_interrupted_never_started: true } : {}),
+        ...(isApprovalWindowExpiredGate(gate) ? { _sema_approval_window_expired: true } : {}),
+        ...(isDenialLimitAutoDeniedGate(gate) ? { _sema_denial_limit_window_expired: true } : {}),
+    };
+}
 export function createToolCardLedger(ctx, idOf) {
     const pending = new Map();
     let assistantResponseId = null;
@@ -63,9 +87,9 @@ export function createToolCardLedger(ctx, idOf) {
                 return null;
             lastLiveTodos = todo.newTodos;
             return { toolUseResult: todo.toolUseResult, isError: todo.isError };
-        });
+        }, () => ctx.toolKillCause?.({ toolCallId: p.id, toolName: p.name }));
         const { body } = outcome;
-        const eventId = end?.eventId ?? p.eventId;
+        const ident = toolResultRowIdentity([{ eventId: end?.eventId, engineRef: end?.engineRef }, { eventId: p.eventId, engineRef: p.engineRef }], p.id, ctx);
         yield transcript({
             type: 'user',
             message: {
@@ -79,12 +103,13 @@ export function createToolCardLedger(ctx, idOf) {
                     },
                 ],
             },
-            uuid: eventId ?? deriveTranscriptId({ toolCallId: p.id }, ctx),
+            uuid: idOf.adopt(ident.uuid, ident.engineRef),
             session_id: ctx.sessionId,
             ...(parentToolCallId !== undefined ? { parent_tool_use_id: parentToolCallId } : {}),
             ...toolResultEnvelopeParts(outcome),
             ...(isCcToolDenialKind(end?.denialKind) ? { _sema_denial_kind: end.denialKind } : {}),
-            ...(end?.notExecuted === true ? { _sema_not_executed: true } : {}),
+            ...(end?.gate !== undefined ? { _sema_gate: end.gate } : {}),
+            ...toolResultRowFlagParts(end?.closeArm),
         }, ctx.now());
     }
     function* closeCard(p, end) {
@@ -99,6 +124,14 @@ export function createToolCardLedger(ctx, idOf) {
         open: (p) => {
             pending.set(p.id, p);
         },
+        detach: (id) => {
+            const p = pending.get(id);
+            if (p === undefined)
+                return undefined;
+            pending.delete(id);
+            assistantResponseId = null;
+            return p;
+        },
         close: closeCard,
         *sweep() {
             for (const [, p] of pending) {

package/dist/adapt/wireShapes.js

@@ -1,8 +1,13 @@
 import { frozenSet } from '../frozenSet.js';
+import { CORE_BUILTIN_SUBAGENT_TYPES } from '../generated/engineFactTables.js';
 import { stripToolUseSideChannels } from '../adapter/types.js';
 import { toolEndOutputText } from '../toolResultContent.js';
 export const FLUSH_INTERVAL_MS = 100;
 export const IDLE_FLUSH_MS = 1500;
+const SHELL_ROLE_SUBAGENT_TYPE = 'worker';
+function isHonouredSubagentType(word) {
+    return word === SHELL_ROLE_SUBAGENT_TYPE || CORE_BUILTIN_SUBAGENT_TYPES.includes(word);
+}
 export const SUBAGENT_TOOL_NAMES = frozenSet(['Task', 'Agent', 'Fork']);
 export const WORKFLOW_TOOL_NAMES = frozenSet(['Workflow', 'RunWorkflow', 'run_workflow']);
 export const TASK_TOOL_NAMES = new Set(['TodoWrite', 'TaskCreate', 'TaskUpdate']);
@@ -61,8 +66,7 @@ export function sanitizeToolUseBlock(block) {
     }
     if (SUBAGENT_TOOL_NAMES.has(out.name) && out.input && typeof out.input === 'object') {
         const inp = out.input;
-        if (typeof inp.subagent_type === 'string' &&
-            !['fork', 'general-purpose', 'worker'].includes(inp.subagent_type)) {
+        if (typeof inp.subagent_type === 'string' && !isHonouredSubagentType(inp.subagent_type)) {
             delete inp.subagent_type;
         }
     }

package/dist/adapt.d.ts

@@ -1,10 +1,12 @@
 import type { AdapterContext, AdapterOutput, WireToCcAdapter } from './seam.js';
 export { CANCEL_MESSAGE, estimateCjkTokens, flattenWireOutput, FLUSH_INTERVAL_MS, IDLE_FLUSH_MS, REJECT_MESSAGE, sanitizeToolUseBlock, SUBAGENT_TOOL_NAMES, WORKFLOW_TOOL_NAMES, } from './adapt/wireShapes.js';
+import { type ParkedToolRowSnapshot } from './adapt/instanceLedger.js';
 export interface AdapterLedgerState {
     version: 1;
     renderedNotifications: string[];
     notifiedRuns: string[];
     cardEnqueuedRuns: string[];
+    parkedToolRows?: ParkedToolRowSnapshot[];
 }
 export declare const ADAPTER_COVERAGE: {
     readonly frames: readonly ["assistant", "user", "stream_event", "turn_usage", "result", "system", "task_notification", "workflow_complete", "diagnostics", "steering_injected", "workspace_changed", "human_input", "message_committed", "engine_notice", "text_end", "prompt_suggestions", "retry_status", "task_progress", "tool_end_result(label 补位 + 关卡 settle + response-id 复位 + 开卡台账出栈 + 经 cards.close 铸 tool_result)"];

package/dist/adapt.js

@@ -1,7 +1,7 @@
 import { isEngineWorkflowNotified, isWorkflowCompletionCardEnqueued, listNotifiedRuns, listWorkflowCompletionCardsEnqueued, markEngineWorkflowNotified, noteWorkflowCompletionCardEnqueued, parseTranscriptNotificationSeeds, } from './notifications.js';
 export { CANCEL_MESSAGE, estimateCjkTokens, flattenWireOutput, FLUSH_INTERVAL_MS, IDLE_FLUSH_MS, REJECT_MESSAGE, sanitizeToolUseBlock, SUBAGENT_TOOL_NAMES, WORKFLOW_TOOL_NAMES, } from './adapt/wireShapes.js';
 import { IDLE_FLUSH_MS } from './adapt/wireShapes.js';
-import { chrome, mainLane, makeIdOf } from './adapt/ids.js';
+import { carryRowSidecars, chrome, mainLane, makeIdOf } from './adapt/ids.js';
 import { createTextStream } from './adapt/textStream.js';
 import { createToolCardLedger } from './adapt/toolCards.js';
 import { createPanelTaskLedger } from './adapt/panelTasks.js';
@@ -122,6 +122,7 @@ class WireToCcAdapterImpl {
             renderedNotifications: this.ledger.listRenderedNotifications(),
             notifiedRuns: listNotifiedRuns(),
             cardEnqueuedRuns: listWorkflowCompletionCardsEnqueued(),
+            ...((rows) => (rows.length > 0 ? { parkedToolRows: rows } : {}))(this.ledger.listParkedToolRows()),
         };
     }
     importLedger(state) {
@@ -142,6 +143,7 @@ class WireToCcAdapterImpl {
             n += this.ledger.takeRenderedNotifications(rendered);
         takeModule(s.notifiedRuns, isEngineWorkflowNotified, markEngineWorkflowNotified);
         takeModule(s.cardEnqueuedRuns, isWorkflowCompletionCardEnqueued, noteWorkflowCompletionCardEnqueued);
+        n += this.ledger.takeParkedToolRows(s.parkedToolRows);
         return n;
     }
     importLedgerFromTranscript(messages) {
@@ -159,19 +161,22 @@ class WireToCcAdapterImpl {
     async *adapt(frames, ctx) {
         const slot = {};
         for await (const out of this.adaptUnstamped(frames, ctx, slot)) {
-            yield slot.text === undefined ? out : slot.text.stampSegmentIdentity(out);
+            const segmented = slot.text === undefined ? out : slot.text.stampSegmentIdentity(out);
+            yield slot.idOf === undefined ? segmented : carryRowSidecars(segmented, slot.idOf);
         }
     }
     async *adaptUnstamped(frames, ctx, slot) {
         const inst = this.ledger;
         const turnStartAt = ctx.now();
         const idOf = makeIdOf(ctx);
+        slot.idOf = idOf;
         const text = createTextStream(ctx, idOf);
         slot.text = text;
         const cards = createToolCardLedger(ctx, idOf);
         const panel = createPanelTaskLedger(ctx, cards, inst);
         const flags = createTurnFlags(ctx, turnStartAt);
-        const deps = { ctx, idOf, text, cards, panel, flags, inst };
+        const pass = inst.beginPass();
+        const deps = { ctx, idOf, text, cards, panel, flags, inst, pass };
         yield chrome({ kind: 'retry_status', laneProof: mainLane(), status: null });
         yield chrome({ kind: 'prompt_suggestions', laneProof: mainLane(), suggestions: null });
         yield chrome({ kind: 'thinking_activity', laneProof: mainLane(), active: false });

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';
@@ -99,6 +100,7 @@ export type SelfHealOutcome = {
     taskId: string;
     status: string;
     alreadyOffered?: true;
+    pendingGateKind?: string | null;
 } | {
     kind: 'running-not-found';
     taskId: string;
@@ -159,6 +161,10 @@ export type SelfHealOutcome = {
 } | {
     kind: 'ask-run-not-found';
     taskId: string;
+} | {
+    kind: 'ask-run-settled';
+    taskId: string;
+    status: string;
 } | {
     kind: 'stale-park-cancelled';
     taskId: string;
@@ -226,6 +232,6 @@ export interface ActiveRunSelfHealCopy {
     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;