@sema-agent/client-core 0.93.1 → 0.95.0

package/dist/resumeRefusalCopy.js

@@ -1,7 +1,8 @@
 import { readErrorNumber, readErrorString } from './wireFailureShape.js';
 import { readOwnDataNonEmptyString } from './ownKey.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, refusalSaysStillPending, } from './engineErrorCodes.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, refusalSaysStillPending, refusalRetriableReading, } from './engineErrorCodes.js';
 import { capForDisplay } from './fleetTaskDesc.js';
+import { engineVersionTier } from './supportFloor.js';
 import { resumeRetryLaterFromError } from './wireErrorTriage.js';
 export const RESUME_REFUSAL_CODES = Object.freeze([
     RESUME_PLACEMENT_MISMATCH,
@@ -87,10 +88,9 @@ export function resumePolicyBlockContent(detail) {
     ].join(' · ');
 }
 export { resumeReopenFromError, resumeReopenContent } from './hitl/suspendedReopen.js';
-const RESUME_SESSION_NOT_FOUND_TAIL = `(${RESUME_SESSION_NOT_FOUND})`;
 const REQUIRE_EXISTING_BY_STATUS = new Map([
-    [404, Object.freeze({ form: 'session_not_found', code: RESUME_SESSION_NOT_FOUND, coarse: 'not_found.resource' })],
-    [422, Object.freeze({ form: 'session_id_missing', code: REQUEST_FIELD_CONFLICT, coarse: 'request.unprocessable' })],
+    [404, Object.freeze({ form: 'session_not_found', code: RESUME_SESSION_NOT_FOUND })],
+    [422, Object.freeze({ form: 'session_id_missing', code: REQUEST_FIELD_CONFLICT })],
 ]);
 export function requireExistingSessionRefusalFromError(err) {
     if (typeof err !== 'object' || err === null)
@@ -101,15 +101,7 @@ export function requireExistingSessionRefusalFromError(err) {
         const byStatus = typeof status === 'number' ? REQUIRE_EXISTING_BY_STATUS.get(status) : undefined;
         if (byStatus === undefined)
             return null;
-        const code = o['errorCode'];
-        if (code === byStatus.code)
-            return Object.freeze({ code: RESUME_SESSION_NOT_FOUND, form: byStatus.form });
-        if (code !== byStatus.coarse)
-            return null;
-        const message = o['message'];
-        return typeof message === 'string' && message.endsWith(RESUME_SESSION_NOT_FOUND_TAIL)
-            ? Object.freeze({ code: RESUME_SESSION_NOT_FOUND, form: byStatus.form })
-            : null;
+        return o['errorCode'] === byStatus.code ? Object.freeze({ code: RESUME_SESSION_NOT_FOUND, form: byStatus.form }) : null;
     }
     catch {
         return null;
@@ -149,13 +141,13 @@ export function resumeContextUnavailableFromError(err) {
 }
 export function resumeContextUnavailableContent(d) {
     const sec = d.staleAfterSec;
-    const retention = typeof sec === 'number' && Number.isSafeInteger(sec) && sec >= 1 ? `(本部署的会话保留时长为 ${sec} 秒)` : '';
+    const retention = typeof sec === 'number' && Number.isSafeInteger(sec) && sec >= 1 ? ` (this deployment keeps conversations for ${sec} seconds)` : '';
     const third = (d.runId !== undefined
-        ? '错误里带了这条运行的 id,请用它自己恢复这条运行再决;调大会话保留时长只能避免以后再发生,救不回这一次'
-        : '错误里没有带运行 id,请回到运行列表找到这条运行自己恢复它再决;调大会话保留时长只能避免以后再发生,救不回这一次') + retention;
+        ? "The error carries this run's id: use it to recover the run yourself, then decide again; raising the conversation retention time only prevents this from happening again and cannot rescue this one"
+        : 'The error carries no run id: go back to the run list, find this run and recover it yourself, then decide again; raising the conversation retention time only prevents this from happening again and cannot rescue this one') + retention;
     return [
-        '这个批准无处投递:发起这次运行的会话当前没有可用的上下文来继续它',
-        '什么都没有被决定,你的决定没有被消费,这张卡仍在等待',
+        'This approval has nowhere to be delivered: the conversation that started this run has no usable context to continue it right now',
+        'Nothing was decided and your decision was not consumed; this card is still waiting',
         third,
     ].join(' · ');
 }
@@ -167,17 +159,7 @@ function parkedResumeStartupCauseWord(err) {
     catch {
         named = undefined;
     }
-    if (named !== undefined)
-        return named;
-    try {
-        const extra = err.extra;
-        if (typeof extra !== 'object' || extra === null || Array.isArray(extra))
-            return undefined;
-        return readOwnDataNonEmptyString(extra, 'cause');
-    }
-    catch {
-        return undefined;
-    }
+    return named;
 }
 export function parkedResumeStartupFromError(err, decision) {
     if (typeof err !== 'object' || err === null)
@@ -231,7 +213,15 @@ export function checkpointUnsupportedVersionFromError(err) {
     }
     if (code !== CHECKPOINT_UNSUPPORTED_VERSION || !refusalSaysStillPending(err))
         return null;
-    return { code: CHECKPOINT_UNSUPPORTED_VERSION, retriable: true };
+    const writerVersion = readErrorString(err, 'writerVersion');
+    const readerVersion = readErrorString(err, 'readerVersion');
+    const versions = writerVersion !== undefined && writerVersion !== '' && readerVersion !== undefined && readerVersion !== '' ? { writerVersion, readerVersion } : {};
+    return { code: CHECKPOINT_UNSUPPORTED_VERSION, retriable: true, ...versions };
+}
+function writerEngineIsNewer(writer, reader) {
+    if (engineVersionTier(writer) === 'unknown' || engineVersionTier(reader) !== 'engine')
+        return false;
+    return engineVersionTier(reader, writer) === 'legacy';
 }
 function checkpointUnsupportedHasRun(kind) {
     switch (kind) {
@@ -250,7 +240,23 @@ const CHECKPOINT_UNSUPPORTED_WHAT = 'This server cannot continue this parked wor
 const CHECKPOINT_UNSUPPORTED_STILL_WAITING = 'Nothing was decided or resumed and the parked work is still waiting, but sending the same request again will not by itself continue it';
 const CHECKPOINT_UNSUPPORTED_DRAIN = " — whoever operates this deployment can find such parked work before an upgrade with the server's pre-upgrade drain check";
 export function checkpointUnsupportedVersionContent(detail, ctx) {
-    void detail;
+    let writer;
+    let reader;
+    try {
+        writer = detail.writerVersion;
+        reader = detail.readerVersion;
+    }
+    catch {
+        writer = undefined;
+        reader = undefined;
+    }
+    if (writerEngineIsNewer(writer, reader)) {
+        return [
+            `This parked work was stored by a newer engine version (${String(writer)}) than this engine (${String(reader)})`,
+            CHECKPOINT_UNSUPPORTED_STILL_WAITING,
+            `Continue it on an engine at version ${String(writer)} or newer`,
+        ].join(' · ');
+    }
     let kind;
     let runId;
     try {
@@ -276,3 +282,98 @@ export function checkpointUnsupportedVersionContent(detail, ctx) {
     }
     return [CHECKPOINT_UNSUPPORTED_WHAT, CHECKPOINT_UNSUPPORTED_STILL_WAITING, outlet + CHECKPOINT_UNSUPPORTED_DRAIN].join(' · ');
 }
+const REFUSED_PARK_CODES = new Set([CHECKPOINT_UNSUPPORTED_VERSION, CHECKPOINT_WALLTIME_AXIS_RETIRED, CHECKPOINT_CONFIG_REFUSED]);
+const REFUSED_PARK_FIELD_TOKEN = /^[A-Za-z][A-Za-z0-9_]{0,63}$/;
+export function refusedParkFromError(failure) {
+    if (typeof failure !== 'object' || failure === null)
+        return null;
+    let code;
+    let status;
+    try {
+        code = failure.errorCode;
+        status = failure.status;
+    }
+    catch {
+        return null;
+    }
+    if (typeof code !== 'string' || !REFUSED_PARK_CODES.has(code))
+        return null;
+    if (status !== undefined && status !== 409)
+        return null;
+    const reading = refusalRetriableReading(failure);
+    const stillPending = reading === true ? true : status === 409 && reading === false ? false : undefined;
+    const rawField = code === CHECKPOINT_CONFIG_REFUSED ? readErrorString(failure, 'field') : undefined;
+    const field = rawField !== undefined && REFUSED_PARK_FIELD_TOKEN.test(rawField) ? rawField : undefined;
+    return Object.freeze({
+        code: code,
+        ...(field !== undefined ? { field } : {}),
+        ...(stillPending !== undefined ? { stillPending } : {}),
+    });
+}
+function refusedParkShownRunId(runId) {
+    return typeof runId === 'string' && /^[A-Za-z0-9._:-]{1,128}$/.test(runId) ? runId : undefined;
+}
+function refusedParkWhy(code, field) {
+    switch (code) {
+        case CHECKPOINT_WALLTIME_AXIS_RETIRED:
+            return 'its run carries a wall-clock time allowance, which this engine version no longer enforces';
+        case CHECKPOINT_CONFIG_REFUSED:
+            return field === 'inheritedGate'
+                ? 'the permission-mode setting it was parked with can no longer be read'
+                : 'the engine refuses the task configuration it was parked with';
+        default:
+            return 'it was parked under conditions this engine version does not support (for example, by an earlier engine version)';
+    }
+}
+export function refusedParkContent(input) {
+    let what;
+    let lane;
+    let runId;
+    let rawCode;
+    let field;
+    let stillPending;
+    try {
+        what = input.what;
+        lane = input.lane;
+        runId = input.runId;
+    }
+    catch {
+        what = lane = runId = undefined;
+    }
+    try {
+        const facts = input.facts;
+        rawCode = facts.code;
+        field = facts.field;
+        stillPending = facts.stillPending;
+    }
+    catch {
+        rawCode = field = stillPending = undefined;
+    }
+    const code = rawCode === CHECKPOINT_WALLTIME_AXIS_RETIRED || rawCode === CHECKPOINT_CONFIG_REFUSED ? rawCode : CHECKPOINT_UNSUPPORTED_VERSION;
+    const shownWhat = typeof what === 'string' && what !== '' ? capForDisplay(what, 40) : 'parked step';
+    const why = refusedParkWhy(code, typeof field === 'string' ? field : undefined);
+    const shownRun = refusedParkShownRunId(runId);
+    const head = `This ${shownWhat} cannot be resumed by this engine version: ${why}. The same refusal comes back every time, so ` +
+        `answering it again will not help (nothing was decided and nothing was resumed).`;
+    const configMayReturn = code === CHECKPOINT_CONFIG_REFUSED && field !== 'inheritedGate' ? ' If that configuration is restored, the same answer can go through again.' : '';
+    if (lane === 'print') {
+        if (stillPending === false) {
+            return `${head} The engine ended that run (${code}); submit the work again as a new task.`;
+        }
+        const cancel = `POST /v1/runs/${shownRun ?? '<run id>'}/cancel`;
+        return `${head}${configMayReturn} The parked run still holds this session (${code}): cancel it (${cancel}), then submit the work again as a new task.`;
+    }
+    if (stillPending === false) {
+        return `${head} The engine ended that parked run, so this conversation is free: send the work again as a new message.`;
+    }
+    return `${head}${configMayReturn} The parked run keeps this conversation busy until it is cancelled.`;
+}
+export function refusedParkBlockedContent(taskId, lane = 'interactive') {
+    const runId = refusedParkShownRunId(taskId);
+    const head = `sema will not put the card for run ${runId ?? '<unknown>'} back on screen by itself: this engine version refuses to resume it.`;
+    if (lane === 'print') {
+        return `${head} Cancel the run (POST /v1/runs/${runId ?? '<run id>'}/cancel) and submit the work again as a new task.`;
+    }
+    return (`${head} To free this conversation, send a message to bring the card back and answer it — sema then offers to cancel ` +
+        `that run, after which you can send the work again as a new message.`);
+}

package/dist/retryStatus.js

@@ -1,3 +1,4 @@
+import { displayUntrusted } from './displayUntrusted.js';
 export const BRAIN_STATUS_PHASES = [
     'rate_limited',
     'retrying',
@@ -40,6 +41,7 @@ export function mapBrainStatusToRetry(p, nowMs) {
         ...(timeoutMs !== undefined ? { timeoutMs } : {}),
     };
     const stalledDetail = typeof p.detail === 'string' && p.detail.length > 0 ? { detail: p.detail } : {};
+    const shown = (absent) => (typeof p.detail === 'string' ? displayUntrusted(p.detail) : absent);
     const extra = { ...counts, ...cause, ...producerTiming, ...failureStatus, ...waitProgress };
     switch (p.phase) {
         case 'recovered':
@@ -47,20 +49,20 @@ export function mapBrainStatusToRetry(p, nowMs) {
         case 'reconnecting':
             return { kind: 'stalled', deadline, ...extra, ...stalledDetail };
         case 'rate_limited':
-            return { kind: 'error', deadline, ...extra, error: { formatted: p.detail ?? '', rateLimits: null } };
+            return { kind: 'error', deadline, ...extra, error: { formatted: shown(''), rateLimits: null } };
         case 'circuit_open':
             return {
                 kind: 'error',
                 deadline,
                 ...extra,
-                error: { formatted: p.detail ?? 'Service temporarily unavailable', isNetworkDown: true },
+                error: { formatted: shown('Service temporarily unavailable'), isNetworkDown: true },
             };
         case 'gave_up':
-            return { kind: 'error', deadline, terminal: true, ...extra, error: { formatted: p.detail ?? '' } };
+            return { kind: 'error', deadline, terminal: true, ...extra, error: { formatted: shown('') } };
         case 'waiting_first_token':
             return { kind: 'waiting', deadline, ...extra, error: { formatted: '' } };
         case 'retrying':
-            return { kind: 'error', deadline, ...extra, error: { formatted: p.detail ?? '' } };
+            return { kind: 'error', deadline, ...extra, error: { formatted: shown('') } };
         default:
             return { kind: 'error', deadline, ...extra, error: { formatted: '' } };
     }

package/dist/rewindArchiveCapability.d.ts

@@ -1,3 +1,4 @@
+import type { RewindMode } from './rewindWireCaps.js';
 export type RewindArchiveBit = 'on' | 'off' | 'not_reported' | 'malformed';
 export type RewindArchiveReading = {
     kind: 'unobserved';
@@ -18,7 +19,7 @@ export declare function observedRewindArchive(baseUrl?: string | undefined): Rew
 export declare function rewindCodeArchiveAvailability(reading: RewindArchiveReading, mode: RewindArchiveMode): RewindCodeArchive;
 export declare function rewindArchiveDoctorDetail(reading: RewindArchiveReading, mode: RewindArchiveMode): string;
 export declare function rewindConversationAvailability(reading: RewindArchiveReading): RewindCodeArchive;
+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 forgetRewindArchiveReading(baseUrl: string | undefined): void;
 export declare function __resetRewindArchiveReadingsForTests(): void;

package/dist/rewindArchiveCapability.js

@@ -1,5 +1,6 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 import { _wireConversationRewindJudge } from './toolHistoryMismatch.js';
 const CAPS_KEYS = {
     conversationAnchor: 'resumeAt',
@@ -10,9 +11,7 @@ const CAPS_KEYS = {
 const _capsKeyPin = true;
 void _capsKeyPin;
 function bitOf(caps, key) {
-    if (!Object.hasOwn(caps, key))
-        return 'not_reported';
-    const v = caps[key];
+    const v = ownDataField(caps, key);
     if (v === undefined)
         return 'not_reported';
     if (v === true)
@@ -22,15 +21,20 @@ function bitOf(caps, key) {
     return 'malformed';
 }
 export function projectRewindArchiveCapability(caps) {
-    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+    try {
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        return {
+            kind: 'present',
+            conversationAnchor: bitOf(caps, CAPS_KEYS.conversationAnchor),
+            forkRestore: bitOf(caps, CAPS_KEYS.forkRestore),
+            codeOnly: bitOf(caps, CAPS_KEYS.codeOnly),
+            restoreFilesEpoch: bitOf(caps, CAPS_KEYS.restoreFilesEpoch),
+        };
+    }
+    catch {
         return undefined;
-    return {
-        kind: 'present',
-        conversationAnchor: bitOf(caps, CAPS_KEYS.conversationAnchor),
-        forkRestore: bitOf(caps, CAPS_KEYS.forkRestore),
-        codeOnly: bitOf(caps, CAPS_KEYS.codeOnly),
-        restoreFilesEpoch: bitOf(caps, CAPS_KEYS.restoreFilesEpoch),
-    };
+    }
 }
 const reader = createEngineCapReader({
     name: 'rewindArchive',
@@ -38,12 +42,12 @@ const reader = createEngineCapReader({
     makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function noteEngineCapsForRewindArchive(baseUrl, caps, opts) {
-    _wireConversationRewindJudge(conversationRewindJudge);
     reader.note(baseUrl, caps, opts);
 }
 function conversationRewindJudge(engineBaseUrl) {
     return rewindConversationAvailability(observedRewindArchive(engineBaseUrl));
 }
+_wireConversationRewindJudge(conversationRewindJudge);
 export function observedRewindArchive(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -91,6 +95,18 @@ export function rewindConversationAvailability(reading) {
         return 'unavailable';
     return 'unknown';
 }
+export function engineRewindRefusedNow(option, reading = observedRewindArchive()) {
+    switch (option) {
+        case 'both':
+            return rewindCodeArchiveAvailability(reading, 'both') === 'unavailable';
+        case 'code':
+            return rewindCodeArchiveAvailability(reading, 'code') === 'unavailable';
+        case 'conversation':
+            return rewindConversationAvailability(reading) === 'unavailable';
+        default:
+            return false;
+    }
+}
 export function rewindConversationDoctorDetail(reading) {
     const lane = 'rewind to a message';
     if (reading.kind !== 'present') {
@@ -122,9 +138,6 @@ export function rewindRestoreFilesEpochDetail(reading) {
             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 forgetRewindArchiveReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetRewindArchiveReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/rewindEngineAction.d.ts

@@ -0,0 +1,21 @@
+import { type RewindArchiveReading } from './rewindArchiveCapability.js';
+import { type RewindMode, type SeamRewindSpec } from './rewindWireCaps.js';
+export type RewindRestoreOption = RewindMode | 'summarize' | 'summarize_up_to' | 'nevermind';
+export type RewindTargetPosition = 'root' | 'after-root' | 'unknown';
+export interface RewindTargetResolution {
+    readonly position: RewindTargetPosition;
+    readonly targetEntryId?: string;
+    readonly anchorUnresolved?: true;
+}
+export type RewindEngineNoneReason = 'not-an-engine-rewind' | 'no-engine-turn-to-rewind' | 'unresolved';
+export type RewindEngineAction = {
+    readonly kind: 'none';
+    readonly reason: RewindEngineNoneReason;
+} | {
+    readonly kind: 'arm';
+    readonly spec: SeamRewindSpec;
+} | {
+    readonly kind: 'reopen';
+};
+export declare function decideRewindEngineAction(option: RewindRestoreOption, resolved: RewindTargetResolution, reading?: RewindArchiveReading): RewindEngineAction;
+export declare function previewEngineRewind(option: RewindRestoreOption, resolved: RewindTargetResolution, reading?: RewindArchiveReading): RewindEngineAction['kind'];

package/dist/rewindEngineAction.js

@@ -0,0 +1,36 @@
+import { observedRewindArchive } from './rewindArchiveCapability.js';
+import { REWIND_MODES, rewindSpecForMode } from './rewindWireCaps.js';
+import { readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+function modeOfOption(option) {
+    return REWIND_MODES.includes(option) ? option : undefined;
+}
+function carriesResumeAt(mode) {
+    return rewindSpecForMode(mode, 'x').resumeAt !== undefined;
+}
+function positionOf(resolved) {
+    const p = readOwnDataValue(resolved, 'position');
+    return p === 'root' || p === 'after-root' ? p : 'unknown';
+}
+export function decideRewindEngineAction(option, resolved, reading = observedRewindArchive()) {
+    const mode = modeOfOption(option);
+    if (mode === undefined)
+        return { kind: 'none', reason: 'not-an-engine-rewind' };
+    const position = positionOf(resolved);
+    const targetEntryId = readOwnDataNonEmptyString(resolved, 'targetEntryId');
+    if (!carriesResumeAt(mode)) {
+        if (targetEntryId !== undefined)
+            return { kind: 'arm', spec: rewindSpecForMode(mode, targetEntryId, reading) };
+        const unresolved = position === 'unknown' || readOwnDataValue(resolved, 'anchorUnresolved') === true;
+        return { kind: 'none', reason: unresolved ? 'unresolved' : 'no-engine-turn-to-rewind' };
+    }
+    if (position === 'root')
+        return { kind: 'reopen' };
+    if (position === 'unknown')
+        return { kind: 'none', reason: 'unresolved' };
+    return targetEntryId !== undefined
+        ? { kind: 'arm', spec: rewindSpecForMode(mode, targetEntryId, reading) }
+        : { kind: 'none', reason: 'no-engine-turn-to-rewind' };
+}
+export function previewEngineRewind(option, resolved, reading = observedRewindArchive()) {
+    return decideRewindEngineAction(option, resolved, reading).kind;
+}

package/dist/rewindWireCaps.d.ts

@@ -5,6 +5,7 @@ export interface SeamRewindSpec {
     restoreFiles?: boolean;
     rewindFilesTo?: string;
 }
-export type RewindMode = 'both' | 'conversation' | 'code';
+export declare const REWIND_MODES: readonly ["both", "conversation", "code"];
+export type RewindMode = (typeof REWIND_MODES)[number];
 export declare function rewindSpecForMode(mode: RewindMode, targetEntryId: string, reading?: RewindArchiveReading): SeamRewindSpec;
 export declare function projectRewind(pending: SeamRewindSpec | undefined): SeamRewindSpec;

package/dist/rewindWireCaps.js

@@ -1,3 +1,4 @@
+export const REWIND_MODES = Object.freeze(['both', 'conversation', 'code']);
 function restoreFilesKeyMaySend(reading) {
     if (reading === undefined)
         return true;

package/dist/{hitl/rosterMountedNames.d.ts → rosterMountedNames.d.ts}

@@ -1,2 +1,2 @@
-import type { ToolRosterView } from '../toolRoster.js';
+import type { ToolRosterView } from './toolRoster.js';
 export declare function rosterMountedNames(roster: ToolRosterView | null | undefined): ReadonlySet<string> | 'absent' | 'unreadable';

package/dist/runCancelContext.js

@@ -34,6 +34,7 @@ export function readRunCancelContext(record) {
     };
 }
 import { readRunTerminal } from './runTerminal.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) {
@@ -56,7 +57,7 @@ export function classifyRunAbortCause(record) {
         return { kind: 'run_still_live', status };
     return { kind: 'unknown', ...(read !== null ? { terminal: read.kind } : {}) };
 }
-export const ABORT_CAUSES = Object.freeze(['client_disconnected', 'ask_park_grace_exhausted', 'cancel_verb']);
+export const ABORT_CAUSES = SDK_ABORT_CAUSES;
 function ownDataOf(o, key) {
     const d = Object.getOwnPropertyDescriptor(o, key);
     return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;

package/dist/runTerminal.d.ts

@@ -60,14 +60,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 declare const TERMINAL_CAUSE_KINDS: readonly ["completed", "failed", "blocked", "paused"];
-export type TerminalCauseKind = (typeof TERMINAL_CAUSE_KINDS)[number];
-export declare function isTerminalCauseKind(kind: unknown): kind is TerminalCauseKind;
-export declare const RUN_TERMINAL_NOT_SUCCESS_STATUSES: readonly ["failed", "killed", "blocked"];
-export type RunTerminalNotSuccessStatus = (typeof RUN_TERMINAL_NOT_SUCCESS_STATUSES)[number];
-export declare function isTerminalNotSuccess(status: unknown): status is RunTerminalNotSuccessStatus;
-export declare const RUN_TERMINAL_STATUSES: readonly ["completed", "failed", "killed", "blocked"];
-export type RunTerminalStatus = (typeof RUN_TERMINAL_STATUSES)[number];
-export declare function isTerminalStatus(status: unknown): status is RunTerminalStatus;
-export declare const TASK_NOTIFICATION_TERMINAL_STATUSES: readonly string[];
-export declare function isTaskNotificationTerminalStatus(status: string | undefined): boolean;

package/dist/runTerminal.js

@@ -1,4 +1,5 @@
-import { CORE_PROMPT_BLOCK_CAUSES, CORE_TERMINAL_CAUSE_KINDS } from './generated/engineFactTables.js';
+import { CORE_PROMPT_BLOCK_CAUSES } from './generated/engineFactTables.js';
+import { isSdkRunParked } from './terminalStatuses.js';
 export const PROMPT_BLOCK_CAUSES = CORE_PROMPT_BLOCK_CAUSES;
 const PROMPT_BLOCKED_BY_HOOK_DETAIL_KIND = 'prompt_blocked_by_hook';
 function str(v) {
@@ -69,7 +70,6 @@ function blockedDetailOf(cause) {
         return undefined;
     }
 }
-const FLAT_PAUSED_STATUSES = ['suspended', 'needs_review'];
 export function readRunTerminal(result) {
     if (typeof result !== 'object' || result === null || Array.isArray(result))
         return null;
@@ -83,7 +83,7 @@ export function readRunTerminal(result) {
         if (kind === undefined)
             return { kind: 'unknown', plane: 'cause' };
         const parkWord = str(r.status);
-        if (parkWord !== undefined && FLAT_PAUSED_STATUSES.includes(parkWord)) {
+        if (isSdkRunParked(parkWord)) {
             return { kind: 'paused', plane: 'cause', flatStatus: parkWord, ...(kind === 'paused' ? (pauseOf(c) ?? {}) : {}) };
         }
         switch (kind) {
@@ -138,7 +138,7 @@ export function readRunTerminal(result) {
             ...(code !== undefined ? { code } : {}),
         };
     }
-    if (FLAT_PAUSED_STATUSES.includes(status)) {
+    if (isSdkRunParked(status)) {
         const gate = gateOf(r.checkpointGate);
         const checkpointId = str(r.checkpointId);
         const restoreMode = str(r.workspaceRestoreMode);
@@ -183,26 +183,3 @@ export function isReviewPark(read) {
         return true;
     return read !== null && read.kind === 'paused' && read.flatStatus === FLAT_REVIEW_STATUS;
 }
-export const TERMINAL_CAUSE_KINDS = CORE_TERMINAL_CAUSE_KINDS;
-export function isTerminalCauseKind(kind) {
-    return typeof kind === 'string' && TERMINAL_CAUSE_KINDS.includes(kind);
-}
-export const RUN_TERMINAL_NOT_SUCCESS_STATUSES = Object.freeze([
-    'failed',
-    'killed',
-    'blocked',
-]);
-export function isTerminalNotSuccess(status) {
-    return typeof status === 'string' && RUN_TERMINAL_NOT_SUCCESS_STATUSES.includes(status);
-}
-export const RUN_TERMINAL_STATUSES = Object.freeze([
-    'completed',
-    ...RUN_TERMINAL_NOT_SUCCESS_STATUSES,
-]);
-export function isTerminalStatus(status) {
-    return typeof status === 'string' && RUN_TERMINAL_STATUSES.includes(status);
-}
-export const TASK_NOTIFICATION_TERMINAL_STATUSES = Object.freeze(['completed', 'failed', 'killed', 'cancelled']);
-export function isTaskNotificationTerminalStatus(status) {
-    return status !== undefined && TASK_NOTIFICATION_TERMINAL_STATUSES.includes(status);
-}

package/dist/sdkRegistryTransit.d.ts

@@ -3,5 +3,6 @@ export { getMeConfig, getScopeConfigDraft, getEffective } from '@sema-agent/sdk/
 export { probeRegistryHealth, postFeedback } from '@sema-agent/sdk/registry';
 export { REGISTRY_AUTH_PATHS, skillContentAddress } from '@sema-agent/sdk/registry';
 export { requestDeviceCode, pollUntilApproved, refreshTokens, listScopes, switchScope } from '@sema-agent/sdk/registry';
+export { classifyRegistryConflict } from '@sema-agent/sdk/registry';
 export { RegistryApiError, OAuthFlowError } from '@sema-agent/sdk/registry';
-export type { RegistryTokens, TokenProvider, } from '@sema-agent/sdk/registry';
+export type { RegistryConflictClass, RegistryTokens, TokenProvider, } from '@sema-agent/sdk/registry';

package/dist/sdkRegistryTransit.js

@@ -3,4 +3,5 @@ export { getMeConfig, getScopeConfigDraft, getEffective } from '@sema-agent/sdk/
 export { probeRegistryHealth, postFeedback } from '@sema-agent/sdk/registry';
 export { REGISTRY_AUTH_PATHS, skillContentAddress } from '@sema-agent/sdk/registry';
 export { requestDeviceCode, pollUntilApproved, refreshTokens, listScopes, switchScope } from '@sema-agent/sdk/registry';
+export { classifyRegistryConflict } from '@sema-agent/sdk/registry';
 export { RegistryApiError, OAuthFlowError } from '@sema-agent/sdk/registry';

package/dist/sealedKeyCapability.d.ts

@@ -13,5 +13,4 @@ export declare function noteEngineCapsForSealedKey(baseUrl: string, caps: unknow
     generation?: number;
 }): void;
 export declare function observedSealedKey(baseUrl?: string | undefined): SealedKeyReading;
-export declare function forgetSealedKeyReading(baseUrl: string | undefined): void;
 export declare function __resetSealedKeyReadingsForTests(): void;

package/dist/sealedKeyCapability.js

@@ -1,27 +1,29 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 function ownNonEmpty(seg, key) {
-    if (!Object.hasOwn(seg, key))
-        return undefined;
-    const v = seg[key];
+    const v = ownDataField(seg, key);
     return typeof v === 'string' && v.length > 0 ? v : undefined;
 }
 export function projectSealedKeyCapability(caps) {
-    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
-        return undefined;
-    if (!Object.hasOwn(caps, 'sealedKey'))
-        return { kind: 'not_reported' };
-    const seg = caps.sealedKey;
-    if (seg === undefined)
-        return { kind: 'not_reported' };
-    if (seg === null || typeof seg !== 'object' || Array.isArray(seg))
+    try {
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        const seg = ownDataField(caps, 'sealedKey');
+        if (seg === undefined)
+            return { kind: 'not_reported' };
+        if (seg === null || typeof seg !== 'object' || Array.isArray(seg))
+            return undefined;
+        const alg = ownNonEmpty(seg, 'alg');
+        const publicKeyId = ownNonEmpty(seg, 'publicKeyId');
+        const publicKey = ownNonEmpty(seg, 'publicKey');
+        if (alg === undefined || publicKeyId === undefined || publicKey === undefined)
+            return undefined;
+        return { kind: 'present', alg, publicKeyId, publicKey };
+    }
+    catch {
         return undefined;
-    const alg = ownNonEmpty(seg, 'alg');
-    const publicKeyId = ownNonEmpty(seg, 'publicKeyId');
-    const publicKey = ownNonEmpty(seg, 'publicKey');
-    if (alg === undefined || publicKeyId === undefined || publicKey === undefined)
-        return undefined;
-    return { kind: 'present', alg, publicKeyId, publicKey };
+    }
 }
 const reader = createEngineCapReader({
     name: 'sealedKey',
@@ -34,9 +36,6 @@ export function noteEngineCapsForSealedKey(baseUrl, caps, opts) {
 export function observedSealedKey(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
-export function forgetSealedKeyReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetSealedKeyReadingsForTests() {
     reader.__resetForTests();
 }