@sema-agent/client-core 0.109.0 → 0.111.0

package/dist/replayBody.js

@@ -62,8 +62,16 @@ export function runRowSentenceOf(carrier) {
         return undefined;
     }
 }
+function isPlainObjectLike(v) {
+    try {
+        return typeof v === 'object' && v !== null && !Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
 export function doneResultView(result) {
-    if (typeof result !== 'object' || result === null || Array.isArray(result))
+    if (!isPlainObjectLike(result))
         return { replay: false, receipt: false, body: result };
     const replay = guarded(result, 'replay') === true;
     const engine = engineResultLayerOf(result);
@@ -80,7 +88,7 @@ export function doneResultView(result) {
     return { replay, receipt: true, body: Object.freeze(view) };
 }
 export function isReplayedTerminal(frame) {
-    if (frame === null || typeof frame !== 'object' || Array.isArray(frame))
+    if (!isPlainObjectLike(frame))
         return false;
     if (guarded(frame, 'type') !== 'done')
         return false;

package/dist/request/taskRequest.d.ts

@@ -179,5 +179,10 @@ export interface LiveDefaultsInput {
     mockScenarioKeys?: ReadonlySet<string>;
 }
 export declare function applyLiveRequestDefaults(req: TaskRequestLike, host: LiveDefaultsInput): TaskRequestLike;
+export interface LiveRequestDefaultsResult {
+    readonly request: TaskRequestLike;
+    readonly notices: readonly HostSettingNotice[];
+}
+export declare function applyLiveRequestDefaultsWithNotices(req: TaskRequestLike, host: LiveDefaultsInput): LiveRequestDefaultsResult;
 export type BuiltTaskRequest = TaskRequest;
 export declare function unregisteredRequestKeys(req: TaskRequestLike, lane: RequestLane): string[];

package/dist/request/taskRequest.js

@@ -8,9 +8,9 @@ import { PROJECT_MEMORY_DISABLED } from '../projectMemory.js';
 import { frameFamiliesJudgementOf } from '../approvalFrameFamilies.js';
 import { outputStyleSeatAdmitted } from '../outputStyleSeatCapability.js';
 import { refuseBadApprovalReach } from '../approvalReachWire.js';
-import { HOST_SUPPLIED_KEYS, UNWIRED_HOST_TURN_SETTINGS, buildHostTurnSettings, hostIntakeSnapshotOf, hostFileHistoryRestoreNotice, hostProjectionNotice, hostTurnSettingsOf, intersectHostHooks, rethrowHostResolvedDeferred, hostSettingsRefusedError, } from '../hostTurnSettings.js';
+import { HOST_SUPPLIED_KEYS, UNWIRED_HOST_TURN_SETTINGS, buildHostTurnSettings, hostIntakeSnapshotOf, hostFileHistoryRestoreNotice, hostProjectionNotice, hostStyleNotAppliedNotice, hostTurnSettingsOf, hookEnvNamesOf, intersectHostHooks, rethrowHostResolvedDeferred, hostSettingsRefusedError, } from '../hostTurnSettings.js';
 import { SUBMISSION_ORIGINS, SUBMISSION_SURFACES, SUBMISSION_TOOLS, submissionAxesOf, } from './submissionIdentity.js';
-import { withAssemblyRefusal } from '../wireFailureShape.js';
+import { slotReadOf, withAssemblyRefusal } from '../wireFailureShape.js';
 import { isPlainRecord, materializeJsonFaithful, shapeTag } from '../jsonFaithful.js';
 export const REQUEST_FIELD_MATRIX = [
     { field: 'objective', lanes: ['interactive', 'print', 'utility'], live: false, why: '本 turn 的真实输入,每条车道都必需', whyUtilityLane: '恒座:三条车道都必须带上本次提交的模型面输入' },
@@ -29,6 +29,7 @@ export const REQUEST_FIELD_MATRIX = [
     { field: 'mcpServers', lanes: ['interactive', 'print'], live: true, why: '本地 .mcp.json 投影;service 单用户门决定是否兑现', whyUtilityLane: '无座:MCP 服务挂的是工具,与零工具面矛盾' },
     { field: 'settings.webSearch', lanes: ['interactive', 'print'], live: true, why: 'SEMA_WEBSEARCH_* / settings.json;per-request 配置赢过部署 env', whyUtilityLane: '无座:联网检索是一只工具,与零工具面矛盾' },
     { field: 'settings.hooks', lanes: ['interactive', 'print'], live: true, why: '[495]① 用户 settings 文件 hooks 逐字上 wire', whyUtilityLane: '无座:hook 挂在工具门上(零工具面没有门),而且 side-channel 是壳自己的提交,不该继承用户那份 hook 表' },
+    { field: 'settings.env', lanes: ['interactive', 'print'], live: true, why: '交引擎执行的 http hook 头 `$NAME` 插值的那一层环境(服务端 `settings.env`:引擎 hook 环境 = 十二名基础名单 + 本键;同一份也进引擎命令 hook 与单用户宿主车道的会话 shell 环境 —— 服务端的设计)。两条用户车道都把 hooks 交给引擎执行 ⇒ 都有座,与 settings.hooks 同座。值只由宿主自供项入口按 hooks 那一行算出:名集 = 这一发请求体 hooks 里引擎点亮的事件下 http 条目 allowedEnvVars 之并 ∩ 宿主环境在场,值 = 环境原值,名集空 ⇒ 键缺席;不按凭据名预筛(凭据判官只在服务端:400 request.env_credential_refused)', whyUtilityLane: '无座:与 settings.hooks 同理由 —— side-channel 不带用户的 hook 表,就没有要插值的 http 头;带上它只会把宿主环境里的值交给一条零工具面的提交' },
     { field: 'settings.approvalFrameFamilies', lanes: ['interactive', 'print'], live: true, why: '这条运行的客户端渲得了哪些审批开卡帧族的**逐运行声明**(服务端提交体 `settings.approvalFrameFamilies`:词数组,值族闭集 tool_approval / approval_request;一条运行只在声明含服务端呈的那一族时才开审批卡,不含 ⇒ 问当场交无人值守政策口、不出卡)。两条用户车道都有审批腿(交互面出卡答人;`-p` 面交宿主的审批口),都得声明;🔴 只在能力读数 confirmed(受理位 `taskSettings.approvalFrameFamilies` 恒真 ∧ 值族位合格)时由装配口自己铸,老服务端(受理位缺席)对表外 settings 子键整条 400', whyUtilityLane: '无座:side-channel 强制零工具面(`excludeAllTools`),没有门控调用、不会问审批 ⇒ 声明没有对象;带上它只会在不认识这一键的老服务端上给这条提交多一种 400' },
     { field: 'settings.<resolved>', lanes: ['interactive', 'print'], live: true, why: 'settings resolver 的 effective 快照(hooks/env/model + 已解析权限投影)。两条车道同源:交互面 replEntry / print 面 printModeEngine 各跑一遍同一个 resolver,产物经同一个 buildWireSettingsStamp 投影。开放集(子键不可枚举)⇒ unregisteredRequestKeys 放行本车道 settings 的**表外**子键,但表内异车道子键仍点名', whyUtilityLane: '无座:这一位是**开放集 spread**(子键原样即 wire 键),摊开的是用户 settings 的已解析面(权限 / env / 模型)。side-channel 是壳自己的提交:摊上去既无用(零工具面没有工具门求值权限)又把用户的配置面带进了一条他没参与的提交。🔴 无座 ⇒ 本车道整只快照不产。🔴 **本行无座的前提由构造期校验兜住**:剥掉的是用户显式的 deny / ask,所以 `refuseUtilityWithoutToolUnload` 强制这条车道必须带字面 `excludeAllTools: true` —— 否则产出会是一条「既没卸工具、又没带用户 deny」的请求(比无人值守车道同一份输入更宽)' },
     { field: 'repo', lanes: ['interactive', 'print'], live: true, why: 'scan/code-review 场景的仓库坐标(passthrough;server 是权威校验方,本层不铸第二判官)', whyUtilityLane: '无座:场景键;side-channel 不走场景' },
@@ -217,6 +218,7 @@ const SETTINGS_KEY_ROUTES = {
     webSearch: row('settings.webSearch'),
     ultracode: row('settings.ultracode'),
     hooks: row('settings.hooks'),
+    env: row('settings.env'),
     approvalFrameFamilies: row('settings.approvalFrameFamilies'),
     outputStyle: { via: 'always' },
 };
@@ -520,27 +522,63 @@ export function refilterHostSettings(request, fresh, lane) {
     const base = tight.request;
     const tightened = tight.tightened;
     const settings = base.settings;
-    if (!isPlainRecord(settings) || !Object.hasOwn(settings, 'hooks'))
+    if (!isPlainRecord(settings))
         return Object.freeze({ kind: 'send', request: base, hooksDropped: 0, tightened });
-    const disposition = intake.dispositions['settings.hooks'];
-    if (disposition === 'unwired')
-        return Object.freeze({ kind: 'send', request: base, hooksDropped: 0, tightened });
-    const now = intake.carried.hooks;
-    const sentHooks = settings.hooks;
-    if (!isPlainRecord(sentHooks))
-        return Object.freeze({ kind: 'refuse', notice: refuseNotice() });
-    const cut = intersectHostHooks(sentHooks, now);
-    if (!cut.judged)
-        return Object.freeze({ kind: 'refuse', notice: refuseNotice() });
-    if (cut.dropped === 0)
+    const unjudged = () => Object.freeze({ kind: 'refuse', notice: refuseNotice() });
+    let nextSettings = settings;
+    let hooksDropped = 0;
+    let finalHooks;
+    if (Object.hasOwn(settings, 'hooks')) {
+        const sentHooks = settings.hooks;
+        if (intake.dispositions['settings.hooks'] === 'unwired')
+            finalHooks = sentHooks;
+        else {
+            const now = intake.carried.hooks;
+            if (!isPlainRecord(sentHooks))
+                return unjudged();
+            const cut = intersectHostHooks(sentHooks, now);
+            if (!cut.judged)
+                return unjudged();
+            finalHooks = cut.hooks;
+            if (cut.dropped > 0) {
+                const { hooks: _sentHooks, ...restSettings } = settings;
+                void _sentHooks;
+                nextSettings = cut.hooks === undefined ? restSettings : { ...restSettings, hooks: cut.hooks };
+                hooksDropped = cut.dropped;
+            }
+        }
+    }
+    const nowEnv = intake.carried.env;
+    const envUnwired = intake.dispositions['settings.env'] === 'unwired';
+    const envMaybeAdded = nowEnv !== undefined && !envUnwired && hostRefuseRowSeated('settings.env', lane, true);
+    const hasSentEnv = Object.hasOwn(nextSettings, 'env');
+    if (hasSentEnv || envMaybeAdded) {
+        const sentEnv = hasSentEnv ? nextSettings.env : {};
+        if (!isPlainRecord(sentEnv))
+            return unjudged();
+        let names;
+        try {
+            names = hookEnvNamesOf(finalHooks);
+        }
+        catch {
+            return unjudged();
+        }
+        const sentKeys = Object.keys(sentEnv);
+        const kept = sentKeys.filter((k) => names.includes(k) && (envUnwired || (nowEnv !== undefined && Object.hasOwn(nowEnv, k))));
+        const added = envMaybeAdded && nowEnv !== undefined ? names.filter((n) => !sentKeys.includes(n) && Object.hasOwn(nowEnv, n)) : [];
+        if (kept.length !== sentKeys.length || added.length > 0) {
+            const { env: _sentEnv, ...restSettings } = nextSettings;
+            void _sentEnv;
+            const rows = [...kept.map((k) => [k, sentEnv[k]]), ...added.map((n) => [n, nowEnv?.[n]])];
+            nextSettings = rows.length === 0 ? restSettings : { ...restSettings, env: Object.fromEntries(rows) };
+        }
+    }
+    if (nextSettings === settings)
         return Object.freeze({ kind: 'send', request: base, hooksDropped: 0, tightened });
-    const { hooks: _sentHooks, ...restSettings } = settings;
-    void _sentHooks;
-    const nextSettings = cut.hooks === undefined ? restSettings : { ...restSettings, hooks: cut.hooks };
     const { settings: _sentSettings, ...restRequest } = base;
     void _sentSettings;
     const next = Object.keys(nextSettings).length > 0 ? { ...restRequest, settings: nextSettings } : restRequest;
-    return Object.freeze({ kind: 'send', request: next, hooksDropped: cut.dropped, tightened });
+    return Object.freeze({ kind: 'send', request: next, hooksDropped, tightened });
 }
 export const MEMORY_CAPTURE_OFF = 'off';
 export function memoryCaptureDeclarationField(declared) {
@@ -924,6 +962,7 @@ export function assembleTaskRequest(input, laneOrIdentity) {
         hooks: intake.carried.hooks,
         outputStyle: intake.carried.outputStyle,
         approvalFrameFamilies: approvalFamilies,
+        env: intake.carried.env,
     };
     refuseBadMemoryCapture(memoryCaptureIn);
     refuseBadMaxCostUsd(maxCostUsdIn);
@@ -1080,6 +1119,7 @@ export function assembleTaskRequest(input, laneOrIdentity) {
         ...(onSetting('webSearch') ? { webSearch: s.webSearch } : {}),
         ...(onSetting('ultracode') ? { ultracode: s.ultracode } : {}),
         ...(onSetting('hooks') ? { hooks: s.hooks } : {}),
+        ...(onSetting('env') ? { env: { ...s.env } } : {}),
         ...(s.outputStyle !== undefined ? { outputStyle: s.outputStyle } : {}),
         ...(onSetting('approvalFrameFamilies') ? { approvalFrameFamilies: [...(s.approvalFrameFamilies ?? [])] } : {}),
     };
@@ -1228,6 +1268,74 @@ export function thinkingTurnProjection(input) {
     return projectThinkingCore({ lane, latch, strength, floor, ultracodeStamped: seated && inPlay('settings.ultracode', ultracode) && ultracode === true });
 }
 export function applyLiveRequestDefaults(req, host) {
+    return liveRequestDefaultsOf(req, host).request;
+}
+export function applyLiveRequestDefaultsWithNotices(req, host) {
+    return liveRequestDefaultsOf(req, host);
+}
+const SELF_KNOWLEDGE_JOIN = '\n\n';
+const OUTPUT_STYLE_MAX_CHARS = 16384;
+function selfKnowledgeSeatOf(block, readBody) {
+    if (typeof block !== 'string')
+        return { kind: 'set', value: block };
+    let body;
+    const read = readBody();
+    if (read !== undefined) {
+        if (read.presence === 'unreadable')
+            return { kind: 'set', value: block, notice: hostStyleNotAppliedNotice('unreadable', OUTPUT_STYLE_MAX_CHARS) };
+        if (read.presence === 'present' && read.value !== undefined && read.value !== null) {
+            if (typeof read.value !== 'string')
+                return { kind: 'set', value: block, notice: hostStyleNotAppliedNotice('unreadable', OUTPUT_STYLE_MAX_CHARS) };
+            if (read.value.trim() !== '')
+                body = read.value;
+        }
+    }
+    if (body === undefined)
+        return { kind: 'set', value: block };
+    let merged;
+    let separable = false;
+    if (block.trim() === '' || body === block || body.startsWith(block + SELF_KNOWLEDGE_JOIN)) {
+        merged = body;
+    }
+    else if (block.endsWith(SELF_KNOWLEDGE_JOIN + body)) {
+        merged = block;
+    }
+    else {
+        merged = block + SELF_KNOWLEDGE_JOIN + body;
+        separable = true;
+    }
+    if (merged.length <= OUTPUT_STYLE_MAX_CHARS)
+        return { kind: 'set', value: merged };
+    const notice = hostStyleNotAppliedNotice('oversize', OUTPUT_STYLE_MAX_CHARS);
+    return separable && block.length <= OUTPUT_STYLE_MAX_CHARS ? { kind: 'set', value: block, notice } : { kind: 'omit', notice };
+}
+const styleBodyReadOf = (settings) => () => typeof settings === 'object' && settings !== null ? slotReadOf(settings, 'outputStyle') : undefined;
+const appendBodyReadOf = (req) => () => typeof req === 'object' && req !== null ? slotReadOf(req, 'appendSystemPrompt') : undefined;
+function settingsWithStyleSeat(settings, seat) {
+    const next = {};
+    const put = (key, value) => {
+        Object.defineProperty(next, key, { value, writable: true, enumerable: true, configurable: true });
+    };
+    const src = Object(settings);
+    let placed = false;
+    for (const key of Reflect.ownKeys(src)) {
+        const d = Object.getOwnPropertyDescriptor(src, key);
+        if (d === undefined || d.enumerable !== true)
+            continue;
+        if (key === 'outputStyle') {
+            if (seat.kind === 'set')
+                put(key, seat.value);
+            placed = true;
+            continue;
+        }
+        put(key, src[key]);
+    }
+    if (!placed && seat.kind === 'set')
+        put('outputStyle', seat.value);
+    return Reflect.ownKeys(next).length > 0 ? next : undefined;
+}
+function liveRequestDefaultsOf(req, host) {
+    const notices = [];
     const out = { ...req };
     if (out.cwd == null && host.cwd !== undefined)
         out.cwd = host.cwd;
@@ -1249,11 +1357,24 @@ export function applyLiveRequestDefaults(req, host) {
     }
     if (host.selfKnowledge !== undefined) {
         if (host.appendSystemPromptCapable) {
-            out.appendSystemPrompt = host.selfKnowledge.forAppend;
+            const seat = selfKnowledgeSeatOf(host.selfKnowledge.forAppend, appendBodyReadOf(req));
+            if (seat.notice !== undefined)
+                appendOwnElement(notices, seat.notice);
+            if (seat.kind === 'set')
+                out.appendSystemPrompt = seat.value;
+            else
+                delete out.appendSystemPrompt;
         }
         else {
             const settings = (out.settings ?? {});
-            out.settings = { ...settings, outputStyle: host.selfKnowledge.forOutputStyle };
+            const seat = selfKnowledgeSeatOf(host.selfKnowledge.forOutputStyle, styleBodyReadOf(settings));
+            if (seat.notice !== undefined)
+                appendOwnElement(notices, seat.notice);
+            const next = settingsWithStyleSeat(settings, seat);
+            if (next !== undefined)
+                out.settings = next;
+            else
+                delete out.settings;
         }
     }
     if (out.outputStyle === undefined && host.outputStyleSeat !== undefined && outputStyleSeatAdmitted(host.outputStyleSeatReading)) {
@@ -1276,7 +1397,7 @@ export function applyLiveRequestDefaults(req, host) {
         delete out.sessionId;
     }
     refuseRequireExistingWithoutSession(out.requireExistingSession, out.sessionId, 'applyLiveRequestDefaults');
-    return out;
+    return Object.freeze({ request: out, notices: Object.freeze(notices) });
 }
 export function unregisteredRequestKeys(req, lane) {
     const liveDefaults = liveDefaultKeyNames();

package/dist/requestCoordinate.d.ts

@@ -0,0 +1 @@
+export declare function requestCoordinateText(root: string, segs: readonly (string | number)[], label?: (seg: string) => string): string;

package/dist/requestCoordinate.js

@@ -0,0 +1,13 @@
+const PLAIN_SEGMENT = /^[^.[\]"\s\p{Cc}]+$/u;
+export function requestCoordinateText(root, segs, label) {
+    let out = root;
+    for (const seg of segs) {
+        if (typeof seg === 'number') {
+            out += `[${seg}]`;
+            continue;
+        }
+        const shown = label === undefined ? seg : label(seg);
+        out += PLAIN_SEGMENT.test(shown) ? `.${shown}` : `[${JSON.stringify(shown)}]`;
+    }
+    return out;
+}

package/dist/resumeRefusalCopy.d.ts

@@ -43,12 +43,10 @@ export interface ParkedResumeStartupDetail {
     code: string;
     cause: ParkedResumeStartupCause;
     taskId?: string;
-    startupCause?: ResumeStartupCause | ResumeCauseCoreAhead;
+    startupCause?: ResumeStartupCause;
     resendable: false;
     denyStaysOpen: true;
 }
-declare const RESUME_CAUSE_CORE_AHEAD: readonly ["transcript_corrupt"];
-type ResumeCauseCoreAhead = Exclude<(typeof RESUME_CAUSE_CORE_AHEAD)[number], ResumeStartupCause>;
 export declare function parkedResumeStartupFromError(err: unknown, decision?: ParkedResumeStartupDecision): ParkedResumeStartupDetail | null;
 export declare function parkedResumeStartupContent(detail: ParkedResumeStartupDetail, lang?: UiLanguage): string;
 export interface CheckpointUnsupportedVersionDetail {

package/dist/resumeRefusalCopy.js

@@ -132,7 +132,6 @@ function parkedResumeStartupCauseWord(err) {
 function isResumeStartupCause(v) {
     return typeof v === 'string' && CORE_RESUME_STARTUP_CAUSES.includes(v);
 }
-const RESUME_CAUSE_CORE_AHEAD = Object.freeze(['transcript_corrupt']);
 const _startupCausePin = true;
 void _startupCausePin;
 export function parkedResumeStartupFromError(err, decision) {
@@ -349,3 +348,5 @@ export function refusedParkBlockedContent(taskId, lane = 'interactive', lang) {
         return renderMessage(msg('resume.refusal.park.blockedPrint', { run, cancel: `POST /v1/runs/${runId ?? '<run id>'}/cancel` }), lang);
     return renderMessage(msg('resume.refusal.park.blockedInteractive', { run }), lang);
 }
+const _pinRefusedPark = [true, true, true];
+void _pinRefusedPark;

package/dist/retryStatus.d.ts

@@ -1,3 +1,4 @@
+import type { BrainStatusPhase } from '@sema-agent/sdk';
 import type { UiLanguage } from './env/uiLanguage.js';
 export type RetryStatus = {
     kind: 'stalled';
@@ -62,7 +63,7 @@ interface RetryStatusErrorPayload {
     } | null;
 }
 export declare const BRAIN_STATUS_PHASES: readonly ["rate_limited", "retrying", "reconnecting", "circuit_open", "recovered", "gave_up", "waiting_first_token"];
-export type BrainStatusPhase = (typeof BRAIN_STATUS_PHASES)[number];
+export type { BrainStatusPhase };
 export type BrainRetryErrClass = 'connect_refused' | 'transport' | 'stall' | 'rate_limit' | 'server' | 'http' | 'output_cap';
 export interface BrainStatusPayload {
     phase: BrainStatusPhase | (string & {});
@@ -161,4 +162,3 @@ export interface ResultWayOut {
 }
 export declare function resultWayOutOf(frame: object | null | undefined): ResultWayOut | undefined;
 export declare function wayOutSentence(wayOut: ResultWayOut | null | undefined, lang?: UiLanguage): string | undefined;
-export {};

package/dist/retryStatus.js

@@ -11,6 +11,8 @@ export const BRAIN_STATUS_PHASES = [
     'gave_up',
     'waiting_first_token',
 ];
+const _brainStatusPhasePin = [true, true];
+void _brainStatusPhasePin;
 export const BRAIN_STATUS_WAIT_SEGMENTS = Object.freeze(['response_headers', 'first_token']);
 void true;
 void true;

package/dist/rewindArchiveReading.js

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

package/dist/runCancelContext.d.ts

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

package/dist/runCancelContext.js

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

package/dist/runPermissionModeSwitch.js

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

package/dist/scenarioRefusal.js

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

package/dist/scenarioSkills.js

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

package/dist/seam.d.ts

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

package/dist/seam.js

@@ -146,6 +146,22 @@ const CHROME_ARM_TABLE = {
             '子代详情的实时输出才按子代任务 id 读得到(子代内容帧只带卡 id)。🔴 座位宿主零逻辑:本臂在座位词表里,按词表转发的宿主自动转发;适配层与渲染层同进程的端(浏览器 lane)适配层已登记,什么都不用做;' +
             '`scope: content` 只写内容归账那一半、`full` 两半都写(含续发目标),别把两者混着登;`full` 臂的 `seq`(帧自带代际号,可缺席)是续发目标「现卡」的顺序证据,交 `noteSeatSubagentAlias` 即可,别自己按到达序排;适配层每次登记都发(tick 逐条各一只),去重在登记口:同对重复收到答 ignored、无副作用;认不得的 `scope` 词整条不登记(读口答 undefined),别猜。',
     },
+    session_box_notice: {
+        required: false,
+        duty: '可选:会话箱通告 —— `noticeKind: inbox`(收件箱一行:pending / delivered 必有,urgent / resupplied 缺席 = 引擎没说,不渲 0)/ `delivery`(投递回执)/ `idle`(对端空闲)。' +
+            '渲 `text`(数据面英文)或按界面语言调 `sessionBoxNoticeSentence(本臂, lang)`;🔴 同一条通告有两个载体(转录行 + 本臂),接本臂的宿主按 `rowUuid` 把那一行摘掉、只渲一个;' +
+            '`state` 是开集机读位,别回显、别按它猜句子;typed 正体缺席时本臂整个不发(不铸状态词)。',
+    },
+    resupply_truncated: {
+        required: false,
+        duty: '可选:停驻补投帧只带了最小形的披露 —— 渲 `text`(数据面英文)或按界面语言调 `resupplyTruncatedSentence(本臂, lang)`,放在这条通知的转录行旁(task_notification)或完成通告旁(workflow_complete)。' +
+            '`droppedKeys` / `bytes` 是机读位,别拼进句子;披露位缺席(全形帧 / 老服务端)或坏形时本臂整个不发,不要自己据「摘要很短」推断截断。',
+    },
+    host_setting_notice: {
+        required: false,
+        duty: '可选:宿主自供设置项的一句通告(`hostTurnSettings()` 产物 `notices` 的一句;载荷 = `HostSettingNotice` 原样)。按 `plane` 呈现:`turn` 本回合系统行 / `session` 每会话每句一次 / ' +
+            '`diagnostic` 不渲只记;🔴 非终态:不是失败卡、不改回合状态;`key` / `cause` 缺席 = 这一句不挂某一行,不是坏形。铸口只有 `hostSettingNoticeEventsOf`,别手拼。',
+    },
     result_text_diverged: {
         required: false,
         duty: '可选:终帧正文与已上屏正文**互相都不是对方前缀**时的诚实披露。🔴 处置是把这一拍的转录行**改口**' +
@@ -157,7 +173,7 @@ const CHROME_ARM_TABLE = {
         required: true,
         duty: '用 sdk isApprovalRequestFrameV1 窄化 frame 才取 card/askId/窗三键;窄不下来 ⇒ 呈通用卡(安全元数据 + 人工 approve/deny),' +
             '🔴 永不 auto-deny;开卡前调 claimApprovalCard(身份, { signal }):joined / aborted ⇒ 不开卡,held ⇒ 开卡且每条出口恰调一次 hold.release(settled?)' +
-            '(去重判定归包 —— legacy 帧那一路的持有与结局在进程级持有表 / 已结表里,宿主不自持 legacy 已收口集);流上下文经 approvalFrameContextOf(这只 chrome 事件) 查,查不到不开卡;' +
+            '(去重判定归包 —— 同一只审批的活卡 / 停驻行 / 另一条宿主路的持有与结局在进程级持有表 / 已结表里,宿主不自持已收口集;服务端 7.133.0 起一条腿一个帧族,不再有先旧族帧、后本帧的并发);流上下文经 approvalFrameContextOf(这只 chrome 事件) 查,查不到不开卡;' +
             '🔴 账本重放的历史帧只用于时间线渲染,卡集的全量对账基准是开流 preamble(它带的 expiresInMs 是铸帧时刻的旧值);' +
             'card 的 message/args 是模型/工具产文,只渲染永不回喂模型',
     },