@sema-agent/client-core 0.110.0 → 0.112.0

package/dist/resumeRefusalCopy.d.ts

@@ -1,6 +1,7 @@
 import type { UiLanguage } from './env/uiLanguage.js';
 import type { ResumeStartupCause } from '@sema-agent/sdk';
 import { RESUME_CONTEXT_UNAVAILABLE, CHECKPOINT_UNSUPPORTED_VERSION, CHECKPOINT_WALLTIME_AXIS_RETIRED, CHECKPOINT_CONFIG_REFUSED } from './engineErrorCodes.js';
+import { type DecisionRefusalWayOut } from './checkpointRowVerdict.js';
 export declare const RESUME_REFUSAL_CODES: readonly string[];
 export interface ResumeRefusalDetail {
     code: string;
@@ -50,7 +51,7 @@ export interface ParkedResumeStartupDetail {
 export declare function parkedResumeStartupFromError(err: unknown, decision?: ParkedResumeStartupDecision): ParkedResumeStartupDetail | null;
 export declare function parkedResumeStartupContent(detail: ParkedResumeStartupDetail, lang?: UiLanguage): string;
 export interface CheckpointUnsupportedVersionDetail {
-    code: 'checkpoint.unsupported_version';
+    code: typeof CHECKPOINT_UNSUPPORTED_VERSION;
     retriable: true;
     writerVersion?: string;
     readerVersion?: string;
@@ -76,6 +77,7 @@ export interface RefusedParkContentInput {
     readonly facts: RefusedParkFacts;
     readonly lane: 'interactive' | 'print';
     readonly runId?: string;
+    readonly wayOut?: DecisionRefusalWayOut | (string & {});
 }
 export declare function refusedParkContent(input: RefusedParkContentInput, lang?: UiLanguage): string;
 export declare function refusedParkBlockedContent(taskId: string, lane?: 'interactive' | 'print', lang?: UiLanguage): string;

package/dist/resumeRefusalCopy.js

@@ -4,6 +4,7 @@ import { guardedRead, ownDataField, readOwnDataNonEmptyString, readOwnDataValue
 import { CORE_RESUME_STARTUP_CAUSES } from './generated/engineFactTables.js';
 import { RESUME_CONTEXT_UNAVAILABLE, RESUME_PLACEMENT_MISMATCH, RESUME_PREFLIGHT_REJECTED, RESUME_PRINCIPAL_MISMATCH, RESUME_COMPOSITION_MISMATCH, RESUME_PARENT_CONSTRAINT_MISSING, RESUME_PARENT_CONSTRAINT_MISMATCH, RESUME_CONSTRAINT_UNPROJECTABLE, 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 { decisionRefusalWayOutContent } from './checkpointRowVerdict.js';
 import { engineVersionTier } from './supportFloor.js';
 import { resumeRetryLaterFromError } from './wireErrorTriage.js';
 const REFUSAL_COPY_KEYS = Object.freeze({
@@ -286,7 +287,7 @@ export function refusedParkFromError(failure) {
 function refusedParkShownRunId(runId) {
     return typeof runId === 'string' && /^[A-Za-z0-9._:-]{1,128}$/.test(runId) ? runId : undefined;
 }
-function refusedParkWhy(code, field) {
+function refusedParkWhy(code, field, newerEngine = false) {
     switch (code) {
         case CHECKPOINT_WALLTIME_AXIS_RETIRED:
             return msg('resume.refusal.park.whyWalltime');
@@ -295,7 +296,7 @@ function refusedParkWhy(code, field) {
                 return msg('resume.refusal.park.whyDeps');
             return msg(field === 'inheritedGate' ? 'resume.refusal.park.whyInheritedGate' : 'resume.refusal.park.whyConfigRefused');
         default:
-            return msg('resume.refusal.park.whyUnsupported');
+            return msg(newerEngine ? 'resume.refusal.park.whyNewerEngine' : 'resume.refusal.park.whyUnsupported');
     }
 }
 export function refusedParkContent(input, lang) {
@@ -306,13 +307,15 @@ export function refusedParkContent(input, lang) {
     let field;
     let stillPending;
     let blockedBy;
+    let wayOut;
     try {
         what = input.what;
         lane = input.lane;
         runId = input.runId;
+        wayOut = input.wayOut;
     }
     catch {
-        what = lane = runId = undefined;
+        what = lane = runId = wayOut = undefined;
     }
     try {
         const facts = input.facts;
@@ -326,7 +329,8 @@ export function refusedParkContent(input, lang) {
     }
     const code = rawCode === CHECKPOINT_WALLTIME_AXIS_RETIRED || rawCode === CHECKPOINT_CONFIG_REFUSED ? rawCode : CHECKPOINT_UNSUPPORTED_VERSION;
     const shownWhat = typeof what === 'string' && what !== '' ? capForDisplay(what, 40) : msg('resume.refusal.park.whatDefault');
-    const why = refusedParkWhy(code, typeof field === 'string' ? field : undefined);
+    const newerWorker = wayOut === 'newer_worker' && stillPending !== false;
+    const why = refusedParkWhy(code, typeof field === 'string' ? field : undefined, newerWorker);
     const shownRun = refusedParkShownRunId(runId);
     const head = msg('resume.refusal.park.head', { what: shownWhat, why });
     const configMayReturn = code === CHECKPOINT_CONFIG_REFUSED && field !== 'inheritedGate' ? msg(field === 'deps' ? 'resume.refusal.park.depsMayReturn' : 'resume.refusal.park.configMayReturn') : '';
@@ -335,10 +339,14 @@ export function refusedParkContent(input, lang) {
         if (stillPending === false)
             return renderMessage(msg('resume.refusal.park.printEnded', { head, code, blocked }), lang);
         const cancel = `POST /v1/runs/${shownRun ?? '<run id>'}/cancel`;
+        if (newerWorker)
+            return renderMessage(msg('resume.refusal.park.printNewerWorker', { head, configMayReturn, code, wayOut: decisionRefusalWayOutContent('newer_worker', lang) ?? '', cancel, blocked }), lang);
         return renderMessage(msg('resume.refusal.park.printHolds', { head, configMayReturn, code, cancel, blocked }), lang);
     }
     if (stillPending === false)
         return renderMessage(msg('resume.refusal.park.interactiveEnded', { head }), lang);
+    if (newerWorker)
+        return renderMessage(msg('resume.refusal.park.interactiveNewerWorker', { head, configMayReturn, wayOut: decisionRefusalWayOutContent('newer_worker', lang) ?? '' }), lang);
     return renderMessage(msg('resume.refusal.park.interactiveBusy', { head, configMayReturn }), lang);
 }
 export function refusedParkBlockedContent(taskId, lane = 'interactive', lang) {

package/dist/rewindArchiveReading.js

@@ -2,9 +2,8 @@ import { createEngineCapReader } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 const CAPS_KEYS = {
     conversationAnchor: 'resumeAt',
-    forkRestore: 'rewindFiles',
+    restoreFiles: 'restoreFiles',
     codeOnly: 'rewindFilesTo',
-    restoreFilesEpoch: 'restoreFiles',
 };
 const _capsKeyPin = true;
 void _capsKeyPin;
@@ -22,12 +21,13 @@ export function projectRewindArchiveCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
+        const restoreFiles = bitOf(caps, CAPS_KEYS.restoreFiles);
         return {
             kind: 'present',
             conversationAnchor: bitOf(caps, CAPS_KEYS.conversationAnchor),
-            forkRestore: bitOf(caps, CAPS_KEYS.forkRestore),
+            forkRestore: restoreFiles,
             codeOnly: bitOf(caps, CAPS_KEYS.codeOnly),
-            restoreFilesEpoch: bitOf(caps, CAPS_KEYS.restoreFilesEpoch),
+            restoreFilesEpoch: restoreFiles,
         };
     }
     catch {

package/dist/runCancelContext.d.ts

@@ -31,9 +31,10 @@ export type RunAbortCause = {
 export declare const RUN_CANCELLED_CODE: "cancelled";
 export declare function classifyRunAbortCause(record: unknown): RunAbortCause;
 export type { AbortCause };
+export type AbortCauseWord = AbortCause | 'stall_verdict';
 export type AbortCauseReading = {
     readonly kind: 'known';
-    readonly cause: AbortCause;
+    readonly cause: AbortCauseWord;
 } | {
     readonly kind: 'unrecognized';
     readonly word: string;

package/dist/runCancelContext.js

@@ -100,6 +100,7 @@ const ABORT_CAUSE_SENTENCES = Object.freeze({
     ask_park_grace_exhausted: 'Aborted: the connection dropped while a question or approval was pending, and the run could not be parked for later resumption in time ' +
         '(cause ask_park_grace_exhausted) — not an engine error.',
     cancel_verb: 'Cancelled: a cancel request to the engine stopped this run (cause cancel_verb) — not an engine error.',
+    stall_verdict: 'Aborted: the server had already marked this run as stalled (its heartbeat lapsed), so this leg stopped itself (cause stall_verdict) — not an engine error.',
 });
 const ABORT_CAUSE_UNRECOGNIZED_SENTENCE = 'Aborted by the engine for a reason this client does not recognize — not an engine error.';
 function secondsText(ms) {

package/dist/runLedgerSnapshot.js

@@ -1,6 +1,7 @@
 import { createStreamDrainingLegs } from './streamDrainingLegs.js';
 import { abortableSleep, settleWithinDeadline } from './abortableSleep.js';
 import { readOwnDataValue } from './ownKey.js';
+import { isStreamEndedWithoutTerminalError } from './sseIdleTriage.js';
 const RUN_LEDGER_SNAPSHOT_BUDGET_MS = 8_000;
 const UNNUMBERED_FRAME_CAP = 64;
 const PARK_TRAILER_MAX = 4;
@@ -168,11 +169,10 @@ export async function readRunLedgerSnapshot(taskId, callId, deps, signal) {
         }
         catch (e) {
             drainLegs.legEnded('threw');
-            const name = errorNameOf(e);
-            if (!ac.signal.aborted && name === 'StreamEndedWithoutTerminalError')
+            if (!ac.signal.aborted && isStreamEndedWithoutTerminalError(e))
                 complete = true;
             else
-                log(`[ledgerSnapshot] read-ended-unproven task=${taskId} name=${name}`);
+                log(`[ledgerSnapshot] read-ended-unproven task=${taskId} name=${errorNameOf(e)}`);
         }
         finally {
             passAc.abort();

package/dist/runPermissionModeSwitch.js

@@ -1,6 +1,7 @@
 import { atMostOnceVerdictOf } from './atMostOnce.js';
 import { readPermissionModeReceiptSegment } from './adapter/downstream/wiringManifestView.js';
 import { displayUntrusted } from './displayUntrusted.js';
+import { CORRUPT_ROW_ERROR_CODE, STEERING_NOT_RUNNING } from './engineErrorCodes.js';
 import { SDK_PERMISSION_MODE_ADMISSION_FOLDS, SDK_PERMISSION_MODE_PERSIST_MISSES } from './generated/sdkFactTables.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { ownDataField, readOwnDataValue } from './ownKey.js';
@@ -8,8 +9,6 @@ import { permissionModeWriteAvailable } from './permissionModeWriteCapability.js
 import { permissionModeTitle } from './permissionWireCaps.js';
 import { isDisplayableWireCode } from './wireFailureShape.js';
 export const PERMISSION_MODE_SWITCH_RESULT_KEYS = Object.freeze(['taskId', 'sessionId', 'status', 'permissionMode', 'admission', 'persisted', 'persistMiss']);
-const NOT_RUNNING_CODE = 'steering.not_running';
-const PRE_SWITCH_CORRUPT_CODE = 'corrupt';
 function guardedSlot(o, key) {
     if (o === null || (typeof o !== 'object' && typeof o !== 'function'))
         return undefined;
@@ -79,11 +78,11 @@ function failureOutcomeOf(e) {
     if (v.delivery === 'rejected' && v.status !== undefined) {
         if (v.status === 404)
             return Object.freeze({ kind: 'not-found' });
-        if (v.status === 409 && v.code === NOT_RUNNING_CODE)
+        if (v.status === 409 && v.code === STEERING_NOT_RUNNING)
             return Object.freeze({ kind: 'not-running' });
         return Object.freeze({ kind: 'refused', status: v.status, ...(v.code !== undefined ? { errorCode: v.code } : {}) });
     }
-    if (v.status === 500 && v.code === PRE_SWITCH_CORRUPT_CODE)
+    if (v.status === 500 && v.code === CORRUPT_ROW_ERROR_CODE)
         return Object.freeze({ kind: 'refused', status: 500, errorCode: v.code });
     return v.status !== undefined
         ? Object.freeze({ kind: 'unconfirmed', why: 'server-error', status: v.status })

package/dist/scenarioRefusal.js

@@ -1,23 +1,21 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { readOwnDataValue } from './ownKey.js';
 import { SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
-import { readErrorRecord, readErrorString } from './wireFailureShape.js';
+import { liftLegacyRefusalFacts, readErrorString } from './wireFailureShape.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 import { msg, renderMessage } from './i18n/translate.js';
 const SCENARIO_REFUSAL_ERROR_MAX = 200;
-function detailBits(detail) {
-    if (detail === undefined)
-        return {};
+function scenarioBits(read) {
     let scenario;
     let source;
     try {
-        scenario = readOwnDataValue(detail, 'scenario');
+        scenario = read('scenario');
     }
     catch {
         scenario = undefined;
     }
     try {
-        source = readOwnDataValue(detail, 'source');
+        source = read('source');
     }
     catch {
         source = undefined;
@@ -42,20 +40,20 @@ export function scenarioRefusalOf(body) {
     try {
         if (!isPlainRecord(raw))
             return Object.freeze({});
-        const own = (key) => {
+        const ownOf = (o) => (key) => {
             try {
-                return readOwnDataValue(raw, key);
+                return readOwnDataValue(o, key);
             }
             catch {
                 return undefined;
             }
         };
-        const errorCode = own('errorCode');
-        const error = own('error');
-        const detail = own('detail');
+        const errorCode = ownOf(raw)('errorCode');
+        const error = ownOf(raw)('error');
+        const facts = liftLegacyRefusalFacts(SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, raw);
         let bits = {};
         try {
-            bits = detailBits(isPlainRecord(detail) ? detail : undefined);
+            bits = scenarioBits(ownOf(facts));
         }
         catch {
             bits = {};
@@ -80,7 +78,7 @@ export function scenarioRefusalFromError(err) {
         return Object.freeze({
             errorCode: SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE,
             ...(error !== undefined && error.length > 0 ? { error: capForDisplay(error, SCENARIO_REFUSAL_ERROR_MAX) } : {}),
-            ...detailBits(readErrorRecord(err, 'detail')),
+            ...scenarioBits((key) => readErrorString(err, key)),
         });
     }
     catch {

package/dist/scenarioSkills.js

@@ -49,24 +49,29 @@ export function scenarioSkillsOf(card) {
     }
 }
 const SCENARIO_SKILLS_CAPABILITY_KEY = 'scenarioSkills';
+const CAP_CONFIRMED = Object.freeze({ kind: 'confirmed' });
+const CAP_ABSENT = Object.freeze({ kind: 'absent' });
+const CAP_DECLINED = Object.freeze({ kind: 'declined' });
+const CAP_UNREADABLE = Object.freeze({ kind: 'unreadable' });
+const CAP_UNOBSERVED = Object.freeze({ kind: 'unobserved' });
 export function observedScenarioSkillsCapability(baseUrl) {
     try {
         const base = baseUrl === undefined ? engineWireTargetBaseUrl() : baseUrl;
         const slot = engineCapValue(typeof base === 'string' ? base : undefined, SCENARIO_SKILLS_CAPABILITY_KEY);
         switch (slot.kind) {
             case 'unobserved':
-                return Object.freeze({ kind: 'unobserved' });
+                return CAP_UNOBSERVED;
             case 'not_reported':
-                return Object.freeze({ kind: 'absent' });
+                return CAP_ABSENT;
             case 'unreadable':
-                return Object.freeze({ kind: 'unreadable' });
+                return CAP_UNREADABLE;
             case 'null':
-                return Object.freeze({ kind: 'declined' });
+                return CAP_DECLINED;
             case 'value':
-                return slot.value === true ? Object.freeze({ kind: 'confirmed' }) : Object.freeze({ kind: 'declined' });
+                return slot.value === true ? CAP_CONFIRMED : CAP_DECLINED;
         }
     }
     catch {
-        return Object.freeze({ kind: 'unobserved' });
+        return CAP_UNOBSERVED;
     }
 }

package/dist/seam.d.ts

@@ -10,7 +10,8 @@ import type { ToolKillCause } from './toolResult.js';
 import type { HumanInputAttachmentView } from './ownKey.js';
 import type { SubagentAliasScope } from './subagentContentStore.js';
 import type { SessionBoxNoticeFacts } from './peerFrames.js';
-import type { TaskNotificationFields } from './notifications.js';
+import type { HostSettingNotice } from './hostTurnSettings.js';
+import type { ResupplyTruncatedSource, TaskNotificationFields } from './notifications.js';
 export interface AbortSignalLike {
     readonly aborted: boolean;
 }
@@ -167,7 +168,7 @@ export type ChromeEvent = {
 } | ({
     kind: 'run_cost_reconciled';
     laneProof: LaneProof;
-} & RunCostReconcile) | HumanInputChromeEvent | MessageCommittedChromeEvent | EngineNoticeChromeEvent | TextSegmentEndChromeEvent | ThinkingSegmentEndChromeEvent | ToolDisclosureChromeEvent | ToolProgressChromeEvent | ToolRosterDeltaChromeEvent | ContextUsageChromeEvent | CompactionOutcomeChromeEvent | CompactionStartedChromeEvent | SubagentStartedChromeEvent | PromptAssembledChromeEvent | MemorySavedChromeEvent | WiringManifestChromeEvent | ResultTextDivergedChromeEvent | ResultReplayedChromeEvent | ToolParkedChromeEvent | SubagentAliasChromeEvent | SessionBoxNoticeChromeEvent | ApprovalRequestChromeEvent | ApprovalRevokeChromeEvent | ApprovalCompleteChromeEvent | SessionTitledChromeEvent | {
+} & RunCostReconcile) | HumanInputChromeEvent | MessageCommittedChromeEvent | EngineNoticeChromeEvent | TextSegmentEndChromeEvent | ThinkingSegmentEndChromeEvent | ToolDisclosureChromeEvent | ToolProgressChromeEvent | ToolRosterDeltaChromeEvent | ContextUsageChromeEvent | CompactionOutcomeChromeEvent | CompactionStartedChromeEvent | SubagentStartedChromeEvent | PromptAssembledChromeEvent | MemorySavedChromeEvent | WiringManifestChromeEvent | ResultTextDivergedChromeEvent | ResultReplayedChromeEvent | ToolParkedChromeEvent | SubagentAliasChromeEvent | SessionBoxNoticeChromeEvent | ResupplyTruncatedChromeEvent | HostSettingNoticeChromeEvent | ApprovalRequestChromeEvent | ApprovalRevokeChromeEvent | ApprovalCompleteChromeEvent | SessionTitledChromeEvent | {
     kind: 'suspended_reopened';
     laneProof: LaneProof;
     reopen: Extract<SuspendedReopenReading, {
@@ -358,6 +359,19 @@ export interface SubagentAliasChromeEvent {
     seq?: number;
 }
 export type SessionBoxNoticeChromeEvent = SessionBoxNoticeChromeEnvelope & SessionBoxNoticeFacts;
+export interface ResupplyTruncatedChromeEvent {
+    kind: 'resupply_truncated';
+    laneProof: LaneProof;
+    source: ResupplyTruncatedSource;
+    taskId: string;
+    bytes: number;
+    droppedKeys: readonly string[];
+    text: string;
+}
+export type HostSettingNoticeChromeEvent = {
+    kind: 'host_setting_notice';
+    laneProof: LaneProof;
+} & HostSettingNotice;
 export interface SessionBoxNoticeChromeEnvelope {
     kind: 'session_box_notice';
     laneProof: LaneProof;

package/dist/seam.js

@@ -152,6 +152,16 @@ const CHROME_ARM_TABLE = {
             '渲 `text`(数据面英文)或按界面语言调 `sessionBoxNoticeSentence(本臂, lang)`;🔴 同一条通告有两个载体(转录行 + 本臂),接本臂的宿主按 `rowUuid` 把那一行摘掉、只渲一个;' +
             '`state` 是开集机读位,别回显、别按它猜句子;typed 正体缺席时本臂整个不发(不铸状态词)。',
     },
+    resupply_truncated: {
+        required: false,
+        duty: '可选:停驻补投帧只带了最小形的披露 —— 渲 `text`(数据面英文)或按界面语言调 `resupplyTruncatedSentence(本臂, lang)`,放在这条通知的转录行旁(task_notification)或完成通告旁(workflow_complete)。' +
+            '`droppedKeys` / `bytes` 是机读位,别拼进句子;披露位缺席(全形帧 / 老服务端)或坏形时本臂整个不发,不要自己据「摘要很短」推断截断。',
+    },
+    host_setting_notice: {
+        required: false,
+        duty: '可选:宿主自供设置项的一句通告(`hostTurnSettings()` 产物 `notices` 的一句;载荷 = `HostSettingNotice` 原样)。按 `plane` 呈现:`turn` 本回合系统行 / `session` 每会话每句一次 / ' +
+            '`diagnostic` 不渲只记;🔴 非终态:不是失败卡、不改回合状态;`key` / `cause` 缺席 = 这一句不挂某一行,不是坏形。铸口只有 `hostSettingNoticeEventsOf`,别手拼。',
+    },
     result_text_diverged: {
         required: false,
         duty: '可选:终帧正文与已上屏正文**互相都不是对方前缀**时的诚实披露。🔴 处置是把这一拍的转录行**改口**' +