@sema-agent/client-core 0.90.0 → 0.92.0

package/dist/promptDelivery.d.ts

@@ -1,16 +1,24 @@
 import type { AgentEvent } from '@sema-agent/sdk';
 import { type SelfHealOutcome } from './adapter/activeRunSelfHeal.js';
+import type { HumanTurnDelivered } from './humanTurn.js';
 export interface PromptDeliveryRecord {
     readonly u: string;
     readonly s: 'a' | 'd';
+    readonly by?: 'frame' | 'steer_receipt';
+    readonly share?: 'full' | 'partial';
 }
 export interface PromptDeliveryLedger {
-    attempted(batchUuids: readonly string[]): readonly PromptDeliveryRecord[];
-    deliveredByFrame(batchUuids: readonly string[], event: AgentEvent): readonly PromptDeliveryRecord[];
-    deliveredBySteerReceipt(batchUuids: readonly string[], outcome: SelfHealOutcome): readonly PromptDeliveryRecord[];
+    attempted(batchUuids: readonly string[], opts?: {
+        readonly generation?: number;
+    }): readonly PromptDeliveryRecord[];
+    deliveredByFrame(batchUuids: readonly string[] | HumanTurnDelivered, event: AgentEvent): readonly PromptDeliveryRecord[];
+    deliveredBySteerReceipt(batchUuids: readonly string[] | HumanTurnDelivered, outcome: SelfHealOutcome): readonly PromptDeliveryRecord[];
     isAttempted(uuid: string): boolean;
     isDelivered(uuid: string): boolean;
     knownUndelivered(uuid: string): boolean;
+    deliveryShareOf(uuid: string): 'full' | 'partial' | undefined;
+    undeliveredInGeneration(generation: number): readonly string[];
+    droppedKeyCount(): number;
     batchOf(uuid: string): readonly string[] | undefined;
     toRecords(): readonly PromptDeliveryRecord[];
     fromRecords(records: readonly PromptDeliveryRecord[]): readonly PromptDeliveryRecord[];

package/dist/promptDelivery.js

@@ -1,8 +1,43 @@
 import { activeRunBusySignal } from './adapter/runStream.js';
 import { selfHealSubmissionDisposition } from './adapter/activeRunSelfHeal.js';
 const uuidOk = (u) => typeof u === 'string' && u.length > 0;
+function isArraySafe(v) {
+    try {
+        return Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
+const generationOk = (g) => typeof g === 'number' && Number.isSafeInteger(g) && g >= 0;
+function generationOpt(opts) {
+    if (typeof opts !== 'object' || opts === null)
+        return undefined;
+    try {
+        const g = opts.generation;
+        return generationOk(g) ? g : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const levelOf = (rec) => !Object.hasOwn(rec, 'by') ? 1 : Object.hasOwn(rec, 'share') && rec.share === 'partial' ? 2 : 3;
+function deliveredByWord(v) {
+    const words = { frame: true, steer_receipt: true };
+    return typeof v === 'string' && Object.hasOwn(words, v) ? v : undefined;
+}
+function deliveredShareWord(v) {
+    const words = { full: true, partial: true };
+    return typeof v === 'string' && Object.hasOwn(words, v) ? v : undefined;
+}
+function ownExtension(rec, key) {
+    const desc = Object.getOwnPropertyDescriptor(rec, key);
+    if (desc === undefined)
+        return key in rec ? { kind: 'unreadable' } : { kind: 'absent' };
+    return 'value' in desc ? { kind: 'value', value: desc.value } : { kind: 'unreadable' };
+}
 function cleanBatch(batch) {
-    if (!Array.isArray(batch))
+    if (!isArraySafe(batch))
         return [];
     const out = [];
     const seen = new Set();
@@ -19,17 +54,73 @@ function cleanBatch(batch) {
     }
     return out;
 }
-function readRecord(rec) {
-    if (typeof rec !== 'object' || rec === null || Array.isArray(rec))
+function readRecord(raw) {
+    if (typeof raw !== 'object' || raw === null)
         return undefined;
+    let u;
+    let s;
     try {
-        const u = rec.u;
-        const s = rec.s;
-        return uuidOk(u) && (s === 'a' || s === 'd') ? { u, s } : undefined;
+        if (Array.isArray(raw))
+            return undefined;
+        u = raw.u;
+        s = raw.s;
     }
     catch {
         return undefined;
     }
+    if (!uuidOk(u) || (s !== 'a' && s !== 'd'))
+        return undefined;
+    const legacy = { u, s };
+    try {
+        let rec = legacy;
+        if (s === 'd') {
+            const byExt = ownExtension(raw, 'by');
+            const shareExt = ownExtension(raw, 'share');
+            const by = byExt.kind === 'value' ? deliveredByWord(byExt.value) : undefined;
+            const share = shareExt.kind === 'value' ? deliveredShareWord(shareExt.value) : undefined;
+            if (by !== undefined && (shareExt.kind === 'absent' || share !== undefined))
+                rec = share === undefined ? { u, s, by } : { u, s, by, share };
+        }
+        const dropped = Object.keys(raw).filter((k) => !Object.hasOwn(rec, k)).length;
+        return { rec, dropped };
+    }
+    catch {
+        return { rec: legacy, dropped: 0 };
+    }
+}
+function readTierStrict(holder, key) {
+    try {
+        if (!Object.hasOwn(holder, key))
+            return [];
+        const raw = holder[key];
+        if (!Array.isArray(raw))
+            return null;
+        const out = [];
+        const seen = new Set();
+        for (const u of raw) {
+            if (!uuidOk(u) || seen.has(u))
+                continue;
+            seen.add(u);
+            out.push(u);
+        }
+        return out;
+    }
+    catch {
+        return null;
+    }
+}
+function batchTiers(batch) {
+    const none = { full: [], partial: [] };
+    if (isArraySafe(batch))
+        return { full: cleanBatch(batch), partial: [] };
+    if (typeof batch !== 'object' || batch === null)
+        return none;
+    const full = readTierStrict(batch, 'full');
+    const partial = readTierStrict(batch, 'partial');
+    if (full === null || partial === null)
+        return none;
+    const inFull = new Set(full);
+    return { full, partial: partial.filter((u) => !inFull.has(u)) };
 }
 const PRE_RUN_FRAME_TYPES = new Set(['meta', 'approval_request', 'approval_revoke']);
 export function frameProvesDelivery(event) {
@@ -56,9 +147,11 @@ export function frameProvesDelivery(event) {
     }
 }
 function outcomeProvesDelivery(outcome) {
-    if (typeof outcome !== 'object' || outcome === null || Array.isArray(outcome))
+    if (typeof outcome !== 'object' || outcome === null)
         return false;
     try {
+        if (Array.isArray(outcome))
+            return false;
         return selfHealSubmissionDisposition(outcome) === 'handed-off';
     }
     catch {
@@ -67,48 +160,88 @@ function outcomeProvesDelivery(outcome) {
 }
 export function createPromptDeliveryLedger() {
     const attemptedSet = new Set();
-    const deliveredSet = new Set();
+    const deliveredLevel = new Map();
     const batchOfMap = new Map();
+    const generationOf = new Map();
     const log = [];
-    const add = (u, s, into) => {
-        const set = s === 'a' ? attemptedSet : deliveredSet;
-        if (set.has(u))
+    let droppedKeys = 0;
+    const keep = (rec, into) => {
+        const frozen = Object.freeze(rec);
+        log.push(frozen);
+        into.push(frozen);
+    };
+    const add = (rec, into) => {
+        if (rec.s === 'a') {
+            if (attemptedSet.has(rec.u))
+                return;
+            attemptedSet.add(rec.u);
+            keep(rec, into);
             return;
-        set.add(u);
-        const rec = Object.freeze({ u, s });
-        log.push(rec);
-        into.push(rec);
+        }
+        const level = levelOf(rec);
+        if ((deliveredLevel.get(rec.u) ?? 0) >= level)
+            return;
+        deliveredLevel.set(rec.u, level);
+        keep(rec, into);
     };
-    const markDelivered = (batchUuids) => {
+    const markDelivered = (batch, by) => {
         const added = [];
-        for (const u of cleanBatch(batchUuids))
-            add(u, 'd', added);
+        const { full, partial } = batchTiers(batch);
+        for (const u of full)
+            add({ u, s: 'd', by }, added);
+        for (const u of partial)
+            add({ u, s: 'd', by, share: 'partial' }, added);
         return Object.freeze(added);
     };
+    const levelNow = (uuid) => (uuidOk(uuid) ? (deliveredLevel.get(uuid) ?? 0) : 0);
+    const knownUndeliveredUuid = (uuid) => uuidOk(uuid) && attemptedSet.has(uuid) && !deliveredLevel.has(uuid);
     const ledger = Object.freeze({
-        attempted(batchUuids) {
+        attempted(batchUuids, opts) {
+            const generation = generationOpt(opts);
             const batch = Object.freeze(cleanBatch(batchUuids));
             const added = [];
             for (const u of batch) {
                 batchOfMap.set(u, batch);
-                add(u, 'a', added);
+                if (generation !== undefined) {
+                    generationOf.delete(u);
+                    generationOf.set(u, generation);
+                }
+                add({ u, s: 'a' }, added);
             }
             return Object.freeze(added);
         },
         deliveredByFrame(batchUuids, event) {
-            return frameProvesDelivery(event) ? markDelivered(batchUuids) : Object.freeze([]);
+            return frameProvesDelivery(event) ? markDelivered(batchUuids, 'frame') : Object.freeze([]);
         },
         deliveredBySteerReceipt(batchUuids, outcome) {
-            return outcomeProvesDelivery(outcome) ? markDelivered(batchUuids) : Object.freeze([]);
+            return outcomeProvesDelivery(outcome) ? markDelivered(batchUuids, 'steer_receipt') : Object.freeze([]);
         },
         isAttempted: (uuid) => uuidOk(uuid) && attemptedSet.has(uuid),
-        isDelivered: (uuid) => uuidOk(uuid) && deliveredSet.has(uuid),
-        knownUndelivered: (uuid) => uuidOk(uuid) && attemptedSet.has(uuid) && !deliveredSet.has(uuid),
+        isDelivered: (uuid) => levelNow(uuid) >= 2,
+        knownUndelivered: (uuid) => knownUndeliveredUuid(uuid),
+        deliveryShareOf: (uuid) => {
+            const level = levelNow(uuid);
+            return level === 3 ? 'full' : level === 2 ? 'partial' : undefined;
+        },
+        undeliveredInGeneration(generation) {
+            const out = [];
+            if (!generationOk(generation))
+                return Object.freeze(out);
+            for (const [u, g] of generationOf) {
+                if (g !== generation)
+                    continue;
+                generationOf.delete(u);
+                if (knownUndeliveredUuid(u))
+                    out.push(u);
+            }
+            return Object.freeze(out);
+        },
+        droppedKeyCount: () => droppedKeys,
         batchOf: (uuid) => (uuidOk(uuid) ? batchOfMap.get(uuid) : undefined),
         toRecords: () => Object.freeze([...log]),
         fromRecords(records) {
             const added = [];
-            if (!Array.isArray(records))
+            if (!isArraySafe(records))
                 return Object.freeze(added);
             let list;
             try {
@@ -118,9 +251,11 @@ export function createPromptDeliveryLedger() {
                 return Object.freeze(added);
             }
             for (const raw of list) {
-                const rec = readRecord(raw);
-                if (rec !== undefined)
-                    add(rec.u, rec.s, added);
+                const read = readRecord(raw);
+                if (read === undefined)
+                    continue;
+                droppedKeys += read.dropped;
+                add(read.rec, added);
             }
             return Object.freeze(added);
         },
@@ -152,7 +287,7 @@ export function promptKnownUndelivered(ledger, message) {
 }
 export function withoutUndeliveredPrompts(ledger, messages) {
     assertLedger(ledger, 'withoutUndeliveredPrompts');
-    if (!Array.isArray(messages))
+    if (!isArraySafe(messages))
         return [];
     return messages.filter((m) => !promptKnownUndelivered(ledger, m));
 }

package/dist/promptProfileWireCaps.d.ts

@@ -1,3 +1,4 @@
+import type { TaskRequest } from '@sema-agent/sdk';
 import { type EnvLike } from './hostEnv.js';
-export type PromptProfile = 'simple' | 'classic';
+export type PromptProfile = NonNullable<TaskRequest['promptProfile']>;
 export declare function promptProfileFromEnv(env?: EnvLike): PromptProfile | undefined;

package/dist/protocolSegment.d.ts

@@ -0,0 +1,9 @@
+export type ProtocolSegment = {
+    readonly kind: 'ok';
+} | {
+    readonly kind: 'unminted';
+    readonly minted?: string;
+} | {
+    readonly kind: 'unknown';
+};
+export declare function protocolSegmentOf(name: string): ProtocolSegment;

package/dist/protocolSegment.js

@@ -0,0 +1,28 @@
+import { hasCoreValuePort, mintNamespacePrefix, protocolOf } from './coreValuePorts.js';
+export function protocolSegmentOf(name) {
+    const ns = protocolOf(name);
+    if (ns === undefined)
+        return hasCoreValuePort('protocolOf') ? { kind: 'ok' } : { kind: 'unknown' };
+    let parsed;
+    try {
+        parsed = ns.parse(name);
+    }
+    catch {
+        return { kind: 'unknown' };
+    }
+    const peer = parsed?.peer;
+    if (typeof peer !== 'string')
+        return { kind: 'ok' };
+    if (peer.includes('*'))
+        return { kind: 'unminted' };
+    let minted;
+    try {
+        minted = mintNamespacePrefix(ns, peer);
+    }
+    catch {
+        return { kind: 'unknown' };
+    }
+    if (typeof minted !== 'string')
+        return { kind: 'unknown' };
+    return minted === `${ns.prefix}${peer}__` ? { kind: 'ok' } : { kind: 'unminted', minted };
+}

package/dist/providerRejection.d.ts

@@ -4,4 +4,5 @@ export interface ProviderRejectionResend {
     resend: 'edit_and_resend' | 'not_by_editing';
     text: string;
 }
+export declare function readProviderRejectionResendKey(v: object | null | undefined): ProviderRejectionResend | undefined;
 export declare function providerRejectionResend(detail: RunTerminalFailureDetail | null | undefined, carrier?: ToolHistoryErrorCarrier | null): ProviderRejectionResend | undefined;

package/dist/providerRejection.js

@@ -29,6 +29,26 @@ function toolHistoryMismatchCarrier(carrier) {
     return carrier !== undefined && carrier !== null && classifyToolHistoryMismatch(carrier) !== null;
 }
 const PROVIDER_REJECTED = 'provider_rejected';
+const RESEND_TEXT_STATUS = /\(HTTP (\d{3})\)/;
+export function readProviderRejectionResendKey(v) {
+    try {
+        if (typeof v !== 'object' || v === null || Array.isArray(v))
+            return undefined;
+        const got = v;
+        const resend = got.resend;
+        const text = got.text;
+        if (typeof text !== 'string' || (resend !== 'edit_and_resend' && resend !== 'not_by_editing'))
+            return undefined;
+        const hit = RESEND_TEXT_STATUS.exec(text);
+        if (hit === null || hit[1] === undefined)
+            return undefined;
+        const again = providerRejectionResend({ kind: PROVIDER_REJECTED, status: Number(hit[1]) });
+        return again !== undefined && again.resend === resend && again.text === text ? { resend: again.resend, text: again.text } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function providerRejectionResend(detail, carrier) {
     let read;
     try {

package/dist/readDenyTiers.d.ts

@@ -0,0 +1,10 @@
+export declare const READ_DENY_BUILTIN_TIERS: readonly ["credentials", "shell-history", "browser", "wallet", "agent-config"];
+export declare const READ_DENY_DEFAULT_TIERS: readonly ["credentials", "agent-config"];
+export type ReadDenyBuiltinTiersParse = {
+    readonly ok: true;
+    readonly value: string | null;
+} | {
+    readonly ok: false;
+    readonly why: string;
+};
+export declare function parseReadDenyBuiltinTiers(input: string): ReadDenyBuiltinTiersParse;

package/dist/readDenyTiers.js

@@ -0,0 +1,29 @@
+import { displayUntrusted } from './displayUntrusted.js';
+import { CORE_READ_DENY_BUILTIN_TIERS, CORE_READ_DENY_DEFAULT_TIERS } from './generated/engineFactTables.js';
+export const READ_DENY_BUILTIN_TIERS = CORE_READ_DENY_BUILTIN_TIERS;
+export const READ_DENY_DEFAULT_TIERS = CORE_READ_DENY_DEFAULT_TIERS;
+const NONE_WORD = 'none';
+const SHOWN_ITEM_MAX = 40;
+const SHOWN_ITEM_WINDOW = 2000;
+const refuse = (why) => ({ ok: false, why });
+const shown = (item) => displayUntrusted(item.length > SHOWN_ITEM_WINDOW ? item.slice(0, SHOWN_ITEM_WINDOW) : item, { max: SHOWN_ITEM_MAX });
+export function parseReadDenyBuiltinTiers(input) {
+    if (typeof input !== 'string')
+        return refuse(`expected a string: comma-separated tier names, or the single word "${NONE_WORD}"`);
+    const text = input.trim();
+    if (text === '')
+        return { ok: true, value: null };
+    const parts = text.split(',').map((p) => p.trim());
+    if (parts.some((p) => p === ''))
+        return refuse('an empty entry between commas');
+    if (parts.includes(NONE_WORD)) {
+        return parts.length === 1 ? { ok: true, value: NONE_WORD } : refuse(`"${NONE_WORD}" must be the only entry`);
+    }
+    const known = READ_DENY_BUILTIN_TIERS;
+    const unknown = parts.filter((p) => !known.includes(p));
+    if (unknown.length > 0) {
+        const more = unknown.length > 1 ? ` (and ${unknown.length - 1} more)` : '';
+        return refuse(`unknown tier "${shown(unknown[0])}"${more}; known tiers: ${known.join(', ')}`);
+    }
+    return { ok: true, value: parts.join(',') };
+}

package/dist/request/taskRequest.js

@@ -1,6 +1,6 @@
 import { refuseBadDisableSkills, refuseDisableSkillsConflict } from '../disableSkillsWire.js';
 import { ATTACHMENTS_SPEC_KEYS, AttachmentsSpecRefused } from '../attachmentsWireCaps.js';
-import { retiredAttachmentsKeyWhy } from '../taskRequestWords.js';
+import { retiredAttachmentsKeyOf } from '../taskRequestWords.js';
 export const REQUEST_FIELD_MATRIX = [
     { field: 'objective', lanes: ['interactive', 'print', 'utility'], live: false, why: '本 turn 的真实输入,每条车道都必需', whyUtilityLane: '恒座:三条车道都必须带上本次提交的模型面输入' },
     { field: 'sessionId', lanes: ['interactive', 'print', 'utility'], live: false, why: '单命名空间(TP-A Step 2):壳 id 即引擎 session id;print 在非 live 下保留 mock 常量', whyUtilityLane: '恒座:side-channel 提交走**独立**会话 id(壳另铸一个,绝不复用用户会话那一个 —— 复用会把这次提交的转录混进用户会话)' },
@@ -44,7 +44,7 @@ export const REQUEST_FIELD_MATRIX = [
     { field: 'systemPrompt', lanes: ['interactive', 'print', 'utility'], live: false, why: '整段替换系统提示(sdk `TaskRequest.systemPrompt`;上游字符数超限 400 响亮拒,本层原样透传)。三条车道都有来源:交互面 = CC QueryParams.systemPrompt,无人值守面 = `--system-prompt[-file]` 一类旗,side-channel 面 = 壳整段给出的那一份。与追加位 `appendSystemPrompt` 不是一个位(那一位归 live 兜底层,见 `LIVE_DEFAULT_FIELDS`)', whyUtilityLane: '有座:side-channel 提交的系统提示由壳整段给出 —— 它不是用户会话的续谈,不该继承用户那一份' },
     { field: 'reasoningEffort', lanes: ['interactive', 'print', 'utility'], live: false, why: '思考档位(sdk `TaskRequest.reasoningEffort` 七词闭集;上游对表外词 400 响亮拒 ⇒ 本层不预铸第二判官)。档位是请求级的位、与车道无关:交互面 = `/effort` 拨盘,无人值守面 = 档位旗。🔴 端交的必须是**档位词**:「思考 token 数」今天没有上游对位(见 `UPSTREAM_ABSENT_REQUEST_INTENTS` 的 `maxThinkingTokens`),别把一个数字折成档位词发出去', whyUtilityLane: '有座:side-channel 该用显式低档(省钱省时);与 model 同一条理由 —— 本车道上这两位都由壳显式给,不跟用户会话的拨盘走' },
     { field: 'model', lanes: ['interactive', 'print', 'utility'], live: false, why: '模型选择(sdk `TaskRequest.model`;交互面 = `/model` 中途换模型的拨盘,无人值守面 = 模型旗 / 部署缺省那一路,side-channel 面 = 壳显式挑的那一只)。三条车道都有来源、都是提交面。🔴 0.79.0 改口:修前「print 的模型走另一条路」这句理由被用户面实测证伪 —— 无人值守车道传了模型名却整键不上请求体,于是同一个坏名字在交互态被引擎 400 点名、在无人值守态却安静换成部署缺省并在首帧回显一个没生效的名字。一个**选择**类声明被静默丢掉,后果与收紧类声明被静默丢掉同形(端不读回执就以为生效)—— 与 `excludeTools` 补 print 座同律。本层原样透传、不预判模型名(名字的合法性归引擎,本层不铸第二判官)', whyUtilityLane: '有座:side-channel 显式挑便宜的那只模型(不跟用户会话的 `/model` 拨盘走)' },
-    { field: 'images', lanes: ['interactive'], live: false, why: '贴图提交是交互动作,`-p` 的 stdin 没有图片块', whyUtilityLane: '无座:贴图是交互动作,side-channel 的提交体里没有图片块' },
+    { field: 'images', lanes: ['interactive', 'print'], live: false, why: '图片输入(sdk `TaskRequest.images`;base64 / url 两形,原样透传)。两条用户车道都是提交面、都有来源:交互面 = 粘贴图与 `@` 图片像素,一次性车道 = 结构化输入里的图片块。张数、单张与合计的座位判定归人类提交装配口 `encodeHumanTurn`(两条车道同一份判定,本表不另判);请求体与图片张数的上限归上游判', whyUtilityLane: '无座:贴图是交互动作,side-channel 的提交体里没有图片块' },
     { field: 'resumeAt/resumeAtMode/restoreFiles/rewindFilesTo', lanes: ['interactive'], live: false, why: 'E18 `/rewind` 是交互命令;四键同生同灭(CC-145:core 6.0.0 起 both 臂发 restoreFiles;CC-223 起退役键 rewindFiles 不再有座 —— 交它按表外子键响亮拒;resumeAtMode 是 both/conversation 两臂恒带的排他截语义位)', whyUtilityLane: '无座:回退是交互命令,而 side-channel 是一次性的独立会话,没有可回退的历史' },
     { field: 'clientContext', lanes: ['interactive'], live: false, why: 'IANA 时区 + 可选邮箱 → core 本地化 `# Environment` 的 today;print 同样跑在用户机器上,缺席让引擎误标 (UTC)', gap: true, whyUtilityLane: '无座:本地化 today 的用途在用户会话的环境段,而 side-channel 的系统提示由壳整段给出 —— 这一列我判不准要不要(与本行 `gap` 同一条待办:要补先单独立项)' },
     { field: 'scratchpadDir', lanes: ['interactive'], live: true, why: '[816]③ per-session 暂存目录;print 也有 session,缺席让 `-p` 的工具写不进 exemptDir', gap: true, whyUtilityLane: '无座:per-session 暂存目录是给**工具**写的,零工具面上没人写' },
@@ -458,7 +458,7 @@ const withoutRetiredAttachmentsKeys = (v) => {
         return v;
     let drop;
     for (const key of Object.keys(v)) {
-        const why = retiredAttachmentsKeyWhy(key, 'key');
+        const why = retiredAttachmentsKeyOf(key, 'key')?.why;
         if (why === undefined)
             continue;
         const d = Object.getOwnPropertyDescriptor(v, key);
@@ -483,13 +483,6 @@ const refuseBadExcludeAllTools = (v) => {
         `收到 ${coarseShape(v)}。这一位是**整只工具面卸载**的收紧声明:本层若把坏值静默删键,这一次运行会挂上声明人以为已经卸掉的全部工具。` +
         '错误文本只报形状,不回显值。');
 };
-const RETIRED_APPROVER_POSTURE_KEY = 'approverPosture';
-const refuseRetiredApproverPosture = () => {
-    throw new TypeError('buildTaskRequest: "approverPosture" 是退役键(引擎 core 7.34.0 起在任务规格入口按名拒收;服务端 7.106.0 起提交体带它整条 400 ' +
-        'request.body_shape,unknownKeys 点名它)。它只是一句渲给模型看的审批姿态声明,从不授权任何东西 —— 删掉它不改变这一次运行被允许做什么。' +
-        '本包在装配前拒:在场即拒,任何值同判(undefined / null = 缺席)。处置:删掉这个键,不要改发别的键来顶替它;' +
-        '若确实要引擎侧放行审批,那是另一件事:显式给权限模式 permissionMode(那是一项授权,受部署策略管)。错误文本只报键名,不回显值。');
-};
 const refuseBadFileHistory = (v) => {
     if (v === undefined || v === null)
         return;
@@ -715,17 +708,12 @@ export function assembleTaskRequest(input, lane) {
     };
     const unknownKeys = [];
     const lateOmitted = [];
-    let retiredApproverPosture = false;
     for (const key of Object.keys(src)) {
         if (hasOwn(INPUT_KEY_ROUTES, key))
             continue;
         const stray = Reflect.get(src, key);
         if (!present(stray))
             continue;
-        if (key === RETIRED_APPROVER_POSTURE_KEY) {
-            retiredApproverPosture = true;
-            continue;
-        }
         const route = routeOfTopLevelKey(key);
         if (route === undefined) {
             unknownKeys.push(key);
@@ -756,8 +744,6 @@ export function assembleTaskRequest(input, lane) {
             retiredRewindFiles = true;
         unknownKeys.push(`rewind.${sub}`);
     }
-    if (retiredApproverPosture)
-        refuseRetiredApproverPosture();
     if (retiredRewindFiles) {
         throw new TypeError('buildTaskRequest: "rewind.rewindFiles" 是退役键(引擎 core 6.0.0 起退役:「逐轮捕获」那一义被引擎忽略 —— 文件首触追踪恒开,' +
             '无需请求;「回退时一并还原文件」那一义被引擎拒收、改名为 restoreFiles)。本包在装配前拒:在场即拒,true / false 同判。' +

package/dist/resumeRefusalCopy.d.ts

@@ -46,3 +46,14 @@ export interface ParkedResumeStartupDetail {
 }
 export declare function parkedResumeStartupFromError(err: unknown, decision?: ParkedResumeStartupDecision): ParkedResumeStartupDetail | null;
 export declare function parkedResumeStartupContent(detail: ParkedResumeStartupDetail): string;
+export interface CheckpointUnsupportedVersionDetail {
+    code: 'checkpoint.unsupported_version';
+    retriable: true;
+}
+export declare function checkpointUnsupportedVersionFromError(err: unknown): CheckpointUnsupportedVersionDetail | null;
+export type CheckpointUnsupportedParkKind = 'tool_approval' | 'plan_review' | 'resource_park' | 'wake' | 'workflow_host';
+export interface CheckpointUnsupportedVersionContext {
+    readonly parkKind?: CheckpointUnsupportedParkKind;
+    readonly runId?: string;
+}
+export declare function checkpointUnsupportedVersionContent(detail: CheckpointUnsupportedVersionDetail, ctx?: CheckpointUnsupportedVersionContext): string;

package/dist/resumeRefusalCopy.js

@@ -1,5 +1,5 @@
 import { readErrorNumber, readErrorString } from './wireFailureShape.js';
-import { RESUME_CONTEXT_UNAVAILABLE, RESUME_PLACEMENT_MISMATCH, RESUME_PREFLIGHT_REJECTED, RESUME_POLICY_FOLD_CODE, PARKED_RESUME_STARTUP_FAILED, isStatusDerivedCoarseCode, RESUME_SESSION_NOT_FOUND, } 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, refusalSaysStillPending, } from './engineErrorCodes.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { resumeRetryLaterFromError } from './wireErrorTriage.js';
 export const RESUME_REFUSAL_CODES = Object.freeze([
@@ -88,8 +88,8 @@ export function resumePolicyBlockContent(detail) {
 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', coarse: 'not_found.resource' })],
-    [422, Object.freeze({ form: 'session_id_missing', coarse: 'request.unprocessable' })],
+    [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' })],
 ]);
 export function requireExistingSessionRefusalFromError(err) {
     if (typeof err !== 'object' || err === null)
@@ -101,7 +101,7 @@ export function requireExistingSessionRefusalFromError(err) {
         if (byStatus === undefined)
             return null;
         const code = o['errorCode'];
-        if (code === RESUME_SESSION_NOT_FOUND)
+        if (code === byStatus.code)
             return Object.freeze({ code: RESUME_SESSION_NOT_FOUND, form: byStatus.form });
         if (code !== byStatus.coarse)
             return null;
@@ -196,3 +196,60 @@ const PARKED_RESUME_STARTUP_SENTENCES = Object.freeze({
 export function parkedResumeStartupContent(detail) {
     return detail.cause === 'resume_rejected' ? PARKED_RESUME_STARTUP_SENTENCES.resume_rejected : PARKED_RESUME_STARTUP_SENTENCES.undetermined;
 }
+export function checkpointUnsupportedVersionFromError(err) {
+    if (typeof err !== 'object' || err === null)
+        return null;
+    let code;
+    try {
+        code = err.errorCode;
+    }
+    catch {
+        return null;
+    }
+    if (code !== CHECKPOINT_UNSUPPORTED_VERSION || !refusalSaysStillPending(err))
+        return null;
+    return { code: CHECKPOINT_UNSUPPORTED_VERSION, retriable: true };
+}
+function checkpointUnsupportedHasRun(kind) {
+    switch (kind) {
+        case 'tool_approval':
+        case 'plan_review':
+        case 'resource_park':
+            return true;
+        case 'wake':
+        case 'workflow_host':
+            return false;
+        default:
+            return undefined;
+    }
+}
+const CHECKPOINT_UNSUPPORTED_WHAT = 'This server cannot continue this parked work in the form it was stored in';
+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 kind;
+    let runId;
+    try {
+        kind = ctx?.parkKind;
+        runId = ctx?.runId;
+    }
+    catch {
+        kind = undefined;
+        runId = undefined;
+    }
+    const hasRun = checkpointUnsupportedHasRun(kind);
+    let outlet;
+    if (hasRun === true) {
+        const named = typeof runId === 'string' && runId.length > 0 ? ` (${capForDisplay(runId, 80)})` : '';
+        outlet = `If it was parked before this server was upgraded, cancel its run${named} first, then submit the work again as a new task`;
+    }
+    else if (hasRun === false) {
+        outlet = 'If it was parked before this server was upgraded, there is no run to cancel: start a new task in that conversation';
+    }
+    else {
+        outlet =
+            'If it was parked before this server was upgraded, submit the work again as a new task: when it still has a run waiting on it (a tool approval, a plan review or a paused resource), cancel that run first; when it was waiting to be woken up, or was a workflow step continuing its host conversation, there is no run to cancel, so start a new task in that conversation';
+    }
+    return [CHECKPOINT_UNSUPPORTED_WHAT, CHECKPOINT_UNSUPPORTED_STILL_WAITING, outlet + CHECKPOINT_UNSUPPORTED_DRAIN].join(' · ');
+}

package/dist/rewindArchiveCapability.js

@@ -109,17 +109,17 @@ export function rewindConversationDoctorDetail(reading) {
 }
 export function rewindRestoreFilesEpochDetail(reading) {
     if (reading.kind !== 'present') {
-        return 'restore-files request spelling not observed — this process has no usable capabilities reading for this engine';
+        return 'restore-files request key not observed — this process has no usable capabilities reading for this engine, so a rewind with code restore still sends the key';
     }
     switch (reading.restoreFilesEpoch) {
         case 'on':
             return 'this engine announces the restore-files request key (tracked-set restore semantics)';
         case 'off':
-            return 'this engine does not announce the restore-files request key; the client sends it anyway because the older spelling is rejected outright by current engines';
+            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); the client sends the current spelling regardless';
+            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';
         case 'malformed':
-            return 'the restore-files epoch bit is reported in an unreadable shape; the client sends the current spelling regardless';
+            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) {

package/dist/rewindWireCaps.d.ts

@@ -1,3 +1,4 @@
+import type { RewindArchiveReading } from './rewindArchiveCapability.js';
 export interface SeamRewindSpec {
     resumeAt?: string;
     resumeAtMode?: 'at' | 'before';
@@ -5,5 +6,5 @@ export interface SeamRewindSpec {
     rewindFilesTo?: string;
 }
 export type RewindMode = 'both' | 'conversation' | 'code';
-export declare function rewindSpecForMode(mode: RewindMode, targetEntryId: string): SeamRewindSpec;
+export declare function rewindSpecForMode(mode: RewindMode, targetEntryId: string, reading?: RewindArchiveReading): SeamRewindSpec;
 export declare function projectRewind(pending: SeamRewindSpec | undefined): SeamRewindSpec;