@sema-agent/client-core 0.87.0 → 0.89.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/providerRejection.d.ts

@@ -0,0 +1,6 @@
+import { type RunTerminalFailureDetail } from './runTerminal.js';
+export interface ProviderRejectionResend {
+    resend: 'edit_and_resend' | 'not_by_editing';
+    text: string;
+}
+export declare function providerRejectionResend(detail: RunTerminalFailureDetail | null | undefined): ProviderRejectionResend | undefined;

package/dist/providerRejection.js

@@ -0,0 +1,52 @@
+import { readRunTerminal } from './runTerminal.js';
+const PROVIDER_STATUS_TIERS = Object.freeze([
+    Object.freeze([400, 400, 'invalid_request']),
+    Object.freeze([401, 401, 'authentication_failed']),
+    Object.freeze([403, 403, 'authentication_failed']),
+    Object.freeze([404, 404, 'model_not_found']),
+    Object.freeze([413, 413, 'invalid_request']),
+    Object.freeze([422, 422, 'invalid_request']),
+    Object.freeze([429, 429, 'rate_limit']),
+    Object.freeze([500, 599, 'server_error']),
+]);
+const UNTIERED = 'unknown';
+function providerStatusTier(status) {
+    for (const [lo, hi, tier] of PROVIDER_STATUS_TIERS)
+        if (status >= lo && status <= hi)
+            return tier;
+    return UNTIERED;
+}
+const EDITABLE_TIER = 'invalid_request';
+const NOT_BY_EDITING_TAIL = new Map([
+    ['authentication_failed', ': check the provider credentials or access for this account.'],
+    ['model_not_found', ': the model is not available from this provider — choose another model.'],
+    ['rate_limit', ': the provider is rate-limiting this account — wait and try again.'],
+    ['server_error', ': the provider reported an internal error — try again later.'],
+    [UNTIERED, ' for a reason that editing it will not fix — check the provider account or try again later.'],
+]);
+const PROVIDER_REJECTED = 'provider_rejected';
+export function providerRejectionResend(detail) {
+    let read;
+    try {
+        const r = readRunTerminal({ terminal: { kind: 'failed', detail } });
+        read = r !== null && r.kind === 'failed' && Object.hasOwn(r, 'detail') ? r.detail : undefined;
+    }
+    catch {
+        return undefined;
+    }
+    if (read === undefined || !Object.hasOwn(read, 'kind') || read.kind !== PROVIDER_REJECTED)
+        return undefined;
+    const status = Object.hasOwn(read, 'status') ? read.status : undefined;
+    if (status === undefined)
+        return undefined;
+    const tier = providerStatusTier(status);
+    return tier === EDITABLE_TIER
+        ? {
+            resend: 'edit_and_resend',
+            text: `The model provider rejected this request as sent (HTTP ${status}). Change it — for example shorten it or remove an attachment — and send it again.`,
+        }
+        : {
+            resend: 'not_by_editing',
+            text: `The model provider refused this request (HTTP ${status})${NOT_BY_EDITING_TAIL.get(tier) ?? NOT_BY_EDITING_TAIL.get(UNTIERED) ?? ''}`,
+        };
+}

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,8 @@ export interface TaskRequestInput {
     memory?: 'off';
     fileHistory?: 'disabled';
     inheritEnv?: InheritEnvWord;
+    requireExistingSession?: TaskRequest['requireExistingSession'];
+    disableSkills?: true;
     rewind?: Record<string, unknown>;
     repo?: string;
     council?: boolean;
@@ -73,6 +75,7 @@ export interface TaskRequestOmission {
 export declare function taskRequestOmissionCauseDetail(cause: unknown): string;
 export declare const TASK_REQUEST_OMISSION_CAUSE_NOTICES: Readonly<Record<TaskRequestOmissionCause, string>>;
 export declare function taskRequestOmissionCauseNotice(cause: unknown): string;
+export declare function taskRequestOmissionCausePhrase(cause: unknown): string;
 export interface TaskRequestAssembly {
     readonly request: TaskRequestLike;
     readonly omitted: readonly TaskRequestOmission[];

package/dist/request/taskRequest.js

@@ -1,3 +1,4 @@
+import { refuseBadDisableSkills, refuseDisableSkillsConflict } from '../disableSkillsWire.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(壳另铸一个,绝不复用用户会话那一个 —— 复用会把这次提交的转录混进用户会话)' },
@@ -24,6 +25,8 @@ 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: 'disableSkills', lanes: ['interactive', 'print'], live: true, why: '「这一发一只技能都不装」的**请求级声明**(出厂技能、调用方给的技能、子代定义里的技能一个都不进引擎;其余工具照挂 —— 与 excludeAllTools 是两件事,两键同带各自生效)。两条用户车道都是提交面 ⇒ 都能声明。本层只认字面 true(false 与缺席同义、不发);非布尔坏值响亮拒(上游对它 400);与非空 skills 或任一非空 agents[].skills 同在 ⇒ 装配期按名响亮拒(上游对这一组合 400),兜底层落 agents 之后同判。🔴 只在能力位读数为真时发(老服务端对表外键整条 400),值由片段口 disableSkillsDeclaration 唯一铸出', whyUtilityLane: '无座:同 skills 一行 —— side-channel 是零工具面,装不装技能都无从谈起' },
     { 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`;这一位是它旁边那条「连问都别问」的声明,不是它的降级替身)' },
@@ -75,18 +78,40 @@ export function taskRequestOmissionCauseDetail(cause) {
     const word = typeof cause === 'string' && cause.length > 0 ? cause : '(none)';
     return `a cause this build does not know (${word}) — this build does not know this cause: receipt causes come from this build's own frozen vocabulary, so a word outside it was not produced here; check whatever supplied it`;
 }
-export const TASK_REQUEST_OMISSION_CAUSE_NOTICES = Object.freeze({
-    upstream_absent: 'Not sent with this request: this version has no way to send this setting in any request, so giving it or leaving it out makes no difference to what is sent.',
-    other_channel: 'Not sent from here: that part of the request belongs to a separate step, so what goes out for it, if anything, is decided there rather than by the value given here.',
-    off_lane: 'Not sent with this request: this kind of request does not carry this setting, so giving it or leaving it out makes no difference to what this request sends.',
-    not_live: 'Not sent with this request: the request was marked as not going to a live engine (for example an offline or test run), and this setting is only sent on requests that go to one.',
+const TASK_REQUEST_OMISSION_CAUSE_NOTICE_PARTS = Object.freeze({
+    upstream_absent: {
+        lead: 'Not sent with this request',
+        reason: 'this version has no way to send this setting in any request, so giving it or leaving it out makes no difference to what is sent',
+    },
+    other_channel: {
+        lead: 'Not sent from here',
+        reason: 'that part of the request belongs to a separate step, so what goes out for it, if anything, is decided there rather than by the value given here',
+    },
+    off_lane: {
+        lead: 'Not sent with this request',
+        reason: 'this kind of request does not carry this setting, so giving it or leaving it out makes no difference to what this request sends',
+    },
+    not_live: {
+        lead: 'Not sent with this request',
+        reason: 'the request was marked as not going to a live engine (for example an offline or test run), and this setting is only sent on requests that go to one',
+    },
 });
-const TASK_REQUEST_OMISSION_UNKNOWN_CAUSE_NOTICE = 'Not sent with this request, for a reason this version does not recognize.';
+const TASK_REQUEST_OMISSION_UNKNOWN_CAUSE_LEAD = 'Not sent with this request';
+const TASK_REQUEST_OMISSION_UNKNOWN_CAUSE_REASON = 'for a reason this version does not recognize';
+const wholeOmissionNotice = (p) => `${p.lead}: ${p.reason}.`;
+export const TASK_REQUEST_OMISSION_CAUSE_NOTICES = Object.freeze(Object.fromEntries(TASK_REQUEST_OMISSION_CAUSES.map((cause) => [cause, wholeOmissionNotice(TASK_REQUEST_OMISSION_CAUSE_NOTICE_PARTS[cause])])));
+const TASK_REQUEST_OMISSION_UNKNOWN_CAUSE_NOTICE = `${TASK_REQUEST_OMISSION_UNKNOWN_CAUSE_LEAD}, ${TASK_REQUEST_OMISSION_UNKNOWN_CAUSE_REASON}.`;
+const omissionNoticePartsOf = (cause) => typeof cause === 'string' && Object.hasOwn(TASK_REQUEST_OMISSION_CAUSE_NOTICE_PARTS, cause)
+    ? TASK_REQUEST_OMISSION_CAUSE_NOTICE_PARTS[cause]
+    : undefined;
 export function taskRequestOmissionCauseNotice(cause) {
-    return typeof cause === 'string' && Object.hasOwn(TASK_REQUEST_OMISSION_CAUSE_NOTICES, cause)
+    return omissionNoticePartsOf(cause) !== undefined
         ? TASK_REQUEST_OMISSION_CAUSE_NOTICES[cause]
         : TASK_REQUEST_OMISSION_UNKNOWN_CAUSE_NOTICE;
 }
+export function taskRequestOmissionCausePhrase(cause) {
+    return omissionNoticePartsOf(cause)?.reason ?? TASK_REQUEST_OMISSION_UNKNOWN_CAUSE_REASON;
+}
 const row = (field) => ({ via: 'matrix', field });
 const INPUT_KEY_ROUTES = {
     objective: { via: 'always' },
@@ -139,6 +164,8 @@ const INPUT_KEY_ROUTES = {
     memory: row('memory'),
     fileHistory: row('fileHistory'),
     inheritEnv: row('inheritEnv'),
+    requireExistingSession: row('requireExistingSession'),
+    disableSkills: row('disableSkills'),
     rewind: row('resumeAt/resumeAtMode/restoreFiles/rewindFilesTo'),
     repo: row('repo'),
     council: row('council'),
@@ -211,6 +238,8 @@ 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,
+    disableSkills: (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 +483,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 +568,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', 'disableSkills'];
 function dataFirstSnapshot(input, afterData) {
     let descs;
     try {
@@ -592,6 +637,8 @@ export function assembleTaskRequest(input, lane) {
     const outputRetriesIn = src.outputRetries;
     const fileHistoryIn = src.fileHistory;
     const inheritEnvIn = src.inheritEnv;
+    const requireExistingSessionIn = src.requireExistingSession;
+    const disableSkillsIn = src.disableSkills;
     const INPUT_KEYS = Object.keys(INPUT_KEY_ROUTES);
     const i = snapshotByName(src, INPUT_KEYS, {
         live,
@@ -603,6 +650,8 @@ export function assembleTaskRequest(input, lane) {
         outputRetries: outputRetriesIn,
         fileHistory: fileHistoryIn,
         inheritEnv: inheritEnvIn,
+        requireExistingSession: requireExistingSessionIn,
+        disableSkills: disableSkillsIn,
         settings: settingsIn,
     });
     const SETTINGS_KEYS = Object.keys(SETTINGS_KEY_ROUTES);
@@ -615,6 +664,8 @@ export function assembleTaskRequest(input, lane) {
     refuseBadOutputRetries(outputRetriesIn);
     refuseBadFileHistory(fileHistoryIn);
     refuseBadInheritEnv(inheritEnvIn);
+    refuseBadRequireExistingSession(requireExistingSessionIn);
+    refuseBadDisableSkills(disableSkillsIn, 'buildTaskRequest');
     const rewindRoute = INPUT_KEY_ROUTES.rewind;
     const RETIRED_REWIND_FILES_KEY = 'rewindFiles';
     const REWIND_KEYS = rewindRoute.via === 'matrix' ? rewindRoute.field.split('/') : [];
@@ -698,6 +749,8 @@ export function assembleTaskRequest(input, lane) {
             '想问某个键有没有座 ⇒ taskRequestSeatOf(key, lane)。`settings` 快照里的开放集子键放进 settings.resolved。' +
             '错误文本只报键名,不回显值。');
     }
+    refuseRequireExistingWithoutSession(requireExistingSessionIn, i.sessionId);
+    refuseDisableSkillsConflict(disableSkillsIn, i.skills, Reflect.get(src, 'agents'), 'buildTaskRequest');
     refuseUtilityWithoutToolUnload(lane, excludeAllToolsIn);
     const carries = (route, value, key) => {
         if (route.via === 'always')
@@ -772,6 +825,8 @@ export function assembleTaskRequest(input, lane) {
         ...(on('memory') ? { memory: 'off' } : {}),
         ...(on('fileHistory') ? { fileHistory: FILE_HISTORY_DISABLED } : {}),
         ...(on('inheritEnv') ? { inheritEnv: inheritEnvIn } : {}),
+        ...(on('requireExistingSession') ? { requireExistingSession: true } : {}),
+        ...(on('disableSkills') ? { disableSkills: true } : {}),
         ...(Object.keys(settingsOut).length > 0 ? { settings: settingsOut } : {}),
     };
     return Object.freeze({ request: out, omitted: Object.freeze([...omitted, ...lateOmitted]) });
@@ -795,6 +850,7 @@ export function applyLiveRequestDefaults(req, host) {
         out.retainSubagentSessions = true;
     if (out.agents === undefined && host.agents !== undefined)
         out.agents = host.agents;
+    refuseDisableSkillsConflict(out.disableSkills, out.skills, out.agents, 'applyLiveRequestDefaults');
     if (typeof out.scenario === 'string' && host.mockScenarioKeys?.has(out.scenario)) {
         delete out.scenario;
     }

package/dist/resumeRefusalCopy.d.ts

@@ -21,6 +21,13 @@ export declare function resumePolicyBlockFromError(err: unknown): ResumePolicyBl
 export declare function resumePolicyBlockContent(detail: ResumePolicyBlockDetail): string;
 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 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_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([
@@ -86,6 +86,50 @@ 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', 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;
+    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 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)
         return null;

package/dist/runTerminal.d.ts

@@ -11,6 +11,11 @@ export interface RunTerminalPausedRead extends RunTerminalPause {
     code?: string;
     flatStatus?: string;
 }
+export interface RunTerminalFailureDetail {
+    kind: string;
+    status?: number;
+    code?: string;
+}
 export type RunTerminalRead = {
     kind: 'completed';
     plane: RunTerminalPlane;
@@ -20,6 +25,7 @@ export type RunTerminalRead = {
     code?: string;
     message?: string;
     nestedPause?: RunTerminalPause;
+    detail?: RunTerminalFailureDetail;
 } | {
     kind: 'blocked';
     plane: RunTerminalPlane;

package/dist/runTerminal.js

@@ -20,6 +20,27 @@ function pauseOf(v) {
         ...(restoreMode !== undefined ? { restoreMode } : {}),
     };
 }
+const PROVIDER_REJECTED_DETAIL_KIND = 'provider_rejected';
+function failureDetailOf(cause) {
+    try {
+        const own = (o, k) => (Object.prototype.hasOwnProperty.call(o, k) ? o[k] : undefined);
+        const v = own(cause, 'detail');
+        if (typeof v !== 'object' || v === null || Array.isArray(v))
+            return undefined;
+        const kind = str(own(v, 'kind'));
+        if (kind === undefined)
+            return undefined;
+        const rawStatus = own(v, 'status');
+        const status = typeof rawStatus === 'number' && Number.isInteger(rawStatus) && rawStatus >= 100 && rawStatus <= 599 ? rawStatus : undefined;
+        if (kind === PROVIDER_REJECTED_DETAIL_KIND && (status === undefined || status < 400))
+            return undefined;
+        const code = str(own(v, 'code'));
+        return { kind, ...(status !== undefined ? { status } : {}), ...(code !== undefined ? { code } : {}) };
+    }
+    catch {
+        return undefined;
+    }
+}
 const FLAT_PAUSED_STATUSES = ['suspended', 'needs_review'];
 export function readRunTerminal(result) {
     if (typeof result !== 'object' || result === null || Array.isArray(result))
@@ -44,12 +65,14 @@ export function readRunTerminal(result) {
                 const code = str(c.code);
                 const message = str(c.message);
                 const nestedPause = c.nestedPause !== undefined ? pauseOf(c.nestedPause) : undefined;
+                const detail = failureDetailOf(c);
                 return {
                     kind: 'failed',
                     plane: 'cause',
                     ...(code !== undefined ? { code } : {}),
                     ...(message !== undefined ? { message } : {}),
                     ...(nestedPause !== undefined ? { nestedPause } : {}),
+                    ...(detail !== undefined ? { detail } : {}),
                 };
             }
             case 'blocked': {

package/dist/seam.d.ts

@@ -173,6 +173,10 @@ export interface WiringManifestChromeEvent {
     autoConsolidation?: WiringManifestAutoConsolidationView;
     readDeny?: WiringManifestReadDenyView;
     hands?: WiringManifestHandsView;
+    fileHistory?: string;
+    instructions?: {
+        readonly selected: readonly string[];
+    };
     eventId?: string;
 }
 export interface TextSegmentCommittedRow {

package/dist/seatContract.d.ts

@@ -61,6 +61,8 @@ export interface ToolPermissionRequest {
     mandate?: ApprovalMandateWord;
     origin?: string;
     ruleOffersAbsence?: string;
+    askClass?: string;
+    classes?: readonly string[];
 }
 declare const SEAT_EVENT_TYPE_TUPLE: readonly ["start", "close", "session_updated", "message", "stream_event", "chrome_event", "error", "tool_permission_resolved"];
 export type SeatEventType = (typeof SEAT_EVENT_TYPE_TUPLE)[number];
@@ -261,7 +263,7 @@ export declare const SEAT_METHOD_NAMES: readonly ["start", "sendMessage", "inter
 export declare const SEAT_STORE_PROPS: readonly ["sessionsStateStore", "focusedSessionStateStore", "settingsStateStore"];
 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 TOOL_PERMISSION_REQUEST_KEYS: readonly ["requestId", "sessionId", "toolName", "toolCallId", "input", "message", "toctouBinding", "createdAtMs", "governanceForced", "delegation", "mandated", "mandate", "origin", "ruleOffersAbsence"];
+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", "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 SEAT_SEND_MESSAGE_KEY_ORIGINS: {
@@ -333,6 +335,12 @@ export declare const SEAT_VALIDATOR_KEY_COVERAGE: {
         }, {
             readonly key: "origin";
             readonly why: "喂姿态谓词 askSurvivesPosture 的安全位(CC-203),按开集读(非空串原文字节、词表不校);权威窄读在卡口与过境口 toolPermissionRequestAskBits,座位门不设第二判官(为一个位拒掉整条 request = 把安全 ask 丢给引擎 TTL deny)。坏形的两种失效方向:非串 / 空串读成缺席 ⇒ 宿主报了没命中时姿态谓词可答可以放(放宽方向:真出身若是必问词就丢了);表外串读成不认识的词 ⇒ 答 unknown,宿主退回自己的规则(不放宽)。不经过境口自铸座位请求的宿主要自己按同一把窄读。";
+        }, {
+            readonly key: "askClass";
+            readonly why: "展示位(CC-284),权威成对窄读在卡口与过境口 toolPermissionRequestAskBits(与 classes 同在同缺、首员等于 askClass、不判成员、不重排);座位门不设第二判官,理由同 mandated(为一个展示位拒掉整条 request = 把安全 ask 丢给引擎超时拒)。坏形读成缺席 ⇒ 卡上不显示问类,不改决断;缺席不是「普通问」。不经过境口自铸座位请求的宿主要自己按同一把成对窄读。";
+        }, {
+            readonly key: "classes";
+            readonly why: "与 askClass 同一对(CC-284),同在同缺、同一只成对窄读(非空、每员非空串、无重复、首员等于 askClass;开集、原样顺序);座位门不设第二判官,理由同 askClass。";
         }, {
             readonly key: "ruleOffersAbsence";
             readonly why: "喂强制判据口 approvalIsMandated 的位(CC-203;寄存行那条腿的强制只以缺席词 mandated 表达),按开集读(非空串原文字节、词表不校);权威窄读在卡口与过境口,座位门不设第二判官,理由同 mandated。坏形读成缺席 ⇒ 这一路不判强制(放宽方向:寄存行上的强制就丢了;另两路 mandated / mandate 照判);表外串只是不等于 mandated。不经过境口自铸座位请求的宿主要自己按同一把窄读。";