@sema-agent/client-core 0.109.0 → 0.111.0

package/dist/sseIdleTriage.d.ts

@@ -1,4 +1,5 @@
 import { type EnvLike } from './hostEnv.js';
+import { SDK_STREAM_ENDED_REASONS } from './generated/sdkFactTables.js';
 import { type RunNotFollowed } from './runFollow.js';
 export declare const SSE_HEARTBEAT_GRACE_ENV = "SEMA_SSE_HEARTBEAT_GRACE_MS";
 export declare const SSE_GRACE_MIN_MS = 5000;
@@ -8,8 +9,19 @@ export declare function resolveSseHeartbeatGraceMs(env?: EnvLike): number | unde
 export declare function markEngineAliveIdle<E extends Error>(err: E): E;
 export declare function engineAliveIdleElapsedMs(err: unknown): number | undefined;
 export declare function isSseIdleError(err: unknown): boolean;
+export type StreamEndedReasonWord = (typeof SDK_STREAM_ENDED_REASONS)[number];
+export type StreamEndedUnknownWhy = 'not_this_class' | 'reason_unreadable' | 'reason_unrecognized';
+export type StreamEndedReading = {
+    readonly kind: 'read';
+    readonly reason: StreamEndedReasonWord;
+    readonly cause?: {} | null;
+} | {
+    readonly kind: 'unknown';
+    readonly why: StreamEndedUnknownWhy;
+};
+export declare function streamEndedReasonOf(err: {} | null | undefined): StreamEndedReading;
 export declare function isStreamEndedWithoutTerminalError(err: {} | null | undefined): boolean;
-export declare function probeEngineAlive(baseUrl: string, timeoutMs?: number): Promise<boolean>;
+export declare function probeEngineAlive(baseUrl: string): Promise<boolean>;
 export declare function diagnoseSseIdleTear<T>(inner: AsyncGenerator<T>, baseUrl: string, signal?: AbortSignal): AsyncGenerator<T>;
 export declare function engineAliveIdleContent(elapsedMs: number, detach?: {
     detached: true;

package/dist/sseIdleTriage.js

@@ -1,6 +1,8 @@
 import { hostEnv } from './hostEnv.js';
 import { SseIdleError, StreamEndedWithoutTerminalError, probeHealth as sdkProbeHealth } from '@sema-agent/sdk';
-import { readThrownSlot, thrownIsInstanceOf } from './wireFailureShape.js';
+import { classifyHealthProbe } from './engineHealthProbeVerdict.js';
+import { THROWN_SLOT_UNREADABLE, readThrownSlot, thrownIsInstanceOf } from './wireFailureShape.js';
+import { SDK_STREAM_ENDED_REASONS } from './generated/sdkFactTables.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { runNotFollowedNoticeRef } from './runFollow.js';
 export const SSE_HEARTBEAT_GRACE_ENV = 'SEMA_SSE_HEARTBEAT_GRACE_MS';
@@ -38,13 +40,30 @@ export function isSseIdleError(err) {
         return true;
     return readThrownSlot(err, 'name', 'data') === 'SseIdleError';
 }
+function streamEndedUnknown(why) {
+    return Object.freeze({ kind: 'unknown', why });
+}
+function isStreamEndedClass(err) {
+    return thrownIsInstanceOf(err, StreamEndedWithoutTerminalError) || readThrownSlot(err, 'name', 'data') === 'StreamEndedWithoutTerminalError';
+}
+export function streamEndedReasonOf(err) {
+    if (!isStreamEndedClass(err))
+        return streamEndedUnknown('not_this_class');
+    const raw = readThrownSlot(err, 'reason', 'data');
+    if (raw === THROWN_SLOT_UNREADABLE || raw === undefined)
+        return streamEndedUnknown('reason_unreadable');
+    const reason = SDK_STREAM_ENDED_REASONS.find((w) => w === raw);
+    if (reason === undefined)
+        return streamEndedUnknown('reason_unrecognized');
+    const cause = readThrownSlot(err, 'cause', 'data');
+    return Object.freeze(cause === THROWN_SLOT_UNREADABLE || cause === undefined ? { kind: 'read', reason } : { kind: 'read', reason, cause: cause });
+}
 export function isStreamEndedWithoutTerminalError(err) {
-    if (thrownIsInstanceOf(err, StreamEndedWithoutTerminalError))
-        return true;
-    return readThrownSlot(err, 'name', 'data') === 'StreamEndedWithoutTerminalError';
+    const reading = streamEndedReasonOf(err);
+    return reading.kind !== 'unknown' || reading.why !== 'not_this_class';
 }
-export async function probeEngineAlive(baseUrl, timeoutMs = 2_000) {
-    return (await sdkProbeHealth(baseUrl, timeoutMs)).alive;
+export async function probeEngineAlive(baseUrl) {
+    return classifyHealthProbe(await sdkProbeHealth(baseUrl))?.kind === 'answered_ok';
 }
 export async function* diagnoseSseIdleTear(inner, baseUrl, signal) {
     try {

package/dist/storeDurabilityWord.d.ts

@@ -0,0 +1,15 @@
+declare const STORE_DURABILITY_WORDS: readonly ["durable", "ephemeral", "unknown"];
+export type EngineHealthStoreDurability = (typeof STORE_DURABILITY_WORDS)[number];
+export type StoreDurabilityRead = {
+    readonly kind: 'word';
+    readonly durability: EngineHealthStoreDurability;
+} | {
+    readonly kind: 'unrecognized';
+    readonly word: string;
+} | {
+    readonly kind: 'absent';
+} | {
+    readonly kind: 'unreadable';
+};
+export declare function readStoreDurability(section: object): StoreDurabilityRead;
+export {};

package/dist/storeDurabilityWord.js

@@ -0,0 +1,18 @@
+import { ownDataField } from './ownKey.js';
+const STORE_DURABILITY_WORDS = ['durable', 'ephemeral', 'unknown'];
+export function readStoreDurability(section) {
+    try {
+        const raw = ownDataField(section, 'durability');
+        if (raw === undefined)
+            return Object.freeze({ kind: 'absent' });
+        if (typeof raw !== 'string' || raw === '')
+            return Object.freeze({ kind: 'unreadable' });
+        for (const w of STORE_DURABILITY_WORDS)
+            if (raw === w)
+                return Object.freeze({ kind: 'word', durability: w });
+        return Object.freeze({ kind: 'unrecognized', word: raw });
+    }
+    catch {
+        return Object.freeze({ kind: 'unreadable' });
+    }
+}

package/dist/storePostureCapability.d.ts

@@ -1,8 +1,12 @@
 import { type SqlEngineCapabilityView } from './sqlEngineCapability.js';
+import { type EngineHealthStoreDurability } from './storeDurabilityWord.js';
+import type { UiLanguage } from './env/uiLanguage.js';
 export interface StorePostureView {
     declared: string;
     backend: string;
-    durable: boolean;
+    durable?: boolean;
+    durability?: EngineHealthStoreDurability;
+    unrecognizedDurability?: string;
     degradedReason?: string;
     sql?: SqlEngineCapabilityView;
 }
@@ -19,5 +23,5 @@ export type StorePostureReading = {
 export declare function projectStorePostureCapability(caps: unknown): StorePostureReading | undefined;
 export declare function observedStorePosture(baseUrl?: string | undefined): StorePostureReading;
 export declare function storePersistence(reading: StorePostureReading): 'durable' | 'not_durable' | 'unknown';
-export declare function storePostureHeadWord(reading: StorePostureReading): string | undefined;
-export declare function storePostureDoctorDetail(reading: StorePostureReading): string;
+export declare function storePostureHeadWord(reading: StorePostureReading, lang?: UiLanguage): string | undefined;
+export declare function storePostureDoctorDetail(reading: StorePostureReading, lang?: UiLanguage): string;

package/dist/storePostureCapability.js

@@ -3,6 +3,8 @@ import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { storeSeatOf, createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { projectSqlEngineCapability } from './sqlEngineCapability.js';
 import { ownDataField } from './ownKey.js';
+import { readStoreDurability } from './storeDurabilityWord.js';
+import { msg, renderMessage } from './i18n/translate.js';
 const nonEmpty = (v) => typeof v === 'string' && v !== '';
 export function projectStorePostureCapability(caps) {
     try {
@@ -21,8 +23,8 @@ function projectStorePostureOf(caps) {
     const store = seat.store;
     const declared = ownDataField(store, 'declared');
     const backend = ownDataField(store, 'backend');
-    const durable = ownDataField(store, 'durable');
-    if (!nonEmpty(declared) || !nonEmpty(backend) || typeof durable !== 'boolean')
+    const durability = durabilityOf(store, 'wire');
+    if (!nonEmpty(declared) || !nonEmpty(backend) || durability.kind === 'malformed')
         return undefined;
     const reason = ownDataField(store, 'degradedReason');
     if (reason !== undefined && !nonEmpty(reason))
@@ -35,12 +37,44 @@ function projectStorePostureOf(caps) {
         view: {
             declared,
             backend,
-            durable,
+            ...(durability.kind === 'legacy' ? { durable: durability.durable } : {}),
+            ...(durability.kind === 'word' ? { durability: durability.durability } : {}),
+            ...(durability.kind === 'unrecognized' ? { unrecognizedDurability: durability.word } : {}),
             ...(nonEmpty(reason) ? { degradedReason: reason } : {}),
             ...(sqlReading.kind === 'present' ? { sql: sqlReading.view } : {}),
         },
     };
 }
+const MALFORMED_DURABILITY = Object.freeze({ kind: 'malformed' });
+function durabilityOf(section, side) {
+    try {
+        const word = readStoreDurability(section);
+        const durable = ownDataField(section, 'durable');
+        const unrecognized = side === 'view' ? ownDataField(section, 'unrecognizedDurability') : undefined;
+        const present = (word.kind === 'absent' ? 0 : 1) + (durable === undefined ? 0 : 1) + (unrecognized === undefined ? 0 : 1);
+        if (present !== 1)
+            return MALFORMED_DURABILITY;
+        if (word.kind === 'word')
+            return { kind: 'word', durability: word.durability };
+        if (word.kind === 'unrecognized')
+            return { kind: 'unrecognized', word: word.word };
+        if (typeof durable === 'boolean')
+            return { kind: 'legacy', durable };
+        if (nonEmpty(unrecognized))
+            return { kind: 'unrecognized', word: unrecognized };
+        return MALFORMED_DURABILITY;
+    }
+    catch {
+        return MALFORMED_DURABILITY;
+    }
+}
+function persistenceOf(d) {
+    if (d.kind === 'legacy')
+        return d.durable ? 'durable' : 'not_durable';
+    if (d.kind !== 'word')
+        return 'unknown';
+    return d.durability === 'durable' ? 'durable' : d.durability === 'ephemeral' ? 'not_durable' : 'unknown';
+}
 const reader = createEngineCapReader({
     name: 'store',
     project: projectStorePostureCapability,
@@ -70,58 +104,54 @@ export function storePersistence(reading) {
     const r = presentView(reading);
     if (r?.kind !== 'present')
         return 'unknown';
-    let durable;
-    try {
-        durable = r.view.durable;
-    }
-    catch {
-        return 'unknown';
-    }
-    return durable === true ? 'durable' : durable === false ? 'not_durable' : 'unknown';
+    return persistenceOf(durabilityOf(r.view, 'view'));
 }
-const STORE_NOT_DURABLE_HEAD = 'NOT durable';
-export function storePostureHeadWord(reading) {
-    return storePersistence(reading) === 'not_durable' ? STORE_NOT_DURABLE_HEAD : undefined;
+const notDurableHead = () => msg('notice.capability.storePosture.notDurableHead');
+export function storePostureHeadWord(reading, lang) {
+    return storePersistence(reading) === 'not_durable' ? renderMessage(notDurableHead(), lang) : undefined;
 }
 const WORD_DETAIL_MAX = 40;
 const word = (v) => capForDisplay(v, WORD_DETAIL_MAX);
-export function storePostureDoctorDetail(reading) {
-    const unobserved = 'store posture not observed — the engine reports it on /v1/capabilities; this process has no usable capabilities reading cached for it, so whether this deployment persists its state is unknown';
+export function storePostureDoctorDetail(reading, lang) {
+    const say = (ref) => renderMessage(ref, lang);
+    const unobserved = msg('notice.capability.storePosture.unobserved');
     const r = presentView(reading);
     if (r?.kind === 'unreadable')
-        return unreadableReadingDetail('store posture');
-    if (r?.kind === 'not_reported') {
-        return 'store posture not reported by this engine; this does not say whether this deployment persists its state';
-    }
+        return unreadableReadingDetail(say(msg('notice.capability.subject.storePosture')), lang);
+    if (r?.kind === 'not_reported')
+        return say(msg('notice.capability.storePosture.notReported'));
     if (r?.kind !== 'present')
-        return unobserved;
+        return say(unobserved);
     let declared;
     let backend;
-    let durable;
     let reason;
     try {
         declared = r.view.declared;
         backend = r.view.backend;
-        durable = r.view.durable;
         reason = r.view.degradedReason;
     }
     catch {
-        return unobserved;
-    }
-    if (!nonEmpty(declared) || !nonEmpty(backend) || typeof durable !== 'boolean')
-        return unobserved;
-    const assembled = declared === backend ? `store ${word(backend)}` : `store declared ${word(declared)}, running on ${word(backend)}`;
-    if (durable) {
-        return `${assembled} — durable: this replica persists its state, so it survives a restart`;
+        return say(unobserved);
     }
-    const lost = `${STORE_NOT_DURABLE_HEAD}: this replica holds its state in memory and loses it on restart`;
+    const durability = durabilityOf(r.view, 'view');
+    if (!nonEmpty(declared) || !nonEmpty(backend) || durability.kind === 'malformed')
+        return say(unobserved);
+    const assembled = declared === backend
+        ? msg('notice.capability.storePosture.assembled', { backend: word(backend) })
+        : msg('notice.capability.storePosture.assembledDeclared', { declared: word(declared), backend: word(backend) });
+    if (durability.kind === 'unrecognized')
+        return say(msg('notice.capability.storePosture.unrecognized', { assembled, word: word(durability.word) }));
+    const persistence = persistenceOf(durability);
+    if (persistence === 'durable')
+        return say(msg('notice.capability.storePosture.durable', { assembled }));
+    if (persistence === 'unknown')
+        return say(msg('notice.capability.storePosture.unknown', { assembled }));
+    const line = msg(durability.kind === 'legacy' ? 'notice.capability.storePosture.memory' : 'notice.capability.storePosture.ephemeral', { assembled, head: notDurableHead() });
     if (!nonEmpty(reason))
-        return `${assembled} — ${lost}`;
-    if (reason === 'db_unreachable') {
-        return `${assembled} — ${lost} (degraded: the declared database could not be opened at start-up, so the engine fell back rather than refusing to start)`;
-    }
-    if (reason === 'local_unwritable') {
-        return `${assembled} — ${lost} (degraded: the default local file store could not be created — a read-only or full data directory is one possible cause, and this client cannot tell which applies)`;
-    }
-    return `${assembled} — ${lost} (degraded for a reason this client does not know yet: "${word(reason)}")`;
+        return say(line);
+    if (reason === 'db_unreachable')
+        return say(msg('notice.capability.storePosture.degraded.dbUnreachable', { line }));
+    if (reason === 'local_unwritable')
+        return say(msg('notice.capability.storePosture.degraded.localUnwritable', { line }));
+    return say(msg('notice.capability.storePosture.degraded.other', { line, reason: word(reason) }));
 }

package/dist/subagent/engineSubagentResume.js

@@ -1,7 +1,7 @@
 import { hostLog } from '../host.js';
 import { isNotFoundFailure, resumeRetryLaterFromError } from '../wireErrorTriage.js';
 import { readThrownSlot, THROWN_SLOT_UNREADABLE } from '../wireFailureShape.js';
-import { RESUME_SESSION_NOT_FOUND } from '../engineErrorCodes.js';
+import { RESUME_SESSION_NOT_FOUND, STEERING_NOT_RUNNING } from '../engineErrorCodes.js';
 import { displayUntrusted } from '../displayUntrusted.js';
 import { engineCapTrue } from '../engineCapsCache.js';
 import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, noAnswerDetailFrom, sendOnce, settleInjected } from '../engineWireFor.js';
@@ -63,7 +63,7 @@ export function classifySubagentResumeFailure(e) {
     }
     if (errorCode === 'steering.still_running')
         return { reason: 'still-running', detail: message };
-    if (errorCode === 'steering.not_running')
+    if (errorCode === STEERING_NOT_RUNNING)
         return { reason: 'not-resumable', detail: message };
     if (errorCode === 'steering.ambiguous_target')
         return { reason: 'ambiguous-target', detail: message };

package/dist/subagent/engineSubagentTail.js

@@ -4,9 +4,10 @@ import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, settleInjected
 import { engineCapStateVia } from '../engineCapsCache.js';
 import { engineSessionParamFor } from '../engineSessionParam.js';
 import { resolveOwnerContext } from './engineSubagentResume.js';
-import { coerceOutput, parentToolCallIdOf, publishSubagentContentEvent, settleSubagentContent, } from '../subagentContentStore.js';
+import { coerceOutput, parentToolCallIdOf, publishSubagentContentEvent, settleSubagentContent, subagentToolEndDenialParts, } from '../subagentContentStore.js';
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
 import { readFrameTrueMark } from '../ownKey.js';
+import { publishEngineInlineTaskModel } from '../engineInlineTaskStats.js';
 function usableTailClient(client) {
     return clientHasVerbs(client, [['capabilities'], ['runs', 'subagentStream']]);
 }
@@ -142,6 +143,7 @@ export function tailEngineSubagent(taskId, opts) {
                         ...(out !== undefined ? { output: out } : {}),
                         ...(d.isError === true ? { isError: true } : {}),
                         ...(readFrameTrueMark(d, 'notExecuted') ? { notExecuted: true } : {}),
+                        ...subagentToolEndDenialParts(d),
                     });
                 }
                 else if (t === 'task_settled') {
@@ -149,6 +151,11 @@ export function tailEngineSubagent(taskId, opts) {
                     hostLog('debug', `[subagent-tail] ${taskId} settled (${String(d.status)}${typeof d.seq === 'number' ? ` seq=${d.seq}` : ''}${typeof d.summary === 'string' ? ` summary=${d.summary.slice(0, 80)}` : ''}) — close`);
                     break;
                 }
+                else if (t === 'task_progress' || t === 'task_started') {
+                    const card = parentToolCallIdOf(taskId);
+                    if (card !== undefined && card !== taskId && typeof d.model === 'string')
+                        publishEngineInlineTaskModel(card, d.model);
+                }
             }
         }
         catch (e) {

package/dist/subagentContentStore.d.ts

@@ -1,3 +1,4 @@
+import { type CcToolDenialKind } from './gateVocabulary.js';
 export type SubagentContentItem = {
     kind: 'text';
     text: string;
@@ -12,6 +13,8 @@ export type SubagentContentItem = {
     output?: string;
     isError?: boolean;
     notExecuted?: true;
+    denialKind?: CcToolDenialKind;
+    refusalNoted?: true;
 } | {
     kind: 'echo';
     text: string;
@@ -33,7 +36,13 @@ export interface SubagentContentEvent {
     output?: string | undefined;
     isError?: boolean | undefined;
     notExecuted?: true | undefined;
+    denialKind?: CcToolDenialKind | undefined;
+    refusalNoted?: true | undefined;
 }
+export declare function subagentToolEndDenialParts(frame: object): {
+    denialKind?: CcToolDenialKind;
+    refusalNoted?: true;
+};
 export declare function coerceOutput(v: unknown): string | undefined;
 export declare function subagentContentEventOf(ev: {
     readonly type: string;
@@ -97,6 +106,8 @@ export type SubagentViewSlot = {
     output?: string;
     isError?: boolean;
     notExecuted?: true;
+    denialKind?: CcToolDenialKind;
+    refusalNoted?: true;
 };
 export declare function planSubagentViewSlots(taskId: string): SubagentViewSlot[];
 export declare function parentToolCallIdOf(taskId: string): string | undefined;

package/dist/subagentContentStore.js

@@ -1,7 +1,18 @@
 import { DEFAULT_SESSION_KEY } from './sessionSlot.js';
-import { readFrameTrueMark, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+import { guardedRead, readFrameTrueMark, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
 import { cycleSeqValue } from './cycleOrder.js';
 import { toolEndOutputText } from './toolResultContent.js';
+import { ccToolDenialKindForToolEnd, gateOutcomeOf } from './gateOutcome.js';
+import { isCcToolDenialKind } from './gateVocabulary.js';
+import { refusalNotedOf } from './engineRowRef.js';
+export function subagentToolEndDenialParts(frame) {
+    const denialKind = guardedRead(() => ccToolDenialKindForToolEnd(frame));
+    const gate = guardedRead(() => gateOutcomeOf(frame));
+    return {
+        ...(denialKind !== undefined ? { denialKind } : {}),
+        ...(refusalNotedOf(denialKind, gate) ? { refusalNoted: true } : {}),
+    };
+}
 export function coerceOutput(v) {
     return toolEndOutputText(v);
 }
@@ -26,6 +37,7 @@ export function subagentContentEventOf(ev) {
         output: coerceOutput(sub.output),
         isError: sub.isError,
         notExecuted: readFrameTrueMark(sub, 'notExecuted') ? true : undefined,
+        ...(t === 'tool_end' ? subagentToolEndDenialParts(ev) : {}),
     };
 }
 const MAX_ITEMS_PER_TASK = 200;
@@ -633,16 +645,26 @@ export function publishSubagentContentEvent(ev) {
                 const outBefore = it.output;
                 const errBefore = it.isError;
                 const notExecBefore = it.notExecuted;
+                const denialBefore = it.denialKind;
+                const notedBefore = it.refusalNoted;
                 it.output = ev.output ?? '';
                 it.isError = ev.isError === true;
                 if (ev.notExecuted === true)
                     it.notExecuted = true;
                 else
                     delete it.notExecuted;
+                if (isCcToolDenialKind(ev.denialKind))
+                    it.denialKind = ev.denialKind;
+                else
+                    delete it.denialKind;
+                if (ev.refusalNoted === true)
+                    it.refusalNoted = true;
+                else
+                    delete it.refusalNoted;
                 const delta = itemBytesOf(it) - before;
                 s.itemBytes[at] = (s.itemBytes[at] ?? 0) + delta;
                 addBytes(s, delta);
-                stampPhase(s, it.id, 'end', ev.eventId, it.output !== outBefore || it.isError !== errBefore || it.notExecuted !== notExecBefore);
+                stampPhase(s, it.id, 'end', ev.eventId, it.output !== outBefore || it.isError !== errBefore || it.notExecuted !== notExecBefore || it.denialKind !== denialBefore || it.refusalNoted !== notedBefore);
                 break;
             }
             const synthId = id ?? `${ev.taskId}-tool-${s.items.length}`;
@@ -654,6 +676,8 @@ export function publishSubagentContentEvent(ev) {
                 output: ev.output ?? '',
                 isError: ev.isError === true,
                 ...(ev.notExecuted === true ? { notExecuted: true } : {}),
+                ...(isCcToolDenialKind(ev.denialKind) ? { denialKind: ev.denialKind } : {}),
+                ...(ev.refusalNoted === true ? { refusalNoted: true } : {}),
             });
             recordCut(s);
             stampPhase(s, synthId, 'end', ev.eventId, true);
@@ -698,6 +722,8 @@ export function planSubagentViewSlots(taskId) {
                 ...(it.output !== undefined ? { output: it.output } : {}),
                 ...(it.isError === true ? { isError: true } : {}),
                 ...(it.notExecuted === true ? { notExecuted: true } : {}),
+                ...(it.denialKind !== undefined ? { denialKind: it.denialKind } : {}),
+                ...(it.refusalNoted === true ? { refusalNoted: true } : {}),
             });
         }
         else if (it.kind === 'text') {

package/dist/terminalStatuses.d.ts

@@ -26,6 +26,7 @@ export type CoreSemaTaskTerminalStatus = (typeof CORE_SEMA_TASK_TERMINAL_STATUSE
 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 function isCoreWorkflowRunParkedEnd(status: unknown, errorCode: unknown): boolean;
 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';

package/dist/terminalStatuses.js

@@ -1,4 +1,4 @@
-import { CORE_TERMINAL_CAUSE_KINDS, CORE_TASK_NOTIFICATION_TERMINAL_STATUSES as GENERATED_TASK_NOTIFICATION_TERMINAL_STATUSES } from './generated/engineFactTables.js';
+import { CORE_TERMINAL_CAUSE_KINDS, CORE_TASK_NOTIFICATION_TERMINAL_STATUSES as GENERATED_TASK_NOTIFICATION_TERMINAL_STATUSES, CORE_WORKFLOW_AGENT_PARKED_ERROR_CODE, } from './generated/engineFactTables.js';
 function memberOf(table, word) {
     return typeof word === 'string' && table.includes(word);
 }
@@ -53,6 +53,9 @@ export const CORE_WORKFLOW_RUN_TERMINAL_STATUSES = Object.freeze(['completed', '
 export function isCoreWorkflowRunTerminal(status) {
     return memberOf(CORE_WORKFLOW_RUN_TERMINAL_STATUSES, status);
 }
+export function isCoreWorkflowRunParkedEnd(status, errorCode) {
+    return status === 'failed' && errorCode === CORE_WORKFLOW_AGENT_PARKED_ERROR_CODE;
+}
 export const CORE_TASK_PROGRESS_TERMINAL_STATUSES = Object.freeze(['completed', 'failed']);
 export function isCoreTaskProgressTerminal(status) {
     return memberOf(CORE_TASK_PROGRESS_TERMINAL_STATUSES, status);

package/dist/toolResult.d.ts

@@ -109,6 +109,7 @@ export interface ToolResultRowFlags {
     readonly interruptedNeverStarted: boolean;
     readonly approvalWindowExpired: boolean;
     readonly denialLimitWindowExpired: boolean;
+    readonly refusalNoted: boolean;
 }
 export declare function toolResultRowFlagsOf(row: object | null | undefined): ToolResultRowFlags;
 export type ToolKillCause = NonNullable<ReturnType<typeof toolKillCauseAcrossEngineIdentity>> | 'memory_pressure';

package/dist/toolResult.js

@@ -8,6 +8,7 @@ import { guardedRead, ownDataField, ownSnapshotWhenTyped, readFrameTrueMark, rea
 import { displayUntrusted } from './displayUntrusted.js';
 import { isCoreSemaTaskTerminal } from './terminalStatuses.js';
 import { CORE_ENGINE_CARD_TYPES } from './generated/engineFactTables.js';
+import { SEMA_REFUSAL_NOTED_KEY } from './engineRowRef.js';
 export const STRUCTURED_DETAIL_TYPES = frozenSet(CORE_ENGINE_CARD_TYPES);
 const LEGACY_STRUCTURED_DETAIL_TYPE = 'task-output';
 export function structuredDetailType(structured) {
@@ -318,6 +319,7 @@ export function toolResultRowFlagsOf(row) {
         interruptedNeverStarted: readFrameTrueMark(row, '_sema_interrupted_never_started'),
         approvalWindowExpired: readFrameTrueMark(row, '_sema_approval_window_expired'),
         denialLimitWindowExpired: readFrameTrueMark(row, '_sema_denial_limit_window_expired'),
+        refusalNoted: readFrameTrueMark(row, SEMA_REFUSAL_NOTED_KEY),
     });
 }
 const TOOL_KILL_TEXT = {

package/dist/turnFailurePresentation.js

@@ -1,6 +1,6 @@
 import { msg, renderMessage } from './i18n/translate.js';
 import { classifyTurnWireError, isPreStreamDrainingReject } from './wireErrorTriage.js';
-import { isSseIdleError } from './sseIdleTriage.js';
+import { isSseIdleError, streamEndedReasonOf } from './sseIdleTriage.js';
 import { runNotFollowedOf } from './runFollow.js';
 import { isCodeClassifiedGateFailure } from './gateFailureCodes.js';
 import { CORRUPT_ROW_ERROR_CODE, CORRUPT_SESSION_ERROR_CODE, MEMORY_CONTROL_PLANE_CORRUPT, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
@@ -36,6 +36,13 @@ const TURN_FAILURE_HEADLINE_KEYS = Object.freeze({
     internal: 'notice.failure.headline.internal',
     cause_unreadable: 'notice.failure.headline.causeUnreadable',
 });
+const STREAM_ENDED_HEADLINE_KEYS = Object.freeze({
+    empty_legs: 'notice.streamEnded.emptyLegs.headline',
+    consecutive_failures: 'notice.streamEnded.consecutiveFailures.headline',
+});
+function parkedHeadlineKeyOf(reading) {
+    return reading.kind === 'read' ? STREAM_ENDED_HEADLINE_KEYS[reading.reason] : TURN_FAILURE_HEADLINE_KEYS.parked;
+}
 function waitSecOf(err) {
     const ms = readThrownSlot(err, 'retryAfterMs', 'data');
     if (typeof ms === 'number' && Number.isFinite(ms) && ms > 0)
@@ -128,7 +135,7 @@ export function turnFailurePresentation(err, evidence, notesCtx, lang) {
     }
     else if (verdict.kind === 'stream-ended-without-terminal') {
         shape = { category: 'parked', offer: false };
-        headlineKey = TURN_FAILURE_HEADLINE_KEYS.parked;
+        headlineKey = parkedHeadlineKeyOf(streamEndedReasonOf(err));
         detail = wireFailureTextsOf(err).reason;
     }
     else if (verdict.kind === 'transport') {

package/dist/typePins.d.ts

@@ -8,4 +8,15 @@ type WritableKeys<T> = {
     }, P, never>;
 }[keyof T];
 export type AllReadonly<T> = [WritableKeys<T>] extends [never] ? true : false;
+export type Same<A, B> = [Exclude<A, B>, Exclude<B, A>] extends [never, never] ? true : false;
+export type KeysEq<A, B> = Same<keyof A, keyof B>;
+export type Fits<A, B> = [A] extends [B] ? true : false;
+export type Present<T> = [T] extends [never] ? false : true;
+export type RequiredKeys<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
+}[keyof T];
+export type NeverValuedKeys<T> = {
+    [K in keyof T]-?: [Exclude<T[K], undefined>] extends [never] ? K : never;
+}[keyof T];
+export type NoNeverValues<T> = Same<NeverValuedKeys<T>, never>;
 export {};

package/dist/usageAnalytics.d.ts

@@ -144,3 +144,20 @@ export declare function projectUsageAnalytics(inputs: UsageAnalyticsInputs, wind
 export declare function readUsageAnalytics(client: UsageAnalyticsClientLike, window: UsageAnalyticsWindow, opts?: {
     signal?: AbortSignal;
 }): Promise<UsageAnalyticsView>;
+export declare const CENTER_USAGE_COST_UNKNOWN_WHYS: readonly ["declared_unknown", "basis_unrecognized", "estimated_zero", "amount_absent"];
+export type CenterUsageCostUnknownWhy = (typeof CENTER_USAGE_COST_UNKNOWN_WHYS)[number];
+export interface CenterUsageCostAmount {
+    readonly value: number;
+    readonly bound: Extract<UsageBound, 'exact' | 'lower'>;
+}
+export interface CenterUsageCostAmountReading {
+    readonly state: 'amount';
+    readonly amount: CenterUsageCostAmount;
+    readonly unpriced: boolean;
+}
+export interface CenterUsageCostUnknownReading {
+    readonly state: 'unknown';
+    readonly why: CenterUsageCostUnknownWhy;
+}
+export type CenterUsageCostReading = CenterUsageCostAmountReading | CenterUsageCostUnknownReading;
+export declare function centerUsageCostOf(body: object | null | undefined): CenterUsageCostReading;

package/dist/usageAnalytics.js

@@ -1,4 +1,4 @@
-import { readThrownSlot, THROWN_SLOT_UNREADABLE } from './wireFailureShape.js';
+import { readThrownSlot, slotReadOf, THROWN_SLOT_UNREADABLE } from './wireFailureShape.js';
 export const USAGE_SENTENCES = Object.freeze({
     analyticsUnavailable: 'Usage analytics aren’t available on this backend.',
     analyticsUnread: 'Usage analytics couldn’t be read just now.',
@@ -161,6 +161,9 @@ export function readUsageBreakdown(client, opts = {}) {
 export function usageBoundPrefix(bound) {
     return bound === 'lower' ? '≥' : bound === 'approximate' ? '≈' : '';
 }
+function costBoundOf(precision, truncated) {
+    return precision === 'exact' && !truncated ? 'exact' : 'lower';
+}
 const DAY_MS = 86_400_000;
 export const USAGE_HEATMAP_MAX_DAYS = 70;
 export function usageWindowOfRange(range, now) {
@@ -275,7 +278,7 @@ export function projectUsageAnalytics(inputs, window) {
         readings.tokens = { value: sv.tokensIn + sv.tokensOut, bound: !exact ? 'approximate' : sv.truncated ? 'lower' : 'exact' };
     }
     if (sv.cost !== undefined)
-        readings.cost = { value: sv.cost, bound: exact && !sv.truncated ? 'exact' : 'lower' };
+        readings.cost = { value: sv.cost, bound: costBoundOf(sv.precision, sv.truncated) };
     const day = inputs.daySeries;
     if (day.kind === 'ok' && isWhole(day.value)) {
         const dayValues = new Map();
@@ -328,3 +331,42 @@ export async function readUsageAnalytics(client, window, opts = {}) {
     ]);
     return projectUsageAnalytics({ summary, daySeries, hourSeries, modelBreakdown }, window);
 }
+const CENTER_COST_BASIS_WORDS = ['exact', 'lowerBound', 'unknown'];
+export const CENTER_USAGE_COST_UNKNOWN_WHYS = Object.freeze(['declared_unknown', 'basis_unrecognized', 'estimated_zero', 'amount_absent']);
+const unknownCost = (why) => ({ state: 'unknown', why });
+const amountCost = (value, bound, unpriced) => ({ state: 'amount', amount: { value, bound }, unpriced });
+const flagNotRuledOut = (r) => r.value === true || r.presence === 'unreadable';
+export function centerUsageCostOf(body) {
+    try {
+        if (!isRecord(body))
+            return unknownCost('amount_absent');
+        const basis = slotReadOf(body, 'costBasis');
+        let word;
+        if (basis.presence === 'present') {
+            word = CENTER_COST_BASIS_WORDS.find((w) => w === basis.value);
+            if (word === undefined)
+                return unknownCost('basis_unrecognized');
+        }
+        else if (basis.presence === 'unreadable') {
+            return unknownCost('basis_unrecognized');
+        }
+        if (word === 'unknown')
+            return unknownCost('declared_unknown');
+        const cost = slotReadOf(body, 'costUsd').value;
+        if (!nonNeg(cost))
+            return unknownCost('amount_absent');
+        const est = slotReadOf(body, 'estimated');
+        const trunc = slotReadOf(body, 'truncated');
+        const unpriced = est.value === true;
+        if (word === 'lowerBound')
+            return amountCost(cost, 'lower', unpriced);
+        if (word === 'exact')
+            return flagNotRuledOut(est) || flagNotRuledOut(trunc) ? amountCost(cost, 'lower', unpriced) : amountCost(cost, 'exact', false);
+        if (unpriced && cost === 0)
+            return unknownCost('estimated_zero');
+        return amountCost(cost, costBoundOf(precisionOf(est.value), flagNotRuledOut(trunc)), unpriced);
+    }
+    catch {
+        return unknownCost('amount_absent');
+    }
+}