@sema-agent/client-core 0.93.1 → 0.95.0

package/dist/subagent/agentStateDetail.d.ts

@@ -0,0 +1 @@
+export declare function subagentStateDetail(carrier: unknown): string | undefined;

package/dist/subagent/agentStateDetail.js

@@ -0,0 +1,41 @@
+import { displayUntrusted } from '../displayUntrusted.js';
+function own(v, key) {
+    if (typeof v !== 'object' || v === null || Array.isArray(v))
+        return undefined;
+    try {
+        const d = Object.getOwnPropertyDescriptor(v, key);
+        return d !== undefined && 'value' in d ? d.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const finite = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : undefined);
+const word = (v) => (typeof v === 'string' && v.trim() !== '' ? displayUntrusted(v, { max: 64 }) : undefined);
+function span(ms) {
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${String(s)} s`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${String(m)} min`;
+    return `${String(Math.floor(m / 60))} h`;
+}
+export function subagentStateDetail(carrier) {
+    const st = own(carrier, 'agentState');
+    const status = word(own(st, 'status'));
+    if (status === undefined)
+        return undefined;
+    const readAt = finite(own(st, 'readAt'));
+    const last = finite(own(st, 'lastActivityAt'));
+    const activity = readAt !== undefined && last !== undefined && last <= readAt ? `last activity ${span(readAt - last)} ago` : 'last activity unknown';
+    const approval = own(st, 'approval');
+    const approvalState = word(own(approval, 'state'));
+    let approvalPart = '';
+    if (approvalState !== undefined) {
+        const deadline = finite(own(approval, 'deadline'));
+        const when = deadline === undefined || readAt === undefined ? '' : deadline > readAt ? ` (deadline in ${span(deadline - readAt)})` : ' (deadline passed)';
+        approvalPart = ` · approval ${approvalState}${when}`;
+    }
+    return `Subagent state: ${status} · ${activity}${approvalPart}`;
+}

package/dist/subagent/engineCompactWire.d.ts

@@ -5,11 +5,26 @@ export type EngineCompactWireClient = {
     runs: Pick<AgentClient['runs'], 'compact'>;
 };
 export type EngineCompactWire = EngineWireInjection<EngineCompactWireClient>;
+export type EngineCompactOutcome = {
+    readonly kind: 'accepted';
+} | {
+    readonly kind: 'refused';
+    readonly status: number;
+    readonly errorCode?: string;
+} | {
+    readonly kind: 'failed';
+    readonly detail: string;
+    readonly status?: number;
+    readonly unconfirmed?: true;
+} | {
+    readonly kind: 'offline';
+};
 export declare function isEngineCompactPending(sessionKey?: string): boolean;
 export declare function resetManualCompactCapability(): void;
 export declare function __resetEngineCompactArmForTests(): void;
 export declare function requestEngineCompact(sessionKey?: string, opts?: {
     wire?: EngineCompactWire;
+    onSettled?: (outcome: EngineCompactOutcome) => void;
 }): 'fired' | 'armed' | 'offline' | 'unsupported';
 export declare function onEngineTaskBound(taskId: string, sessionKey?: string, opts?: {
     wire?: EngineCompactWire;

package/dist/subagent/engineCompactWire.js

@@ -1,54 +1,39 @@
 import { hostLog, hostTimersFor } from '../host.js';
-import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, settleInjected, } from '../engineWireFor.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']]);
 }
 const COMPACT_PROBE_SETTLE_MS = 5000;
 const pendingCompactKeys = new Set();
+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();
 }
 function deferFire(ms, fn, why, sessionKey) {
     const timers = hostTimersFor(sessionKey);
@@ -80,26 +65,65 @@ function freezeCompactShot(taskId, sessionKey, wire) {
         ...(sid !== undefined ? { session: sid } : {}),
     };
 }
-async function postCompact(shot, retriesLeft = 1) {
+function emitCompactOutcome(sink, outcome) {
+    if (sink === undefined)
+        return;
+    void Promise.resolve().then(() => callSinkIsolated(sink, outcome));
+}
+function callSinkIsolated(sink, outcome) {
+    invokeHostCallbackIsolated('engineCompactWire: onSettled sink', () => sink(outcome));
+}
+function fanOutCompactSinks(sinks) {
+    if (sinks === undefined || sinks.length === 0)
+        return undefined;
+    return (outcome) => {
+        for (const s of sinks)
+            callSinkIsolated(s, outcome);
+    };
+}
+function compactFailureOutcomeOf(e) {
+    const shape = wireFailureShapeOf(e);
+    const status = typeof shape.status === 'number' && Number.isFinite(shape.status) ? shape.status : undefined;
+    const code = shape.errorCode !== undefined && shape.errorCode !== '' ? shape.errorCode : undefined;
+    if (status !== undefined) {
+        if ((status >= 400 && status < 500) || isUnavailableFaceCode(code)) {
+            return { kind: 'refused', status, ...(code !== undefined ? { errorCode: code } : {}) };
+        }
+        return { kind: 'failed', status, detail: wireFailureTextsOf(e).reason };
+    }
+    const noAnswer = typeof e === 'object' && e !== null ? noAnswerDetailFrom(e) : null;
+    if (noAnswer !== null)
+        return { kind: 'failed', detail: noAnswer, unconfirmed: true };
+    return { kind: 'failed', detail: wireFailureTextsOf(e).reason };
+}
+async function postCompact(shot, sink, retriesLeft = 1) {
     const client = shot.client();
-    if (!client)
+    if (!client) {
+        emitCompactOutcome(sink, { kind: 'offline' });
         return;
+    }
     const taskId = shot.taskId;
     try {
         const fire = (signal) => client.runs.compact(taskId, { ...(shot.session !== undefined ? { session: shot.session } : {}), ...(signal ? { signal } : {}) });
         const ack = shot.injected ? await settleInjected(INJECTED_WIRE_SETTLE_MS, undefined, fire) : await fire(undefined);
         hostLog('debug', `engineCompactWire: POST compact ${taskId} → ok${ack?.status ? ` (${ack.status})` : ''}`);
+        emitCompactOutcome(sink, { kind: 'accepted' });
     }
     catch (e) {
-        const status = e?.status;
-        if (typeof status === 'number') {
-            hostLog('debug', `engineCompactWire: POST compact ${taskId} → ${status}`);
-            if (status === 404 && retriesLeft > 0) {
-                deferFire(2000, () => void postCompact(shot, retriesLeft - 1), '404 单次重试', shot.sessionKey);
-            }
-            return;
+        const outcome = compactFailureOutcomeOf(e);
+        if (outcome.kind === 'refused' || (outcome.kind === 'failed' && outcome.status !== undefined)) {
+            hostLog('debug', `engineCompactWire: POST compact ${taskId} → ${outcome.status}`);
+        }
+        else {
+            hostLog('debug', `engineCompactWire: compact fire failed (best-effort): ${wireFailureTextsOf(e).log}`);
         }
-        hostLog('debug', `engineCompactWire: compact fire failed (best-effort): ${String(e)}`);
+        if (outcome.kind === 'refused' && outcome.status === 404 && retriesLeft > 0) {
+            if (deferFire(2000, () => void postCompact(shot, sink, retriesLeft - 1), '404 单次重试', shot.sessionKey))
+                return;
+        }
+        if (outcome.kind === 'refused' && outcome.errorCode === COMPACT_NOT_RUNNING)
+            surfaceCompactNotRunning(shot.sessionKey);
+        emitCompactOutcome(sink, outcome);
     }
 }
 export function requestEngineCompact(sessionKey = DEFAULT_SESSION_KEY, opts) {
@@ -108,18 +132,29 @@ 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';
     }
     const taskId = activeEngineRunIdFor(sessionKey);
+    const rawSink = opts?.onSettled;
+    const sink = typeof rawSink === 'function' ? rawSink : undefined;
     if (taskId) {
         const shot = freezeCompactShot(taskId, sessionKey, wire);
         if (shot !== null)
-            void postCompact(shot);
+            void postCompact(shot, sink);
+        else
+            emitCompactOutcome(sink, { kind: 'offline' });
         return 'fired';
     }
     pendingCompactKeys.add(sessionKey);
+    if (sink !== undefined) {
+        const sinks = pendingCompactSinks.get(sessionKey);
+        if (sinks === undefined)
+            pendingCompactSinks.set(sessionKey, [sink]);
+        else
+            sinks.push(sink);
+    }
     return 'armed';
 }
 const BOUND_FIRE_DELAY_MS = 1500;
@@ -132,7 +167,9 @@ export function onEngineTaskBound(taskId, sessionKey = DEFAULT_SESSION_KEY, opts
     const shot = freezeCompactShot(taskId, sessionKey, wire);
     if (shot === null)
         return;
-    if (deferFire(BOUND_FIRE_DELAY_MS, () => void postCompact(shot), 'bind 后发射', sessionKey)) {
+    const sink = fanOutCompactSinks(pendingCompactSinks.get(sessionKey));
+    if (deferFire(BOUND_FIRE_DELAY_MS, () => void postCompact(shot, sink), 'bind 后发射', sessionKey)) {
         pendingCompactKeys.delete(sessionKey);
+        pendingCompactSinks.delete(sessionKey);
     }
 }

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/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,3 +1,4 @@
+import { DEFAULT_SESSION_KEY } from './sessionSlot.js';
 export function coerceOutput(v) {
     if (v === undefined || v === null)
         return undefined;
@@ -648,7 +649,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 +703,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.js

@@ -1,8 +1,5 @@
-export const SUPPORT_FLOOR = Object.freeze({
-    server: '7.106.0',
-    core: '7.35.2',
-    sdk: '12.0.1',
-});
+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];

package/dist/taskRequestWords.d.ts

@@ -1,9 +1,8 @@
 import type { TaskRequest } from '@sema-agent/sdk';
 export type TaskRequestReasoningEffort = NonNullable<TaskRequest['reasoningEffort']>;
 export declare const REASONING_EFFORT_WORDS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
-type SdkTaskRequestPermissionMode = NonNullable<TaskRequest['permissionMode']>;
-export type TaskRequestPermissionMode = SdkTaskRequestPermissionMode | 'dontAsk';
-export declare const PERMISSION_MODE_WORDS: readonly ["default", "plan", "acceptEdits", "bypassPermissions", "auto", "dontAsk"];
+export type TaskRequestPermissionMode = NonNullable<TaskRequest['permissionMode']>;
+export declare const PERMISSION_MODE_WORDS: readonly ["default", "acceptEdits", "plan", "auto", "bypassPermissions", "dontAsk"];
 export interface RetiredAttachmentsKey {
     readonly key: string;
     readonly why: string;
@@ -11,4 +10,3 @@ export interface RetiredAttachmentsKey {
     readonly remedy: string;
 }
 export declare function retiredAttachmentsKeyOf(nameOrToken: string, form?: 'token' | 'key'): RetiredAttachmentsKey | undefined;
-export {};

package/dist/taskRequestWords.js

@@ -1,6 +1,7 @@
+import { CORE_PERMISSION_MODES } from './generated/engineFactTables.js';
 export const REASONING_EFFORT_WORDS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
-export const PERMISSION_MODE_WORDS = ['default', 'plan', 'acceptEdits', 'bypassPermissions', 'auto', 'dontAsk'];
-const _taskRequestWordPins = [true, true, true, true];
+export const PERMISSION_MODE_WORDS = CORE_PERMISSION_MODES;
+const _taskRequestWordPins = [true, true, true, true, true, true];
 void _taskRequestWordPins;
 export function retiredAttachmentsKeyOf(nameOrToken, form = 'token') {
     const lower = nameOrToken.trim().toLowerCase();

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/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 = {