@sema-agent/client-core 0.86.0 → 0.88.0

package/dist/promptDelivery.js

@@ -0,0 +1,153 @@
+import { activeRunBusySignal } from './adapter/runStream.js';
+import { selfHealSubmissionDisposition } from './adapter/activeRunSelfHeal.js';
+const uuidOk = (u) => typeof u === 'string' && u.length > 0;
+function cleanBatch(batch) {
+    if (!Array.isArray(batch))
+        return [];
+    const out = [];
+    const seen = new Set();
+    try {
+        for (const u of batch) {
+            if (!uuidOk(u) || seen.has(u))
+                continue;
+            seen.add(u);
+            out.push(u);
+        }
+    }
+    catch {
+        return [];
+    }
+    return out;
+}
+function readRecord(rec) {
+    if (typeof rec !== 'object' || rec === null || Array.isArray(rec))
+        return undefined;
+    try {
+        const u = rec.u;
+        const s = rec.s;
+        return uuidOk(u) && (s === 'a' || s === 'd') ? { u, s } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const PRE_RUN_FRAME_TYPES = new Set(['meta', 'approval_request', 'approval_revoke']);
+function frameProvesDelivery(event) {
+    if (typeof event !== 'object' || event === null || Array.isArray(event))
+        return false;
+    try {
+        const type = event.type;
+        if (typeof type !== 'string' || type.length === 0 || PRE_RUN_FRAME_TYPES.has(type))
+            return false;
+        if (type === 'done') {
+            const result = event.result;
+            if (typeof result === 'object' && result !== null && !Array.isArray(result) && result.status === undefined) {
+                const r = result;
+                if (activeRunBusySignal({ type: 'failed', errorCode: r.errorCode, activeTaskId: r.activeTaskId }) !== null)
+                    return false;
+            }
+        }
+        return activeRunBusySignal(event) === null;
+    }
+    catch {
+        return false;
+    }
+}
+function outcomeProvesDelivery(outcome) {
+    if (typeof outcome !== 'object' || outcome === null || Array.isArray(outcome))
+        return false;
+    try {
+        return selfHealSubmissionDisposition(outcome) === 'handed-off';
+    }
+    catch {
+        return false;
+    }
+}
+export function createPromptDeliveryLedger() {
+    const attemptedSet = new Set();
+    const deliveredSet = new Set();
+    const batchOfMap = new Map();
+    const log = [];
+    const add = (u, s, into) => {
+        const set = s === 'a' ? attemptedSet : deliveredSet;
+        if (set.has(u))
+            return;
+        set.add(u);
+        const rec = Object.freeze({ u, s });
+        log.push(rec);
+        into.push(rec);
+    };
+    const markDelivered = (batchUuids) => {
+        const added = [];
+        for (const u of cleanBatch(batchUuids))
+            add(u, 'd', added);
+        return Object.freeze(added);
+    };
+    return Object.freeze({
+        attempted(batchUuids) {
+            const batch = Object.freeze(cleanBatch(batchUuids));
+            const added = [];
+            for (const u of batch) {
+                batchOfMap.set(u, batch);
+                add(u, 'a', added);
+            }
+            return Object.freeze(added);
+        },
+        deliveredByFrame(batchUuids, event) {
+            return frameProvesDelivery(event) ? markDelivered(batchUuids) : Object.freeze([]);
+        },
+        deliveredBySteerReceipt(batchUuids, outcome) {
+            return outcomeProvesDelivery(outcome) ? markDelivered(batchUuids) : 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),
+        batchOf: (uuid) => (uuidOk(uuid) ? batchOfMap.get(uuid) : undefined),
+        toRecords: () => Object.freeze([...log]),
+        fromRecords(records) {
+            const added = [];
+            if (!Array.isArray(records))
+                return Object.freeze(added);
+            let list;
+            try {
+                list = [...records];
+            }
+            catch {
+                return Object.freeze(added);
+            }
+            for (const raw of list) {
+                const rec = readRecord(raw);
+                if (rec !== undefined)
+                    add(rec.u, rec.s, added);
+            }
+            return Object.freeze(added);
+        },
+    });
+}
+function uuidOfMessage(m) {
+    if (typeof m !== 'object' || m === null)
+        return undefined;
+    try {
+        const u = m.uuid;
+        return uuidOk(u) ? u : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function assertLedger(ledger, fn) {
+    if (typeof ledger !== 'object' || ledger === null || typeof ledger.knownUndelivered !== 'function') {
+        throw new TypeError(`${fn}: the first argument must be a ledger from createPromptDeliveryLedger()`);
+    }
+}
+export function promptKnownUndelivered(ledger, message) {
+    assertLedger(ledger, 'promptKnownUndelivered');
+    const u = uuidOfMessage(message);
+    return u !== undefined && ledger.knownUndelivered(u);
+}
+export function withoutUndeliveredPrompts(ledger, messages) {
+    assertLedger(ledger, 'withoutUndeliveredPrompts');
+    if (!Array.isArray(messages))
+        return [];
+    return messages.filter((m) => !promptKnownUndelivered(ledger, m));
+}

package/dist/registryConflict.d.ts

@@ -0,0 +1,3 @@
+export type RegistryConflictClass = 'gone' | 'conflict' | 'none';
+export declare function classifyRegistryConflict(status: number, body: unknown): RegistryConflictClass;
+export declare function isScopeGoneError(err: unknown): boolean;

package/dist/registryConflict.js

@@ -0,0 +1,44 @@
+const SCOPE_GONE_CODE = 'scope_gone';
+const nonBlank = (v) => {
+    const s = typeof v === 'string' ? v.trim() : '';
+    return s === '' ? undefined : s;
+};
+export function classifyRegistryConflict(status, body) {
+    if (status !== 409)
+        return 'none';
+    try {
+        const b = (typeof body === 'object' && body !== null ? body : {});
+        const error = b.error;
+        const objectForm = typeof error === 'object' && error !== null ? error.code : undefined;
+        const code = nonBlank(b.errorCode) ?? nonBlank(objectForm) ?? (typeof error === 'string' ? error : undefined);
+        return code === SCOPE_GONE_CODE ? 'gone' : 'conflict';
+    }
+    catch {
+        return 'gone';
+    }
+}
+const SCOPE_GONE_ERROR_NAMES = Object.freeze(['ScopeGoneError', 'ControlScopeGoneError']);
+export function isScopeGoneError(err) {
+    if ((typeof err !== 'object' && typeof err !== 'function') || err === null)
+        return false;
+    let status;
+    try {
+        status = err.status;
+    }
+    catch {
+        return false;
+    }
+    if (status !== 409)
+        return false;
+    try {
+        const o = err;
+        const body = o.body;
+        if (body !== undefined && body !== null && classifyRegistryConflict(409, body) === 'gone')
+            return true;
+        const name = o.name;
+        return typeof name === 'string' && SCOPE_GONE_ERROR_NAMES.includes(name);
+    }
+    catch {
+        return true;
+    }
+}

package/dist/request/taskRequest.d.ts

@@ -50,6 +50,7 @@ export interface TaskRequestInput {
     memory?: 'off';
     fileHistory?: 'disabled';
     inheritEnv?: InheritEnvWord;
+    requireExistingSession?: TaskRequest['requireExistingSession'];
     rewind?: Record<string, unknown>;
     repo?: string;
     council?: boolean;

package/dist/request/taskRequest.js

@@ -24,6 +24,7 @@ export const REQUEST_FIELD_MATRIX = [
     { field: 'memory', lanes: ['interactive', 'print', 'utility'], live: true, why: '这一次运行不挂记忆面的**请求级**开关(server §12.7 body 键,单成员闭集 "off");每条车道都是提交面 ⇒ 都能声明。与 memoryCapture(采集面)不是一个轴、可并存;与 memoryWrite:false(只读平面)也不是一个轴', whyUtilityLane: '有座:side-channel 提交不需要挂记忆面(不挂记忆段 / 索引 / 三只记忆工具),省 token 且零记忆写入;与 memoryCapture 不是一个轴,两条都带' },
     { field: 'fileHistory', lanes: ['interactive', 'print'], live: true, why: '「这一次运行别捕获文件历史」的**请求级声明**(server 7.104.0 提交体键,单成员闭集 "disabled";`POST /v1/tasks` · `/v1/tasks/stream` · `/v1/runs` 同收,子代继承)。两条用户车道都是提交面、都跑在用户的文件上 ⇒ 都能声明;「本会话不捕获」= 每个提交都带(续跑腿重放同一个体)。🔴 只在能力读数 `on-optional` 时发(老 server 对表外键 400),值由片段口 `fileHistoryDeclarationField` 唯一铸出。与 rewind 还原键同交 ⇒ 上游 400 `request.field_conflict`', whyUtilityLane: '无座:side-channel 强制零工具面(`excludeAllTools`),不会改任何文件 ⇒ 没有可捕获的东西;带上它只会在不认识这一键的老 server 上给这条提交多一种 400' },
     { field: 'inheritEnv', lanes: ['interactive', 'print'], live: true, why: '模型驱动的宿主 shell「继承多少用户环境」的**请求级声明**(server 7.106.0 提交体键,两词闭集 "all" / "scrub";`POST /v1/tasks` · `/v1/tasks/stream` · `/v1/runs` 同收,续跑腿重放同判)。两条用户车道都是提交面、都可能在用户机器上跑 shell ⇒ 都能声明。本层两词原样透传、不按车道 / 部署预判(非 host 车道 × "all" 400、托管 × "all" 422 归上游判)。🔴 缺席 = 缺省清洗且清掉本会话上一条声明 ⇒ 要「本会话整份继承」就每个提交都带。🔴 只在服务端版本 ≥ 7.106.0 时发(老 server 对表外键整条 400),值由片段口 `inheritEnvDeclaration` 唯一铸出', whyUtilityLane: '无座:side-channel 强制零工具面(`excludeAllTools`),没有模型驱动的 shell 去继承环境;带上它只会在不认这一键的老服务端上给这条提交多一种 400' },
+    { field: 'requireExistingSession', lanes: ['interactive', 'print'], live: true, why: '「只续已有会话」的**请求级断言**(sdk `TaskRequest.requireExistingSession`):`true` 且会话不在 ⇒ 服务端在任何东西跑起来之前拒(会话不在 / 没给会话 id 两形),而**不是**静默新开一个同 id 的空会话;缺席 / `false` = 历史的「找不到就新开」。两条用户车道都有「续某个会话」的入口 ⇒ 都能声明。本层只认字面 `true`(`false` 与缺席同义、不发);非布尔坏值响亮拒(上游对它 400);`true` 而入参没有可续的会话 id ⇒ 装配期按名响亮拒,不留给上游。上游两形的拒绝经 `requireExistingSessionRefusalFromError` 归成一句', whyUtilityLane: '无座:side-channel 每一次提交都走壳另铸的**独立**会话 id(见 sessionId 那一行),从不续任何已有会话 ⇒「必须已存在」对它没有意义,带上去只会让每一次提交都被拒' },
     { field: 'finalVerification', lanes: ['print'], live: true, why: 'P1-1 终验:无人值守车道才需要引擎自证;交互 REPL 由人当场看结果。#106 裁 B(让位+告知)后交互面默认关', whyUtilityLane: '无座:终验让引擎再跑一轮自证,而 side-channel 要的是一次小提交的即时答案;「无人值守才需要引擎自证」这条理由在本车道上让位给「小预算优先」' },
     { field: 'limits', lanes: ['print', 'utility'], live: true, why: 'P2-3-b:`-p` 的预算护栏(--max-* flag 族),交互 REPL 由人随时 Esc', whyUtilityLane: '有座:side-channel 必须带预算护栏(墙钟 / 输出 token / 轮数)—— 它同样没有人看着,而且没有后续回合可以中断' },
     { field: 'interactiveTools', lanes: ['print', 'utility'], live: true, why: '[909]B 件3:无人值守 stamp false,从 roster 源头灭掉 AskUserQuestion/plan 门。交互车道 stamp false 等于自废武功', whyUtilityLane: '有座:side-channel 绝不该弹交互问答 / plan 门(没有人在看这条提交)。它与 excludeAllTools 是**两条独立**的收紧声明、在这条车道上**并存**(本车道强制带卸载声明,见 `refuseUtilityWithoutToolUnload`;这一位是它旁边那条「连问都别问」的声明,不是它的降级替身)' },
@@ -139,6 +140,7 @@ const INPUT_KEY_ROUTES = {
     memory: row('memory'),
     fileHistory: row('fileHistory'),
     inheritEnv: row('inheritEnv'),
+    requireExistingSession: row('requireExistingSession'),
     rewind: row('resumeAt/resumeAtMode/restoreFiles/rewindFilesTo'),
     repo: row('repo'),
     council: row('council'),
@@ -211,6 +213,7 @@ const VALUE_LEVEL_IN_PLAY = Object.freeze({
     memoryCapture: (v) => v === 'off',
     memory: (v) => v === 'off',
     fileHistory: (v) => v === FILE_HISTORY_DISABLED,
+    requireExistingSession: (v) => v === true,
     rewind: (v) => typeof v === 'object' && v !== null && rewindSubKeys().some((k) => hasOwn(v, k) && present(v[k])),
 });
 const inPlay = (key, v) => present(v) && (VALUE_LEVEL_IN_PLAY[key]?.(v) ?? true);
@@ -454,6 +457,22 @@ const refuseBadInheritEnv = (v) => {
         '这一位是「模型驱动的宿主 shell 继承多少用户环境」的两词闭集声明,上游对词表外的值响亮拒;环境变量名单不是请求值。' +
         '本层若静默删键,这一次运行会按缺省清洗跑、还清掉本会话上一条声明,而声明人不会知道。错误文本只报形状,不回显值。');
 };
+const refuseBadRequireExistingSession = (v) => {
+    if (v === undefined || v === null || v === true || v === false)
+        return;
+    throw new TypeError(`buildTaskRequest: requireExistingSession 只接受布尔或缺席(undefined/null)—— 收到 ${coarseShape(v)}。` +
+        '这一位是「只续已有会话、找不到就失败」的收紧断言:本层若把坏值折成缺席,这一次提交在会话不在时会静默新开一个空会话 —— 正是这一键要挡的那一形;' +
+        '上游对非布尔值同样拒收。错误文本只报形状,不回显值。');
+};
+const hasResumableSessionId = (sid) => typeof sid === 'string' && sid.length > 0;
+const refuseRequireExistingWithoutSession = (requireExisting, sessionId) => {
+    if (requireExisting !== true || hasResumableSessionId(sessionId))
+        return;
+    const shape = sessionId === undefined ? '缺席' : typeof sessionId === 'string' ? '空串' : coarseShape(sessionId);
+    throw new TypeError(`buildTaskRequest: requireExistingSession: true 要求续一个已存在的会话,但 sessionId ${shape} —— 没有可续的会话。` +
+        '上游对这一形同样拒收(不会新开会话,也不会续上任何东西);本层在装配前拒,不让它走一次往返。' +
+        '处置:要续哪个会话,就把它的 id 交在 sessionId 上;要开新会话,就别带 requireExistingSession(或给 false)。错误文本只报形状,不回显值。');
+};
 const refuseBadMaxTokens = (v) => {
     if (v === undefined || v === null)
         return;
@@ -523,7 +542,7 @@ export function parseMaxCostUsd(text) {
         return { ok: false, why: 'not_positive' };
     return { ok: true, value };
 }
-const ACCESSOR_READ_ORDER = ['live', 'memoryCapture', 'memory', 'settings', 'maxCostUsd', 'excludeAllTools', 'maxTokens', 'outputRetries', 'fileHistory', 'inheritEnv'];
+const ACCESSOR_READ_ORDER = ['live', 'memoryCapture', 'memory', 'settings', 'maxCostUsd', 'excludeAllTools', 'maxTokens', 'outputRetries', 'fileHistory', 'inheritEnv', 'requireExistingSession'];
 function dataFirstSnapshot(input, afterData) {
     let descs;
     try {
@@ -592,6 +611,7 @@ export function assembleTaskRequest(input, lane) {
     const outputRetriesIn = src.outputRetries;
     const fileHistoryIn = src.fileHistory;
     const inheritEnvIn = src.inheritEnv;
+    const requireExistingSessionIn = src.requireExistingSession;
     const INPUT_KEYS = Object.keys(INPUT_KEY_ROUTES);
     const i = snapshotByName(src, INPUT_KEYS, {
         live,
@@ -603,6 +623,7 @@ export function assembleTaskRequest(input, lane) {
         outputRetries: outputRetriesIn,
         fileHistory: fileHistoryIn,
         inheritEnv: inheritEnvIn,
+        requireExistingSession: requireExistingSessionIn,
         settings: settingsIn,
     });
     const SETTINGS_KEYS = Object.keys(SETTINGS_KEY_ROUTES);
@@ -615,6 +636,7 @@ export function assembleTaskRequest(input, lane) {
     refuseBadOutputRetries(outputRetriesIn);
     refuseBadFileHistory(fileHistoryIn);
     refuseBadInheritEnv(inheritEnvIn);
+    refuseBadRequireExistingSession(requireExistingSessionIn);
     const rewindRoute = INPUT_KEY_ROUTES.rewind;
     const RETIRED_REWIND_FILES_KEY = 'rewindFiles';
     const REWIND_KEYS = rewindRoute.via === 'matrix' ? rewindRoute.field.split('/') : [];
@@ -698,6 +720,7 @@ export function assembleTaskRequest(input, lane) {
             '想问某个键有没有座 ⇒ taskRequestSeatOf(key, lane)。`settings` 快照里的开放集子键放进 settings.resolved。' +
             '错误文本只报键名,不回显值。');
     }
+    refuseRequireExistingWithoutSession(requireExistingSessionIn, i.sessionId);
     refuseUtilityWithoutToolUnload(lane, excludeAllToolsIn);
     const carries = (route, value, key) => {
         if (route.via === 'always')
@@ -772,6 +795,7 @@ export function assembleTaskRequest(input, lane) {
         ...(on('memory') ? { memory: 'off' } : {}),
         ...(on('fileHistory') ? { fileHistory: FILE_HISTORY_DISABLED } : {}),
         ...(on('inheritEnv') ? { inheritEnv: inheritEnvIn } : {}),
+        ...(on('requireExistingSession') ? { requireExistingSession: true } : {}),
         ...(Object.keys(settingsOut).length > 0 ? { settings: settingsOut } : {}),
     };
     return Object.freeze({ request: out, omitted: Object.freeze([...omitted, ...lateOmitted]) });

package/dist/resumeRefusalCopy.d.ts

@@ -19,13 +19,15 @@ export interface ResumePolicyBlockDetail {
 }
 export declare function resumePolicyBlockFromError(err: unknown): ResumePolicyBlockDetail | null;
 export declare function resumePolicyBlockContent(detail: ResumePolicyBlockDetail): string;
-export interface ResumeReopenDetail {
-    code: string;
-    reason: 'env_failed' | 'tool_unavailable' | 'tool_contract_mismatch';
-    retriable: true;
+export { resumeReopenFromError, resumeReopenContent } from './hitl/suspendedReopen.js';
+export type { ResumeReopenDetail } from './hitl/suspendedReopen.js';
+export type RequireExistingSessionRefusalForm = 'session_not_found' | 'session_id_missing';
+export interface RequireExistingSessionRefusalDetail {
+    readonly code: string;
+    readonly form: RequireExistingSessionRefusalForm;
 }
-export declare function resumeReopenFromError(err: unknown): ResumeReopenDetail | null;
-export declare function resumeReopenContent(detail: ResumeReopenDetail): string;
+export declare function requireExistingSessionRefusalFromError(err: unknown): RequireExistingSessionRefusalDetail | null;
+export declare function requireExistingSessionRefusalContent(detail: Pick<RequireExistingSessionRefusalDetail, 'form'>): string;
 export interface ResumeContextUnavailableDetail {
     code: typeof RESUME_CONTEXT_UNAVAILABLE;
     staleAfterSec?: number;

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_REOPEN_CODES, RESUME_ENV_FAILED, RESUME_TOOL_UNAVAILABLE, RESUME_POLICY_FOLD_CODE, PARKED_RESUME_STARTUP_FAILED, isStatusDerivedCoarseCode, } 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, } from './engineErrorCodes.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { resumeRetryLaterFromError } from './wireErrorTriage.js';
 export const RESUME_REFUSAL_CODES = Object.freeze([
@@ -85,28 +85,50 @@ export function resumePolicyBlockContent(detail) {
         "This refusal does not say whether anything was consumed before it or whether a retry would pass — check the task's current state before deciding again, and ask whoever operates this deployment if it keeps happening",
     ].join(' · ');
 }
-export function resumeReopenFromError(err) {
+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' })],
+]);
+export function requireExistingSessionRefusalFromError(err) {
     if (typeof err !== 'object' || err === null)
         return null;
-    const code = err.errorCode;
-    if (typeof code !== 'string' || !RESUME_REOPEN_CODES.includes(code))
-        return null;
-    if (err.retriable !== true)
+    try {
+        const o = err;
+        const status = o['status'];
+        const byStatus = typeof status === 'number' ? REQUIRE_EXISTING_BY_STATUS.get(status) : undefined;
+        if (byStatus === undefined)
+            return null;
+        const code = o['errorCode'];
+        if (code === RESUME_SESSION_NOT_FOUND)
+            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;
+    }
+    catch {
         return null;
-    const reason = code.slice('resume.'.length);
-    return { code, reason, retriable: true };
+    }
 }
-export function resumeReopenContent(detail) {
-    const first = detail.code === RESUME_ENV_FAILED
-        ? 'The execution environment for this parked work could not be brought back'
-        : detail.code === RESUME_TOOL_UNAVAILABLE
-            ? 'The tool this approval was granted for is not available on this engine'
-            : 'The tool this approval was granted for has changed since the approval was recorded';
-    return [
-        first,
-        'The engine re-parked the work before consuming anything — the approval is still pending and your decision was not consumed',
-        'Re-fetch the pending approvals and decide again on an engine where the same tool is available',
-    ].join(' · ');
+const REQUIRE_EXISTING_SESSION_SENTENCES = Object.freeze({
+    session_not_found: 'The engine did not continue this conversation: the conversation it was asked to continue does not exist there (it may have expired, been removed, or never been created on that engine), and this request asked to continue only an existing one, so no new conversation was started · Start a new conversation, or pick another one to continue',
+    session_id_missing: 'The engine did not continue this conversation: this request asked to continue only an existing conversation but named none, so there was nothing to continue and no new conversation was started · Name the conversation to continue, or start a new one',
+});
+const REQUIRE_EXISTING_SESSION_GENERIC = 'The engine did not continue this conversation: this request asked to continue only an existing conversation and there was none it could continue, so no new conversation was started · Start a new conversation, or pick another one to continue';
+export function requireExistingSessionRefusalContent(detail) {
+    try {
+        const form = detail?.form;
+        return typeof form === 'string' && Object.hasOwn(REQUIRE_EXISTING_SESSION_SENTENCES, form)
+            ? REQUIRE_EXISTING_SESSION_SENTENCES[form]
+            : REQUIRE_EXISTING_SESSION_GENERIC;
+    }
+    catch {
+        return REQUIRE_EXISTING_SESSION_GENERIC;
+    }
 }
 export function resumeContextUnavailableFromError(err) {
     if (typeof err !== 'object' || err === null)

package/dist/rewindArchiveCapability.js

@@ -1,5 +1,6 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { _wireConversationRewindJudge } from './toolHistoryMismatch.js';
 const CAPS_KEYS = {
     conversationAnchor: 'resumeAt',
     forkRestore: 'rewindFiles',
@@ -37,8 +38,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));
+}
 export function observedRewindArchive(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }

package/dist/seam.d.ts

@@ -3,6 +3,7 @@ import type { EngineTurnUsage } from './adapter/downstream/turnUsageToModelUsage
 import type { RunCostReconcile } from './adapter/downstream/terminalToSdkResult.js';
 import type { WiringManifestAutoMode, WiringManifestModelGate, WiringManifestMcpEntryView, WiringManifestHookEntryView, WiringManifestLspSeamView, WiringManifestWriteProtectionView, WiringManifestAutoConsolidationView, WiringManifestReadDenyView, ContextUsageSectionView, PromptManifestSectionView, PromptManifestBlockView, PromptManifestToolView } from './adapter/downstream/eventToSdkMessage.js';
 import type { ToolRosterView, ToolRosterDeltaView, WiringManifestHandsView } from './toolRoster.js';
+import type { SuspendedReopenReading } from './hitl/suspendedReopen.js';
 export interface AbortSignalLike {
     readonly aborted: boolean;
 }
@@ -149,7 +150,16 @@ export type ChromeEvent = {
 } | ({
     kind: 'run_cost_reconciled';
     laneProof: LaneProof;
-} & RunCostReconcile) | HumanInputChromeEvent | MessageCommittedChromeEvent | EngineNoticeChromeEvent | TextSegmentEndChromeEvent | ThinkingSegmentEndChromeEvent | ToolDisclosureChromeEvent | ToolProgressChromeEvent | ToolRosterDeltaChromeEvent | ContextUsageChromeEvent | CompactionOutcomeChromeEvent | PromptAssembledChromeEvent | MemorySavedChromeEvent | WiringManifestChromeEvent | ResultTextDivergedChromeEvent | ApprovalRequestChromeEvent | ApprovalRevokeChromeEvent;
+} & RunCostReconcile) | HumanInputChromeEvent | MessageCommittedChromeEvent | EngineNoticeChromeEvent | TextSegmentEndChromeEvent | ThinkingSegmentEndChromeEvent | ToolDisclosureChromeEvent | ToolProgressChromeEvent | ToolRosterDeltaChromeEvent | ContextUsageChromeEvent | CompactionOutcomeChromeEvent | PromptAssembledChromeEvent | MemorySavedChromeEvent | WiringManifestChromeEvent | ResultTextDivergedChromeEvent | ApprovalRequestChromeEvent | ApprovalRevokeChromeEvent | {
+    kind: 'suspended_reopened';
+    laneProof: LaneProof;
+    reopen: Extract<SuspendedReopenReading, {
+        kind: 'reopened';
+    }>;
+    content?: string;
+    eventId?: string;
+    taskId?: string;
+};
 export interface WiringManifestChromeEvent {
     kind: 'wiring_manifest';
     laneProof: LaneProof;
@@ -163,6 +173,7 @@ export interface WiringManifestChromeEvent {
     autoConsolidation?: WiringManifestAutoConsolidationView;
     readDeny?: WiringManifestReadDenyView;
     hands?: WiringManifestHandsView;
+    fileHistory?: string;
     eventId?: string;
 }
 export interface TextSegmentCommittedRow {

package/dist/seam.js

@@ -126,6 +126,13 @@ const CHROME_ARM_TABLE = {
             '🔴 账本重放的历史帧只用于时间线渲染,卡集的全量对账基准是开流 preamble(它带的 expiresInMs 是铸帧时刻的旧值);' +
             'card 的 message/args 是模型/工具产文,只渲染永不回喂模型',
     },
+    suspended_reopened: {
+        required: false,
+        duty: '可选:引擎确认把一次已送出的决定重新挂回待决 ⇒ 上屏一句「决定没被消费、再决一次」(`content`,单源句;缺席 = 码不在 reopen 族闭集,可照 `reopen.code` 原词显示,开集按成员渲染必带 default 臂)。' +
+            '🔴 按 `eventId` 幂等(同一条流的重放本包已去重;前台腿与接管腿各发一条、同 eventId,去重归宿主);' +
+            '🔴 接管 / 从头重放的腿:本臂之后同流又来「门已不在」的帧(text / tool_start / turn_end / done / failed 或新的挂起)⇒ 那次重开是历史,别当现状上屏;会话已切走的别补发 —— 这两件归宿主判;' +
+            '明说没重开 / 老引擎缺键一条都不发,本臂没来 ≠ 确认没重开;`taskId` 只在帧上自带时在场',
+    },
     approval_revoke: {
         required: true,
         duty: '用 sdk isApprovalRevokeFrameV1 窄化 frame 取 batchId/askIds/taskId;窄不下来按通用撤卡处理(该批本地卡照清);' +

package/dist/sessionMemoryErase.d.ts

@@ -0,0 +1,76 @@
+import type { EngineWireClientConfig } from './engineWireSdk.js';
+import type { MemoryEraseReceiptReading, MemoryEraseUnreadableCause } from './memoryEntriesWire.js';
+export type SessionMemoryEraseWire = Pick<EngineWireClientConfig, 'baseUrl' | 'token' | 'principal' | 'timeoutMs' | 'fetchImpl'>;
+export interface SessionMemoryEraseCall {
+    sessionId: string;
+    requestId: string;
+    allowUnevidenced?: boolean;
+}
+export interface SessionMemoryEraseOptions {
+    signal?: AbortSignal | null;
+}
+export interface SessionMemoryEraseSent {
+    sessionId: string;
+    requestId: string;
+    allowUnevidenced?: boolean;
+}
+export type SessionMemoryEraseNotSentWhy = 'bad_input' | 'no_connection' | 'cancelled';
+export type SessionMemoryEraseJson = null | boolean | number | string | readonly SessionMemoryEraseJson[] | {
+    readonly [key: string]: SessionMemoryEraseJson;
+};
+export type SessionMemoryEraseAnswer = {
+    kind: 'not_sent';
+    why: SessionMemoryEraseNotSentWhy;
+    detail: string;
+} | {
+    kind: 'answered';
+    sent: SessionMemoryEraseSent;
+    status: number;
+    body: SessionMemoryEraseJson | undefined;
+} | {
+    kind: 'no_answer';
+    sent: SessionMemoryEraseSent;
+    detail: string;
+};
+export declare function eraseSessionMemory(call: SessionMemoryEraseCall, wire: SessionMemoryEraseWire, opts?: SessionMemoryEraseOptions): Promise<SessionMemoryEraseAnswer>;
+export type SessionMemoryEraseRefusalReason = 'bad_input' | 'no_connection' | 'cancelled_before_send' | 'credentials_required' | 'not_permitted' | 'memory_engine_absent' | 'session_not_found' | 'route_absent' | 'request_rejected' | 'evidence_unavailable' | 'request_id_reused' | 'store_unreadable';
+export type SessionMemoryEraseUnconfirmedWhy = 'no_answer' | 'receipt_unreadable' | 'receipt_mismatch' | 'store_link_outside' | 'control_plane_corrupt' | 'engine_fault' | 'unclassified' | 'no_code' | 'unreadable';
+export type SessionMemoryEraseRetry = 'not_needed' | 'same_request_id' | 'new_request_id' | 'needs_operator' | 'needs_consent' | 'human_decision' | 'pointless';
+type SessionMemoryEraseReceipt = Extract<MemoryEraseReceiptReading, {
+    kind: 'present';
+}>;
+export type SessionMemoryEraseOutcome = {
+    kind: 'erased';
+    receipt: SessionMemoryEraseReceipt;
+    text: string;
+    retry: 'not_needed';
+    retryText: string;
+} | {
+    kind: 'partial';
+    receipt: SessionMemoryEraseReceipt;
+    text: string;
+    retry: 'same_request_id' | 'human_decision';
+    retryText: string;
+} | {
+    kind: 'refused';
+    reason: SessionMemoryEraseRefusalReason;
+    text: string;
+    retry: SessionMemoryEraseRetry;
+    retryText: string;
+    status?: number;
+    errorCode?: string;
+} | {
+    kind: 'unconfirmed';
+    why: SessionMemoryEraseUnconfirmedWhy;
+    text: string;
+    retry: SessionMemoryEraseRetry;
+    retryText: string;
+    status?: number;
+    errorCode?: string;
+    receiptWhy?: MemoryEraseUnreadableCause;
+};
+export declare const SESSION_MEMORY_ERASE_REFUSAL_REASONS: readonly SessionMemoryEraseRefusalReason[];
+export declare const SESSION_MEMORY_ERASE_UNCONFIRMED_WHYS: readonly SessionMemoryEraseUnconfirmedWhy[];
+export declare const SESSION_MEMORY_ERASE_RETRIES: readonly SessionMemoryEraseRetry[];
+export declare function sessionMemoryEraseOutcome(answer: SessionMemoryEraseAnswer): SessionMemoryEraseOutcome;
+export {};