@sema-agent/client-core 0.97.0 → 0.98.0

package/dist/preemptWire.js

@@ -0,0 +1,83 @@
+import { isAssistantLaneAbsent } from './assistantInbox.js';
+import { atMostOnceVerdictOf } from './atMostOnce.js';
+import { readOwnDataValue } from './ownKey.js';
+import { isSdkRunTerminal } from './terminalStatuses.js';
+import { isDisplayableWireCode, readErrorString } from './wireFailureShape.js';
+const ALREADY_SUSPENDED = 'conflict.already_suspended';
+const APPROVAL_SETTLED = 'conflict.approval_settled';
+function own(v, key) {
+    try {
+        return readOwnDataValue(v, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function preemptReadingOfAck(taskId, ack) {
+    const body = ack;
+    const unreadable = { kind: 'unconfirmed', why: 'unreadable-answer' };
+    if (body === null || typeof body !== 'object')
+        return unreadable;
+    const echoed = own(body, 'taskId');
+    const status = own(body, 'status');
+    if (echoed !== taskId || typeof status !== 'string' || status === '')
+        return unreadable;
+    if (status === 'preempting')
+        return { kind: 'yield-requested', taskId };
+    if (status === 'running')
+        return { kind: 'not-eligible', taskId };
+    if (status === 'suspended' || status === 'needs_review')
+        return { kind: 'already-parked', status };
+    if (isSdkRunTerminal(status))
+        return { kind: 'already-ended', taskId, status };
+    return unreadable;
+}
+export function preemptReadingOfError(e) {
+    if (isAssistantLaneAbsent(e))
+        return { kind: 'lane-absent' };
+    const v = atMostOnceVerdictOf(e);
+    if (v.delivery === 'rejected' && v.status !== undefined) {
+        if (v.status === 409 && v.code === ALREADY_SUSPENDED) {
+            const word = e === null || e === undefined ? undefined : readErrorString(e, 'status');
+            return { kind: 'already-parked', ...(word === 'suspended' || word === 'needs_review' ? { status: word } : {}) };
+        }
+        if (v.status === 409 && v.code === APPROVAL_SETTLED)
+            return { kind: 'approval-settled' };
+        if (v.status === 404)
+            return { kind: 'not-found' };
+        return { kind: 'refused', status: v.status, ...(v.code !== undefined ? { errorCode: v.code } : {}) };
+    }
+    if (v.status !== undefined)
+        return { kind: 'unconfirmed', why: 'server-error', status: v.status };
+    return { kind: 'unconfirmed', why: 'transport' };
+}
+export function preemptReceiptLine(outcome) {
+    switch (outcome.kind) {
+        case 'yield-requested':
+            return 'Asked the run to yield — it will pause at its next clean turn boundary and can be resumed later.';
+        case 'not-eligible':
+            return 'This run cannot be asked to yield (it is a verification or cascade leg), so nothing changed and it keeps running — stop it instead if it has to end.';
+        case 'already-ended':
+            return isSdkRunTerminal(outcome.status)
+                ? `The run had already ended (${outcome.status}), so there was nothing to yield.`
+                : 'The run had already ended, so there was nothing to yield.';
+        case 'already-parked':
+            return 'The run is already paused waiting on a decision, so there is nothing to yield — answer what it is waiting on, or stop it.';
+        case 'approval-settled':
+            return 'The approval this run was waiting on was decided at the same moment, so the yield request did not apply — check the run and ask again if it is still active.';
+        case 'not-found':
+            return 'No such run is visible to you, so nothing was asked.';
+        case 'unconfirmed':
+            return 'The yield request was sent but no confirmation came back — it may or may not have been applied, so check the run before asking again.';
+        case 'refused':
+            return outcome.errorCode !== undefined && isDisplayableWireCode(outcome.errorCode)
+                ? `The engine refused the yield request (${outcome.status} ${outcome.errorCode}).`
+                : `The engine refused the yield request (${outcome.status}).`;
+        case 'no-run':
+            return 'There is no run in flight to yield.';
+        case 'cancelled-instead':
+            return 'Yielding is not available on this engine, so the run was stopped instead — that is a hard stop and the run cannot be resumed.';
+        case 'unavailable':
+            return 'Yielding is not available on this engine, so nothing was sent.';
+    }
+}

package/dist/printToolResultFrame.js

@@ -1,11 +1,19 @@
 import { isCcToolDenialKind } from './gateVocabulary.js';
 export { flattenWireOutput as flattenToolOutput } from './adapt/wireShapes.js';
 import { flattenWireOutput } from './adapt/wireShapes.js';
-import { toolResultEnvelopeParts, toolResultOutcomeOf } from './adapt/toolCards.js';
-import { readFrameTrueMark } from './ownKey.js';
+import { toolResultEnvelopeParts, toolResultOutcomeOf, toolResultRowFlagParts, toolResultRowIdentity } from './adapt/toolCards.js';
+import { engineRefOf } from './engineRowRef.js';
+import { guardedRead } from './ownKey.js';
+import { gateOutcomeOf } from './gateOutcome.js';
+import { isUnsettledHeldToolEnd } from './engineRowRef.js';
 export function toolEndResultToUserFrame(arm) {
     if (typeof arm.toolCallId !== 'string' || arm.toolCallId.length === 0)
         return null;
+    if (isUnsettledHeldToolEnd(arm))
+        return null;
+    const armEventId = arm.eventId;
+    const callId = arm.toolCallId;
+    const rowIdentity = toolResultRowIdentity([{ eventId: typeof armEventId === 'string' ? armEventId : undefined, engineRef: engineRefOf(arm) }], callId, { uuid: () => callId });
     const text = flattenWireOutput(arm.output);
     const parent = typeof arm.parentToolCallId === 'string' ? arm.parentToolCallId : null;
     const outcome = toolResultOutcomeOf(typeof arm.toolName === 'string' ? arm.toolName : '', {
@@ -15,6 +23,7 @@ export function toolEndResultToUserFrame(arm) {
         isError: arm.isError === true,
     }, undefined, parent === null ? 'leader' : 'subagent');
     const envelope = toolResultEnvelopeParts(outcome);
+    const gateView = guardedRead(() => gateOutcomeOf(arm));
     const content = Array.isArray(outcome.body.content) ? outcome.body.content : arm.truncated === true ? `${text}\n…(truncated)` : text;
     return {
         type: 'user',
@@ -31,10 +40,12 @@ export function toolEndResultToUserFrame(arm) {
         },
         parent_tool_use_id: parent,
         ...(isCcToolDenialKind(arm._sema_denial_kind) ? { _sema_denial_kind: arm._sema_denial_kind } : {}),
-        ...(readFrameTrueMark(arm, 'notExecuted') ? { _sema_not_executed: true } : {}),
+        ...(gateView !== undefined ? { _sema_gate: gateView } : {}),
+        ...toolResultRowFlagParts(arm),
         ...(Object.hasOwn(envelope, 'tool_use_result') ? { tool_use_result: envelope.tool_use_result } : {}),
         ...(Object.hasOwn(envelope, '_sema_degraded') ? { _sema_degraded: envelope._sema_degraded } : {}),
-        uuid: arm.uuid,
+        uuid: rowIdentity.uuid,
         session_id: arm.session_id,
+        ...(rowIdentity.engineRef !== undefined ? { _sema_engine_ref: rowIdentity.engineRef } : {}),
     };
 }

package/dist/replayBody.d.ts

@@ -10,3 +10,6 @@ export interface DoneResultView {
     readonly row?: ReplayRowView;
 }
 export declare function doneResultView(result: unknown): DoneResultView;
+export declare function isReplayedTerminal(frame: object | null | undefined): boolean;
+export declare function isReplayMarked(message: object | null | undefined): boolean;
+export declare const RESULT_REPLAYED_TEXT = "No new run was started: this request's idempotency key matched an earlier submission.";

package/dist/replayBody.js

@@ -1,3 +1,4 @@
+import { readFrameTrueMark } from './ownKey.js';
 function guarded(o, k) {
     try {
         return o[k];
@@ -23,3 +24,16 @@ export function doneResultView(result) {
     }
     return { replay: true, engine: guarded(result, 'result'), row };
 }
+export function isReplayedTerminal(frame) {
+    if (frame === null || typeof frame !== 'object' || Array.isArray(frame))
+        return false;
+    if (guarded(frame, 'type') !== 'done')
+        return false;
+    if (readFrameTrueMark(frame, 'replay'))
+        return true;
+    return doneResultView(guarded(frame, 'result')).replay;
+}
+export function isReplayMarked(message) {
+    return readFrameTrueMark(message, '_sema_replay');
+}
+export const RESULT_REPLAYED_TEXT = "No new run was started: this request's idempotency key matched an earlier submission.";

package/dist/request/taskRequest.d.ts

@@ -75,7 +75,6 @@ export interface TaskRequestOmission {
 export declare function taskRequestOmissionCauseDetail(cause: unknown): string;
 export declare const TASK_REQUEST_OMISSION_CAUSE_NOTICES: Readonly<Record<TaskRequestOmissionCause, string>>;
 export declare function taskRequestOmissionCauseNotice(cause: unknown): string;
-export declare function taskRequestOmissionCausePhrase(cause: unknown): string;
 export interface TaskRequestAssembly {
     readonly request: TaskRequestLike;
     readonly omitted: readonly TaskRequestOmission[];

package/dist/request/taskRequest.js

@@ -112,9 +112,6 @@ export function taskRequestOmissionCauseNotice(cause) {
         ? TASK_REQUEST_OMISSION_CAUSE_NOTICES[cause]
         : TASK_REQUEST_OMISSION_UNKNOWN_CAUSE_NOTICE;
 }
-export function taskRequestOmissionCausePhrase(cause) {
-    return omissionNoticePartsOf(cause)?.reason ?? TASK_REQUEST_OMISSION_UNKNOWN_CAUSE_REASON;
-}
 const row = (field) => ({ via: 'matrix', field });
 const INPUT_KEY_ROUTES = {
     objective: { via: 'always' },

package/dist/resumeRefusalCopy.d.ts

@@ -1,3 +1,4 @@
+import type { ResumeStartupCause } from '@sema-agent/sdk';
 import { RESUME_CONTEXT_UNAVAILABLE, CHECKPOINT_UNSUPPORTED_VERSION, CHECKPOINT_WALLTIME_AXIS_RETIRED, CHECKPOINT_CONFIG_REFUSED } from './engineErrorCodes.js';
 export declare const RESUME_REFUSAL_CODES: readonly string[];
 export interface ResumeRefusalDetail {
@@ -41,7 +42,7 @@ export interface ParkedResumeStartupDetail {
     code: string;
     cause: ParkedResumeStartupCause;
     taskId?: string;
-    startupCause?: string;
+    startupCause?: ResumeStartupCause;
     resendable: false;
     denyStaysOpen: true;
 }

package/dist/resumeRefusalCopy.js

@@ -1,5 +1,6 @@
 import { readBlockedBy, readErrorNumber, readErrorString } from './wireFailureShape.js';
-import { guardedRead, ownDataField, readOwnDataNonEmptyString } from './ownKey.js';
+import { guardedRead, ownDataField, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+import { CORE_RESUME_STARTUP_CAUSES } from './generated/engineFactTables.js';
 import { RESUME_CONTEXT_UNAVAILABLE, RESUME_PLACEMENT_MISMATCH, RESUME_PREFLIGHT_REJECTED, RESUME_POLICY_FOLD_CODE, PARKED_RESUME_STARTUP_FAILED, isStatusDerivedCoarseCode, RESUME_SESSION_NOT_FOUND, REQUEST_FIELD_CONFLICT, CHECKPOINT_UNSUPPORTED_VERSION, CHECKPOINT_WALLTIME_AXIS_RETIRED, CHECKPOINT_CONFIG_REFUSED, isRefusedParkCode, refusalSaysStillPending, refusalRetriableReading, } from './engineErrorCodes.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineVersionTier } from './supportFloor.js';
@@ -144,8 +145,13 @@ function parkedResumeStartupCauseWord(err) {
     catch {
         named = undefined;
     }
-    return named;
+    return isResumeStartupCause(named) ? named : undefined;
 }
+function isResumeStartupCause(v) {
+    return typeof v === 'string' && CORE_RESUME_STARTUP_CAUSES.includes(v);
+}
+const _startupCausePin = true;
+void _startupCausePin;
 export function parkedResumeStartupFromError(err, decision) {
     if (typeof err !== 'object' || err === null)
         return null;
@@ -183,7 +189,37 @@ const PARKED_RESUME_STARTUP_SENTENCES = Object.freeze({
         'If the card is still there: when the engine rejected the decision itself (for example an answer given to the wrong question), correct it and decide again; when the approved tool is one the agent inherits from the task that started it, approving it again will not work on this server — deny the card, or wait for a server upgrade',
     ].join(' · '),
 });
+const PARKED_RESUME_STARTUP_CAUSE_SENTENCES = Object.freeze({
+    environment: [
+        'The engine could not start the parked work to apply this decision: the environment it runs in failed to come up (for example the workspace could not be restored); the decision itself was not rejected',
+        PARKED_RESUME_STARTUP_STATE,
+        'If the card is still there, deciding it again replays the same decision',
+    ].join(' · '),
+    session_gone: [
+        'The engine could not start the parked work to apply this decision: the session of the agent it would resume is gone',
+        PARKED_RESUME_STARTUP_STATE,
+        'If the card is still there, deny it to close it; the work it was waiting on cannot be resumed',
+    ].join(' · '),
+    tool_unavailable: [
+        'The engine could not start the parked work to apply this decision: the approved tool is not available to the resumed work (it is gone, or a different tool now has its name)',
+        PARKED_RESUME_STARTUP_STATE,
+        'This approval cannot run as decided — if the card is still there, decide it afresh (denying it settles it)',
+    ].join(' · '),
+    configuration: [
+        "The engine could not start the parked work to apply this decision: this deployment's configuration refuses the resumed work",
+        PARKED_RESUME_STARTUP_STATE,
+        'Deciding again under the same configuration fails the same way — the configuration has to change first; denying the card settles it',
+    ].join(' · '),
+    decision_rejected: [
+        'The engine could not start the parked work to apply this decision: the engine rejected the decision itself (for example an answer given to the wrong question, or an edited input the constraints refuse)',
+        PARKED_RESUME_STARTUP_STATE,
+        'If the card is still there, correct the decision and decide it again from the fresh list',
+    ].join(' · '),
+});
 export function parkedResumeStartupContent(detail) {
+    const word = guardedRead(() => readOwnDataValue(detail, 'startupCause'));
+    if (isResumeStartupCause(word))
+        return PARKED_RESUME_STARTUP_CAUSE_SENTENCES[word];
     return detail.cause === 'resume_rejected' ? PARKED_RESUME_STARTUP_SENTENCES.resume_rejected : PARKED_RESUME_STARTUP_SENTENCES.undetermined;
 }
 export function checkpointUnsupportedVersionFromError(err) {

package/dist/retryStatus.d.ts

@@ -71,4 +71,12 @@ export interface BrainStatusPayload {
 }
 export declare const BRAIN_STATUS_PAYLOAD_KEYS: readonly ["phase", "detail", "retryInSec", "retryInMs", "attempt", "maxRetries", "errClass", "retryAtMs", "errorStatus", "elapsedMs", "timeoutMs", "providerCondition", "providerConditionSource"];
 export declare function mapBrainStatusToRetry(p: BrainStatusPayload, nowMs: number): RetryStatus | null;
+export interface RetryStatusNotice {
+    readonly line: string;
+    readonly recourse?: 'switch_model' | 'wait' | 'fix_request';
+    readonly phase: 'retrying' | 'reconnecting' | 'waiting_first_token' | 'gave_up' | 'cleared';
+}
+export declare function retryStatusNotice(status: RetryStatus | null, ctx?: {
+    readonly modelName?: string;
+}): RetryStatusNotice;
 export {};

package/dist/retryStatus.js

@@ -1,4 +1,5 @@
 import { displayUntrusted } from './displayUntrusted.js';
+import { guardedRead, readOwnDataFiniteNumber, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
 export const BRAIN_STATUS_PHASES = [
     'rate_limited',
     'retrying',
@@ -25,9 +26,12 @@ export const BRAIN_STATUS_PAYLOAD_KEYS = [
 ];
 const _brainStatusKeyPin = [true, true];
 void _brainStatusKeyPin;
+const RETRY_AT_SKEW_BUDGET_MS = 5_000;
 export function mapBrainStatusToRetry(p, nowMs) {
     const remainingMs = typeof p.retryInMs === 'number' ? p.retryInMs : (p.retryInSec ?? 0) * 1000;
-    const deadline = nowMs + Math.max(0, remainingMs);
+    const localDeadline = nowMs + Math.max(0, remainingMs);
+    const producerAt = typeof p.retryAtMs === 'number' && Number.isFinite(p.retryAtMs) ? p.retryAtMs : undefined;
+    const deadline = producerAt !== undefined && Math.abs(producerAt - localDeadline) <= RETRY_AT_SKEW_BUDGET_MS ? producerAt : localDeadline;
     const counts = {
         ...(typeof p.attempt === 'number' ? { attempt: p.attempt } : {}),
         ...(typeof p.maxRetries === 'number' ? { maxRetries: p.maxRetries } : {}),
@@ -74,3 +78,104 @@ export function mapBrainStatusToRetry(p, nowMs) {
             return { kind: 'error', deadline, ...extra, error: { formatted: '' } };
     }
 }
+const WAIT_SWITCH_FRACTION = 0.5;
+const CONDITION_READINGS = Object.freeze({
+    quota_exhausted: { clause: 'this account cannot be served by the model service until someone acts or its usage window resets', recourse: 'switch_model' },
+    throttled: { clause: 'the model service is rate limiting requests, which clears on its own', recourse: 'switch_model' },
+    overloaded: { clause: 'the model service is overloaded', recourse: 'switch_model' },
+    stop_other: { clause: 'the model service refused this request', resendNote: 'resending will not change it', recourse: 'fix_request' },
+    unknown: null,
+});
+function conditionReadingOf(word) {
+    if (word === undefined || !Object.hasOwn(CONDITION_READINGS, word))
+        return undefined;
+    return CONDITION_READINGS[word] ?? undefined;
+}
+function noticeNumber(carrier, key) {
+    return guardedRead(() => readOwnDataFiniteNumber(carrier, key));
+}
+function noticeText(carrier, key) {
+    return guardedRead(() => readOwnDataNonEmptyString(carrier, key));
+}
+function noticeValue(carrier, key) {
+    return guardedRead(() => readOwnDataValue(carrier, key));
+}
+function washedText(raw) {
+    if (raw === undefined)
+        return undefined;
+    const shown = displayUntrusted(raw);
+    return shown.trim() === '' ? undefined : shown;
+}
+function noticeCount(n) {
+    return n !== undefined && Number.isInteger(n) && n >= 1 ? n : undefined;
+}
+function noticeHttp(n) {
+    return n !== undefined && Number.isInteger(n) && n >= 100 && n <= 999 ? n : undefined;
+}
+function spanText(ms) {
+    const total = Math.floor(ms / 1000);
+    const h = Math.floor(total / 3600);
+    const mi = Math.floor((total % 3600) / 60);
+    const se = total % 60;
+    return h > 0 ? `${h}h ${mi}m ${se}s` : mi > 0 ? `${mi}m ${se}s` : `${se}s`;
+}
+function noticeAttemptTail(attempt, maxRetries) {
+    if (attempt !== undefined && maxRetries !== undefined)
+        return `, attempt ${attempt} of ${maxRetries}`;
+    if (attempt !== undefined)
+        return `, attempt ${attempt}`;
+    if (maxRetries !== undefined)
+        return `, up to ${maxRetries} ${maxRetries === 1 ? 'retry' : 'retries'}`;
+    return '';
+}
+function sealNotice(line, phase, recourse) {
+    return Object.freeze(recourse === undefined ? { line, phase } : { line, recourse, phase });
+}
+export function retryStatusNotice(status, ctx) {
+    const modelName = washedText(noticeText(ctx, 'modelName'))?.trim();
+    const prefix = modelName === undefined || modelName === '' ? '' : `${modelName}: `;
+    if (status === null)
+        return sealNotice('', 'cleared', undefined);
+    const armWord = noticeText(status, 'kind');
+    const kind = armWord === 'stalled' || armWord === 'waiting' ? armWord : 'error';
+    if (kind === 'waiting') {
+        const elapsedRaw = noticeNumber(status, 'elapsedMs');
+        const timeoutRaw = noticeNumber(status, 'timeoutMs');
+        const elapsed = elapsedRaw !== undefined && elapsedRaw >= 0 && elapsedRaw <= Number.MAX_SAFE_INTEGER ? elapsedRaw : undefined;
+        const ceiling = timeoutRaw !== undefined && timeoutRaw > 0 && timeoutRaw <= Number.MAX_SAFE_INTEGER ? timeoutRaw : undefined;
+        const progress = [...(elapsed === undefined ? [] : [`${spanText(elapsed)} so far`]), ...(ceiling === undefined ? [] : [`limit ${spanText(ceiling)}`])];
+        const offerSwitch = prefix !== '' && elapsed !== undefined && ceiling !== undefined && elapsed >= ceiling * WAIT_SWITCH_FRACTION;
+        const text = `${prefix}Waiting for the model's first token${progress.length === 0 ? '' : ` — ${progress.join(', ')}`}${offerSwitch ? '; keep waiting or switch model' : ''}`;
+        return sealNotice(text, 'waiting_first_token', offerSwitch ? 'switch_model' : 'wait');
+    }
+    const terminal = kind === 'error' && noticeValue(status, 'terminal') === true;
+    const reading = conditionReadingOf(noticeText(status, 'providerCondition'));
+    const http = noticeHttp(noticeNumber(status, 'errorStatus'));
+    const attempt = noticeCount(noticeNumber(status, 'attempt'));
+    const maxRetries = noticeCount(noticeNumber(status, 'maxRetries'));
+    const engineWords = kind === 'stalled' ? noticeText(status, 'detail') : noticeText(noticeValue(status, 'error'), 'formatted');
+    const httpPart = http === undefined ? '' : ` (HTTP ${http})`;
+    let first;
+    if (terminal) {
+        const after = attempt === undefined ? '' : ` after ${attempt} attempt${attempt === 1 ? '' : 's'}`;
+        const why = reading === undefined ? '' : `: ${reading.clause}${reading.resendNote === undefined ? '' : `, and ${reading.resendNote}`}`;
+        first = `Stopped${after}${why}${httpPart}`;
+    }
+    else {
+        const head = reading !== undefined ? `${reading.clause.charAt(0).toUpperCase()}${reading.clause.slice(1)}` : http !== undefined || kind === 'error' ? 'Request failed' : 'Waiting for the API response';
+        first = `${head}${httpPart} — ${kind === 'stalled' ? 'will retry' : 'retrying'}${noticeAttemptTail(attempt, maxRetries)}`;
+    }
+    const note = washedText(engineWords);
+    const serviceSide = http !== undefined && (http === 429 || (http >= 500 && http <= 599));
+    const knownArm = armWord === 'stalled' || armWord === 'error';
+    const recourse = !knownArm
+        ? undefined
+        : reading !== undefined
+            ? reading.recourse
+            : serviceSide
+                ? 'switch_model'
+                : !terminal
+                    ? 'wait'
+                    : undefined;
+    return sealNotice(`${prefix}${first}${note === undefined ? '' : ` · ${note}`}`, kind === 'stalled' ? 'reconnecting' : terminal ? 'gave_up' : 'retrying', recourse);
+}

package/dist/rewindArchiveCapability.d.ts

@@ -3,13 +3,9 @@ import type { RewindMode } from './rewindWireCaps.js';
 export { projectRewindArchiveCapability, rewindConversationAvailability } from './rewindArchiveReading.js';
 export type { RewindArchiveBit, RewindArchiveReading, RewindCodeArchive } from './rewindArchiveReading.js';
 export type RewindArchiveMode = 'both' | 'code';
-export declare function noteEngineCapsForRewindArchive(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 export declare function observedRewindArchive(baseUrl?: string | undefined): RewindArchiveReading;
 export declare function rewindCodeArchiveAvailability(reading: RewindArchiveReading, mode: RewindArchiveMode): RewindCodeArchive;
 export declare function rewindArchiveDoctorDetail(reading: RewindArchiveReading, mode: RewindArchiveMode): string;
 export declare function engineRewindRefusedNow(option: RewindMode, reading?: RewindArchiveReading): boolean;
 export declare function rewindConversationDoctorDetail(reading: RewindArchiveReading): string;
 export declare function rewindRestoreFilesEpochDetail(reading: RewindArchiveReading): string;
-export declare function __resetRewindArchiveReadingsForTests(): void;

package/dist/rewindArchiveCapability.js

@@ -1,12 +1,7 @@
 import { engineWireTarget } from './engineWireTarget.js';
-import { resetRewindArchiveReader, rewindArchiveReadingAt, rewindConversationAvailability, } from './rewindArchiveReading.js';
+import { rewindArchiveReadingAt, rewindConversationAvailability, } from './rewindArchiveReading.js';
 import { unreadableReadingDetail } from './engineCapReader.js';
 export { projectRewindArchiveCapability, rewindConversationAvailability } from './rewindArchiveReading.js';
-export function noteEngineCapsForRewindArchive(baseUrl, caps, opts) {
-    void baseUrl;
-    void caps;
-    void opts;
-}
 export function observedRewindArchive(baseUrl = engineWireTarget()?.baseUrl) {
     return rewindArchiveReadingAt(baseUrl);
 }
@@ -87,11 +82,8 @@ export function rewindRestoreFilesEpochDetail(reading) {
         case 'off':
             return 'this engine does not announce the restore-files request key, so a rewind with code restore built from this reading leaves the key out and moves the conversation only';
         case 'not_reported':
-            return 'this engine does not report the restore-files epoch bit (older engine), so a rewind with code restore built from this reading leaves the key out and moves the conversation only';
+            return 'this engine does not report the restore-files epoch bit, so a rewind with code restore built from this reading leaves the key out and moves the conversation only';
         case 'malformed':
             return 'the restore-files epoch bit is reported in an unreadable shape, so a rewind with code restore built from this reading leaves the key out and moves the conversation only';
     }
 }
-export function __resetRewindArchiveReadingsForTests() {
-    resetRewindArchiveReader();
-}

package/dist/rewindArchiveReading.d.ts

@@ -13,5 +13,4 @@ export type RewindArchiveReading = {
 export type RewindCodeArchive = 'available' | 'unavailable' | 'unknown';
 export declare function projectRewindArchiveCapability(caps: unknown): RewindArchiveReading | undefined;
 export declare function rewindArchiveReadingAt(baseUrl: string | undefined): RewindArchiveReading;
-export declare function resetRewindArchiveReader(): void;
 export declare function rewindConversationAvailability(reading: RewindArchiveReading): RewindCodeArchive;

package/dist/rewindArchiveReading.js

@@ -41,9 +41,6 @@ const reader = createEngineCapReader({
 export function rewindArchiveReadingAt(baseUrl) {
     return reader.observed(baseUrl);
 }
-export function resetRewindArchiveReader() {
-    reader.__resetForTests();
-}
 export function rewindConversationAvailability(reading) {
     if (reading.kind !== 'present')
         return 'unknown';

package/dist/runCancelContext.d.ts

@@ -12,6 +12,7 @@ export type RunCancelContextReading = {
 };
 export declare function readRunCancelContext(record: unknown): RunCancelContextReading | undefined;
 import { type RunTerminalRead } from './runTerminal.js';
+import type { AbortCause } from '@sema-agent/sdk';
 export type RunAbortCause = {
     kind: 'cancelled';
     context?: RunCancelContextView;
@@ -30,7 +31,7 @@ export type RunAbortCause = {
 export declare const RUN_CANCELLED_CODE: "cancelled";
 export declare function classifyRunAbortCause(record: unknown): RunAbortCause;
 export declare const ABORT_CAUSES: readonly ["client_disconnected", "ask_park_grace_exhausted", "cancel_verb"];
-export type AbortCause = (typeof ABORT_CAUSES)[number];
+export type { AbortCause };
 export type AbortCauseReading = {
     readonly kind: 'known';
     readonly cause: AbortCause;

package/dist/runCancelContext.js

@@ -34,9 +34,9 @@ export function readRunCancelContext(record) {
     };
 }
 import { readRunTerminal } from './runTerminal.js';
+import { isSdkRunLive } from './terminalStatuses.js';
 import { SDK_ABORT_CAUSES } from './generated/sdkFactTables.js';
 export const RUN_CANCELLED_CODE = 'cancelled';
-const LIVE_STATUSES = new Set(['running', 'queued', 'suspended', 'needs_review']);
 export function classifyRunAbortCause(record) {
     if (record === null || typeof record !== 'object')
         return { kind: 'unknown' };
@@ -53,11 +53,13 @@ export function classifyRunAbortCause(record) {
     }
     if (read !== null && read.kind === 'paused')
         return { kind: 'run_still_live', ...(status !== undefined ? { status } : {}) };
-    if ((read === null || read.kind === 'unknown') && status !== undefined && LIVE_STATUSES.has(status))
+    if ((read === null || read.kind === 'unknown') && status !== undefined && isSdkRunLive(status))
         return { kind: 'run_still_live', status };
     return { kind: 'unknown', ...(read !== null ? { terminal: read.kind } : {}) };
 }
 export const ABORT_CAUSES = SDK_ABORT_CAUSES;
+const _abortCauseTablePin = true;
+void _abortCauseTablePin;
 function ownDataOf(o, key) {
     const d = Object.getOwnPropertyDescriptor(o, key);
     return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;

package/dist/runReattachPolicy.d.ts

@@ -0,0 +1,31 @@
+export declare const REATTACH_MAX_TRIES = 5;
+export interface ReattachBudget {
+    readonly tries: number;
+    readonly drainingStreak: number;
+    readonly drainingTotal: number;
+}
+export declare const REATTACH_BUDGET_FRESH: ReattachBudget;
+export type ReattachEvent = {
+    readonly cause: 'connection_lost';
+    readonly hasRunId: boolean;
+    readonly error?: object;
+} | {
+    readonly cause: 'stream_cap';
+    readonly hasRunId: boolean;
+} | {
+    readonly cause: 'stream_draining';
+    readonly hasRunId: boolean;
+    readonly frame: object;
+    readonly madeProgress?: boolean;
+};
+export type ReattachGiveUp = 'no_run_id' | 'budget_exhausted' | 'bad_input';
+export type ReattachDecision = {
+    readonly action: 'reattach';
+    readonly afterMs: number;
+    readonly budget: ReattachBudget;
+} | {
+    readonly action: 'give_up';
+    readonly reason: ReattachGiveUp;
+    readonly budget: ReattachBudget;
+};
+export declare function runReattachPolicy(budget: ReattachBudget, event: ReattachEvent): ReattachDecision;

package/dist/runReattachPolicy.js

@@ -0,0 +1,46 @@
+import { STREAM_DRAINING_RECONNECT_MAX, drainingRetryDelayMs, isPreStreamDrainingReject } from './wireErrorTriage.js';
+import { drainingLegStep } from './streamDrainingLegs.js';
+export const REATTACH_MAX_TRIES = 5;
+const DRAINING_TOTAL_MAX = REATTACH_MAX_TRIES * STREAM_DRAINING_RECONNECT_MAX;
+export const REATTACH_BUDGET_FRESH = Object.freeze({ tries: 0, drainingStreak: 0, drainingTotal: 0 });
+const isCount = (v) => typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
+const giveUp = (reason, budget) => Object.freeze({ action: 'give_up', reason, budget });
+const reattach = (afterMs, tries, drainingStreak, drainingTotal) => Object.freeze({ action: 'reattach', afterMs, budget: Object.freeze({ tries, drainingStreak, drainingTotal }) });
+export function runReattachPolicy(budget, event) {
+    try {
+        if (typeof budget !== 'object' || budget === null || !isCount(budget.tries) || !isCount(budget.drainingStreak) || !isCount(budget.drainingTotal))
+            return giveUp('bad_input', REATTACH_BUDGET_FRESH);
+        if (typeof event !== 'object' || event === null || typeof event.hasRunId !== 'boolean')
+            return giveUp('bad_input', budget);
+        if (!event.hasRunId)
+            return giveUp('no_run_id', budget);
+        const { tries, drainingStreak, drainingTotal } = budget;
+        if (event.cause === 'connection_lost') {
+            if (tries >= REATTACH_MAX_TRIES)
+                return giveUp('budget_exhausted', budget);
+            const next = tries + 1;
+            const afterMs = isPreStreamDrainingReject(event.error) ? drainingRetryDelayMs(event.error, next - 1) : 1000 * next;
+            return reattach(afterMs, next, 0, drainingTotal);
+        }
+        if (event.cause === 'stream_cap') {
+            if (tries >= REATTACH_MAX_TRIES)
+                return giveUp('budget_exhausted', budget);
+            return reattach(0, tries + 1, 0, drainingTotal);
+        }
+        if (event.cause === 'stream_draining') {
+            const streak = event.madeProgress === true ? 0 : drainingStreak;
+            const { decision, streak: nextStreak } = drainingLegStep(streak, event.frame);
+            if ('reconnectAfterMs' in decision && drainingTotal < DRAINING_TOTAL_MAX)
+                return reattach(decision.reconnectAfterMs, tries, nextStreak, drainingTotal + 1);
+            if ('giveUp' in decision && decision.giveUp === 'not_draining_end')
+                return giveUp('bad_input', budget);
+            if (tries >= REATTACH_MAX_TRIES)
+                return giveUp('budget_exhausted', budget);
+            return reattach(0, tries + 1, nextStreak, drainingTotal);
+        }
+        return giveUp('bad_input', budget);
+    }
+    catch {
+        return giveUp('bad_input', REATTACH_BUDGET_FRESH);
+    }
+}

package/dist/runTerminal.d.ts

@@ -1,4 +1,4 @@
-import type { CheckpointGate, TerminalModelOutputInvalidDetail } from '@sema-agent/sdk';
+import type { CheckpointGate, PromptBlockCause, TerminalModelOutputInvalidDetail } from '@sema-agent/sdk';
 export type RunTerminalPlane = 'cause' | 'flat';
 export interface RunTerminalPause {
     gate?: CheckpointGate;
@@ -55,7 +55,7 @@ export type RunTerminalCompletedDetail = {
     word: string;
 };
 export declare const PROMPT_BLOCK_CAUSES: readonly ["block", "crashed", "timeout", "cancelled"];
-export type PromptBlockCause = (typeof PROMPT_BLOCK_CAUSES)[number];
+export type { PromptBlockCause };
 export type RunTerminalBlockedDetail = {
     kind: 'prompt_blocked_by_hook';
     cause: PromptBlockCause;
@@ -69,9 +69,7 @@ export type RunTerminalBlockedDetail = {
     kind: 'unrecognized';
     word: string;
 };
-export type RunTerminalRead = RunTerminalReadArm & {
-    readonly replay?: true;
-};
+export type RunTerminalRead = RunTerminalReadArm;
 type RunTerminalReadArm = {
     kind: 'completed';
     plane: RunTerminalPlane;
@@ -102,4 +100,3 @@ export declare function runTerminalGateKind(read: RunTerminalRead | null): strin
 export declare function runTerminalGateToolName(read: RunTerminalRead | null): string | undefined;
 export declare function runTerminalCode(read: RunTerminalRead | null): string | undefined;
 export declare function isReviewPark(read: RunTerminalRead | null): boolean;
-export {};