@sema-agent/client-core 0.100.0 → 0.102.0

package/dist/request/taskRequest.js

@@ -1,10 +1,17 @@
+import { appendOwnElement, readOwnDataValue } from '../ownKey.js';
 import { refuseBadDisableSkills, refuseDisableSkillsConflict } from '../disableSkillsWire.js';
 import { ATTACHMENTS_SPEC_KEYS, AttachmentsSpecRefused } from '../attachmentsWireCaps.js';
-import { retiredAttachmentsKeyOf } from '../taskRequestWords.js';
+import { REASONING_EFFORT_WORDS, retiredAttachmentsKeyOf } from '../taskRequestWords.js';
+import { THINKING_LATCH_SET_STATES } from '../thinkingLatchWords.js';
 import { msg, renderMessage } from '../i18n/translate.js';
+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, HostSettingsRefused, UNWIRED_HOST_TURN_SETTINGS, buildHostTurnSettings, hostIntakeSnapshotOf, hostProjectionNotice, hostTurnSettingsOf, intersectHostHooks, rethrowHostResolvedDeferred, } from '../hostTurnSettings.js';
+import { HOST_SUPPLIED_KEYS, UNWIRED_HOST_TURN_SETTINGS, buildHostTurnSettings, hostIntakeSnapshotOf, hostFileHistoryRestoreNotice, hostProjectionNotice, hostTurnSettingsOf, intersectHostHooks, rethrowHostResolvedDeferred, hostSettingsRefusedError, } from '../hostTurnSettings.js';
+import { SUBMISSION_ORIGINS, SUBMISSION_SURFACES, SUBMISSION_TOOLS, submissionAxesOf, } from './submissionIdentity.js';
+import { 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: '恒座:三条车道都必须带上本次提交的模型面输入' },
     { field: 'sessionId', lanes: ['interactive', 'print', 'utility'], live: false, why: '单命名空间(TP-A Step 2):壳 id 即引擎 session id;print 在非 live 下保留 mock 常量', whyUtilityLane: '恒座:side-channel 提交走**独立**会话 id(壳另铸一个,绝不复用用户会话那一个 —— 复用会把这次提交的转录混进用户会话)' },
@@ -18,19 +25,21 @@ export const REQUEST_FIELD_MATRIX = [
     { field: 'enableFork', lanes: ['interactive', 'print'], live: true, why: '显式布尔才 stamp([503]② fail-OPEN 教训:off 必须显式)', whyUtilityLane: '无座:分叉是会话面的动作,而 side-channel 提交是一次性的独立会话' },
     { field: 'attachments', lanes: ['interactive', 'print'], live: true, why: 'design/133 + G1 缺省开的 turn 边界 attachment', whyUtilityLane: '无座:turn 边界的附件配置属用户会话;side-channel 提交不带附件' },
     { field: 'skills', lanes: ['interactive', 'print'], live: true, why: '本地技能目录投影(布局取 CC 同款);两条车道都由 launchRepl 载入面注入', whyUtilityLane: '无座:技能挂的是工具,与零工具面矛盾' },
-    { field: 'userInvokedSkills', lanes: ['interactive', 'print'], live: true, why: '人用名字点过的技能(sdk `TaskRequest.userInvokedSkills`:非空串数组;这些技能的 allowedTools / disallowedTools 开跑即生效、不出技能卡,只管这一次 run)。两条用户车道都有「人敲 /技能名」的入口 ⇒ 都有座。🔴 放宽方向:值只经片段口给(能力读数 present 才给键);空数组 = 没点名 ⇒ 不 stamp;坏形(不是串数组)装配期响亮拒;名字对不对归引擎判(`config.user_invoked_skill_unknown`)', whyUtilityLane: '无座:技能挂的是工具,与零工具面矛盾(与 skills 一行同理)' },
+    { field: 'userInvokedSkills', lanes: ['interactive', 'print'], live: true, why: '人用名字点过的技能(sdk `TaskRequest.userInvokedSkills`:非空串数组;这些技能的 allowedTools / disallowedTools 开跑即生效、不出技能卡,只管这一次 run)。两条用户车道都有「人敲 /技能名」的入口 ⇒ 都有座。🔴 放宽方向:值只经片段口给(能力读数 present 才给键);空数组 = 没点名 ⇒ 不 stamp;坏形(不是串数组)装配期响亮拒;名字对不对归引擎判(`config.user_invoked_skill_unknown`)', whyUtilityLane: '无座:技能挂的是工具,与零工具面矛盾(与 skills 一行同理)', origins: ['user'], whyOriginLimited: '只给用户所写的提交:点名的技能是用户本人敲名字点的(放宽方向:点名即生效、不出技能卡);注入件与客户端自发的旁路提交不许借用户的点名放宽这一次的工具面' },
     { 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.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 不走场景' },
     { 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: '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: 'fileHistory', lanes: ['interactive', 'print'], live: true, why: '「这一次运行别捕获文件历史」的**请求级声明**(server 7.104.0 提交体键,单成员闭集 "disabled";`POST /v1/tasks` · `/v1/tasks/stream` · `/v1/runs` 同收,子代继承)。两条用户车道都是提交面、都跑在用户的文件上 ⇒ 都能声明;「本会话不捕获」= 每个提交都带(续跑腿重放同一个体)。🔴 只在能力读数 `on-optional` 时发(老 server 对表外键 400),值由装配产物 `fileHistory` 行铸出(AS-4)。与 rewind 还原键同交 ⇒ 上游 400 `request.field_conflict`', whyUtilityLane: '无座:side-channel 强制零工具面(`excludeAllTools`),不会改任何文件 ⇒ 没有可捕获的东西;带上它只会在不认识这一键的老 server 上给这条提交多一种 400' },
+    { field: 'projectMemory', lanes: ['interactive', 'print', 'utility'], live: true, why: '「这一次运行别读部署的项目上下文(项目指令文件与项目层)」的**请求级声明**(core 7.55.0 `TaskSpec.projectMemory`,单成员闭集 "disabled";子代继承、续跑腿重放同一个体)。三条车道都是提交面、引擎对每一条都会调部署的项目上下文座 ⇒ 都能声明(关闭是收紧方向;不关的车道会把项目指令文件递给模型)。缺席 = 座照常读 = 不带键,本层不铸 "on"。🔴 宿主经见位才发的片段口取值,服务端能力位 `projectMemory` 为真才给键(老服务端对表外顶层键整条 400)', whyUtilityLane: '有座:side-channel 提交虽然零工具面,引擎仍对它调部署的项目上下文座;壳在「不读项目指令文件」的模式(`--safe-mode` / `--bare`)下,这一条旁路提交也不该把项目指令文件带给模型 —— 这一位是收紧方向,带上去只会更严(与 memory / memoryCapture 同理由)' },
     { 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: 'finalVerification', lanes: ['print'], live: true, why: 'P1-1 终验:无人值守车道才需要引擎自证;交互 REPL 由人当场看结果。裁定「让位+告知」后交互面默认关', 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`;这一位是它旁边那条「连问都别问」的声明,不是它的降级替身)' },
     { field: 'oneShot', lanes: ['print', 'utility'], live: true, why: 'SDK TaskRequest.oneShot(server ≥7.12.0 消费):`-p` 提交是一次性的——没有后续回合接住异步后台通知,core 据此把「结束回合等通知」指引换成 block-wait;交互车道有后续回合,stamp true 就是谎报。老 worker 静默忽略(开集提交体),故发送侧不设能力位前置门(oneShotWireCaps 头注)', whyUtilityLane: '有座:side-channel 就是一次性提交 —— 没有后续回合接住异步后台通知,引擎据此把「结束回合等通知」换成 block-wait' },
@@ -38,7 +47,7 @@ export const REQUEST_FIELD_MATRIX = [
     { field: 'outputRetries', lanes: ['print', 'utility'], live: true, why: '结构化输出的重试轮数(sdk `TaskRequest.outputRetries`;与 `outputSchema` 是**成对旋钮** —— 没有 schema 时引擎忽略它)。🔴 座位集与 `outputSchema` 那一行**逐字相同**:一半有座一半没座 = 端调得动重试轮数却调不动它所服务的约束(同座孪生分开定座,正是「主轴改了、孪生漏了」那一族)。上游接受域很窄(有限、≥1、向下取整、封顶 10),**表外一律整键省略**并回落引擎缺省 ⇒ 本层对坏值**响亮拒**(见 `refuseBadOutputRetries`),但**不预夹** [1,10]:夹是上游的事,本层不铸第二判官', whyUtilityLane: '有座:与 outputSchema 同座孪生 —— side-channel 要机读小答案时,重试轮数是同一个旋钮的另一半' },
     { field: 'maxCostUsd', lanes: ['print', 'utility'], live: true, why: '花费上限声明(sdk `TaskRequest.maxCostUsd`,请求体**顶层**位;上游向下夹到部署上限 —— 只许要得更少)。与 `limits` 同一条理由只在无人值守车道:交互面由人随时中断。🔴 坏值(非数 / 非有限 / 非正)在本层**响亮拒**:上游对这一位的坏值是安静忽略并回落部署上限,不是 4xx(见 `refuseBadMaxCostUsd`)', whyUtilityLane: '有座:小预算是本车道的定义之一(与 limits 同一条理由);上游向下夹到部署上限,只许要得更少' },
     { field: 'maxTokens', lanes: ['print', 'utility'], live: true, why: '整任务 token 预算上限声明(sdk `TaskRequest.maxTokens`,请求体**顶层**位,与 `maxCostUsd` 同属上游那一族「调用方要求的上限」:向下夹到部署上限 —— 只许要得更少)。🔴 座位集与 `maxCostUsd` 那一行**逐字相同**:同一条预算轴的两种计价单位,分开定座就是让其中一条静默漂。🔴 坏值(非数 / 非有限 / 非正 / 非整)在本层**响亮拒**:上游对这一位的坏值是安静按「调用方没给」处理并回落部署上限,不是 4xx —— 部署没设上限时这一次运行就没有 token 闸,而声明人不会知道(见 `refuseBadMaxTokens`)', whyUtilityLane: '有座:与 maxCostUsd 同轴孪生 —— 小预算是本车道的定义之一,两种计价单位都该能声明' },
-    { field: 'attachmentIds', lanes: ['interactive'], live: true, why: '附件**字节通道**(uploadAttachment 回执 id;server ≥1.289 绑定会话并把文件物化进 run 的 attachments/)。有上传入口的端才有 id 可引用:web/desktop 有,壳走 images / 本地文件路径,`-p` 车道连 uploadAttachment 都没有 ⇒ print 缺席是**没有来源**,不是漏。🔴 与上面的 `attachments` 同名不同物(那是 turn 边界的配置键),两条永远不许合并', whyUtilityLane: '无座:预上传附件句柄要先有上传入口才有 id 可引用,而 side-channel 没有上传面' },
+    { field: 'attachmentIds', lanes: ['interactive'], live: true, why: '附件**字节通道**(uploadAttachment 回执 id;server ≥1.289 绑定会话并把文件物化进 run 的 attachments/)。有上传入口的端才有 id 可引用:web/desktop 有,壳走 images / 本地文件路径,`-p` 车道连 uploadAttachment 都没有 ⇒ print 缺席是**没有来源**,不是漏。🔴 与上面的 `attachments` 同名不同物(那是 turn 边界的配置键),两条永远不许合并', whyUtilityLane: '无座:预上传附件句柄要先有上传入口才有 id 可引用,而 side-channel 没有上传面', origins: ['user'], whyOriginLimited: '只给用户所写的提交:上传件句柄是用户本人上传、挂在这一条消息上的文件;注入件与客户端自发的旁路提交不带用户的上传件(带上去 = 把用户的文件交给一条不是他写的提交)' },
     { field: 'excludeTools', lanes: ['interactive', 'print', 'utility'], live: true, why: 'design/161 W3(2026-07-30):真 wire 键(SDK types `excludeTools`)且早在 seatContract `START_SESSION_OPTION_KEYS` 里,却是 desktop 手写 taskReq 的第 9 键、矩阵外——而 stamp 门对未登记键**静默丢弃**,真实危险形=「用户显式排除的工具被静默放回」(权限方向回归,类型层不报)。今天只有 desktop 在发;壳的工具面走 roster/interactiveTools 另一条路。0.77.0 补 print 座(三问:① wire 位与车道无关 —— sdk 具名位、提交体真收 `body.excludeTools`;② 来源 —— print 今天没有排除入口,但这是**收紧方向**的声明,传了只进回执 = 端不读回执就把用户排除的工具放回;③ 口径 —— 仍是 live 门后的位,与交互面同一行)', whyUtilityLane: '有座:逐名排除是卸载声明旁边的第二条收紧声明(两键同带各自生效)。⚠️ 它**不是** excludeAllTools 的降级替身 —— 本车道强制带卸载声明(见 `refuseUtilityWithoutToolUnload`),不认那一键的上游会把整条提交拒掉,那时正解是换车道或不发' },
     { field: 'allowTools', lanes: ['interactive', 'print'], live: true, why: '引擎的可用性选择器(收紧方向的声明:只给点名的工具;`[]` = 什么都不给,照发)。两条用户车道都是提交面、都有「只给这几只工具」的用户入口(终端 `--tools`)⇒ 都有座;坏形(不是串数组)在装配期响亮拒,不静默删键', whyUtilityLane: '无座:side-channel 恒带 excludeAllTools(零工具面),可用性选择器在零工具面上没有可选的东西' },
     { field: 'excludeAllTools', lanes: ['interactive', 'print', 'utility'], live: true, why: '0.78.0(sdk 11.x 具名位 `excludeAllTools`,server ≥7.90.0 请求面):整只工具面卸载 —— 调用方工具 / 脚手架 / 手 / MCP / A2A / skills 一个都不挂,终局必然纯文本(wire 上 `wiring_manifest.tools.count === 0`,整条流零 tool_start / tool_end / tool_disclosure)。与 excludeTools 是两种语义、刻意不折叠(`"*"` 是一个合法的工具名,「卸全部」不能写成 `excludeTools:["*"]`);两键同带各自生效。类型只收字面 `true`(server 只把 literal true 写上任务规格,`false` = 替引擎重申它自己的缺省 ⇒ 不发、与缺席同义、不进回执);坏值响亮拒(收紧方向的声明不许被打字错误安静丢掉)。每条车道都是提交面 ⇒ 都能声明。探测靠键闭集、没有能力位:没接线的 server(≤7.89.x)400 `request.body_shape` 并在 `unknownKeys` 里逐字点名,本层不替它猜;A2A 入站面不承载本键(零工具面走 skill 路由)', whyUtilityLane: '有座,而且**本车道强制**:零工具面就是这条车道的定义 —— side-channel 提交整只工具面卸载,终局必然纯文本。🔴 缺这一位(或给 `false`)⇒ 构造期响亮拒(`refuseUtilityWithoutToolUnload`):本车道上一整片「无座」的理由都压在这个前提上,其中 `settings.<resolved>` 那一行剥掉的是用户显式的 deny / ask ——前提不成立时产出会是一条「既没卸工具、又没带用户 deny」的请求' },
@@ -46,8 +55,8 @@ export const REQUEST_FIELD_MATRIX = [
     { field: 'systemPrompt', lanes: ['interactive', 'print', 'utility'], live: false, why: '整段替换系统提示(sdk `TaskRequest.systemPrompt`;上游字符数超限 400 响亮拒,本层原样透传)。三条车道都有来源:交互面 = CC QueryParams.systemPrompt,无人值守面 = `--system-prompt[-file]` 一类旗,side-channel 面 = 壳整段给出的那一份。与追加位 `appendSystemPrompt` 不是一个位(那一位归 live 兜底层,见 `LIVE_DEFAULT_FIELDS`)', whyUtilityLane: '有座:side-channel 提交的系统提示由壳整段给出 —— 它不是用户会话的续谈,不该继承用户那一份' },
     { field: 'reasoningEffort', lanes: ['interactive', 'print', 'utility'], live: false, why: '思考档位(sdk `TaskRequest.reasoningEffort` 七词闭集;上游对表外词 400 响亮拒 ⇒ 本层不预铸第二判官)。档位是请求级的位、与车道无关:交互面 = `/effort` 拨盘,无人值守面 = 档位旗。🔴 端交的必须是**档位词**:「思考 token 数」今天没有上游对位(见 `UPSTREAM_ABSENT_REQUEST_INTENTS` 的 `maxThinkingTokens`),别把一个数字折成档位词发出去', whyUtilityLane: '有座:side-channel 该用显式低档(省钱省时);与 model 同一条理由 —— 本车道上这两位都由壳显式给,不跟用户会话的拨盘走' },
     { field: 'model', lanes: ['interactive', 'print', 'utility'], live: false, why: '模型选择(sdk `TaskRequest.model`;交互面 = `/model` 中途换模型的拨盘,无人值守面 = 模型旗 / 部署缺省那一路,side-channel 面 = 壳显式挑的那一只)。三条车道都有来源、都是提交面。🔴 0.79.0 改口:修前「print 的模型走另一条路」这句理由被用户面实测证伪 —— 无人值守车道传了模型名却整键不上请求体,于是同一个坏名字在交互态被引擎 400 点名、在无人值守态却安静换成部署缺省并在首帧回显一个没生效的名字。一个**选择**类声明被静默丢掉,后果与收紧类声明被静默丢掉同形(端不读回执就以为生效)—— 与 `excludeTools` 补 print 座同律。本层原样透传、不预判模型名(名字的合法性归引擎,本层不铸第二判官)', whyUtilityLane: '有座:side-channel 显式挑便宜的那只模型(不跟用户会话的 `/model` 拨盘走)' },
-    { field: 'images', lanes: ['interactive', 'print'], live: false, why: '图片输入(sdk `TaskRequest.images`;base64 / url 两形,原样透传)。两条用户车道都是提交面、都有来源:交互面 = 粘贴图与 `@` 图片像素,一次性车道 = 结构化输入里的图片块。张数、单张与合计的座位判定归人类提交装配口 `encodeHumanTurn`(两条车道同一份判定,本表不另判);请求体与图片张数的上限归上游判', whyUtilityLane: '无座:贴图是交互动作,side-channel 的提交体里没有图片块' },
-    { field: 'userAttachments', lanes: ['interactive', 'print'], live: false, why: '请求层附件(sdk `TaskRequest.userAttachments`:挂在这次提交目标上的 `@` 文本类附件条目,引擎铸帧、在第一次模型调用之前判形)。两条用户车道都是提交面、都经同一只装配口 `encodeHumanTurn`(条目只在这台引擎的席位读数判 `yes` 时出;老服务端对这一键 400,所以没有条目就不发);空数组 = 没带附件 ⇒ 整键不 stamp。座位集与 `images` 一行逐字相同', whyUtilityLane: '无座:side-channel 是壳自己的一次性提交,没有用户 `@` 附件' },
+    { field: 'images', lanes: ['interactive', 'print'], live: false, why: '图片输入(sdk `TaskRequest.images`;base64 / url 两形,原样透传)。两条用户车道都是提交面、都有来源:交互面 = 粘贴图与 `@` 图片像素,一次性车道 = 结构化输入里的图片块。张数、单张与合计的座位判定归人类提交装配口 `encodeHumanTurn`(两条车道同一份判定,本表不另判);请求体与图片张数的上限归上游判', whyUtilityLane: '无座:贴图是交互动作,side-channel 的提交体里没有图片块', origins: ['user'], whyOriginLimited: '只给用户所写的提交:图片是用户本人贴进 / 点名进这一条消息的内容;注入件(计划复核结局等)与客户端自发的旁路提交没有用户贴的图片,带上去就是把别处的图片当成这一发的输入' },
+    { field: 'userAttachments', lanes: ['interactive', 'print'], live: false, why: '请求层附件(sdk `TaskRequest.userAttachments`:挂在这次提交目标上的 `@` 文本类附件条目,引擎铸帧、在第一次模型调用之前判形)。两条用户车道都是提交面、都经同一只装配口 `encodeHumanTurn`(条目只在这台引擎的席位读数判 `yes` 时出;老服务端对这一键 400,所以没有条目就不发);空数组 = 没带附件 ⇒ 整键不 stamp。座位集与 `images` 一行逐字相同', whyUtilityLane: '无座:side-channel 是壳自己的一次性提交,没有用户 `@` 附件', origins: ['user'], whyOriginLimited: '只给用户所写的提交:请求层附件是用户本人 `@` 进这一条消息的附件;注入件与客户端自发的旁路提交不带用户的附件' },
     { field: 'resumeAt/resumeAtMode/restoreFiles/rewindFilesTo', lanes: ['interactive'], live: false, why: 'E18 `/rewind` 是交互命令;四键同生同灭(CC-145:core 6.0.0 起 both 臂发 restoreFiles;CC-223 起退役键 rewindFiles 不再有座 —— 交它按表外子键响亮拒;resumeAtMode 是 both/conversation 两臂恒带的排他截语义位)', whyUtilityLane: '无座:回退是交互命令,而 side-channel 是一次性的独立会话,没有可回退的历史' },
     { field: 'clientContext', lanes: ['interactive'], live: false, why: 'IANA 时区 + 可选邮箱 → core 本地化 `# Environment` 的 today;print 同样跑在用户机器上,缺席让引擎误标 (UTC)', gap: true, whyUtilityLane: '无座:本地化 today 的用途在用户会话的环境段,而 side-channel 的系统提示由壳整段给出 —— 这一列我判不准要不要(与本行 `gap` 同一条待办:要补先单独立项)' },
     { field: 'scratchpadDir', lanes: ['interactive'], live: true, why: '[816]③ per-session 暂存目录;print 也有 session,缺席让 `-p` 的工具写不进 exemptDir', gap: true, whyUtilityLane: '无座:per-session 暂存目录是给**工具**写的,零工具面上没人写' },
@@ -70,12 +79,14 @@ export const TASK_REQUEST_OMISSION_CAUSES = Object.freeze([
     'upstream_absent',
     'other_channel',
     'off_lane',
+    'off_origin',
     'not_live',
 ]);
 const TASK_REQUEST_OMISSION_CAUSE_SENTENCES = Object.freeze({
     upstream_absent: 'this build knows the intent but the engine has no request field for it, so nothing was sent and nothing will be until that field exists upstream — retire the knob, or wait for the upstream field',
     other_channel: 'this is a real request field, but the request assembler never sets it — it belongs to the live-defaults layer, so hand the value to that layer instead of to the assembler',
     off_lane: 'this request lane has no seat for the key, so the value was not sent — the lane table records why that lane does not carry it; submit on a lane that seats it, or stop passing it here',
+    off_origin: 'the key has a seat on this lane, but not for the origin of this submission, so the value was not sent — the lane table records which origins carry it and why; pass it only on a submission whose origin is listed there, or stop passing it here',
     not_live: 'the key has a seat on this lane but only reaches the wire on a live submission, and this submission was not live — nothing is wrong here: a mock or fixture submission keeps its request shape fixed',
 });
 export function taskRequestOmissionCauseDetail(cause) {
@@ -98,6 +109,10 @@ const TASK_REQUEST_OMISSION_CAUSE_NOTICE_PARTS = Object.freeze({
         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',
     },
+    off_origin: {
+        lead: 'Not sent with this request',
+        reason: 'the request was marked as not written by a person (for example an automatic follow-up), and this setting is only sent with requests a person writes themselves',
+    },
     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',
@@ -169,12 +184,16 @@ const INPUT_KEY_ROUTES = {
     },
     memoryCapture: row('memoryCapture'),
     inheritEnv: row('inheritEnv'),
+    projectMemory: row('projectMemory'),
     requireExistingSession: row('requireExistingSession'),
     disableSkills: row('disableSkills'),
     rewind: row('resumeAt/resumeAtMode/restoreFiles/rewindFilesTo'),
     repo: row('repo'),
     allowTools: row('allowTools'),
     hostSettings: { via: 'control' },
+    approvalFrameFamiliesReading: { via: 'control' },
+    thinkingLatch: { via: 'control' },
+    reasoningFloor: { via: 'control' },
     settings: { via: 'settings' },
 };
 const HOST_TOP_KEY_ROUTES = {
@@ -184,15 +203,21 @@ const HOST_TOP_KEY_ROUTES = {
 const HOST_TOP_KEYS = Object.freeze(Object.keys(HOST_TOP_KEY_ROUTES));
 const _hostTopKeysPin = [true];
 void _hostTopKeysPin;
+const _projectMemoryWordPin = [true, true];
+void _projectMemoryWordPin;
+const _thinkingLatchWordPin = [true, true];
+void _thinkingLatchWordPin;
 const HOST_TOP_ASK_AFTER = 'memoryCapture';
 const HOST_SETTINGS_SUBKEYS = Object.freeze(HOST_SUPPLIED_KEYS.filter((k) => k.startsWith('settings.')).map((k) => k.slice('settings.'.length)));
-const _hostSubkeysPin = [true, true, true];
+const MINTED_SETTINGS_SUBKEYS = Object.freeze(['approvalFrameFamilies']);
+const _hostSubkeysPin = [true, true, true, true];
 void _hostSubkeysPin;
 const SETTINGS_KEY_ROUTES = {
     resolved: row('settings.<resolved>'),
     webSearch: row('settings.webSearch'),
     ultracode: row('settings.ultracode'),
     hooks: row('settings.hooks'),
+    approvalFrameFamilies: row('settings.approvalFrameFamilies'),
     outputStyle: { via: 'always' },
 };
 export const UPSTREAM_ABSENT_REQUEST_INTENTS = Object.freeze(Object.entries(INPUT_KEY_ROUTES).flatMap(([key, route]) => route.via === 'fixed' && route.cause === 'upstream_absent' ? [Object.freeze({ key, why: route.why })] : []));
@@ -226,10 +251,11 @@ const OMISSION_JUDGES = {
     upstream_absent: s => s.via === 'fixed' && s.cause === 'upstream_absent',
     other_channel: s => s.via === 'fixed' && s.cause === 'other_channel',
     off_lane: (s, lane) => s.via === 'matrix' && !s.spec.lanes.includes(lane),
+    off_origin: (s, _lane, _live, origin) => s.via === 'matrix' && origin !== undefined && s.spec.origins !== undefined && !s.spec.origins.includes(origin),
     not_live: (s, _lane, live) => s.via === 'matrix' && s.spec.live && !live,
 };
-const omissionCauseOf = (s, lane, live) => TASK_REQUEST_OMISSION_CAUSES.find(cause => OMISSION_JUDGES[cause](s, lane, live));
-const hostRefusalNoticeOf = (intake, lane, live) => {
+const omissionCauseOf = (s, lane, live, origin) => TASK_REQUEST_OMISSION_CAUSES.find(cause => OMISSION_JUDGES[cause](s, lane, live, origin));
+const hostRefusalNoticeOf = (intake, lane, live, origin) => {
     const verdictNotice = intake.notice ?? hostProjectionNotice();
     try {
         const refusing = intake.refusingKeys;
@@ -238,7 +264,7 @@ const hostRefusalNoticeOf = (intake, lane, live) => {
         const turnNotices = intake.turnNotices;
         const aligned = turnNotices !== undefined && turnNotices.length === refusing.length;
         for (const [i, key] of refusing.entries()) {
-            if (!hostRefuseRowSeated(key, lane, live))
+            if (!hostRefuseRowSeated(key, lane, live, origin))
                 continue;
             return aligned ? (turnNotices[i] ?? verdictNotice) : verdictNotice;
         }
@@ -248,10 +274,10 @@ const hostRefusalNoticeOf = (intake, lane, live) => {
         return verdictNotice;
     }
 };
-const hostRefuseRowSeated = (key, lane, live) => {
+const hostRefuseRowSeated = (key, lane, live, origin) => {
     if (hasOwn(HOST_TOP_KEY_ROUTES, key)) {
         const top = HOST_TOP_KEY_ROUTES[key];
-        return top === undefined || (top.via !== 'matrix' && top.via !== 'fixed') || omissionCauseOf(standingOf(top), lane, live) === undefined;
+        return top === undefined || (top.via !== 'matrix' && top.via !== 'fixed') || omissionCauseOf(standingOf(top), lane, live, origin) === undefined;
     }
     if (!key.startsWith('settings.'))
         return true;
@@ -262,7 +288,7 @@ const hostRefuseRowSeated = (key, lane, live) => {
     if (route === undefined || route.via === 'always')
         return true;
     if (route.via === 'matrix' || route.via === 'fixed')
-        return omissionCauseOf(standingOf(route), lane, live) === undefined;
+        return omissionCauseOf(standingOf(route), lane, live, origin) === undefined;
     return true;
 };
 const REQUEST_LANE_SET = { interactive: true, print: true, utility: true };
@@ -273,6 +299,60 @@ const refuseBadLane = (lane) => {
     throw new TypeError(`buildTaskRequest: 车道实参只接受 ${Object.keys(REQUEST_LANE_SET).map(l => `'${l}'`).join(' / ')} —— 收到 ${coarseShape(lane)}。` +
         '表外的车道词会让车道表里每一行都判「不属于本车道」,请求体只剩 objective 与 sessionId 而没有任何信号,所以在装配前拒。错误文本只报形状,不回显值。');
 };
+const laneAxesOf = (arg, port) => {
+    if (typeof arg !== 'object' || arg === null) {
+        refuseBadLane(arg);
+        return { lane: arg, origin: undefined };
+    }
+    const axes = submissionAxesOf(arg);
+    if (axes !== undefined)
+        return axes;
+    let shape;
+    try {
+        shape = coarseShape(arg);
+    }
+    catch {
+        shape = 'typeof=object / unreadable';
+    }
+    const err = new TypeError(renderMessage(msg('config.taskRequest.submissionIdentityMalformed', {
+        shape,
+        lanes: REQUEST_LANES.join(' / '),
+        surfaces: SUBMISSION_SURFACES.join(' / '),
+        origins: SUBMISSION_ORIGINS.join(' / '),
+        tools: SUBMISSION_TOOLS.join(' / '),
+    })));
+    throw port === 'assembly' ? withAssemblyRefusal(err, 'input_malformed') : err;
+};
+const originAxisFaultOf = (origins, why, lanes) => {
+    if (origins === undefined)
+        return '写了 whyOriginLimited 却没写 origins(理由没有对象)';
+    if (typeof why !== 'string' || why.length === 0)
+        return '写了 origins 却没写 whyOriginLimited(来源受限必须带理由)';
+    if (!Array.isArray(origins) || origins.length === 0)
+        return 'origins 不是非空数组';
+    if (!origins.every((o) => SUBMISSION_ORIGINS.includes(o)) || new Set(origins).size !== origins.length) {
+        return 'origins 里有出身闭集外的词或重复词';
+    }
+    if (origins.length === SUBMISSION_ORIGINS.length)
+        return 'origins 是全集(与缺省同义:两种写法说同一件事,删掉这一位)';
+    if (!origins.includes('user'))
+        return 'origins 不含 user(成因 off_origin 的终端用户句说「这一发被标成不是人写的」,对这一行会是假话;真有这种行时先加成因词与句子)';
+    if (!origins.includes('shell') && lanes.includes('utility'))
+        return 'origins 排除壳出身却占 utility 座(身份形派生到 utility 必是壳出身,那个座永远到不了)';
+    return undefined;
+};
+const refuseOriginAxisDrift = () => {
+    for (const r of REQUEST_FIELD_MATRIX) {
+        const origins = r.origins;
+        const why = r.whyOriginLimited;
+        if (origins === undefined && why === undefined)
+            continue;
+        const fault = originAxisFaultOf(origins, why, r.lanes);
+        if (fault === undefined)
+            continue;
+        throw new Error(`buildTaskRequest: 车道表 REQUEST_FIELD_MATRIX 的「${r.field}」一行来源轴不自洽 —— ${fault}。这是本包内部缺陷,不是调用方入参的问题。`);
+    }
+};
 const present = (v) => v !== undefined && v !== null;
 const rewindSubKeys = () => {
     const r = INPUT_KEY_ROUTES.rewind;
@@ -290,6 +370,7 @@ const VALUE_LEVEL_IN_PLAY = Object.freeze({
     memoryCapture: (v) => v === 'off',
     memory: (v) => v === 'off',
     fileHistory: (v) => v === FILE_HISTORY_DISABLED,
+    projectMemory: (v) => v === PROJECT_MEMORY_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])),
@@ -304,15 +385,16 @@ const snapshotByName = (source, keys, seed = {}) => {
 const UNKNOWN_KEY_DISPLAY_MAX = 64;
 const MAX_UNKNOWN_KEYS_SHOWN = 16;
 const keyForDisplay = (k) => k.length > UNKNOWN_KEY_DISPLAY_MAX ? `${JSON.stringify(k.slice(0, UNKNOWN_KEY_DISPLAY_MAX))}(已截短)` : JSON.stringify(k);
-export function taskRequestSeatOf(key, lane) {
-    refuseBadLane(lane);
+export function taskRequestSeatOf(key, laneOrIdentity) {
+    const { lane, origin } = laneAxesOf(laneOrIdentity, 'seat');
+    refuseOriginAxisDrift();
     const route = typeof key === 'string' ? routeOfInputKey(key) : undefined;
     if (route === undefined)
         return SEAT_UNKNOWN;
     if (route.via === 'always' || route.via === 'control' || route.via === 'settings')
         return SEATED_UNGATED;
     const standing = standingOf(route);
-    const cause = omissionCauseOf(standing, lane, true);
+    const cause = omissionCauseOf(standing, lane, true, origin);
     if (cause !== undefined && cause !== 'not_live')
         return Object.freeze({ seat: 'none', cause });
     return standing.via === 'matrix' && standing.spec.live ? SEATED_LIVE_GATED : SEATED_UNGATED;
@@ -324,99 +406,6 @@ const foreignSettingsSubKeys = (lane) => REQUEST_FIELD_MATRIX.filter(f => f.fiel
 const namedSettingsSubKeys = () => REQUEST_FIELD_MATRIX.filter(f => f.field.startsWith('settings.') && f.field !== 'settings.<resolved>').map(f => f.field.slice('settings.'.length));
 const PERMISSION_FACE_KEY = 'permissions';
 const coarseShape = (v) => v === null ? 'typeof=object / null' : Array.isArray(v) ? 'typeof=object / array' : `typeof=${typeof v}`;
-const shapeTag = (v) => {
-    try {
-        const proto = Object.getPrototypeOf(v);
-        const carrier = proto === null
-            ? 'null-prototype'
-            : String(proto?.constructor?.name ?? 'anonymous');
-        return `typeof=${typeof v} / ${Object.prototype.toString.call(v)} / prototype=${carrier}`;
-    }
-    catch {
-        return `typeof=${typeof v} / shape=unreadable`;
-    }
-};
-const isPlainRecord = (v) => {
-    if (typeof v !== 'object' || v === null)
-        return false;
-    const proto = Object.getPrototypeOf(v);
-    if (proto === null)
-        return true;
-    if (typeof proto !== 'object')
-        return false;
-    if (!Object.prototype.hasOwnProperty.call(proto, 'constructor'))
-        return false;
-    const ctor = proto.constructor;
-    if (typeof ctor !== 'function')
-        return false;
-    if (Function.prototype.toString.call(ctor) !== Function.prototype.toString.call(Object))
-        return false;
-    return ctor.prototype === proto;
-};
-const materializeJsonFaithful = (v, path, seen = new Set()) => {
-    if (v === null)
-        return { value: null };
-    const t = typeof v;
-    if (t === 'string' || t === 'boolean')
-        return { value: v };
-    if (t === 'number') {
-        return Number.isFinite(v) ? { value: v } : { bad: `${path}(非有限数 ⇒ 序列化成 null)` };
-    }
-    if (t !== 'object')
-        return { bad: `${path}(typeof=${t} 不是 JSON 值)` };
-    const o = v;
-    if (seen.has(o))
-        return { bad: `${path}(循环引用)` };
-    const toJSONProp = o.toJSON;
-    if (typeof toJSONProp === 'function')
-        return { bad: `${path}(自报 toJSON ⇒ 字节被改写)` };
-    seen.add(o);
-    try {
-        if (Array.isArray(o)) {
-            const rawLen = o.length;
-            if (typeof rawLen === 'bigint' || typeof rawLen === 'symbol') {
-                return { bad: `${path}(length 是 ${typeof rawLen} ⇒ 原生序列化直接抛,归 0 会静默发空表)` };
-            }
-            let lenNum;
-            try {
-                lenNum = +rawLen;
-            }
-            catch {
-                return { bad: `${path}(length 按 ToNumber 转换即抛(BigInt/symbol 形)⇒ 原生序列化也抛,归 0 会静默发空表)` };
-            }
-            if (lenNum === Number.POSITIVE_INFINITY) {
-                return { bad: `${path}(length 是 +Infinity ⇒ 原生序列化抛 RangeError,归 0 会静默发空表)` };
-            }
-            const len = Number.isNaN(lenNum)
-                ? 0
-                : Math.min(Math.max(0, Math.trunc(lenNum)), Number.MAX_SAFE_INTEGER);
-            const items = [];
-            for (let i = 0; i < len; i++) {
-                const r = materializeJsonFaithful(o[i], `${path}[${i}]`, seen);
-                if ('bad' in r)
-                    return r;
-                items.push(r.value);
-            }
-            return { value: items };
-        }
-        const rec = Object.create(null);
-        for (const k of Object.keys(o)) {
-            const val = o[k];
-            if (val === undefined)
-                continue;
-            const r = materializeJsonFaithful(val, `${path}.${k}`, seen);
-            if ('bad' in r)
-                return r;
-            Object.defineProperty(rec, k, { value: r.value, enumerable: true, writable: true, configurable: true });
-        }
-        if (!isPlainRecord(o))
-            return { bad: `${path}(${shapeTag(o)})` };
-        return { value: rec };
-    }
-    finally {
-        seen.delete(o);
-    }
-};
 const resolvedSnapshotForWire = (resolved) => {
     if (resolved === undefined || resolved === null)
         return {};
@@ -461,6 +450,58 @@ const resolvedSnapshotForWire = (resolved) => {
 export function hostTurnSettings(input) {
     return buildHostTurnSettings(input, { materialize: (snapshot) => resolvedSnapshotForWire(snapshot), memoryOffDeclared });
 }
+const fileRestoreRequested = (restoreFiles, rewindFilesTo, rewindFiles) => restoreFiles === true || (typeof rewindFilesTo === 'string' && rewindFilesTo.length > 0) || rewindFiles === true;
+function tightenedRequestOf(request, intake, lane) {
+    const readData = (key) => {
+        try {
+            if (!hasOwn(request, key))
+                return { ok: true, value: undefined };
+            const d = Object.getOwnPropertyDescriptor(request, key);
+            if (d === undefined)
+                return { ok: true, value: undefined };
+            if (!Object.hasOwn(d, 'value'))
+                return { ok: false };
+            if (d.enumerable !== true)
+                return { ok: true, value: undefined };
+            const got = request[key];
+            return got === d.value ? { ok: true, value: d.value } : { ok: false };
+        }
+        catch {
+            return { ok: false };
+        }
+    };
+    const unjudged = { kind: 'refuse', notice: hostProjectionNotice() };
+    const add = {};
+    const tightened = [];
+    if (intake.carried.memory === MEMORY_OFF && hostRefuseRowSeated('memory', lane, true)) {
+        const sent = readData('memory');
+        if (!sent.ok)
+            return unjudged;
+        if (sent.value !== MEMORY_OFF) {
+            add.memory = MEMORY_OFF;
+            appendOwnElement(tightened, 'memory');
+        }
+    }
+    if (intake.carried.fileHistory === FILE_HISTORY_DISABLED && hostRefuseRowSeated('fileHistory', lane, true)) {
+        const sent = readData('fileHistory');
+        if (!sent.ok)
+            return unjudged;
+        if (sent.value !== FILE_HISTORY_DISABLED) {
+            const restoreFiles = readData('restoreFiles');
+            const rewindFilesTo = readData('rewindFilesTo');
+            const rewindFiles = readData('rewindFiles');
+            if (!restoreFiles.ok || !rewindFilesTo.ok || !rewindFiles.ok)
+                return unjudged;
+            if (fileRestoreRequested(restoreFiles.value, rewindFilesTo.value, rewindFiles.value))
+                return { kind: 'refuse', notice: hostFileHistoryRestoreNotice() };
+            add.fileHistory = FILE_HISTORY_DISABLED;
+            appendOwnElement(tightened, 'fileHistory');
+        }
+    }
+    if (tightened.length === 0)
+        return { kind: 'ok', request, tightened: Object.freeze([]) };
+    return { kind: 'ok', request: { ...request, ...add }, tightened: Object.freeze(tightened) };
+}
 export function refilterHostSettings(request, fresh, lane) {
     refuseBadLane(lane);
     const host = hostTurnSettingsOf(fresh);
@@ -470,16 +511,21 @@ export function refilterHostSettings(request, fresh, lane) {
     }
     const refuseNotice = () => intake.notice ?? hostProjectionNotice();
     if (intake.refuses) {
-        const refusing = hostRefusalNoticeOf(intake, lane, true);
+        const refusing = hostRefusalNoticeOf(intake, lane, true, undefined);
         if (refusing !== undefined)
             return Object.freeze({ kind: 'refuse', notice: refusing });
     }
-    const settings = request.settings;
+    const tight = tightenedRequestOf(request, intake, lane);
+    if (tight.kind === 'refuse')
+        return Object.freeze({ kind: 'refuse', notice: tight.notice });
+    const base = tight.request;
+    const tightened = tight.tightened;
+    const settings = base.settings;
     if (!isPlainRecord(settings) || !Object.hasOwn(settings, 'hooks'))
-        return Object.freeze({ kind: 'send', request, hooksDropped: 0 });
+        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, hooksDropped: 0 });
+        return Object.freeze({ kind: 'send', request: base, hooksDropped: 0, tightened });
     const now = intake.carried.hooks;
     const sentHooks = settings.hooks;
     if (!isPlainRecord(sentHooks))
@@ -488,14 +534,14 @@ export function refilterHostSettings(request, fresh, lane) {
     if (!cut.judged)
         return Object.freeze({ kind: 'refuse', notice: refuseNotice() });
     if (cut.dropped === 0)
-        return Object.freeze({ kind: 'send', request, hooksDropped: 0 });
+        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 } = request;
+    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 });
+    return Object.freeze({ kind: 'send', request: next, hooksDropped: cut.dropped, tightened });
 }
 export const MEMORY_CAPTURE_OFF = 'off';
 export function memoryCaptureDeclarationField(declared) {
@@ -540,7 +586,7 @@ const withoutRetiredAttachmentsKeys = (v) => {
         const d = Object.getOwnPropertyDescriptor(v, key);
         if (d !== undefined && Object.prototype.hasOwnProperty.call(d, 'value') && d.value === undefined) {
             ;
-            (drop ??= []).push(key);
+            appendOwnElement((drop ??= []), key);
             continue;
         }
         throw new AttachmentsSpecRefused(`buildTaskRequest: refusing attachments key ${JSON.stringify(key)} — ${why}`, { token: key, why, allowed: ATTACHMENTS_SPEC_KEYS, key });
@@ -559,7 +605,7 @@ function allowToolsSnapshot(v) {
         return v;
     let n;
     try {
-        n = Object.getOwnPropertyDescriptor(v, 'length')?.value;
+        n = readOwnDataValue(v, 'length');
     }
     catch {
         return ALLOW_TOOLS_UNREADABLE_ITEM;
@@ -569,27 +615,31 @@ function allowToolsSnapshot(v) {
     const out = new Array(n);
     for (let k = 0; k < n; k += 1) {
         let d;
+        let unreadable = false;
         try {
             d = Object.getOwnPropertyDescriptor(v, k);
         }
         catch {
-            out[k] = ALLOW_TOOLS_UNREADABLE_ITEM;
-            continue;
+            unreadable = true;
         }
-        if (d === undefined)
-            continue;
-        out[k] = 'value' in d ? d.value : ALLOW_TOOLS_UNREADABLE_ITEM;
+        if (unreadable)
+            defineOwnIndex(out, k, ALLOW_TOOLS_UNREADABLE_ITEM);
+        else if (d !== undefined)
+            defineOwnIndex(out, k, Object.hasOwn(d, 'value') ? d.value : ALLOW_TOOLS_UNREADABLE_ITEM);
     }
     return Object.freeze(out);
 }
+const defineOwnIndex = (list, k, value) => {
+    Object.defineProperty(list, k, { value, writable: true, enumerable: true, configurable: true });
+};
 const allowToolsCopy = (v) => {
     if (!Array.isArray(v))
         return [];
     const out = [];
     for (let k = 0; k < v.length; k += 1) {
         const d = Object.getOwnPropertyDescriptor(v, k);
-        if (d !== undefined && 'value' in d && typeof d.value === 'string')
-            out.push(d.value);
+        if (d !== undefined && Object.hasOwn(d, 'value') && typeof d.value === 'string')
+            appendOwnElement(out, d.value);
     }
     return out;
 };
@@ -600,7 +650,7 @@ const refuseBadAllowTools = (v) => {
         let ok = true;
         for (let k = 0; k < v.length; k += 1) {
             const d = Object.getOwnPropertyDescriptor(v, k);
-            if (d === undefined || !('value' in d) || typeof d.value !== 'string') {
+            if (d === undefined || !Object.hasOwn(d, 'value') || typeof d.value !== 'string') {
                 ok = false;
                 break;
             }
@@ -619,7 +669,7 @@ const refuseBadUserInvokedSkills = (v) => {
         let ok = true;
         for (let k = 0; k < v.length; k += 1) {
             const d = Object.getOwnPropertyDescriptor(v, k);
-            if (d === undefined || !('value' in d) || typeof d.value !== 'string') {
+            if (d === undefined || !Object.hasOwn(d, 'value') || typeof d.value !== 'string') {
                 ok = false;
                 break;
             }
@@ -645,6 +695,24 @@ const refuseBadInheritEnv = (v) => {
         '这一位是「模型驱动的宿主 shell 继承多少用户环境」的两词闭集声明,上游对词表外的值响亮拒;环境变量名单不是请求值。' +
         '本层若静默删键,这一次运行会按缺省清洗跑、还清掉本会话上一条声明,而声明人不会知道。错误文本只报形状,不回显值。');
 };
+const refuseBadProjectMemory = (v) => {
+    if (v === undefined || v === null)
+        return;
+    if (v === PROJECT_MEMORY_DISABLED)
+        return;
+    throw new TypeError(`buildTaskRequest: projectMemory 只接受字面量 '${PROJECT_MEMORY_DISABLED}' 或缺席(undefined/null)—— 收到 ${coarseShape(v)}。` +
+        '这一位是「这一次运行别读部署的项目上下文」的收紧声明,引擎是**单成员闭集**(没有第二个词:要照常读就不带这一键)且对坏值拒启。' +
+        '本层若静默删键,请求会照发、项目指令文件会照常递给模型,而声明人不会知道自己的 opt-out 丢了。错误文本只报形状,不回显值。');
+};
+const refuseBadThinkingLatch = (v) => {
+    if (v === undefined || v === null)
+        return;
+    if (typeof v === 'string' && THINKING_LATCH_SET_STATES.includes(v))
+        return;
+    throw new TypeError(`buildTaskRequest: thinkingLatch 只接受 ${THINKING_LATCH_SET_STATES.map((w) => `'${w}'`).join(' / ')} 或缺席(undefined/null = 未设)—— 收到 ${coarseShape(v)}。` +
+        '这一位是会话级思考开关的读数(从存储宿主的端口读:readThinkingLatch(port).state;未设就不带这一键):「关」被打字错误静默吞掉,' +
+        '这一发会照档位词思考而关掉开关的人不会知道。错误文本只报形状,不回显值。');
+};
 const refuseBadRequireExistingSession = (v) => {
     if (v === undefined || v === null || v === true || v === false)
         return;
@@ -733,7 +801,7 @@ export function parseMaxCostUsd(text) {
         return { ok: false, why: 'not_positive' };
     return { ok: true, value };
 }
-const ACCESSOR_READ_ORDER = ['live', 'memoryCapture', 'hostSettings', 'settings', 'maxCostUsd', 'excludeAllTools', 'maxTokens', 'outputRetries', 'inheritEnv', 'requireExistingSession', 'disableSkills', 'approvalReach', 'allowTools', 'userInvokedSkills'];
+const ACCESSOR_READ_ORDER = ['live', 'memoryCapture', 'hostSettings', 'settings', 'maxCostUsd', 'excludeAllTools', 'maxTokens', 'outputRetries', 'inheritEnv', 'requireExistingSession', 'disableSkills', 'approvalReach', 'allowTools', 'userInvokedSkills', 'projectMemory', 'thinkingLatch'];
 const MATERIALIZE_AT_READ = Object.freeze({ allowTools: (v) => allowToolsSnapshot(v), userInvokedSkills: (v) => allowToolsSnapshot(v) });
 function dataFirstSnapshot(input, afterData) {
     let descs;
@@ -749,10 +817,10 @@ function dataFirstSnapshot(input, afterData) {
         const d = descs[k];
         if (d === undefined || (d.enumerable !== true && routeOfTopLevelKey(k) === undefined))
             continue;
-        if ('value' in d)
+        if (Object.hasOwn(d, 'value'))
             bag[k] = Object.hasOwn(MATERIALIZE_AT_READ, k) ? MATERIALIZE_AT_READ[k](d.value) : d.value;
         else
-            accessors.push(k);
+            appendOwnElement(accessors, k);
     }
     afterData?.(bag);
     const ordered = [
@@ -765,8 +833,9 @@ function dataFirstSnapshot(input, afterData) {
     }
     return bag;
 }
-export function assembleTaskRequest(input, lane) {
-    refuseBadLane(lane);
+export function assembleTaskRequest(input, laneOrIdentity) {
+    const { lane, origin } = laneAxesOf(laneOrIdentity, 'assembly');
+    refuseOriginAxisDrift();
     let resolvedInEarly;
     let resolvedMaterialized;
     let resolvedMaterializeError;
@@ -809,7 +878,7 @@ export function assembleTaskRequest(input, lane) {
         throw new TypeError(renderMessage(msg('config.taskRequest.hostSettingsMalformed', { shape: coarseShape(hostIn) })));
     const resolvedIn = resolvedInEarly;
     const resolvedRoute = SETTINGS_KEY_ROUTES.resolved;
-    const resolvedOpen = resolvedRoute.via === 'matrix' && omissionCauseOf(standingOf(resolvedRoute), lane, live) === undefined;
+    const resolvedOpen = resolvedRoute.via === 'matrix' && omissionCauseOf(standingOf(resolvedRoute), lane, live, origin) === undefined;
     if (resolvedOpen && resolvedMaterializeError !== undefined)
         throw resolvedMaterializeError;
     const resolvedWire = resolvedOpen ? (resolvedMaterialized ?? resolvedSnapshotForWire(resolvedIn)) : {};
@@ -822,6 +891,8 @@ export function assembleTaskRequest(input, lane) {
     const disableSkillsIn = src.disableSkills;
     const approvalReachIn = src.approvalReach;
     const allowToolsIn = src.allowTools;
+    const projectMemoryIn = src.projectMemory;
+    const thinkingLatchIn = src.thinkingLatch;
     const INPUT_KEYS = Object.keys(INPUT_KEY_ROUTES);
     const i = snapshotByName(src, INPUT_KEYS, {
         live,
@@ -835,17 +906,25 @@ export function assembleTaskRequest(input, lane) {
         disableSkills: disableSkillsIn,
         approvalReach: approvalReachIn,
         allowTools: allowToolsIn,
+        projectMemory: projectMemoryIn,
+        thinkingLatch: thinkingLatchIn,
         settings: settingsIn,
     });
     const SETTINGS_KEYS = Object.keys(SETTINGS_KEY_ROUTES);
     const hostSettingsKeysIn = HOST_SETTINGS_SUBKEYS.filter((k) => hasOwn(settingsObj, k) && present(Reflect.get(settingsObj, k)));
     const hostTopKeysIn = HOST_TOP_KEYS.filter((k) => hasOwn(src, k) && present(Reflect.get(src, k)));
+    const approvalFamiliesReadingIn = i.approvalFrameFamiliesReading;
+    const familiesJudged = present(approvalFamiliesReadingIn)
+        ? frameFamiliesJudgementOf(approvalFamiliesReadingIn)
+        : undefined;
+    const approvalFamilies = familiesJudged?.ok === true ? familiesJudged.families : undefined;
     const s = {
         resolved: resolvedIn,
         webSearch: intake.carried.webSearch,
         ultracode: snapshotByName(settingsObj, ['ultracode']).ultracode,
         hooks: intake.carried.hooks,
         outputStyle: intake.carried.outputStyle,
+        approvalFrameFamilies: approvalFamilies,
     };
     refuseBadMemoryCapture(memoryCaptureIn);
     refuseBadMaxCostUsd(maxCostUsdIn);
@@ -857,6 +936,8 @@ export function assembleTaskRequest(input, lane) {
     refuseBadDisableSkills(disableSkillsIn, 'buildTaskRequest');
     refuseBadApprovalReach(approvalReachIn, 'buildTaskRequest');
     refuseBadAllowTools(allowToolsIn);
+    refuseBadProjectMemory(projectMemoryIn);
+    refuseBadThinkingLatch(thinkingLatchIn);
     refuseBadUserInvokedSkills(i.userInvokedSkills);
     const rewindRoute = INPUT_KEY_ROUTES.rewind;
     const RETIRED_REWIND_FILES_KEY = 'rewindFiles';
@@ -878,7 +959,7 @@ export function assembleTaskRequest(input, lane) {
     const rewindForGate = present(rewindIn) ? rewindWire : rewindIn;
     const omitted = [];
     const omit = (key, cause) => {
-        omitted.push(Object.freeze({ key, cause }));
+        appendOwnElement(omitted, Object.freeze({ key, cause }));
     };
     const unknownKeys = [];
     const lateOmitted = [];
@@ -892,22 +973,22 @@ export function assembleTaskRequest(input, lane) {
             continue;
         const route = routeOfTopLevelKey(key);
         if (route === undefined) {
-            unknownKeys.push(key);
+            appendOwnElement(unknownKeys, key);
             continue;
         }
         if (route.via !== 'matrix' && route.via !== 'fixed')
             continue;
-        const cause = omissionCauseOf(standingOf(route), lane, live);
+        const cause = omissionCauseOf(standingOf(route), lane, live, origin);
         if (cause !== undefined)
-            lateOmitted.push(Object.freeze({ key, cause }));
+            appendOwnElement(lateOmitted, Object.freeze({ key, cause }));
     }
     for (const sub of Object.keys(settingsObj)) {
-        if (hasOwn(SETTINGS_KEY_ROUTES, sub))
+        if (hasOwn(SETTINGS_KEY_ROUTES, sub) && !MINTED_SETTINGS_SUBKEYS.includes(sub))
             continue;
         const stray = Reflect.get(settingsObj, sub);
         if (!present(stray))
             continue;
-        unknownKeys.push(`settings.${sub}`);
+        appendOwnElement(unknownKeys, `settings.${sub}`);
     }
     let retiredRewindFiles = false;
     for (const sub of Object.keys(rewindObj)) {
@@ -918,7 +999,7 @@ export function assembleTaskRequest(input, lane) {
             continue;
         if (sub === RETIRED_REWIND_FILES_KEY)
             retiredRewindFiles = true;
-        unknownKeys.push(`rewind.${sub}`);
+        appendOwnElement(unknownKeys, `rewind.${sub}`);
     }
     if (retiredRewindFiles) {
         throw new TypeError('buildTaskRequest: "rewind.rewindFiles" 是退役键(引擎 core 6.0.0 起退役:「逐轮捕获」那一义被引擎忽略 —— 文件首触追踪恒开,' +
@@ -943,19 +1024,19 @@ export function assembleTaskRequest(input, lane) {
             '错误文本只报键名,不回显值。');
     }
     refuseRequireExistingWithoutSession(requireExistingSessionIn, i.sessionId);
-    refuseDisableSkillsConflict(disableSkillsIn, i.skills, Reflect.get(src, 'agents'), 'buildTaskRequest');
+    refuseDisableSkillsConflict(disableSkillsIn, i.skills, Reflect.get(src, 'agents'), 'buildTaskRequest', i.userInvokedSkills);
     refuseUtilityWithoutToolUnload(lane, excludeAllToolsIn);
     if (intake.refuses) {
-        const refusing = hostRefusalNoticeOf(intake, lane, live);
+        const refusing = hostRefusalNoticeOf(intake, lane, live, origin);
         if (refusing !== undefined)
-            throw new HostSettingsRefused(refusing);
+            throw hostSettingsRefusedError(refusing, intake, intake.refusingKeys.find((k) => hostRefuseRowSeated(k, lane, live, origin)));
     }
     const carries = (route, value, key) => {
         if (route.via === 'always')
             return present(value);
         if (route.via === 'control' || route.via === 'settings')
             return false;
-        const cause = omissionCauseOf(standingOf(route), lane, live);
+        const cause = seatCauseOf(route, lane, live, origin);
         if (!inPlay(key, value))
             return false;
         if (cause === undefined)
@@ -965,6 +1046,8 @@ export function assembleTaskRequest(input, lane) {
     };
     const gate = Object.create(null);
     const askInput = (key) => {
+        if (key === THINKING_DEFERRED_ASK)
+            return;
         const route = INPUT_KEY_ROUTES[key];
         if (route.via === 'settings') {
             for (const sub of SETTINGS_KEYS)
@@ -983,14 +1066,23 @@ export function assembleTaskRequest(input, lane) {
     };
     for (const key of INPUT_KEYS.slice(hostTopAt))
         askInput(key);
-    const on = (key) => gate[key] === true;
     const onSetting = (sub) => gate[`settings.${sub}`] === true;
+    const thinking = projectThinkingCore({
+        lane,
+        latch: thinkingLatchIn,
+        strength: i.reasoningEffort,
+        floor: i.reasoningFloor,
+        ultracodeStamped: onSetting('ultracode') && s.ultracode === true,
+    });
+    gate[THINKING_DEFERRED_ASK] = carries(INPUT_KEY_ROUTES[THINKING_DEFERRED_ASK], thinking.word, THINKING_DEFERRED_ASK);
+    const on = (key) => gate[key] === true;
     const settingsOut = {
         ...resolvedWire,
         ...(onSetting('webSearch') ? { webSearch: s.webSearch } : {}),
         ...(onSetting('ultracode') ? { ultracode: s.ultracode } : {}),
         ...(onSetting('hooks') ? { hooks: s.hooks } : {}),
         ...(s.outputStyle !== undefined ? { outputStyle: s.outputStyle } : {}),
+        ...(onSetting('approvalFrameFamilies') ? { approvalFrameFamilies: [...(s.approvalFrameFamilies ?? [])] } : {}),
     };
     const attachmentsForWire = on('attachments') ? withoutRetiredAttachmentsKeys(i.attachments) : undefined;
     const out = {
@@ -998,7 +1090,7 @@ export function assembleTaskRequest(input, lane) {
         sessionId: i.sessionId,
         ...(on('scenario') ? { scenario: i.scenario } : {}),
         ...(on('systemPrompt') ? { systemPrompt: i.systemPrompt } : {}),
-        ...(on('reasoningEffort') ? { reasoningEffort: i.reasoningEffort } : {}),
+        ...(on('reasoningEffort') ? { reasoningEffort: thinking.word } : {}),
         ...(on('model') ? { model: i.model } : {}),
         ...(on('images') ? { images: i.images } : {}),
         ...(on('userAttachments') ? { userAttachments: [...(i.userAttachments ?? [])] } : {}),
@@ -1036,12 +1128,105 @@ export function assembleTaskRequest(input, lane) {
         ...(on('requireExistingSession') ? { requireExistingSession: true } : {}),
         ...(on('disableSkills') ? { disableSkills: true } : {}),
         ...(on('approvalReach') ? { approvalReach: approvalReachIn } : {}),
+        ...(on('projectMemory') ? { projectMemory: PROJECT_MEMORY_DISABLED } : {}),
         ...(Object.keys(settingsOut).length > 0 ? { settings: settingsOut } : {}),
     };
-    return Object.freeze({ request: out, omitted: Object.freeze([...omitted, ...lateOmitted]), host });
+    const familiesRoute = SETTINGS_KEY_ROUTES.approvalFrameFamilies;
+    const familiesSeated = (familiesRoute.via === 'matrix' || familiesRoute.via === 'fixed') && omissionCauseOf(standingOf(familiesRoute), lane, live, origin) === undefined;
+    const familiesWithheld = familiesSeated && approvalFamilies === undefined ? Object.freeze({ cause: familiesJudged === undefined || familiesJudged.ok ? 'reading_absent' : familiesJudged.cause }) : undefined;
+    return Object.freeze({
+        request: out,
+        omitted: Object.freeze([...omitted, ...lateOmitted]),
+        host,
+        ...(familiesWithheld !== undefined ? { approvalFrameFamiliesWithheld: familiesWithheld } : {}),
+        thinking,
+    });
+}
+export function buildTaskRequest(input, laneOrIdentity) {
+    return assembleTaskRequest(input, laneOrIdentity).request;
 }
-export function buildTaskRequest(input, lane) {
-    return assembleTaskRequest(input, lane).request;
+const THINKING_DEFERRED_ASK = 'reasoningEffort';
+const FLOOR_WORDS = Object.freeze(REASONING_EFFORT_WORDS.filter((w) => w !== 'off'));
+const effortRank = (w) => (typeof w === 'string' ? REASONING_EFFORT_WORDS.indexOf(w) : -1);
+const seatCauseOf = (route, lane, live, origin) => omissionCauseOf(standingOf(route), lane, live, origin);
+const frozenProjection = (p) => Object.freeze(p);
+function projectThinkingCore(c) {
+    const latch = c.latch === 'on' || c.latch === 'off' ? c.latch : 'unset';
+    const ultracodeStamped = c.ultracodeStamped === true;
+    const strength = c.strength;
+    if (c.lane === 'utility')
+        return frozenProjection({ word: strength, verdict: 'utility_lane', latch, ultracodeStamped });
+    if (latch === 'off') {
+        const overruled = present(strength) && strength !== 'off';
+        return frozenProjection({ word: 'off', verdict: 'off', latch, ultracodeStamped, ...(overruled ? { strengthOverruled: strength } : {}) });
+    }
+    let base = strength;
+    let overruledOff = false;
+    if (latch === 'on' && base === 'off') {
+        base = undefined;
+        overruledOff = true;
+    }
+    let floorApplied = false;
+    const floor = c.floor;
+    if (typeof floor === 'string' && FLOOR_WORDS.includes(floor) && base !== 'off') {
+        const baseRank = effortRank(base);
+        if (!present(base) || (baseRank >= 0 && baseRank < effortRank(floor))) {
+            base = floor;
+            floorApplied = true;
+        }
+    }
+    return frozenProjection({
+        word: base,
+        verdict: 'strength',
+        latch,
+        ultracodeStamped,
+        ...(floorApplied ? { floorApplied: true } : {}),
+        ...(overruledOff ? { strengthOverruled: 'off' } : {}),
+    });
+}
+export function thinkingTurnProjection(input) {
+    let submission;
+    let live;
+    let latch;
+    let strength;
+    let floor;
+    let ultracode;
+    try {
+        if (typeof input === 'object' && input !== null) {
+            submission = input.submission;
+            live = input.live;
+            latch = input.latch;
+            strength = input.strength;
+            floor = input.floor;
+            ultracode = input.ultracode;
+        }
+    }
+    catch {
+        submission = live = latch = strength = floor = ultracode = undefined;
+    }
+    let lane;
+    let origin;
+    try {
+        const axes = laneAxesOf(submission, 'seat');
+        lane = axes.lane;
+        origin = axes.origin;
+    }
+    catch {
+        lane = undefined;
+        origin = undefined;
+    }
+    const ultracodeRoute = SETTINGS_KEY_ROUTES.ultracode;
+    let seated = false;
+    try {
+        seated =
+            lane !== undefined &&
+                (ultracodeRoute.via === 'matrix' || ultracodeRoute.via === 'fixed') &&
+                seatCauseOf(ultracodeRoute, lane, live === true, origin) === undefined;
+    }
+    catch {
+        seated = false;
+    }
+    return projectThinkingCore({ lane, latch, strength, floor, ultracodeStamped: seated && inPlay('settings.ultracode', ultracode) && ultracode === true });
 }
 export function applyLiveRequestDefaults(req, host) {
     const out = { ...req };
@@ -1059,7 +1244,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');
+    refuseDisableSkillsConflict(out.disableSkills, out.skills, out.agents, 'applyLiveRequestDefaults', Array.isArray(out.userInvokedSkills) ? out.userInvokedSkills : undefined);
     if (typeof out.scenario === 'string' && host.mockScenarioKeys?.has(out.scenario)) {
         delete out.scenario;
     }
@@ -1116,25 +1301,25 @@ export function unregisteredRequestKeys(req, lane) {
             if (settings === null || typeof settings !== 'object')
                 continue;
             if (typeof settings.toJSON === 'function')
-                out.push('settings.toJSON');
+                appendOwnElement(out, 'settings.toJSON');
             for (const [sub, value] of Object.entries(settings)) {
                 if (sub === 'toJSON')
                     continue;
                 if (typeof value === 'function') {
-                    out.push(`settings.${sub}`);
+                    appendOwnElement(out, `settings.${sub}`);
                     continue;
                 }
                 if (laneSettingsKeys.has(sub) || liveDefaults.has(`settings.${sub}`))
                     continue;
                 if (settingsIsOpenSet && !foreignSettingsKeys.has(sub))
                     continue;
-                out.push(`settings.${sub}`);
+                appendOwnElement(out, `settings.${sub}`);
             }
             continue;
         }
         if (laneTopKeys.has(key) || liveDefaults.has(key))
             continue;
-        out.push(key);
+        appendOwnElement(out, key);
     }
     return out;
 }