@sema-agent/client-core 0.94.0 → 0.96.0

package/dist/subagent/engineCompactWire.js

@@ -1,10 +1,12 @@
 import { hostLog, hostTimersFor } from '../host.js';
+import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
 import { COMPACT_NOT_RUNNING, isUnavailableFaceCode } from '../engineErrorCodes.js';
 import { surfaceCompactNotRunning } from '../hitl/hitlHostSurface.js';
 import { wireFailureShapeOf, wireFailureTextsOf } from '../wireFailureShape.js';
 import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, noAnswerDetailFrom, settleInjected, } from '../engineWireFor.js';
 import { activeEngineRunIdFor, engineSessionParamFor } from '../engineSessionParam.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
+import { engineCapState, kickEngineCapsProbe } from '../engineCapsCache.js';
 function usableCompactClient(client) {
     return clientHasVerbs(client, [['capabilities'], ['runs', 'compact']]);
 }
@@ -14,43 +16,21 @@ const pendingCompactSinks = new Map();
 export function isEngineCompactPending(sessionKey = DEFAULT_SESSION_KEY) {
     return pendingCompactKeys.has(sessionKey);
 }
-const manualCompactCapableByBase = new Map();
-const capabilitiesProbeByBase = new Map();
 function probeManualCompactCapability(wire) {
     const base = wire.kind === 'injected' ? wire.capsBaseUrl : wire.target.baseUrl;
     if (base === undefined)
         return;
-    if (capabilitiesProbeByBase.has(base))
+    if (wire.kind === 'injected') {
+        const injected = wire.client;
+        kickEngineCapsProbe(base, () => settleInjected(COMPACT_PROBE_SETTLE_MS, undefined, (signal) => injected.capabilities({ signal })));
         return;
-    capabilitiesProbeByBase.set(base, (async () => {
-        try {
-            let caps;
-            if (wire.kind === 'injected') {
-                const injected = wire.client;
-                caps = await settleInjected(COMPACT_PROBE_SETTLE_MS, undefined, (signal) => injected.capabilities({ signal }));
-            }
-            else {
-                const client = wire.make({ timeoutMs: 5000 });
-                if (!client) {
-                    capabilitiesProbeByBase.delete(base);
-                    return;
-                }
-                caps = await client.capabilities();
-            }
-            if (typeof caps.manualCompact === 'boolean')
-                manualCompactCapableByBase.set(base, caps.manualCompact);
-            else
-                capabilitiesProbeByBase.delete(base);
-        }
-        catch {
-            capabilitiesProbeByBase.delete(base);
-        }
-    })());
-}
-export function resetManualCompactCapability() {
-    manualCompactCapableByBase.clear();
-    capabilitiesProbeByBase.clear();
+    }
+    const client = wire.make({ timeoutMs: 5000 });
+    if (!client)
+        return;
+    kickEngineCapsProbe(base, () => client.capabilities());
 }
+export function resetManualCompactCapability() { }
 export function __resetEngineCompactArmForTests() {
     pendingCompactKeys.clear();
     pendingCompactSinks.clear();
@@ -91,12 +71,7 @@ function emitCompactOutcome(sink, outcome) {
     void Promise.resolve().then(() => callSinkIsolated(sink, outcome));
 }
 function callSinkIsolated(sink, outcome) {
-    try {
-        sink(outcome);
-    }
-    catch (e) {
-        hostLog('debug', `engineCompactWire: onSettled sink threw (ignored): ${wireFailureTextsOf(e).log}`);
-    }
+    invokeHostCallbackIsolated('engineCompactWire: onSettled sink', () => sink(outcome));
 }
 function fanOutCompactSinks(sinks) {
     if (sinks === undefined || sinks.length === 0)
@@ -157,7 +132,7 @@ export function requestEngineCompact(sessionKey = DEFAULT_SESSION_KEY, opts) {
         return 'offline';
     probeManualCompactCapability(wire);
     const capsKey = wire.kind === 'injected' ? wire.capsBaseUrl : wire.target.baseUrl;
-    if (capsKey !== undefined && manualCompactCapableByBase.get(capsKey) === false) {
+    if (engineCapState(capsKey, 'manualCompact') === 'false') {
         hostLog('debug', 'engineCompactWire: engine capabilities report manualCompact:false — verb suppressed (TOC-local runStore-less engine, [488])');
         return 'unsupported';
     }

package/dist/subagent/engineDelegatedPrompt.js

@@ -1,23 +1,25 @@
 import { stripSystemReminderBlocks } from '../systemReminderTag.js';
 import { hostLog } from '../host.js';
+import { isSessionIdPathSegment } from '../sessionIdSegment.js';
 import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, settleInjected } from '../engineWireFor.js';
 import { resolveOwnerContext } from './engineSubagentResume.js';
+import { panelAnchorOf } from '../panelReduce.js';
+import { clearEnginePanelAnchors, panelStateNow, stepEnginePanel } from '../panelStateHolder.js';
 function usableDelegatedPromptClient(client) {
     return clientHasVerbs(client, [['sessions', 'get']]);
 }
 const TAIL_WINDOW = 200;
 const BLOB_CAP = 8 * 1024;
-const transcriptIdByTask = new Map();
 export function recordEngineTranscriptId(taskId, transcriptId) {
     if (!taskId || !transcriptId)
         return;
-    transcriptIdByTask.set(taskId, transcriptId);
+    stepEnginePanel({ kind: 'anchor', taskId, transcriptId });
 }
 export function getEngineTranscriptId(taskId) {
-    return transcriptIdByTask.get(taskId);
+    return panelAnchorOf(panelStateNow(), taskId);
 }
 export function __resetEngineDelegatedPromptForTests() {
-    transcriptIdByTask.clear();
+    clearEnginePanelAnchors();
     promptHydrateInFlight.clear();
 }
 const promptHydrateInFlight = new Set();
@@ -94,6 +96,8 @@ export function __setTranscriptWindowReaderForTests(r) {
 async function readTranscriptWindow(transcriptId, sessionKey, injectedWire) {
     if (transcriptWindowReader)
         return transcriptWindowReader(transcriptId);
+    if (!isSessionIdPathSegment(transcriptId))
+        return null;
     const wire = engineWireFor(injectedWire, sessionKey, usableDelegatedPromptClient);
     if (wire.kind === 'no-target' || wire.kind === 'injected-unusable')
         return null;
@@ -112,8 +116,8 @@ async function readTranscriptWindow(transcriptId, sessionKey, injectedWire) {
 export async function fetchDelegatedPrompt(taskId, opts) {
     if (promptHydrateInFlight.has(taskId))
         return { outcome: 'skipped' };
-    const transcriptId = transcriptIdByTask.get(taskId);
-    if (!transcriptId)
+    const transcriptId = getEngineTranscriptId(taskId);
+    if (!isSessionIdPathSegment(transcriptId))
         return { outcome: 'skipped' };
     promptHydrateInFlight.add(taskId);
     let msgs = null;

package/dist/subagent/engineSubagentOutput.d.ts

@@ -5,7 +5,6 @@ export type SubagentReportWireClient = {
     runs: Pick<AgentClient['runs'], 'subagentOutput'>;
 };
 export type SubagentReportWire = EngineWireInjection<SubagentReportWireClient>;
-export declare function __resetSubagentOutputCapCacheForTests(): void;
 export interface EngineSubagentReport {
     content: string;
     status?: string;

package/dist/subagent/engineSubagentOutput.js

@@ -1,32 +1,17 @@
 import { hostLog } from '../host.js';
 import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, settleInjected } from '../engineWireFor.js';
+import { engineCapStateVia } from '../engineCapsCache.js';
 import { engineSessionParamFor } from '../engineSessionParam.js';
 import { resolveOwnerContext } from './engineSubagentResume.js';
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
 function usableReportClient(client) {
     return clientHasVerbs(client, [['capabilities'], ['runs', 'subagentOutput']]);
 }
-const capByBase = new Map();
-const CAP_FALSE_RETRY_TTL_MS = 5 * 60_000;
 async function subagentOutputCapable(client, cacheKey, signal, deadlineMs) {
-    const hit = cacheKey !== undefined ? capByBase.get(cacheKey) : undefined;
-    if (hit && (hit.ok || Date.now() - hit.at < CAP_FALSE_RETRY_TTL_MS))
-        return hit.ok;
-    try {
-        const caps = deadlineMs !== undefined
-            ? await settleInjected(deadlineMs, signal, (s) => client.capabilities({ signal: s }))
-            : await client.capabilities({ ...(signal ? { signal } : {}) });
-        const ok = caps.subagentOutput === true;
-        if (cacheKey !== undefined)
-            capByBase.set(cacheKey, { ok, at: Date.now() });
-        return ok;
-    }
-    catch {
-        return false;
-    }
-}
-export function __resetSubagentOutputCapCacheForTests() {
-    capByBase.clear();
+    const state = await engineCapStateVia(cacheKey, 'subagentOutput', (s) => deadlineMs !== undefined
+        ? settleInjected(deadlineMs, s, (x) => client.capabilities({ signal: x }))
+        : client.capabilities({ ...(s ? { signal: s } : {}) }), { withinMs: deadlineMs ?? INJECTED_WIRE_SETTLE_MS, ...(signal ? { signal } : {}) });
+    return state === 'true';
 }
 export async function fetchEngineSubagentReport(taskId, opts) {
     const { record: owner, runId, key } = resolveOwnerContext(taskId);

package/dist/subagent/engineSubagentSteer.js

@@ -5,6 +5,7 @@ import { resolveOwnerContext, resolveOwnerRunId } from './engineSubagentResume.j
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
 import { errCodes, steeringRefusedBeforeEngine } from '../controlRouter.js';
 import { ownNonEmptyStringOf } from '../steerReceipt.js';
+import { wireFailureTextsOf } from '../wireFailureShape.js';
 function usableSteerClient(client) {
     return clientHasVerbs(client, [['runs', 'steerSubagent']]);
 }
@@ -53,14 +54,14 @@ export async function steerEngineSubagent(target, text, childTaskId, opts) {
             status = undefined;
         }
         if (status !== undefined) {
-            const detail = e instanceof Error ? e.message : String(e);
-            hostLog('debug', `engineSubagentSteer: ${status} ${detail.slice(0, 200)}`);
+            const texts = wireFailureTextsOf(e);
+            hostLog('debug', `engineSubagentSteer: ${status} ${texts.log.slice(0, 200)}`);
             const refused = typeof e === 'object' && e !== null ? steeringRefusedBeforeEngine(e) : undefined;
             if (refused !== undefined && refused.safety === 'ledger_unavailable') {
                 return { ok: false, reason: 'not-delivered', safety: refused.safety, detail: refused.advice };
             }
             if (status === 409 || status === 404) {
-                return { ok: false, reason: 'not-running', detail };
+                return { ok: false, reason: 'not-running', detail: texts.reason };
             }
             return { ok: false, reason: 'error', detail: `${status}` };
         }
@@ -69,7 +70,8 @@ export async function steerEngineSubagent(target, text, childTaskId, opts) {
             hostLog('debug', `engineSubagentSteer: may have been received, no answer — ${noAnswer}`);
             return { ok: false, reason: 'error', detail: noAnswer, unconfirmed: true };
         }
-        hostLog('debug', `engineSubagentSteer: fetch failed ${String(e)}`);
-        return { ok: false, reason: 'error', detail: String(e) };
+        const texts = wireFailureTextsOf(e);
+        hostLog('debug', `engineSubagentSteer: fetch failed ${texts.log}`);
+        return { ok: false, reason: 'error', detail: texts.reason };
     }
 }

package/dist/subagent/engineSubagentTail.d.ts

@@ -5,7 +5,6 @@ export type SubagentTailWireClient = {
     runs: Pick<AgentClient['runs'], 'subagentStream'>;
 };
 export type SubagentTailWire = EngineWireInjection<SubagentTailWireClient>;
-export declare function __resetSubagentStreamCapCacheForTests(): void;
 export interface SubagentActivity {
     taskId: string;
     toolName: string;

package/dist/subagent/engineSubagentTail.js

@@ -1,5 +1,7 @@
 import { hostLog } from '../host.js';
+import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
 import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, settleInjected } from '../engineWireFor.js';
+import { engineCapStateVia } from '../engineCapsCache.js';
 import { engineSessionParamFor } from '../engineSessionParam.js';
 import { resolveOwnerContext } from './engineSubagentResume.js';
 import { coerceOutput, parentToolCallIdOf, publishSubagentContentEvent, settleSubagentContent, } from '../subagentContentStore.js';
@@ -7,27 +9,11 @@ import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
 function usableTailClient(client) {
     return clientHasVerbs(client, [['capabilities'], ['runs', 'subagentStream']]);
 }
-const capByBase = new Map();
-const CAP_FALSE_RETRY_TTL_MS = 5 * 60_000;
 async function subagentStreamCapable(client, cacheKey, signal, deadlineMs) {
-    const hit = cacheKey !== undefined ? capByBase.get(cacheKey) : undefined;
-    if (hit && (hit.ok || Date.now() - hit.at < CAP_FALSE_RETRY_TTL_MS))
-        return hit.ok;
-    try {
-        const caps = deadlineMs !== undefined
-            ? await settleInjected(deadlineMs, signal, (s) => client.capabilities({ signal: s }))
-            : await client.capabilities({ ...(signal ? { signal } : {}) });
-        const ok = caps.subagentStream === true;
-        if (cacheKey !== undefined)
-            capByBase.set(cacheKey, { ok, at: Date.now() });
-        return ok;
-    }
-    catch {
-        return false;
-    }
-}
-export function __resetSubagentStreamCapCacheForTests() {
-    capByBase.clear();
+    const state = await engineCapStateVia(cacheKey, 'subagentStream', (s) => deadlineMs !== undefined
+        ? settleInjected(deadlineMs, s, (x) => client.capabilities({ signal: x }))
+        : client.capabilities({ ...(s ? { signal: s } : {}) }), { withinMs: deadlineMs ?? INJECTED_WIRE_SETTLE_MS, ...(signal ? { signal } : {}) });
+    return state === 'true';
 }
 const activeTails = new Map();
 let activitySink = null;
@@ -106,18 +92,7 @@ export function tailEngineSubagent(taskId, opts) {
                 }
                 switch (ev.event) {
                     case 'meta':
-                        try {
-                            const out = tailMetaSink?.({ taskId, meta: ev.data });
-                            if (out !== null && typeof out === 'object' && typeof out.then === 'function') {
-                                ;
-                                out.then(undefined, (e) => {
-                                    hostLog('debug', `[subagent-tail] ${taskId} meta sink rejected: ${String(e).slice(0, 160)}`);
-                                });
-                            }
-                        }
-                        catch (e) {
-                            hostLog('debug', `[subagent-tail] ${taskId} meta sink threw: ${String(e).slice(0, 160)}`);
-                        }
+                        invokeHostCallbackIsolated(`[subagent-tail] ${taskId} meta sink`, () => tailMetaSink?.({ taskId, meta: ev.data }));
                         continue;
                     case 'forward':
                         break;

package/dist/subagentContentStore.js

@@ -1,21 +1,11 @@
+import { DEFAULT_SESSION_KEY } from './sessionSlot.js';
+import { toolEndOutputText } from './toolResultContent.js';
 export function coerceOutput(v) {
     if (v === undefined || v === null)
         return undefined;
-    if (typeof v === 'string')
-        return v;
-    if (Array.isArray(v)) {
-        const parts = [];
-        for (const block of v) {
-            if (block && typeof block === 'object') {
-                const b = block;
-                if (b.type === 'text' && typeof b.text === 'string')
-                    parts.push(b.text);
-                else if (b.type === 'image')
-                    parts.push('[image]');
-            }
-        }
-        return parts.join('');
-    }
+    const text = toolEndOutputText(v);
+    if (text !== undefined)
+        return text;
     try {
         return JSON.stringify(v);
     }
@@ -648,7 +638,6 @@ export function getBgTerminalFacts(taskId) {
 }
 const MAX_BG_PARENT_RUNS = 320;
 const bgParentRun = new Map();
-const DEFAULT_OWNER_SLOT = '__default__';
 let ownerSessionConflictCount = 0;
 let lastOwnerSessionConflict;
 const conflictQuarantine = new Map();
@@ -703,8 +692,8 @@ export function recordSubagentOwner(taskId, runId, sessionId, sessionKey) {
             },
             next: { ...nextPair },
         };
-        const priorSlot = prior?.sessionKey ?? DEFAULT_OWNER_SLOT;
-        const nextSlot = nextPair.sessionKey ?? DEFAULT_OWNER_SLOT;
+        const priorSlot = prior?.sessionKey ?? DEFAULT_SESSION_KEY;
+        const nextSlot = nextPair.sessionKey ?? DEFAULT_SESSION_KEY;
         if (priorSlot !== nextSlot) {
             bgParentRun.delete(taskId);
             if (conflictQuarantine.size >= MAX_BG_PARENT_RUNS && !conflictQuarantine.has(taskId)) {

package/dist/supportFloor.d.ts

@@ -8,4 +8,5 @@ export declare const SUPPORT_FLOOR: Readonly<SupportFloor>;
 export declare function supportFloorOf(component: unknown): string | undefined;
 export type EngineVersionTier = 'engine' | 'legacy' | 'unknown';
 export declare function engineVersionTier(version: unknown, floor?: string): EngineVersionTier;
+export declare function engineSupportFloorEffective(floor?: string): string;
 export declare function coreVersionTier(version: unknown, floor?: string): EngineVersionTier;

package/dist/supportFloor.js

@@ -1,8 +1,5 @@
-export const SUPPORT_FLOOR = Object.freeze({
-    server: '7.106.0',
-    core: '7.35.2',
-    sdk: '18.1.0',
-});
+import { DECLARED_SUPPORT_FLOOR } from './declared/supportFloorDeclared.js';
+export const SUPPORT_FLOOR = DECLARED_SUPPORT_FLOOR;
 export function supportFloorOf(component) {
     if (component === 'server' || component === 'core' || component === 'sdk')
         return SUPPORT_FLOOR[component];
@@ -14,7 +11,8 @@ function releaseTriple(v) {
     const m = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.exec(v);
     if (m === null)
         return undefined;
-    return [Number(m[1]), Number(m[2]), Number(m[3])];
+    const t = [Number(m[1]), Number(m[2]), Number(m[3])];
+    return t.every(Number.isSafeInteger) ? t : undefined;
 }
 function compareTriple(a, b) {
     for (let i = 0; i < 3; i++) {
@@ -25,28 +23,31 @@ function compareTriple(a, b) {
     }
     return 0;
 }
-function versionTierAgainst(version, base, floor, caller) {
+function judgeAgainst(version, base, floor, caller) {
     const baseTriple = releaseTriple(base);
     if (baseTriple === undefined) {
         throw new TypeError(`${caller}: 门槛只接受纯 x.y.z 版本串(整串、无前导零、无前后缀)—— 收到 typeof=${base === null ? 'null' : typeof base}。错误文本只报形状,不回显值。`);
     }
-    let need = baseTriple;
+    let need = { triple: baseTriple, text: base };
     if (floor !== undefined) {
         const own = releaseTriple(floor);
         if (own === undefined) {
             throw new TypeError(`${caller}: floor 只接受纯 x.y.z 版本串(整串、无前导零、无前后缀)或缺席 —— 收到 typeof=${floor === null ? 'null' : typeof floor}。错误文本只报形状,不回显值。`);
         }
-        if (compareTriple(own, need) > 0)
-            need = own;
+        if (compareTriple(own, need.triple) > 0)
+            need = { triple: own, text: floor };
     }
     const got = releaseTriple(version);
     if (got === undefined)
-        return 'unknown';
-    return compareTriple(got, need) >= 0 ? 'engine' : 'legacy';
+        return { need: need.text, tier: 'unknown' };
+    return { need: need.text, tier: compareTriple(got, need.triple) >= 0 ? 'engine' : 'legacy' };
 }
 export function engineVersionTier(version, floor) {
-    return versionTierAgainst(version, SUPPORT_FLOOR.server, floor, 'engineVersionTier');
+    return judgeAgainst(version, SUPPORT_FLOOR.server, floor, 'engineVersionTier').tier;
+}
+export function engineSupportFloorEffective(floor) {
+    return judgeAgainst(undefined, SUPPORT_FLOOR.server, floor, 'engineSupportFloorEffective').need;
 }
 export function coreVersionTier(version, floor) {
-    return versionTierAgainst(version, SUPPORT_FLOOR.core, floor, 'coreVersionTier');
+    return judgeAgainst(version, SUPPORT_FLOOR.core, floor, 'coreVersionTier').tier;
 }

package/dist/systemReminderTag.d.ts

@@ -5,3 +5,4 @@ export interface SystemReminderOpenTagSpan {
 export declare function findSystemReminderOpenTag(text: string, from?: number): SystemReminderOpenTagSpan | null;
 export declare function unwrapSystemReminder(text: string): string;
 export declare function stripSystemReminderBlocks(text: string): string;
+export declare function stripSystemReminderTagTokens(text: string): string;

package/dist/systemReminderTag.js

@@ -39,3 +39,11 @@ export function stripSystemReminderBlocks(text) {
     }
     return pos === 0 ? text : out + text.slice(pos);
 }
+const SYSTEM_REMINDER_TAG_TOKEN = /<[^A-Za-z0-9>]{0,12}system-reminder(?:[^>]{0,200}>)?/gi;
+const SYSTEM_REMINDER_TAG_HEAD = /<[^A-Za-z0-9>]{0,12}system-reminder/i;
+export function stripSystemReminderTagTokens(text) {
+    if (typeof text !== 'string')
+        return text;
+    const once = text.replace(SYSTEM_REMINDER_TAG_TOKEN, ' ');
+    return SYSTEM_REMINDER_TAG_HEAD.test(once) ? once.replace(/</g, '&lt;') : once;
+}

package/dist/terminalStatuses.d.ts

@@ -0,0 +1,30 @@
+import type { SDKTaskUpdatedMessage } from '@sema-agent/agent-types';
+import { CORE_TERMINAL_CAUSE_KINDS } from './generated/engineFactTables.js';
+export { CORE_TERMINAL_CAUSE_KINDS };
+export type CoreTerminalCauseKind = (typeof CORE_TERMINAL_CAUSE_KINDS)[number];
+export declare function isCoreTerminalCauseKind(kind: unknown): kind is CoreTerminalCauseKind;
+export declare const SDK_RUN_TERMINAL_STATUSES: readonly ["completed", "failed", "blocked", "timeout"];
+export type SdkRunTerminalStatus = (typeof SDK_RUN_TERMINAL_STATUSES)[number];
+export declare function isSdkRunTerminal(status: unknown): status is SdkRunTerminalStatus;
+export declare function isSdkRunTerminalNotSuccess(status: unknown): status is Exclude<SdkRunTerminalStatus, 'completed'>;
+export declare const SDK_PARKED_RUN_STATUSES: readonly ["suspended", "needs_review"];
+export declare function isSdkRunParked(status: unknown): status is (typeof SDK_PARKED_RUN_STATUSES)[number];
+export declare function isSdkRunFrameSynthesizable(status: unknown): boolean;
+export declare const SDK_FLEET_TASK_TERMINAL_STATUSES: readonly ["completed", "failed", "killed"];
+export type SdkFleetTaskTerminalStatus = (typeof SDK_FLEET_TASK_TERMINAL_STATUSES)[number];
+export declare function isSdkFleetTaskTerminal(status: unknown): status is SdkFleetTaskTerminalStatus;
+export declare function isSdkFleetTaskTerminalNotSuccess(status: unknown): status is Exclude<SdkFleetTaskTerminalStatus, 'completed'>;
+export declare const CORE_TASK_NOTIFICATION_TERMINAL_STATUSES: readonly ["completed", "failed", "killed", "cancelled"];
+export type CoreTaskNotificationTerminalStatus = (typeof CORE_TASK_NOTIFICATION_TERMINAL_STATUSES)[number];
+export declare function isCoreTaskNotificationTerminal(status: unknown): status is CoreTaskNotificationTerminalStatus;
+export declare function isCoreTaskNotificationTerminalNotSuccess(status: unknown): status is Exclude<CoreTaskNotificationTerminalStatus, 'completed'>;
+export declare const CORE_SEMA_TASK_TERMINAL_STATUSES: readonly ["completed", "failed", "killed", "cancelled"];
+export type CoreSemaTaskTerminalStatus = (typeof CORE_SEMA_TASK_TERMINAL_STATUSES)[number];
+export declare function isCoreSemaTaskTerminal(status: unknown): status is CoreSemaTaskTerminalStatus;
+export declare const CORE_WORKFLOW_RUN_TERMINAL_STATUSES: readonly ["completed", "failed"];
+export declare function isCoreWorkflowRunTerminal(status: unknown): status is (typeof CORE_WORKFLOW_RUN_TERMINAL_STATUSES)[number];
+export declare const CORE_TASK_PROGRESS_TERMINAL_STATUSES: readonly ["completed", "failed"];
+export declare function isCoreTaskProgressTerminal(status: unknown): status is (typeof CORE_TASK_PROGRESS_TERMINAL_STATUSES)[number];
+export declare function isCoreTaskProgressTerminalNotSuccess(status: unknown): status is 'failed';
+export type CcTaskTerminalStatus = Extract<NonNullable<SDKTaskUpdatedMessage['patch']['status']>, 'completed' | 'failed' | 'killed'>;
+export declare function ccTaskTerminalStatusOf(status: unknown): CcTaskTerminalStatus | undefined;

package/dist/terminalStatuses.js

@@ -0,0 +1,67 @@
+import { CORE_TERMINAL_CAUSE_KINDS } from './generated/engineFactTables.js';
+function memberOf(table, word) {
+    return typeof word === 'string' && table.includes(word);
+}
+function terminalNotSuccessOf(table, word) {
+    return word !== 'completed' && memberOf(table, word);
+}
+export { CORE_TERMINAL_CAUSE_KINDS };
+export function isCoreTerminalCauseKind(kind) {
+    return memberOf(CORE_TERMINAL_CAUSE_KINDS, kind);
+}
+export const SDK_RUN_TERMINAL_STATUSES = Object.freeze(['completed', 'failed', 'blocked', 'timeout']);
+export function isSdkRunTerminal(status) {
+    return memberOf(SDK_RUN_TERMINAL_STATUSES, status);
+}
+export function isSdkRunTerminalNotSuccess(status) {
+    return terminalNotSuccessOf(SDK_RUN_TERMINAL_STATUSES, status);
+}
+export const SDK_PARKED_RUN_STATUSES = Object.freeze(['suspended', 'needs_review']);
+export function isSdkRunParked(status) {
+    return memberOf(SDK_PARKED_RUN_STATUSES, status);
+}
+export function isSdkRunFrameSynthesizable(status) {
+    return isSdkRunTerminal(status) || isSdkRunParked(status);
+}
+export const SDK_FLEET_TASK_TERMINAL_STATUSES = Object.freeze(['completed', 'failed', 'killed']);
+export function isSdkFleetTaskTerminal(status) {
+    return memberOf(SDK_FLEET_TASK_TERMINAL_STATUSES, status);
+}
+export function isSdkFleetTaskTerminalNotSuccess(status) {
+    return terminalNotSuccessOf(SDK_FLEET_TASK_TERMINAL_STATUSES, status);
+}
+export const CORE_TASK_NOTIFICATION_TERMINAL_STATUSES = Object.freeze(['completed', 'failed', 'killed', 'cancelled']);
+export function isCoreTaskNotificationTerminal(status) {
+    return memberOf(CORE_TASK_NOTIFICATION_TERMINAL_STATUSES, status);
+}
+export function isCoreTaskNotificationTerminalNotSuccess(status) {
+    return terminalNotSuccessOf(CORE_TASK_NOTIFICATION_TERMINAL_STATUSES, status);
+}
+export const CORE_SEMA_TASK_TERMINAL_STATUSES = Object.freeze(['completed', 'failed', 'killed', 'cancelled']);
+export function isCoreSemaTaskTerminal(status) {
+    return memberOf(CORE_SEMA_TASK_TERMINAL_STATUSES, status);
+}
+export const CORE_WORKFLOW_RUN_TERMINAL_STATUSES = Object.freeze(['completed', 'failed']);
+export function isCoreWorkflowRunTerminal(status) {
+    return memberOf(CORE_WORKFLOW_RUN_TERMINAL_STATUSES, status);
+}
+export const CORE_TASK_PROGRESS_TERMINAL_STATUSES = Object.freeze(['completed', 'failed']);
+export function isCoreTaskProgressTerminal(status) {
+    return memberOf(CORE_TASK_PROGRESS_TERMINAL_STATUSES, status);
+}
+export function isCoreTaskProgressTerminalNotSuccess(status) {
+    return terminalNotSuccessOf(CORE_TASK_PROGRESS_TERMINAL_STATUSES, status);
+}
+const CC_TASK_TERMINAL_STATUS_OF = Object.freeze({
+    completed: 'completed',
+    failed: 'failed',
+    killed: 'killed',
+    cancelled: 'killed',
+    blocked: 'failed',
+    timeout: 'failed',
+});
+export function ccTaskTerminalStatusOf(status) {
+    return typeof status === 'string' && Object.hasOwn(CC_TASK_TERMINAL_STATUS_OF, status)
+        ? CC_TASK_TERMINAL_STATUS_OF[status]
+        : undefined;
+}

package/dist/toolHistoryMismatch.d.ts

@@ -18,8 +18,6 @@ export declare const TOOL_HISTORY_MISMATCH_ANCHORS: readonly ToolHistoryMismatch
 export declare function classifyToolHistoryMismatch(err: ToolHistoryErrorCarrier | null | undefined): ToolHistoryMismatch | null;
 export declare const TOOL_HISTORY_REWIND_SENTENCE = "Run /rewind to recover the conversation.";
 export declare function toolHistoryRepeatSentence(n: number): string;
-type ConversationRewindVerdict = 'available' | 'unavailable' | 'unknown';
-export declare function _wireConversationRewindJudge(judge: (engineBaseUrl: string) => ConversationRewindVerdict): void;
 export declare function toolHistoryRewindOffered(declared: boolean | {
     readonly engineBaseUrl: string;
 } | undefined): boolean;
@@ -61,4 +59,3 @@ export type ToolHistoryRewindResolution<R> = {
     undecidable: ToolHistoryUndecidableReason;
 };
 export declare function resolveToolHistoryRewindTarget<R extends ToolHistoryRow>(rows: readonly (R | null | undefined)[] | null | undefined, mismatch: ToolHistoryMismatch | null | undefined): ToolHistoryRewindResolution<R>;
-export {};

package/dist/toolHistoryMismatch.js

@@ -1,3 +1,4 @@
+import { rewindArchiveReadingAt, rewindConversationAvailability } from './rewindArchiveReading.js';
 export const TOOL_HISTORY_MISMATCH_KINDS = Object.freeze([
     'tool_use_without_result',
     'orphan_tool_result',
@@ -224,10 +225,6 @@ export const TOOL_HISTORY_REWIND_SENTENCE = 'Run /rewind to recover the conversa
 export function toolHistoryRepeatSentence(n) {
     return `The same error has now happened ${n} times in a row; /rewind is the only way to recover this conversation.`;
 }
-let conversationRewindJudge;
-export function _wireConversationRewindJudge(judge) {
-    conversationRewindJudge = judge;
-}
 export function toolHistoryRewindOffered(declared) {
     const decl = declared;
     if (decl === true)
@@ -238,10 +235,9 @@ export function toolHistoryRewindOffered(declared) {
         if (Array.isArray(decl))
             return false;
         const base = decl.engineBaseUrl;
-        const judge = conversationRewindJudge;
-        if (typeof base !== 'string' || base.length === 0 || judge === undefined)
+        if (typeof base !== 'string' || base.length === 0)
             return true;
-        return judge(base) !== 'unavailable';
+        return rewindConversationAvailability(rewindArchiveReadingAt(base)) !== 'unavailable';
     }
     catch {
         return true;

package/dist/toolResult.d.ts

@@ -13,6 +13,7 @@ export declare const PROTOCOL_MARKERS: {
     readonly delegationNoTextResult: "(no text result)";
     readonly delegationTrailer: "Verify this result before concluding. If it leaves more to do, continue or delegate again.";
     readonly delegationTrailerFork: "Verify this result before concluding. If it leaves more to do, continue the work yourself or fork again.";
+    readonly delegationFieldLine: RegExp;
     readonly taskOutputLabel: RegExp;
     readonly taskOutputStatus: RegExp;
     readonly taskOutputHeadSlots: RegExp;
@@ -52,6 +53,10 @@ export type DelegationReportFrame = {
     before: string;
     after: string;
     section: 'result' | 'partial_findings' | 'no_text_result';
+    status?: string;
+    error?: string;
+    stats?: string;
+    headRest?: string;
 };
 export declare function displayBody(text: unknown, origin?: DisplayBodyOrigin): DisplayBody | undefined;
 export type ModelFacingTaskOutput = {
@@ -81,7 +86,7 @@ export declare function _resetBackgroundReceiptParseCountForTest(): void;
 export type FlattenWireOutput = (output: unknown) => string;
 export declare const TOOL_RESULT_DEGRADED_WIRE_NO_OUTPUT: "wire_carried_no_output";
 export interface ToolResultBody {
-    content: unknown;
+    content: string | unknown[];
     isError: boolean;
     toolUseResult?: unknown;
     degraded?: typeof TOOL_RESULT_DEGRADED_WIRE_NO_OUTPUT;