@sema-agent/client-core 0.108.0 → 0.110.0

package/dist/sessionEngine.js

@@ -377,6 +377,117 @@ function methodOf(o, key) {
         return undefined;
     }
 }
+function addressBindingOf(raw) {
+    if (typeof raw !== 'string')
+        return undefined;
+    const b = addressBinding(raw);
+    return b.ok && b.identityKind === 'address' ? b : undefined;
+}
+function enginesTableOf(record) {
+    const slot = slotReadOf(record, 'engines');
+    if (slot.presence === 'absent' || (slot.presence === 'present' && slot.value === undefined))
+        return 'absent';
+    return slot.presence === 'present' && isObj(slot.value) ? slot.value : 'unreadable';
+}
+function movedEngines(table, dropKey, putKey, entry) {
+    const out = {};
+    for (const k of Object.keys(table)) {
+        if (k === dropKey)
+            continue;
+        const slot = slotReadOf(table, k);
+        if (slot.presence !== 'present')
+            return undefined;
+        Object.defineProperty(out, k, { value: slot.value, writable: true, enumerable: true, configurable: true });
+    }
+    Object.defineProperty(out, putKey, { value: entry, writable: true, enumerable: true, configurable: true });
+    return out;
+}
+function repointStep(prior, from, to, fromNs, toNs, now) {
+    try {
+        const reading = readSessionEngine(prior);
+        if (reading.kind === 'none')
+            return { result: 'unaffected' };
+        if (reading.kind === 'unresolved' || prior === undefined)
+            return { result: 'unreadable' };
+        const table = enginesTableOf(prior);
+        if (reading.kind === 'bound') {
+            const id = reading.binding.identity;
+            if (id.identityKind !== 'address' || id.key !== from.key)
+                return { result: 'unaffected' };
+            if (table === 'absent' || table === 'unreadable')
+                return { result: 'unreadable' };
+            if (Object.hasOwn(table, to.key))
+                return { result: 'conflict' };
+            const entry = slotReadOf(table, from.key);
+            if (entry.presence !== 'present' || !isObj(entry.value))
+                return { result: 'unreadable' };
+            const engines = movedEngines(table, from.key, to.key, entry.value);
+            if (engines === undefined)
+                return { result: 'unreadable' };
+            return {
+                result: 'moved',
+                next: { ...prior, boundEngine: snapshotOf({ kind: reading.binding.kind, identity: to }), engines, updatedAt: now },
+            };
+        }
+        if (table === 'absent')
+            return { result: 'unaffected' };
+        if (table === 'unreadable')
+            return { result: 'unreadable' };
+        if (!Object.hasOwn(table, fromNs))
+            return { result: 'unaffected' };
+        if (Object.hasOwn(table, toNs))
+            return { result: 'conflict' };
+        const entry = slotReadOf(table, fromNs);
+        if (entry.presence !== 'present' || !isObj(entry.value))
+            return { result: 'unreadable' };
+        const engines = movedEngines(table, fromNs, toNs, entry.value);
+        if (engines === undefined)
+            return { result: 'unreadable' };
+        return { result: 'moved', next: { ...prior, engines, updatedAt: now } };
+    }
+    catch {
+        return { result: 'unreadable' };
+    }
+}
+export function repointSessionEngine(store, from, to) {
+    let readMergeWrite;
+    let fromB;
+    let toB;
+    try {
+        if (!isObj(store))
+            return 'request-invalid';
+        const rmw = methodOf(store, 'readMergeWrite');
+        if (rmw === undefined)
+            return 'request-invalid';
+        readMergeWrite = (build) => rmw.call(store, build);
+        const f = addressBindingOf(from);
+        const t = addressBindingOf(to);
+        if (f === undefined || t === undefined || f.key === t.key)
+            return 'request-invalid';
+        fromB = f;
+        toB = t;
+    }
+    catch {
+        return 'request-invalid';
+    }
+    const fromNs = engineNamespaceKeyFor(from);
+    const toNs = engineNamespaceKeyFor(to);
+    let step;
+    try {
+        const returned = readMergeWrite((prior) => {
+            step = repointStep(prior, fromB, toB, fromNs, toNs, new Date().toISOString());
+            return Object.hasOwn(step, 'next') ? step.next : undefined;
+        });
+        if (step === undefined)
+            return 'store-failed';
+        if (Object.hasOwn(step, 'next') && !isObj(returned))
+            return 'store-failed';
+        return step.result;
+    }
+    catch {
+        return 'store-failed';
+    }
+}
 const REFUSAL_KEYS = {
     'not-wired': 'session.engine.dispatch.notWired',
     'scope-mismatch': 'session.engine.dispatch.scopeMismatch',

package/dist/sessionMemoryStatus.d.ts

@@ -9,7 +9,8 @@ export interface MemoryStatusClientLike {
         } & SessionMemoryStatus>;
     };
 }
-export type MemoryStatusFacts = Omit<SessionMemoryStatusResponse, 'sessionId' | 'memorySync'> & {
+export type MemoryStatusFacts = SessionMemoryStatus & {
+    autoConsolidationArmed?: SessionMemoryStatusResponse['autoConsolidationArmed'];
     readonly memorySync?: MemorySyncFacts;
 };
 export interface MemorySyncFacts {

package/dist/sessionSyncFileHistory.d.ts

@@ -1,4 +1,8 @@
+import type { RowBitsOutcome } from '@sema-agent/sdk';
+import { type UiLanguage } from './env/uiLanguage.js';
 export declare const FILE_HISTORY_SKIPPED_NOTICE: string;
 export declare function fileHistorySyncNotice(result: unknown): string | undefined;
 export declare function fileHistorySyncNoticeIdentity(result: unknown): string | undefined;
 export declare function isFileHistoryBlobMissing(err: unknown): boolean;
+export type PushRowBitsWord = RowBitsOutcome | 'writer_side';
+export declare function sessionPushRowBitsNotice(result: {} | null | undefined, lang?: UiLanguage | (string & {})): string | undefined;

package/dist/sessionSyncFileHistory.js

@@ -1,6 +1,8 @@
 import { NOT_FOUND_BLOB } from './engineErrorCodes.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 import { readThrownSlot } from './wireFailureShape.js';
+import { isUiLanguage } from './env/uiLanguage.js';
+import { msg, renderMessage } from './i18n/translate.js';
 export const FILE_HISTORY_SKIPPED_NOTICE = 'File history was not copied: only the conversation was synced, because one of the two engines does not confirm that it can ' +
     'transfer file history (the record /rewind uses to restore files). Syncing this session again will not add it until ' +
     'the conversation has new turns and both engines can transfer file history.';
@@ -64,3 +66,29 @@ export function isFileHistoryBlobMissing(err) {
         return false;
     }
 }
+function pushRowBitsSpeaks(word) {
+    switch (word) {
+        case 'writer_side':
+            return true;
+        case 'mirrored':
+        case 'unsupported':
+        case 'absent':
+            return false;
+    }
+}
+function isPushRowBitsWord(v) {
+    return v === 'mirrored' || v === 'unsupported' || v === 'absent' || v === 'writer_side';
+}
+export function sessionPushRowBitsNotice(result, lang) {
+    if (result === null || typeof result !== 'object')
+        return undefined;
+    try {
+        const word = getOwn(result, 'rowBits');
+        if (typeof word !== 'string' || !isPushRowBitsWord(word) || !pushRowBitsSpeaks(word))
+            return undefined;
+        return renderMessage(msg('session.sync.pushRowBitsWriterSide'), isUiLanguage(lang) ? lang : undefined);
+    }
+    catch {
+        return undefined;
+    }
+}

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,7 @@
 import { hostEnv } from './hostEnv.js';
 import { SseIdleError, StreamEndedWithoutTerminalError, probeHealth as sdkProbeHealth } from '@sema-agent/sdk';
-import { readThrownSlot, thrownIsInstanceOf } from './wireFailureShape.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 +39,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 (await sdkProbeHealth(baseUrl)).alive;
 }
 export async function* diagnoseSseIdleTear(inner, baseUrl, signal) {
     try {

package/dist/subagent/engineSubagentTail.js

@@ -7,6 +7,7 @@ import { resolveOwnerContext } from './engineSubagentResume.js';
 import { coerceOutput, parentToolCallIdOf, publishSubagentContentEvent, settleSubagentContent, } 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']]);
 }
@@ -149,6 +150,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

@@ -49,6 +49,18 @@ export declare function __resetSubagentContentStoreConfigForTests(): void;
 export declare function bindSubagentIdentityReader(fn: (id: string) => readonly string[] | undefined): void;
 export declare function registerSubagentContentAlias(parentToolCallId: string, taskId: string): void;
 export declare function registerSubagentAlias(parentToolCallId: string, taskId: string): void;
+export declare const SUBAGENT_ALIAS_SCOPES: readonly ["content", "full"];
+export type SubagentAliasScope = (typeof SUBAGENT_ALIAS_SCOPES)[number];
+export type SubagentAliasOutcome = 'new' | 'unchanged' | 'rejected';
+export declare function applySubagentAlias(parentToolCallId: string, taskId: string, scope: SubagentAliasScope, seq?: number): SubagentAliasOutcome;
+export interface SeatSubagentAlias {
+    readonly parentToolCallId: string;
+    readonly taskId: string;
+    readonly scope: SubagentAliasScope;
+    readonly seq?: number;
+}
+export declare function readSeatSubagentAlias(ev: object | null | undefined): SeatSubagentAlias | undefined;
+export declare function noteSeatSubagentAlias(ev: object | null | undefined): 'registered' | 'ignored';
 export declare function publishSubagentContentEvent(ev: SubagentContentEvent): void;
 export declare function pushSubagentLocalEcho(taskId: string, text: string): void;
 export interface SubagentContentSnapshot {

package/dist/subagentContentStore.js

@@ -1,5 +1,6 @@
 import { DEFAULT_SESSION_KEY } from './sessionSlot.js';
-import { readFrameTrueMark } from './ownKey.js';
+import { readFrameTrueMark, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+import { cycleSeqValue } from './cycleOrder.js';
 import { toolEndOutputText } from './toolResultContent.js';
 export function coerceOutput(v) {
     return toolEndOutputText(v);
@@ -398,7 +399,7 @@ function scheduleNotify(taskId) {
     }, NOTIFY_COALESCE_MS);
 }
 export function registerSubagentContentAlias(parentToolCallId, taskId) {
-    aliasContentKey(parentToolCallId, taskId);
+    applySubagentAlias(parentToolCallId, taskId, 'content');
 }
 function aliasContentKey(parentToolCallId, taskId) {
     if (!parentToolCallId || !taskId || parentToolCallId === taskId)
@@ -415,10 +416,72 @@ function aliasContentKey(parentToolCallId, taskId) {
     return true;
 }
 export function registerSubagentAlias(parentToolCallId, taskId) {
+    applySubagentAlias(parentToolCallId, taskId, 'full');
+}
+export const SUBAGENT_ALIAS_SCOPES = ['content', 'full'];
+export function applySubagentAlias(parentToolCallId, taskId, scope, seq) {
+    const hadContent = parentToTask.get(parentToolCallId) === taskId;
     if (!aliasContentKey(parentToolCallId, taskId))
-        return;
-    if (taskToParent.get(taskId)?.card !== parentToolCallId)
-        taskToParent.set(taskId, { card: parentToolCallId, stamp: ++parentStampSeq });
+        return 'rejected';
+    let changed = !hadContent;
+    if (scope === 'full') {
+        const cycle = cycleSeqValue(seq);
+        const cur = taskToParent.get(taskId);
+        if (cur?.card !== parentToolCallId) {
+            const stale = cur !== undefined && cycle !== undefined && cur.seq !== undefined && cycle < cur.seq;
+            if (!stale) {
+                taskToParent.set(taskId, { card: parentToolCallId, stamp: ++parentStampSeq, ...(cycle !== undefined ? { seq: cycle } : {}) });
+                changed = true;
+            }
+        }
+        else if (cycle !== undefined && (cur.seq === undefined || cycle > cur.seq)) {
+            taskToParent.set(taskId, { card: cur.card, stamp: cur.stamp, seq: cycle });
+        }
+    }
+    return changed ? 'new' : 'unchanged';
+}
+export function readSeatSubagentAlias(ev) {
+    try {
+        if (typeof ev !== 'object' || ev === null)
+            return undefined;
+        if (readOwnDataValue(ev, 'kind') !== 'subagent_alias')
+            return undefined;
+        const parentToolCallId = readOwnDataNonEmptyString(ev, 'parentToolCallId');
+        const taskId = readOwnDataNonEmptyString(ev, 'taskId');
+        const scope = readOwnDataNonEmptyString(ev, 'scope');
+        if (parentToolCallId === undefined || taskId === undefined || scope === undefined)
+            return undefined;
+        if (!SUBAGENT_ALIAS_SCOPES.includes(scope))
+            return undefined;
+        const proof = readOwnDataValue(ev, 'laneProof');
+        if (typeof proof !== 'object' || proof === null)
+            return undefined;
+        if (readOwnDataValue(proof, 'lane') !== 'subagent')
+            return undefined;
+        if (readOwnDataNonEmptyString(proof, 'parentToolCallId') !== parentToolCallId)
+            return undefined;
+        const seqDesc = Object.getOwnPropertyDescriptor(ev, 'seq');
+        let seq;
+        if (seqDesc !== undefined) {
+            if (!Object.hasOwn(seqDesc, 'value'))
+                return undefined;
+            if (seqDesc.value !== undefined) {
+                seq = cycleSeqValue(seqDesc.value);
+                if (seq === undefined)
+                    return undefined;
+            }
+        }
+        return { parentToolCallId, taskId, scope: scope, ...(seq !== undefined ? { seq } : {}) };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function noteSeatSubagentAlias(ev) {
+    const alias = readSeatSubagentAlias(ev);
+    if (alias === undefined)
+        return 'ignored';
+    return applySubagentAlias(alias.parentToolCallId, alias.taskId, alias.scope, alias.seq) === 'new' ? 'registered' : 'ignored';
 }
 function replaySeen(s, ev) {
     const id = ev.eventId;
@@ -661,18 +724,16 @@ export function planSubagentViewSlots(taskId) {
 export function parentToolCallIdOf(taskId) {
     const ids = sameSubagentIds(taskId);
     let stated;
-    let statedStamp = -1;
     for (const id of ids) {
         const hit = taskToParent.get(id);
         if (hit === undefined)
             continue;
-        if (stated === undefined || hit.stamp > statedStamp) {
-            stated = hit.card;
-            statedStamp = hit.stamp;
-        }
+        const newer = hit.seq !== undefined && stated?.seq !== undefined && hit.seq !== stated.seq ? hit.seq > stated.seq : hit.stamp > (stated?.stamp ?? -1);
+        if (stated === undefined || newer)
+            stated = hit;
     }
     if (stated !== undefined)
-        return stated;
+        return stated.card;
     for (const id of ids) {
         const fromContent = tasks.get(id)?.parentToolCallId;
         if (fromContent !== undefined)

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.js

@@ -3,7 +3,7 @@ import { markEngineWorkflowNotified, registerOutstandingBgTask, registerOutstand
 import { parseWorkflowPollEnvelope, projectWorkflowTaskOutput } from './workflow.js';
 import { asModelFallbackReason } from './engineErrorCodes.js';
 import { frozenSet } from './frozenSet.js';
-import { bashExitOf, bashExitReadingFailed } from './bashExitReading.js';
+import { bashCurtailedResultPart, bashCurtailmentOf, bashCurtailmentSentence, bashExitOf, bashExitReadingFailed } from './bashExitReading.js';
 import { guardedRead, ownDataField, ownSnapshotWhenTyped, readFrameTrueMark, readFrameTrueMarkReading, readOwnDataFiniteNumber, readOwnDataNonEmptyString, readOwnDataValue, toolResultBlockOf, } from './ownKey.js';
 import { displayUntrusted } from './displayUntrusted.js';
 import { isCoreSemaTaskTerminal } from './terminalStatuses.js';
@@ -370,6 +370,7 @@ export function wireOutputToBody(toolName, output, isError, truncated, flatten,
         let parsedMemo;
         const parseOnce = () => (parsedMemo === undefined ? (parsedMemo = parseModelFacingBash(text)) : parsedMemo);
         const exit = bashExitOf(structured, parseOnce);
+        const cut = bashCurtailmentOf(structured);
         const structuredSlots = sType === 'bash' && (typeof s?.stdout === 'string' || typeof s?.stderr === 'string');
         const textSlots = structuredSlots ? null : parseOnce();
         const slots = structuredSlots
@@ -392,26 +393,37 @@ export function wireOutputToBody(toolName, output, isError, truncated, flatten,
                 }
                 if (body.trim() === '' && text.trim() !== '')
                     body = text;
+                else if (cut !== undefined) {
+                    if (body.trim() === '')
+                        body = bashCurtailmentSentence(cut);
+                    else if (reason.trim() !== '')
+                        body = `${bashCurtailmentSentence(cut)}\n${body}`;
+                }
                 return { content: truncated ? `${body}\n…(truncated)` : body, isError: true };
             }
             const stdout = truncated ? `${slots.stdout}\n…(truncated)` : slots.stdout;
             const processedStdout = stdout.replace(/^(\s*\n)+/, '').trimEnd();
             return {
-                content: [processedStdout, slots.stderr.trim()].filter(Boolean).join('\n'),
+                content: [cut !== undefined ? bashCurtailmentSentence(cut) : '', processedStdout, slots.stderr.trim()].filter(Boolean).join('\n'),
                 isError: false,
                 toolUseResult: {
                     stdout,
-                    stderr: slots.stderr,
+                    ...bashCurtailedResultPart(slots.stderr, cut),
                     interrupted: false,
                     ...(benignInterp !== undefined ? { returnCodeInterpretation: benignInterp } : {}),
                 },
             };
         }
         const stdout = truncated ? `${text}\n…(truncated)` : text;
+        const cutSentence = cut !== undefined ? bashCurtailmentSentence(cut) : undefined;
         if (isError || bashExitReadingFailed(exit)) {
+            if (cutSentence !== undefined && text.trim() === '' && exit.exitCode !== 137) {
+                return { content: truncated ? `${cutSentence}\n…(truncated)` : cutSentence, isError: true };
+            }
             return { content: exit.exitCode === 137 ? `${stdout}\n${killedBySignalSentence(killCauseOf)}` : stdout, isError: true };
         }
-        return { content: stdout, isError, toolUseResult: { stdout, stderr: '', interrupted: false } };
+        const okContent = cutSentence === undefined ? stdout : text.trim() === '' ? (truncated ? `${cutSentence}\n…(truncated)` : cutSentence) : `${cutSentence}\n${stdout}`;
+        return { content: okContent, isError, toolUseResult: { stdout, ...bashCurtailedResultPart('', cut), interrupted: false } };
     }
     if (name === 'taskoutput' || name === 'task_output') {
         const body = truncated ? `${text}\n…(truncated)` : text;
@@ -498,10 +510,11 @@ export function structuredToToolUseResult(structured, modelText, leaderLedger =
                 return null;
             const exit = bashExitOf(structured, () => null);
             const benignInterp = exit.benignNote;
+            const cut = bashCurtailmentOf(structured);
             return {
                 toolUseResult: {
                     stdout: typeof s.stdout === 'string' ? s.stdout : '',
-                    stderr: typeof s.stderr === 'string' ? s.stderr : '',
+                    ...bashCurtailedResultPart(typeof s.stderr === 'string' ? s.stderr : '', cut),
                     interrupted: false,
                     ...(benignInterp !== undefined ? { returnCodeInterpretation: benignInterp } : {}),
                 },

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');
+    }
+}