@sema-agent/client-core 0.85.2 → 0.86.0

package/dist/printInitToolFace.d.ts

@@ -28,6 +28,12 @@ export declare function printInitRosterSignal(message: SDKMessage): PrintInitRos
 export declare function decidePrintInitToolFace(signal: Exclude<PrintInitRosterSignal, {
     kind: 'pending';
 }>, fallback: LiveInitToolFace | null): PrintInitToolFace | null;
+export type PrintInitToolsSource = 'engine-roster' | 'estimate' | 'host-static';
+export interface PrintInitToolFaceSupersetKeys {
+    _sema_tools_source: PrintInitToolsSource;
+    _sema_tools_fallback_reason?: PrintInitRosterFallbackReason;
+}
+export declare function printInitToolFaceSupersetKeys(face: PrintInitToolFace | null): PrintInitToolFaceSupersetKeys;
 export declare function printInitToolFaceDebugLine(face: PrintInitToolFace | null): string;
 export type PrintInitGateStep = {
     kind: 'hold';

package/dist/printInitToolFace.js

@@ -36,8 +36,9 @@ export function decidePrintInitToolFace(signal, fallback) {
     const tools = fallback === null ? undefined : fallback.tools;
     if (fallback === null || !Array.isArray(tools))
         return null;
+    const assembly = fallback.source;
     return {
-        source: fallback.source,
+        source: assembly === 'scenario-probe' ? 'scenario-probe' : 'wire-vocabulary',
         tools: tools.flatMap((t) => {
             const name = typeof t === 'object' && t !== null ? t.name : undefined;
             return typeof name === 'string' ? [{ name }] : [];
@@ -45,6 +46,116 @@ export function decidePrintInitToolFace(signal, fallback) {
         fallbackReason: signal.reason,
     };
 }
+const TOOLS_SOURCE_KEY = '_sema_tools_source';
+const TOOLS_FALLBACK_REASON_KEY = '_sema_tools_fallback_reason';
+const FALLBACK_REASONS = ['manifest-without-roster', 'model-activity-first', 'run-ended', 'wait-timeout'];
+export function printInitToolFaceSupersetKeys(face) {
+    const f = face;
+    if (typeof f !== 'object' || f === null)
+        return { _sema_tools_source: 'host-static' };
+    let source;
+    try {
+        source = f.source;
+    }
+    catch {
+        source = undefined;
+    }
+    let reason;
+    let reasonRead = true;
+    try {
+        reason = f.fallbackReason;
+    }
+    catch {
+        reason = undefined;
+        reasonRead = false;
+    }
+    if (source === 'engine-roster' && reasonRead && reason === undefined)
+        return { _sema_tools_source: 'engine-roster' };
+    return typeof reason === 'string' && FALLBACK_REASONS.includes(reason)
+        ? { _sema_tools_source: 'estimate', _sema_tools_fallback_reason: reason }
+        : { _sema_tools_source: 'estimate' };
+}
+const PROTO_WALK_MAX = 64;
+function snapshotStampKeys(rec) {
+    try {
+        const saved = [];
+        for (const key of [TOOLS_SOURCE_KEY, TOOLS_FALLBACK_REASON_KEY]) {
+            let own;
+            let o = rec;
+            for (let depth = 0; o !== null; depth++) {
+                if (depth >= PROTO_WALK_MAX)
+                    return undefined;
+                const d = Reflect.getOwnPropertyDescriptor(o, key);
+                if (d !== undefined) {
+                    if ('get' in d || 'set' in d)
+                        return undefined;
+                    if (depth === 0)
+                        own = d;
+                    break;
+                }
+                o = Reflect.getPrototypeOf(o);
+            }
+            saved.push({ key, own });
+        }
+        return { keys: saved, extensible: Reflect.isExtensible(rec) };
+    }
+    catch {
+        return undefined;
+    }
+}
+function restoreStampKeys(rec, saved) {
+    let clean = true;
+    for (const s of saved) {
+        try {
+            const now = Reflect.getOwnPropertyDescriptor(rec, s.key);
+            let ok = true;
+            if (s.own !== undefined) {
+                if (now === undefined)
+                    ok = Reflect.defineProperty(rec, s.key, s.own);
+                else if (!('value' in now) || !Object.is(now.value, s.own.value))
+                    ok = Reflect.set(rec, s.key, s.own.value);
+            }
+            else if (now !== undefined) {
+                ok = Reflect.deleteProperty(rec, s.key);
+            }
+            if (!ok)
+                clean = false;
+        }
+        catch {
+            clean = false;
+        }
+    }
+    return clean;
+}
+function stampPrintInitToolFaceKeys(frame, face) {
+    if (typeof frame !== 'object' || frame === null || Array.isArray(frame))
+        return;
+    const keys = printInitToolFaceSupersetKeys(face);
+    const rec = frame;
+    const snap = snapshotStampKeys(rec);
+    if (snap === undefined)
+        return;
+    const saved = snap.keys;
+    const hadSource = saved[0]?.own !== undefined;
+    const hadReason = saved[1]?.own !== undefined;
+    const reason = keys._sema_tools_fallback_reason;
+    if (!snap.extensible && (!hadSource || (reason !== undefined && !hadReason)))
+        return;
+    const writeSource = () => Reflect.set(rec, TOOLS_SOURCE_KEY, keys._sema_tools_source);
+    const writeReason = () => reason !== undefined ? Reflect.set(rec, TOOLS_FALLBACK_REASON_KEY, reason) : !hadReason || Reflect.deleteProperty(rec, TOOLS_FALLBACK_REASON_KEY);
+    const steps = reason === undefined && hadReason && !hadSource ? [writeReason, writeSource] : [writeSource, writeReason];
+    try {
+        for (const step of steps) {
+            if (!step()) {
+                restoreStampKeys(rec, saved);
+                return;
+            }
+        }
+    }
+    catch {
+        restoreStampKeys(rec, saved);
+    }
+}
 export function printInitToolFaceDebugLine(face) {
     if (face === null) {
         return "init tools: the host's static list — no tool roster arrived and no estimate was available";
@@ -121,7 +232,9 @@ export async function* withPrintInitFrame(source, opts) {
         }
         catch {
         }
-        yield await opts.buildInit(step.face);
+        const init = await opts.buildInit(step.face);
+        stampPrintInitToolFaceKeys(init, step.face);
+        yield init;
         for (const m of step.messages)
             yield m;
     };

package/dist/readCredentialRefusal.d.ts

@@ -0,0 +1,2 @@
+export declare function isReadCredentialRefusal(e: unknown): boolean;
+export declare const READ_CREDENTIAL_NOT_ACCEPTED_NOTICE = "This engine requires a credential to show this, and this client did not present one it accepts.";

package/dist/readCredentialRefusal.js

@@ -0,0 +1,7 @@
+import { wireFailureShapeOf } from './wireFailureShape.js';
+const AUTH_UNAUTHORIZED = 'auth.unauthorized';
+export function isReadCredentialRefusal(e) {
+    const { status, errorCode } = wireFailureShapeOf(e);
+    return status === 401 && (errorCode === undefined || errorCode === '' || errorCode === AUTH_UNAUTHORIZED);
+}
+export const READ_CREDENTIAL_NOT_ACCEPTED_NOTICE = 'This engine requires a credential to show this, and this client did not present one it accepts.';

package/dist/request/taskRequest.d.ts

@@ -48,8 +48,8 @@ export interface TaskRequestInput {
     maxThinkingTokens?: number;
     memoryCapture?: 'off';
     memory?: 'off';
-    approverPosture?: NonNullable<TaskRequest['approverPosture']>;
     fileHistory?: 'disabled';
+    inheritEnv?: InheritEnvWord;
     rewind?: Record<string, unknown>;
     repo?: string;
     council?: boolean;
@@ -101,11 +101,10 @@ export declare const MEMORY_OFF: "off";
 export declare function memoryOffDeclarationField(declared: boolean): {
     memory: 'off';
 } | Record<string, never>;
-export declare const APPROVER_POSTURE_BYPASS: "bypass";
-export declare function approverPostureDeclarationField(declared: boolean): {
-    approverPosture: 'bypass';
-} | Record<string, never>;
 export declare const FILE_HISTORY_DISABLED: "disabled";
+export declare const INHERIT_ENV_WORDS: readonly ["all", "scrub"];
+export type InheritEnvWord = (typeof INHERIT_ENV_WORDS)[number];
+export declare function isInheritEnvWord(v: unknown): v is InheritEnvWord;
 export declare function memoryOffDeclared(input: {
     flag?: unknown;
     settingsMemory?: unknown;

package/dist/request/taskRequest.js

@@ -22,8 +22,8 @@ export const REQUEST_FIELD_MATRIX = [
     { field: 'lenses', lanes: ['interactive', 'print'], live: true, why: 'code-review 镜头数(server 场景按数字读、非数字回 400;本层型面仍按旧形声明为字符串数组 —— 已知不一致,随该族退役处理)', whyUtilityLane: '无座:场景键;side-channel 不走场景' },
     { field: 'memoryCapture', lanes: ['interactive', 'print', 'utility'], live: true, why: '本会话永远不进长期记忆的**声明形**(server §12.4 body 键,单成员闭集 "off");每条车道都是提交面 ⇒ 都能声明。与 memoryWrite:false 不是一个轴(那是「本 run 只读平面」)。⚠️ parked 续跑腿结构性拿不到声明(决策/续跑端点从持久 body 重建 spec),那是引擎侧事实,不是本层的漏', whyUtilityLane: '有座:side-channel 提交是壳自己的一次性问答,**绝不该**进用户的长期记忆 —— 这一位正是那句声明,且它是收紧方向,带上去只会更严' },
     { field: 'memory', lanes: ['interactive', 'print', 'utility'], live: true, why: '这一次运行不挂记忆面的**请求级**开关(server §12.7 body 键,单成员闭集 "off");每条车道都是提交面 ⇒ 都能声明。与 memoryCapture(采集面)不是一个轴、可并存;与 memoryWrite:false(只读平面)也不是一个轴', whyUtilityLane: '有座:side-channel 提交不需要挂记忆面(不挂记忆段 / 索引 / 三只记忆工具),省 token 且零记忆写入;与 memoryCapture 不是一个轴,两条都带' },
-    { field: 'approverPosture', lanes: ['interactive', 'print'], live: true, why: '宿主对这个 run 的**审批姿态声明**(「这个 run 的审批卡由我自己自动答」;单成员闭集 `"bypass"`)。🔴 它不授权任何东西、也不是一只门:引擎只把这句声明**渲**给模型(它自己的标记块,首个回合),没有任何裁决腿读它 —— 与 `permissionMode` 的 `bypassPermissions`(选门的形状)**不是一回事**,两键在请求体上各自原样过境、**互不派生**:宿主完全可以一边留着缺省权限模式、一边自己自动答这个 run 的审批卡。🔴 **声明它的唯一条件是「宿主确实自己自动答这个 run 的审批卡」,不许据此推导或改动 `permissionMode`** —— 拿这一位当理由去把门放宽,是把一句只渲给模型看的话读成了授权。宿主并不自动答卡却声明了它 ⇒ 那是对模型说了一句与实际不符的话,修法是**别声明**,不是去动门。加座的理由是**一个事实一处铸点**:同样一句话,要么由引擎在它自己的标记块里说,要么由壳把提醒形文本拼进本 turn 的输入 —— 后者在模型眼里是一段**没有引擎标记**的提醒形副本,按标记声明它该当**数据**处理并报出来。所以壳从此停拼,交这一位。两条用户车道都是提交面 ⇒ 都能声明。坏词由引擎响亮拒(单成员闭集,打错字不许被折成缺席),本层同律在构造期就拒(见 `refuseBadApproverPosture`)。⚠️ 上游的**提交体**与**引擎规格**两层都真读这一键,而装着的 sdk 型面尚未镜像它 ⇒ 本层的字面按提交体的形声明,不从 sdk 取型', whyUtilityLane: '无座:审批姿态是**用户**对他自己那条会话的声明,而 side-channel 是壳自己的提交 —— 把用户的 bypass 姿态带进一条他没参与的提交,等于替他重申一句他没说过的话;况且零工具面根本产不出审批卡' },
     { 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: '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`;这一位是它旁边那条「连问都别问」的声明,不是它的降级替身)' },
@@ -137,8 +137,8 @@ const INPUT_KEY_ROUTES = {
     },
     memoryCapture: row('memoryCapture'),
     memory: row('memory'),
-    approverPosture: row('approverPosture'),
     fileHistory: row('fileHistory'),
+    inheritEnv: row('inheritEnv'),
     rewind: row('resumeAt/resumeAtMode/restoreFiles/rewindFilesTo'),
     repo: row('repo'),
     council: row('council'),
@@ -210,7 +210,6 @@ const VALUE_LEVEL_IN_PLAY = Object.freeze({
     excludeAllTools: (v) => v === true,
     memoryCapture: (v) => v === 'off',
     memory: (v) => v === 'off',
-    approverPosture: (v) => v === APPROVER_POSTURE_BYPASS,
     fileHistory: (v) => v === FILE_HISTORY_DISABLED,
     rewind: (v) => typeof v === 'object' && v !== null && rewindSubKeys().some((k) => hasOwn(v, k) && present(v[k])),
 });
@@ -386,13 +385,11 @@ export const MEMORY_OFF = 'off';
 export function memoryOffDeclarationField(declared) {
     return declared ? { memory: MEMORY_OFF } : {};
 }
-export const APPROVER_POSTURE_BYPASS = 'bypass';
-void APPROVER_POSTURE_BYPASS;
-void true;
-export function approverPostureDeclarationField(declared) {
-    return declared ? { approverPosture: APPROVER_POSTURE_BYPASS } : {};
-}
 export const FILE_HISTORY_DISABLED = 'disabled';
+export const INHERIT_ENV_WORDS = Object.freeze(['all', 'scrub']);
+export function isInheritEnvWord(v) {
+    return typeof v === 'string' && INHERIT_ENV_WORDS.includes(v);
+}
 export function memoryOffDeclared(input) {
     if (typeof input !== 'object' || input === null)
         return false;
@@ -432,15 +429,12 @@ const refuseBadExcludeAllTools = (v) => {
         `收到 ${coarseShape(v)}。这一位是**整只工具面卸载**的收紧声明:本层若把坏值静默删键,这一次运行会挂上声明人以为已经卸掉的全部工具。` +
         '错误文本只报形状,不回显值。');
 };
-const refuseBadApproverPosture = (v) => {
-    if (v === undefined || v === null)
-        return;
-    if (v === APPROVER_POSTURE_BYPASS)
-        return;
-    throw new TypeError('buildTaskRequest: approverPosture 只接受字面量 `\'bypass\'` 或缺席(undefined/null)—— ' +
-        `收到 ${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)
@@ -451,6 +445,15 @@ const refuseBadFileHistory = (v) => {
         `收到 ${coarseShape(v)}。这一位是「这一次运行别捕获文件历史」的收紧声明,上游是**单成员闭集**(没有第二个词)且对坏值` +
         '**响亮拒**。本层若静默删键,这一次运行照常捕获而声明人不会知道。错误文本只报形状,不回显值。');
 };
+const refuseBadInheritEnv = (v) => {
+    if (v === undefined || v === null)
+        return;
+    if (isInheritEnvWord(v))
+        return;
+    throw new TypeError(`buildTaskRequest: inheritEnv 只接受 ${INHERIT_ENV_WORDS.map((w) => `'${w}'`).join(' / ')} 或缺席(undefined/null)—— 收到 ${coarseShape(v)}。` +
+        '这一位是「模型驱动的宿主 shell 继承多少用户环境」的两词闭集声明,上游对词表外的值响亮拒;环境变量名单不是请求值。' +
+        '本层若静默删键,这一次运行会按缺省清洗跑、还清掉本会话上一条声明,而声明人不会知道。错误文本只报形状,不回显值。');
+};
 const refuseBadMaxTokens = (v) => {
     if (v === undefined || v === null)
         return;
@@ -520,7 +523,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', 'approverPosture', 'maxTokens', 'outputRetries', 'fileHistory'];
+const ACCESSOR_READ_ORDER = ['live', 'memoryCapture', 'memory', 'settings', 'maxCostUsd', 'excludeAllTools', 'maxTokens', 'outputRetries', 'fileHistory', 'inheritEnv'];
 function dataFirstSnapshot(input, afterData) {
     let descs;
     try {
@@ -585,10 +588,10 @@ export function assembleTaskRequest(input, lane) {
     const resolvedWire = resolvedOpen ? (resolvedMaterialized ?? resolvedSnapshotForWire(resolvedIn)) : {};
     const maxCostUsdIn = src.maxCostUsd;
     const excludeAllToolsIn = src.excludeAllTools;
-    const approverPostureIn = src.approverPosture;
     const maxTokensIn = src.maxTokens;
     const outputRetriesIn = src.outputRetries;
     const fileHistoryIn = src.fileHistory;
+    const inheritEnvIn = src.inheritEnv;
     const INPUT_KEYS = Object.keys(INPUT_KEY_ROUTES);
     const i = snapshotByName(src, INPUT_KEYS, {
         live,
@@ -597,9 +600,9 @@ export function assembleTaskRequest(input, lane) {
         maxCostUsd: maxCostUsdIn,
         maxTokens: maxTokensIn,
         excludeAllTools: excludeAllToolsIn,
-        approverPosture: approverPostureIn,
         outputRetries: outputRetriesIn,
         fileHistory: fileHistoryIn,
+        inheritEnv: inheritEnvIn,
         settings: settingsIn,
     });
     const SETTINGS_KEYS = Object.keys(SETTINGS_KEY_ROUTES);
@@ -608,10 +611,10 @@ export function assembleTaskRequest(input, lane) {
     refuseBadMemoryOff(memoryIn);
     refuseBadMaxCostUsd(maxCostUsdIn);
     refuseBadExcludeAllTools(excludeAllToolsIn);
-    refuseBadApproverPosture(approverPostureIn);
     refuseBadMaxTokens(maxTokensIn);
     refuseBadOutputRetries(outputRetriesIn);
     refuseBadFileHistory(fileHistoryIn);
+    refuseBadInheritEnv(inheritEnvIn);
     const rewindRoute = INPUT_KEY_ROUTES.rewind;
     const RETIRED_REWIND_FILES_KEY = 'rewindFiles';
     const REWIND_KEYS = rewindRoute.via === 'matrix' ? rewindRoute.field.split('/') : [];
@@ -636,12 +639,17 @@ 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);
@@ -672,6 +680,8 @@ 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 同判。' +
@@ -760,8 +770,8 @@ export function assembleTaskRequest(input, lane) {
         ...(on('maxTokens') ? { maxTokens: i.maxTokens } : {}),
         ...(on('memoryCapture') ? { memoryCapture: 'off' } : {}),
         ...(on('memory') ? { memory: 'off' } : {}),
-        ...(on('approverPosture') ? { approverPosture: APPROVER_POSTURE_BYPASS } : {}),
         ...(on('fileHistory') ? { fileHistory: FILE_HISTORY_DISABLED } : {}),
+        ...(on('inheritEnv') ? { inheritEnv: inheritEnvIn } : {}),
         ...(Object.keys(settingsOut).length > 0 ? { settings: settingsOut } : {}),
     };
     return Object.freeze({ request: out, omitted: Object.freeze([...omitted, ...lateOmitted]) });

package/dist/runTerminal.js

@@ -1,3 +1,4 @@
+import { CORE_TERMINAL_CAUSE_KINDS } from './generated/engineFactTables.js';
 function str(v) {
     return typeof v === 'string' && v.length > 0 ? v : undefined;
 }
@@ -130,12 +131,7 @@ export function isReviewPark(read) {
         return true;
     return read !== null && read.kind === 'paused' && read.flatStatus === FLAT_REVIEW_STATUS;
 }
-export const TERMINAL_CAUSE_KINDS = Object.freeze([
-    'completed',
-    'failed',
-    'blocked',
-    'paused',
-]);
+export const TERMINAL_CAUSE_KINDS = CORE_TERMINAL_CAUSE_KINDS;
 export function isTerminalCauseKind(kind) {
     return typeof kind === 'string' && TERMINAL_CAUSE_KINDS.includes(kind);
 }

package/dist/sqlEngineCapability.js

@@ -1,11 +1,21 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
-import { createEngineCapReader } from './engineCapReader.js';
+import { capsGenerationOf, createEngineCapReader } from './engineCapReader.js';
 export function projectSqlEngineCapability(caps) {
     if (caps === null || typeof caps !== 'object')
         return undefined;
     if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
         return undefined;
+    const gen = capsGenerationOf(caps);
+    if (gen.generation === 'new') {
+        const store = gen.store;
+        if (!Object.hasOwn(store, 'sql'))
+            return { kind: 'none' };
+        const nested = store.sql;
+        if (nested === undefined)
+            return { kind: 'none' };
+        return projectSqlEngineView(nested);
+    }
     if (!Object.hasOwn(caps, 'sql'))
         return { kind: 'not_reported' };
     const sql = caps.sql;
@@ -13,7 +23,10 @@ export function projectSqlEngineCapability(caps) {
         return { kind: 'none' };
     if (sql === undefined)
         return { kind: 'not_reported' };
-    if (typeof sql !== 'object')
+    return projectSqlEngineView(sql);
+}
+function projectSqlEngineView(sql) {
+    if (sql === null || typeof sql !== 'object')
         return undefined;
     const s = sql;
     const engine = s.engine;

package/dist/storePostureCapability.d.ts

@@ -0,0 +1,25 @@
+import { type SqlEngineCapabilityView } from './sqlEngineCapability.js';
+export interface StorePostureView {
+    declared: string;
+    backend: string;
+    durable: boolean;
+    degradedReason?: string;
+    sql?: SqlEngineCapabilityView;
+}
+export type StorePostureReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'present';
+    view: StorePostureView;
+};
+export declare function projectStorePostureCapability(caps: unknown): StorePostureReading | undefined;
+export declare function noteEngineCapsForStorePosture(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+export declare function observedStorePosture(baseUrl?: string | undefined): StorePostureReading;
+export declare function storePersistence(reading: StorePostureReading): 'durable' | 'not_durable' | 'unknown';
+export declare function storePostureDoctorDetail(reading: StorePostureReading): string;
+export declare function forgetStorePostureReading(baseUrl: string | undefined): void;
+export declare function __resetStorePostureReadingsForTests(): void;

package/dist/storePostureCapability.js

@@ -0,0 +1,132 @@
+import { capForDisplay } from './fleetTaskDesc.js';
+import { engineWireTarget } from './engineWireTarget.js';
+import { capsGenerationOf, createEngineCapReader } from './engineCapReader.js';
+import { projectSqlEngineCapability } from './sqlEngineCapability.js';
+const nonEmpty = (v) => typeof v === 'string' && v !== '';
+export function projectStorePostureCapability(caps) {
+    try {
+        return projectStorePostureOf(caps);
+    }
+    catch {
+        return undefined;
+    }
+}
+function projectStorePostureOf(caps) {
+    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+        return undefined;
+    const gen = capsGenerationOf(caps);
+    if (gen.generation === 'old')
+        return gen.store === 'absent' ? { kind: 'not_reported' } : undefined;
+    const store = gen.store;
+    const s = store;
+    const declared = s.declared;
+    const backend = s.backend;
+    const durable = s.durable;
+    if (!nonEmpty(declared) || !nonEmpty(backend) || typeof durable !== 'boolean')
+        return undefined;
+    const hasReason = Object.hasOwn(store, 'degradedReason');
+    const reason = hasReason ? s.degradedReason : undefined;
+    if (hasReason && reason !== undefined && !nonEmpty(reason))
+        return undefined;
+    const sqlReading = projectSqlEngineCapability({ store });
+    if (sqlReading === undefined)
+        return undefined;
+    return {
+        kind: 'present',
+        view: {
+            declared,
+            backend,
+            durable,
+            ...(nonEmpty(reason) ? { degradedReason: reason } : {}),
+            ...(sqlReading.kind === 'present' ? { sql: sqlReading.view } : {}),
+        },
+    };
+}
+const reader = createEngineCapReader({
+    name: 'store',
+    project: projectStorePostureCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+export function noteEngineCapsForStorePosture(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+export function observedStorePosture(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+function presentView(reading) {
+    if (typeof reading !== 'object' || reading === null)
+        return undefined;
+    try {
+        const kind = reading.kind;
+        if (kind === 'not_reported' || kind === 'unobserved')
+            return { kind };
+        if (kind !== 'present')
+            return undefined;
+        const view = reading.view;
+        if (typeof view !== 'object' || view === null)
+            return undefined;
+        return { kind: 'present', view: view };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function storePersistence(reading) {
+    const r = presentView(reading);
+    if (r?.kind !== 'present')
+        return 'unknown';
+    let durable;
+    try {
+        durable = r.view.durable;
+    }
+    catch {
+        return 'unknown';
+    }
+    return durable === true ? 'durable' : durable === false ? 'not_durable' : 'unknown';
+}
+const WORD_DETAIL_MAX = 40;
+const word = (v) => capForDisplay(v, WORD_DETAIL_MAX);
+export function storePostureDoctorDetail(reading) {
+    const unobserved = 'store posture not observed — the engine reports it on /v1/capabilities; this process has no usable capabilities reading cached for it, so whether this deployment persists its state is unknown';
+    const r = presentView(reading);
+    if (r?.kind === 'not_reported') {
+        return 'store posture not reported by this engine — only newer engines advertise it; this does not say whether this deployment persists its state';
+    }
+    if (r?.kind !== 'present')
+        return unobserved;
+    let declared;
+    let backend;
+    let durable;
+    let reason;
+    try {
+        declared = r.view.declared;
+        backend = r.view.backend;
+        durable = r.view.durable;
+        reason = r.view.degradedReason;
+    }
+    catch {
+        return unobserved;
+    }
+    if (!nonEmpty(declared) || !nonEmpty(backend) || typeof durable !== 'boolean')
+        return unobserved;
+    const assembled = declared === backend ? `store ${word(backend)}` : `store declared ${word(declared)}, running on ${word(backend)}`;
+    if (durable) {
+        return `${assembled} — durable: this replica persists its state, so it survives a restart`;
+    }
+    const lost = 'NOT durable: this replica holds its state in memory and loses it on restart';
+    if (!nonEmpty(reason))
+        return `${assembled} — ${lost}`;
+    if (reason === 'db_unreachable') {
+        return `${assembled} — ${lost} (degraded: the declared database could not be opened at start-up, so the engine fell back rather than refusing to start)`;
+    }
+    if (reason === 'local_unwritable') {
+        return `${assembled} — ${lost} (degraded: the default local file store could not be created, for example a read-only or full data directory)`;
+    }
+    return `${assembled} — ${lost} (degraded for a reason this client does not know yet: "${word(reason)}")`;
+}
+export function forgetStorePostureReading(baseUrl) {
+    reader.forget(baseUrl);
+}
+export function __resetStorePostureReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/toolResult.js

@@ -3,53 +3,8 @@ import { markEngineWorkflowNotified, registerOutstandingBgTask, registerOutstand
 import { parseWorkflowPollEnvelope, projectWorkflowTaskOutput } from './workflow.js';
 import { asModelFallbackReason } from './engineErrorCodes.js';
 import { frozenSet } from './frozenSet.js';
-export const STRUCTURED_DETAIL_TYPES = frozenSet([
-    'edit',
-    'create',
-    'update',
-    'bash',
-    'notebook-edit',
-    'notebook',
-    'text',
-    'grep',
-    'glob',
-    'mcp',
-    'agent',
-    'task',
-    'task-list',
-    'task-output',
-    'workflow-run',
-    'web-fetch',
-    'web-search',
-    'todo',
-    'cron-create',
-    'cron-delete',
-    'cron-list',
-    'image',
-    'task-stop',
-    'tool-search',
-    'repo-map',
-    'fork',
-    'enter-plan-mode',
-    'exit-plan-mode',
-    'file_unchanged',
-    'worktree',
-    'monitor-start',
-    'path_not_in_root',
-    'readonly_out_of_root',
-    'report-findings',
-    'schedule-wakeup',
-    'send-message',
-    'agent-transcript',
-    'a2a',
-    'document',
-    'ask-question',
-    'bash_invalid_timeout',
-    'read_path_denied',
-    'list-agents',
-    'artifact',
-    'read-inbox',
-]);
+import { CORE_ENGINE_CARD_TYPES } from './generated/engineFactTables.js';
+export const STRUCTURED_DETAIL_TYPES = frozenSet(CORE_ENGINE_CARD_TYPES);
 export function structuredDetailType(structured) {
     if (typeof structured !== 'object' || structured === null)
         return undefined;

package/dist/wireErrorTriage.d.ts

@@ -6,6 +6,7 @@ export type TurnWireErrorVerdict = {
     message: string;
     storedRowWhere?: string;
     sessionUnreadable?: true;
+    leaseUnavailable?: true;
 } | {
     kind: 'stream-ended-without-terminal';
 } | {

package/dist/wireErrorTriage.js

@@ -1,5 +1,6 @@
 import { readErrorNumber, readErrorString, readErrorStringList } from './wireFailureShape.js';
 import { capForDisplay } from './fleetTaskDesc.js';
+import { fleetLeaseUnavailableFromError } from './wireRefusalCopy.js';
 import { DRAINING_ERROR_CODE, isCorruptSessionCode, RESUME_AT_ERROR_CODE_PREFIX, RESUME_POLICY_FOLD_CODE, RESUME_RETRY_LATER_CODES, RESUME_USAGE_WINDOW_EXHAUSTED, SCENARIO_NOT_ALLOWED_ERROR_CODE, } from './engineErrorCodes.js';
 export const WIRE_NETWORK_ERROR_PATTERN = /fetch failed|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|EHOSTUNREACH|ENETUNREACH|EPIPE|socket hang up|UND_ERR|terminated|other side closed/i;
 function wireErrorDetail(err) {
@@ -16,6 +17,7 @@ export function classifyTurnWireError(err) {
         const message = typeof e.message === 'string' && e.message.length > 0 ? e.message : String(err);
         const storedRowWhere = corruptStoredRowWhere(err);
         const sessionUnreadable = isCorruptSessionCode(effectiveWireErrorCode(err));
+        const leaseUnavailable = fleetLeaseUnavailableFromError(err) !== null;
         return {
             kind: 'http',
             status: e.status,
@@ -23,6 +25,7 @@ export function classifyTurnWireError(err) {
             message,
             ...(storedRowWhere !== undefined ? { storedRowWhere } : {}),
             ...(sessionUnreadable ? { sessionUnreadable: true } : {}),
+            ...(leaseUnavailable ? { leaseUnavailable: true } : {}),
         };
     }
     const errName = typeof err === 'object' && err !== null && typeof err.name === 'string'