@sema-agent/client-core 0.94.0 → 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;
@@ -221,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) {
@@ -240,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 {
@@ -266,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/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)
@@ -43,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);
 }
@@ -96,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') {
@@ -127,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/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,18 +1,15 @@
 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) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
-        if (!Object.hasOwn(caps, 'sealedKey'))
-            return { kind: 'not_reported' };
-        const seg = caps.sealedKey;
+        const seg = ownDataField(caps, 'sealedKey');
         if (seg === undefined)
             return { kind: 'not_reported' };
         if (seg === null || typeof seg !== 'object' || Array.isArray(seg))
@@ -39,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();
 }

package/dist/seatContract.d.ts

@@ -5,6 +5,8 @@ import type { QuestionAnswer } from "./liveQuestionStore.js";
 import type { ToolApprovalDelegation } from "./hitl/toolApprovalWire.js";
 import type { ApprovalMandateWord } from "./gateVocabulary.js";
 import type { ModelApiWord } from "./model/providerPresets.js";
+import type { LiveModelCatalog } from "./liveModelCatalog.js";
+import { type RewindMode } from "./rewindWireCaps.js";
 export interface SeatValidationFailure {
     reason: string;
     field?: string;
@@ -97,13 +99,15 @@ export interface LocalSessionEvent {
     hasPreClearSession?: boolean;
     requestId?: string;
     outcome?: string;
+    parked?: true;
     chrome?: SeatChromeEnvelope;
 }
 export declare const HITL_RESOLUTION_OUTCOMES: readonly string[];
-export declare const SEAT_CAPABILITY_NAMES: readonly ["pickFolder"];
+export declare const SEAT_CAPABILITY_NAMES: readonly ["pickFolder", "rewind"];
 export type SeatCapabilityName = (typeof SEAT_CAPABILITY_NAMES)[number];
 export interface SeatCapabilitiesState {
     pickFolder?: boolean;
+    rewind?: boolean;
 }
 export type SeatCapabilityReading = {
     readonly kind: "reported";
@@ -130,6 +134,28 @@ export interface SeatTurnSettings {
     ultracode?: boolean;
 }
 export declare const SEAT_TURN_SETTINGS_KEYS: readonly ["ultracode"];
+export declare const SEAT_TURN_SETTINGS_ORIGINS: Readonly<{
+    ultracode: Readonly<{
+        carriedBy: "renderer";
+    }>;
+    webSearch: Readonly<{
+        hostSupplied: "联网检索的每请求配置来自宿主的设置源(可能带检索服务的凭据与私网地址);渲染端没有设置文件,也不该持有凭据";
+    }>;
+    hooks: Readonly<{
+        hostSupplied: "hooks 表来自宿主的设置文件(宿主经设置端口与 hooksForWire 投影);渲染端没有设置文件、也不执行本机 hook";
+    }>;
+    resolved: Readonly<{
+        hostSupplied: "设置解析器的生效快照(hooks / env / model / 已解析权限)由宿主跑解析器得出;渲染端没有设置源可解析";
+    }>;
+    outputStyle: Readonly<{
+        hostSupplied: "输出风格正文由宿主的兜底层随请求带(风格文件在宿主);渲染端只选名字,不持正文";
+    }>;
+}>;
+export interface SeatRewindIntent {
+    mode: RewindMode;
+    targetMessageUuid: string;
+}
+export declare const SEAT_REWIND_INTENT_KEYS: readonly ["mode", "targetMessageUuid"];
 export interface SendMessageRequest {
     sessionId: string;
     text: string;
@@ -145,6 +171,7 @@ export interface SendMessageRequest {
         max?: number;
     };
     settings?: SeatTurnSettings;
+    rewind?: SeatRewindIntent;
     scenario?: string;
 }
 export interface AttachmentUploadRequest {
@@ -163,17 +190,6 @@ export interface AttachmentUploadReceipt {
     sha256: string;
     sizeBytes: number;
 }
-export interface SeatModelInfo {
-    id: string;
-    name?: string;
-    provider?: string;
-    contextWindow?: number;
-    maxOutputTokens?: number;
-}
-export interface SeatModelCatalog {
-    models: SeatModelInfo[];
-    defaultId?: string;
-}
 export interface SendMessageAck {
     sessionId: string;
     userMessageUuid: string;
@@ -242,7 +258,7 @@ export interface LocalSessionsApi {
     getTranscript(sessionId: string): Promise<GetTranscriptResult>;
     searchSessions(query: string): Promise<SessionSearchEnvelope>;
     uploadAttachment(req: AttachmentUploadRequest): Promise<AttachmentUploadReceipt>;
-    listModels(): Promise<SeatModelCatalog>;
+    listModels(): Promise<LiveModelCatalog>;
     applyModelConfig(req: ApplyModelConfigRequest): Promise<ApplyModelConfigResult>;
     pickFolder(): Promise<string | null>;
     onEvent(cb: (ev: LocalSessionEvent) => void): () => void;
@@ -276,16 +292,17 @@ export interface ApplyModelConfigResult {
     reason?: string;
     requiresRestart: boolean;
 }
-export declare function isSeatModelCatalog(v: unknown): v is SeatModelCatalog;
+export declare function checkSendMessageRequest(v: unknown): SeatValidation;
+export declare function isSendMessageRequest(v: unknown): v is SendMessageRequest;
 export declare function isSendMessageAck(v: unknown): v is SendMessageAck;
 export declare const LOCAL_SESSIONS_SPEC: EipcServiceSpec;
 export declare const SEAT_METHOD_NAMES: readonly ["start", "sendMessage", "interrupt", "stop", "respondToToolPermission", "cancelQueuedMessage", "reorderQueuedMessage", "promoteQueuedMessage", "setFocusedSession", "setModel", "getTranscript", "searchSessions", "uploadAttachment", "listModels", "applyModelConfig", "pickFolder", "onEvent", "onToolPermissionRequest"];
 export declare const SEAT_STORE_PROPS: readonly ["sessionsStateStore", "focusedSessionStateStore", "settingsStateStore", "seatCapabilitiesStateStore"];
 export declare const SEAT_EVENT_METHOD_NAMES: readonly ["onEvent", "onToolPermissionRequest"];
-export declare const LOCAL_SESSION_EVENT_KEYS: readonly ["type", "sessionId", "message", "messages", "error", "errorCategory", "code", "request", "data", "sources", "permissionMode", "session", "userMessageUuid", "hasPreClearSession", "requestId", "outcome", "chrome"];
+export declare const LOCAL_SESSION_EVENT_KEYS: readonly ["type", "sessionId", "message", "messages", "error", "errorCategory", "code", "request", "data", "sources", "permissionMode", "session", "userMessageUuid", "hasPreClearSession", "requestId", "outcome", "parked", "chrome"];
 export declare const TOOL_PERMISSION_REQUEST_KEYS: readonly ["requestId", "sessionId", "toolName", "toolCallId", "input", "message", "toctouBinding", "createdAtMs", "governanceForced", "delegation", "mandated", "mandate", "origin", "ruleOffersAbsence", "askClass", "classes"];
 export declare const LOCAL_SESSION_RECORD_KEYS: readonly ["sessionId", "engineSessionId", "model", "title", "cwd", "isRunning", "createdAt", "lastActivityAt", "queuedMessages", "parked"];
-export declare const SEND_MESSAGE_REQUEST_KEYS: readonly ["sessionId", "text", "model", "userMessageUuid", "permissionMode", "attachmentIds", "reasoningEffort", "retainBackgroundProcesses", "forwardSubagentEvents", "retainSubagentSessions", "settings", "scenario"];
+export declare const SEND_MESSAGE_REQUEST_KEYS: readonly ["sessionId", "text", "model", "userMessageUuid", "permissionMode", "attachmentIds", "reasoningEffort", "retainBackgroundProcesses", "forwardSubagentEvents", "retainSubagentSessions", "settings", "scenario", "rewind"];
 export declare const SEAT_SEND_MESSAGE_KEY_ORIGINS: {
     readonly sessionId: {
         readonly seatOnly: "座位会话句柄(渲染端持有的本地 id);引擎会话 id 由座位记录的 `engineSessionId` 承载 —— 与引擎请求体上的同名位**同名不同义**,绝不直传";
@@ -323,19 +340,23 @@ export declare const SEAT_SEND_MESSAGE_KEY_ORIGINS: {
     readonly scenario: {
         readonly taskRequestKey: "scenario";
     };
+    readonly rewind: {
+        readonly projectedBy: "rewindSpecForMode";
+        readonly taskRequestKeys: readonly ["resumeAt", "resumeAtMode", "restoreFiles", "rewindFilesTo"];
+    };
 };
 export declare const TOOL_PERMISSION_DECISION_KEYS: readonly ["sessionId", "requestId", "decision", "answer", "updatedInput", "remember"];
 export declare const START_SESSION_OPTION_KEYS: readonly ["model", "title", "cwd", "excludeTools"];
 export declare const SEAT_VALIDATOR_KEY_COVERAGE: {
     readonly LocalSessionRecord: {
         readonly guard: "isLocalSessionRecord";
-        readonly check: (s: unknown) => SeatValidation;
+        readonly check: (v: unknown) => SeatValidation;
         readonly validated: readonly ["sessionId", "engineSessionId", "model", "title", "cwd", "isRunning", "createdAt", "lastActivityAt", "queuedMessages", "parked"];
         readonly unchecked: readonly [];
     };
     readonly ToolPermissionRequest: {
         readonly guard: "isToolPermissionRequest";
-        readonly check: (r: unknown) => SeatValidation;
+        readonly check: (v: unknown) => SeatValidation;
         readonly validated: readonly ["requestId", "sessionId", "toolName", "toolCallId", "message", "toctouBinding", "createdAtMs"];
         readonly unchecked: readonly [{
             readonly key: "input";
@@ -369,7 +390,7 @@ export declare const SEAT_VALIDATOR_KEY_COVERAGE: {
     readonly LocalSessionEvent: {
         readonly guard: "isLocalSessionEvent";
         readonly check: (v: unknown) => SeatValidation;
-        readonly validated: readonly ["type", "sessionId", "messages", "error", "errorCategory", "code", "request", "data", "sources", "permissionMode", "session", "userMessageUuid", "hasPreClearSession", "requestId", "outcome", "chrome"];
+        readonly validated: readonly ["type", "sessionId", "messages", "error", "errorCategory", "code", "request", "data", "sources", "permissionMode", "session", "userMessageUuid", "hasPreClearSession", "requestId", "outcome", "parked", "chrome"];
         readonly unchecked: readonly [{
             readonly key: "message";
             readonly why: "transcript 面直通位(CC fQe 逐字姿态:SDKMessage 体不做 schema 校验)—— 校它 = 引擎加一种消息体的那天整条转录被门吃掉。";
@@ -381,10 +402,18 @@ export declare const SEAT_VALIDATOR_KEY_COVERAGE: {
         readonly validated: readonly ["id", "name", "mime", "sha256", "sizeBytes"];
         readonly unchecked: readonly [];
     };
-    readonly SeatModelCatalog: {
-        readonly guard: "isSeatModelCatalog";
+    readonly LiveModelCatalog: {
         readonly check: (v: unknown) => SeatValidation;
-        readonly validated: readonly ["models", "defaultId"];
+        readonly validated: readonly ["models", "default", "defaultModel"];
+        readonly unchecked: readonly [{
+            readonly key: "droppedEntries";
+            readonly why: "诊断面(哪些目录条目没被引擎收下),三态读法归 droppedModelEntriesOf(含坏形 malformed);出站门为它拒掉整份目录 = 选单为一行诊断整个消失。";
+        }];
+    };
+    readonly SendMessageRequest: {
+        readonly guard: "isSendMessageRequest";
+        readonly check: typeof checkSendMessageRequest;
+        readonly validated: readonly ["sessionId", "text", "model", "userMessageUuid", "permissionMode", "attachmentIds", "reasoningEffort", "retainBackgroundProcesses", "forwardSubagentEvents", "retainSubagentSessions", "settings", "scenario", "rewind"];
         readonly unchecked: readonly [];
     };
     readonly ApplyModelConfigResult: {
@@ -440,12 +469,12 @@ export declare const SEAT_VALIDATOR_KEY_COVERAGE: {
     };
     readonly SeatCapabilitiesState: {
         readonly check: (v: unknown) => SeatValidation;
-        readonly validated: readonly ["pickFolder"];
+        readonly validated: readonly ["pickFolder", "rewind"];
         readonly unchecked: readonly [];
     };
-    readonly SeatModelInfo: {
+    readonly SeatRewindIntent: {
         readonly check: (v: unknown) => SeatValidation;
-        readonly validated: readonly ["id", "name", "provider", "contextWindow", "maxOutputTokens"];
+        readonly validated: readonly ["mode", "targetMessageUuid"];
         readonly unchecked: readonly [];
     };
     readonly SessionSearchResult: {