@sema-agent/client-core 0.77.1 → 0.78.0

package/dist/request/taskRequest.js

@@ -1,11 +1,4 @@
-/**
- * 逐字段对照表(B4 从三个构造器**逐行**读出来的,不是设计出来的)。
- *
- * 读法:`lanes` 只有一条 = 今天的漂移面;`gap:true` = 我判它是**漏**而不是**设计**。
- * 🔴 `gap` 是【判断】不是【事实】——补齐任何一条都要按宪法三问单独立项,别当 B4 的收尾顺手做。
- */
 export const REQUEST_FIELD_MATRIX = [
-    // ── 两条车道都有 ────────────────────────────────────────────────────────────────────────────
     { field: 'objective', lanes: ['interactive', 'print'], live: false, why: '本 turn 的真实输入,两条车道都必需' },
     { field: 'sessionId', lanes: ['interactive', 'print'], live: false, why: '单命名空间(TP-A Step 2):壳 id 即引擎 session id;print 在非 live 下保留 mock 常量' },
     { field: 'scenario', lanes: ['interactive', 'print'], live: false, why: 'TUI 走 selectScenario(objective) 嗅探,print 走 --scenario/SEMA_HEADLESS_SCENARIO 显式值' },
@@ -13,87 +6,40 @@ export const REQUEST_FIELD_MATRIX = [
     { field: 'permissionMode', lanes: ['interactive', 'print'], live: true, why: 'TUI 读 AppState.toolPermissionContext(带 stampDefault 门),print 读 flag>env(headlessPermissionModeWire)' },
     { field: 'selfOrchestration', lanes: ['interactive', 'print'], live: true, why: 'SEMA_SELF_ORCHESTRATION opt-in → core 挂 run_workflow' },
     { field: 'deferTools', lanes: ['interactive', 'print'], live: true, why: '[1052]① Workflow 延迟披露;selfOrchestration 前置门' },
-    { field: 'retainBackgroundProcesses', lanes: ['interactive', 'print'], live: true, why: '缺省 ON(clay 2026-07-26 翻转);SEMA_RETAIN_BACKGROUND=0 逃生' },
+    { field: 'retainBackgroundProcesses', lanes: ['interactive', 'print'], live: true, why: '缺省 ON(2026-07-26 起翻转);SEMA_RETAIN_BACKGROUND=0 逃生' },
     { field: 'promptProfile', lanes: ['interactive', 'print'], live: true, why: 'core 1.328 呈现轴 A/B 口,缺省不 stamp = 引擎缺省 simple' },
     { field: 'enableFork', lanes: ['interactive', 'print'], live: true, why: '显式布尔才 stamp([503]② fail-OPEN 教训:off 必须显式)' },
     { field: 'attachments', lanes: ['interactive', 'print'], live: true, why: 'design/133 + G1 缺省开的 turn 边界 attachment' },
-    // ⚠️ 这条 why 原文写的是本地技能目录的**字面路径**,B8 把本模块拉进壳的生产闭包之后,那串
-    //    字面量随 bundle 进了 `dist/sema.js` 并被壳的品牌门当场逮住(壳的 R11 codemod 只走自己
-    //    的 src,走不到 node_modules ⇒ 包里的 CC 路径字面 = 品牌面泄漏)。见本文件末的包内纪律。
     { field: 'skills', lanes: ['interactive', 'print'], live: true, why: '本地技能目录投影(布局取 CC 同款);两条车道都由 launchRepl 载入面注入' },
     { field: 'mcpServers', lanes: ['interactive', 'print'], live: true, why: '本地 .mcp.json 投影;service 单用户门决定是否兑现' },
     { field: 'settings.webSearch', lanes: ['interactive', 'print'], live: true, why: 'SEMA_WEBSEARCH_* / settings.json;per-request 配置赢过部署 env' },
     { field: 'settings.hooks', lanes: ['interactive', 'print'], live: true, why: '[495]① 用户 settings 文件 hooks 逐字上 wire' },
-    // ⚠️ 这一行 2026-08-17 之前是 `lanes:['interactive'] gap:true`(表内自标「这条差异没有正当理由,
-    //    是漏的」),#292 P1 把它补齐并搬进本节。补齐的理由不是对称美观,是 [4208] 实测的**权限方向**
-    //    后果:`-p` 车道上用户 settings 的 `permissions.deny/ask` 整体不被引擎求值(deny 拦不住),
-    //    而交互 REPL 同一份文件照拦 —— 两条车道对同一份配置给出相反的安全结论。
-    //    🔴 配对纪律:这一行只管**包内 stamp 门**;端还得把值放进 `input.settings.resolved`
-    //    (壳 print 车道 = `-p` 前置步装一个晚绑定供给器,`seamQueryEngine` 在拼装请求那一刻求值)。
-    //    任一半单独改都无效 —— 这正是本条修前长期停在 gap 的原因([4285]/[4309] 定谳)。
     { field: 'settings.<resolved>', lanes: ['interactive', 'print'], live: true, why: 'settings resolver 的 effective 快照(hooks/env/model + 已解析权限投影)。两条车道同源:交互面 replEntry / print 面 printModeEngine 各跑一遍同一个 resolver,产物经同一个 buildWireSettingsStamp 投影。开放集(子键不可枚举)⇒ unregisteredRequestKeys 放行本车道 settings 的**表外**子键,但表内异车道子键仍点名' },
-    // ── repo 场景五键([C135] 请托,2026-08-08):SDK TaskRequest 成文 passthrough 键(types doc
-    //    「scenario-specific fields like code-review's repo/council/debate/rounds ride here」),server
-    //    resolve-spec 顶层直读(council/debate 按 `=== true`,rounds 进 clamp [1,3])。lanes 与
-    //    scenario 同款(print 有 --scenario/SEMA_HEADLESS_SCENARIO,scan 场景无 repo 即 501/无意义,
-    //    值缺席不 stamp,登位为 -p 侧未来入口留座)。今天唯一供给方=web BFF lane 的 repo 字段入口。──
     { field: 'repo', lanes: ['interactive', 'print'], live: true, why: 'scan/code-review 场景的仓库坐标(passthrough;server 是权威校验方,本层不铸第二判官)' },
     { field: 'council', lanes: ['interactive', 'print'], live: true, why: 'code-review council 形开关(server 读 `=== true`;非 true 不 stamp=与缺席同义,发小的那个)' },
     { field: 'debate', lanes: ['interactive', 'print'], live: true, why: 'council 的 debate 变体开关(server 读 `=== true`)' },
     { field: 'rounds', lanes: ['interactive', 'print'], live: true, why: 'debate 轮数(server clamp [1,3],非有限数被 server 归 undefined——本层原样透传不预 clamp)' },
     { field: 'lenses', lanes: ['interactive', 'print'], live: true, why: 'code-review 镜头集(passthrough 同 repo;形状由 server 场景定义,本层不闭集)' },
-    // ── memoryCapture([7226] 包侧缺口 ⑤,0.68.1)──────────────────────────────────────────────
-    // 🔴 **单成员闭集**:server 契约 §12.4 逐字「`memoryCapture?: "off"`。单成员闭集(**没有**
-    //    `"on"`)」—— 所以本层只在值**恰是** `'off'` 时 stamp;`'on'` / 坏拼写一律不上 wire
-    //    (坏拼写 server 判 400 `request.field_invalid`,本层不预铸第二判官,但也不替它买路)。
-    // 🔴 与**中途翻转 verb** `POST /v1/runs/:id/memory/capture-optout`(§12.5,能力位
-    //    `runMemoryCaptureOptOut`)是**同一条一次性单向记录的两个口**,不是两个轴:verb 管这一条
-    //    在飞的 run,本键管「本会话的下一次新提交」。非 live 的 verb(parked / 终态 / 他副本)回
-    //    409 `steering.not_running` 并**指路本键** —— 端没有本键就接不住那条指路。
     { field: 'memoryCapture', lanes: ['interactive', 'print'], live: true, why: '本会话永远不进长期记忆的**声明形**(server §12.4 body 键,单成员闭集 "off");两条车道都是提交面 ⇒ 都能声明。与 memoryWrite:false 不是一个轴(那是「本 run 只读平面」)。⚠️ parked 续跑腿结构性拿不到声明(决策/续跑端点从持久 body 重建 spec),那是引擎侧事实,不是本层的漏' },
-    // ── memory:"off"(CC-39③,0.72.8;server 7.84.0 S-405 / core #863 W3)────────────────────────
-    // 🔴 契约 §12.7 姊妹键:`memoryCapture` = 「记忆照常用,但别记住我」(会话级采集面关,一次性);`memory` =
-    //    「这一次别给我记忆」(请求级整面关:不挂 # Memory 段 / 索引 / 三只记忆工具 / 写准入;零记录,可逐请求开关)。
-    //    同形、不同轴、可并存;两键共用同一只拼写判据(400 `request.field_invalid` 两腿同句)。缺席 = 记忆照常挂。
-    //    无能力位(7.78.1–7.83.x 只能 trial-by-400)⇒ 本层不预判 server 版本,照发。子代地板(ParentSpecSeat.memoryOff)归 core。
     { field: 'memory', lanes: ['interactive', 'print'], live: true, why: '这一次运行不挂记忆面的**请求级**开关(server §12.7 body 键,单成员闭集 "off");两条车道都是提交面 ⇒ 都能声明。与 memoryCapture(采集面)不是一个轴、可并存;与 memoryWrite:false(只读平面)也不是一个轴' },
-    // ── print 独有(§8-5 认定的**有理由**的差异)──────────────────────────────────────────────
     { field: 'finalVerification', lanes: ['print'], live: true, why: 'P1-1 终验:无人值守车道才需要引擎自证;交互 REPL 由人当场看结果。#106 裁 B(让位+告知)后交互面默认关' },
     { field: 'limits', lanes: ['print'], live: true, why: 'P2-3-b:`-p` 的预算护栏(--max-* flag 族),交互 REPL 由人随时 Esc' },
     { field: 'interactiveTools', lanes: ['print'], live: true, why: '[909]B 件3:无人值守 stamp false,从 roster 源头灭掉 AskUserQuestion/plan 门。交互车道 stamp false 等于自废武功' },
     { field: 'oneShot', lanes: ['print'], live: true, why: 'SDK TaskRequest.oneShot(server ≥7.12.0 消费):`-p` 提交是一次性的——没有后续回合接住异步后台通知,core 据此把「结束回合等通知」指引换成 block-wait;交互车道有后续回合,stamp true 就是谎报。老 worker 静默忽略(开集提交体),故发送侧不设能力位前置门(oneShotWireCaps 头注)' },
-    // ── 0.77.0(CC-101)print 车道补座两件:无人值守车道才有来源的请求位 ─────────────────────────
-    // 加座判据三处同时成立才加(缺一处 ⇒ 不加座,登 `upstream_absent`,见 {@link UPSTREAM_ABSENT_REQUEST_INTENTS}):
-    //   ① 装着的 sdk `TaskRequest` 型面上有这一位的**具名**声明(索引签名 `[k: string]: unknown` 不算 ——
-    //      它对任何键都成立,拿它当证据等于没有证据);② 上游提交体真读这一键;③ 引擎 spec 真消费它。
     { field: 'outputSchema', lanes: ['print'], live: true, why: '结构化输出约束(sdk `TaskRequest.outputSchema`:最终答案必须匹配的 JSON Schema)。上游只验形状与序列化尺寸(坏形 400 响亮拒)、深层合法性归引擎 ⇒ 本层原样透传、不预铸第二判官。来源只在无人值守车道(`--json-schema` 一类旗);交互面今天没有入口 ⇒ 缺席是**没有来源**,不是漏。⚠️ 本行只管**上行**这一位:结果一侧的结构化产出落不落 CC 形 result 帧是下行投影的事,不在本表' },
     { field: 'maxCostUsd', lanes: ['print'], live: true, why: '花费上限声明(sdk `TaskRequest.maxCostUsd`,请求体**顶层**位;上游向下夹到部署上限 —— 只许要得更少)。与 `limits` 同一条理由只在无人值守车道:交互面由人随时中断。🔴 坏值(非数 / 非有限 / 非正)在本层**响亮拒**:上游对这一位的坏值是安静忽略并回落部署上限,不是 4xx(见 `refuseBadMaxCostUsd`)' },
-    // ── interactive 车道独有 ────────────────────────────────────────────────────────────────────
-    // ⚠️ 「interactive」**不等于**「TUI」:web 的 BFF lane 也报 `interactive`
-    //    (`sema-web-client` `WEB_REQUEST_LANE`)。下面多数条目的理由写的是壳的 TUI 面 —— 它们是
-    //    B4 从壳的三个构造器逐行读出来的,那时这条车道只有壳一个消费者。`attachmentIds` 是**反过来**
-    //    的第一条:它今天只有 web/desktop 在发,壳反而没有这个入口。别把本节读成「壳独有」。
     { field: 'attachmentIds', lanes: ['interactive'], live: true, why: '附件**字节通道**(uploadAttachment 回执 id;server ≥1.289 绑定会话并把文件物化进 run 的 attachments/)。有上传入口的端才有 id 可引用:web/desktop 有,壳走 images / 本地文件路径,`-p` 车道连 uploadAttachment 都没有 ⇒ print 缺席是**没有来源**,不是漏。🔴 与上面的 `attachments` 同名不同物(那是 turn 边界的配置键),两条永远不许合并' },
     { field: 'excludeTools', lanes: ['interactive', 'print'], 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 门后的位,与交互面同一行)' },
+    { field: 'excludeAllTools', lanes: ['interactive', 'print'], 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 路由)' },
     { field: 'settings.ultracode', lanes: ['interactive'], live: true, why: 'design/111:sticky `/effort ultracode` 拨盘 + 当轮关键词嗅探,两个来源都只在交互面存在', gap: true },
-    // ⚠️ 下面两行 0.77.0(CC-101)之前是 `lanes:['interactive']`。修前的理由句(「print 腿的 params 没有这一位」/
-    //    「print 无 AppState」)描述的是搬迁当天壳内两个构造器的**形参**,不是 wire 事实:两位在 sdk `TaskRequest`
-    //    上都是与车道无关的具名顶层位,上游提交体与引擎 spec 两层都真消费。后果 = 无人值守车道传了也整键不上
-    //    请求体,而调用方拿不到任何信号(下游壳实测:只好把对应的旗判成「未接线」如实告知用户)。
-    //    行留在本节(而不是搬到「两条车道都有」那一节)只为让 diff 停在一行上;`lanes` 才是事实。
     { field: 'systemPrompt', lanes: ['interactive', 'print'], live: false, why: '整段替换系统提示(sdk `TaskRequest.systemPrompt`;上游字符数超限 400 响亮拒,本层原样透传)。两条车道都有来源:交互面 = CC QueryParams.systemPrompt,无人值守面 = `--system-prompt[-file]` 一类旗。与追加位 `appendSystemPrompt` 不是一个位(那一位归 live 兜底层,见 `LIVE_DEFAULT_FIELDS`)' },
     { field: 'reasoningEffort', lanes: ['interactive', 'print'], live: false, why: '思考档位(sdk `TaskRequest.reasoningEffort` 七词闭集;上游对表外词 400 响亮拒 ⇒ 本层不预铸第二判官)。档位是请求级的位、与车道无关:交互面 = `/effort` 拨盘,无人值守面 = 档位旗。🔴 端交的必须是**档位词**:「思考 token 数」今天没有上游对位(见 `UPSTREAM_ABSENT_REQUEST_INTENTS` 的 `maxThinkingTokens`),别把一个数字折成档位词发出去' },
     { field: 'model', lanes: ['interactive'], live: false, why: '`/model` 中途换模型读 toolUseContext.options.mainLoopModel;print 的模型走 MODEL_ID/--model 另一条路', gap: true },
     { field: 'images', lanes: ['interactive'], live: false, why: '贴图提交是交互动作,`-p` 的 stdin 没有图片块' },
-    // ⚠️ 四键一条(0.35.0 补第四键 `resumeAtMode`):它是 `rewindWireCaps` 的 `SeamRewindSpec` 真 wire 键,
-    //    且 `rewindSpecForMode` 的 `both` / `conversation` 两臂**恒返**它(排他截语义 —— 回到目标消息
-    //    **之前**)。修前合写项只列三键 ⇒ 真 `/rewind` 还原 turn 上 `unregisteredRequestKeys` 会点名
-    //    `resumeAtMode`,而那正是「本层不许有未登记键」这条判据的误报,会教端去白名单化真键。
     { field: 'resumeAt/resumeAtMode/rewindFiles/rewindFilesTo', lanes: ['interactive'], live: false, why: 'E18 `/rewind` 是交互命令;四键同生同灭(resumeAtMode 是 both/conversation 两臂恒带的排他截语义位)' },
     { field: 'clientContext', lanes: ['interactive'], live: false, why: 'IANA 时区 + 可选邮箱 → core 本地化 `# Environment` 的 today;print 同样跑在用户机器上,缺席让引擎误标 (UTC)', gap: true },
     { field: 'scratchpadDir', lanes: ['interactive'], live: true, why: '[816]③ per-session 暂存目录;print 也有 session,缺席让 `-p` 的工具写不进 exemptDir', gap: true },
 ];
-/** live 兜底层(`toLiveRequest`)追加的字段 —— 两条车道**都**经过,故不进上表。 */
 export const LIVE_DEFAULT_FIELDS = [
     'cwd',
     'additionalDirectories',
@@ -106,35 +52,6 @@ export const LIVE_DEFAULT_FIELDS = [
     'compactionModel',
     'sessionId(三态解析)',
 ];
-// ══ 逐键去向(0.77.0 / CC-101)════════════════════════════════════════════════════════════════════
-//
-// 修前的病形:stamp 门 `on()` 有**四种**说「不」的理由(值缺席 / 表里没有这一行 / 本车道不在 lanes 里 /
-// live 门没开),四种都折成同一个 `false`;而入参上构造器**压根不读**的键(表外键)连这个 `false` 都轮不到。
-// 调用方拿到的只有一份请求体 —— 少了哪个键、为什么少,没有任何位能答。
-//
-// 修形分两半,**刻意不合并**:
-//   (甲) 本包**认识**的键这一次没上请求体 ⇒ 不抛,照常装配,逐键给成因({@link TaskRequestOmission})。
-//        一个多余但无害的键不该把提交升级成硬失败;该知道的人从回执上知道。
-//   (乙) 本包**不认识**的键 ⇒ 响亮拒(`TypeError`)。不认识 = 三种可能分不开:打错的在座键名 / 真 wire 位而
-//        本包的表还没登记 / 纯垃圾。前两种里都可能是**收紧方向**的声明(排除工具、关记忆、花费上限),
-//        安静丢掉 = 这次运行比声明人以为的更宽,而且没有任何人会知道 —— 与 `memoryCapture` 坏拼写同一条
-//        纪律,只是错在键名那一轴。🔴 把这一档折成 (甲) 的某个成因词 = 拿「不知道」冒充「明确不带」。
-/**
- * 「入参里在场、却没上请求体」的**成因词表**(冻结)。🔴 词序就是判定序(先中先得),判定逐词走
- * {@link OMISSION_JUDGES} —— 那张判官表的键型就是本词表的成员型:加词不加判官 / 加判官不加词,编译当场红。
- *
- *   · `upstream_absent` —— 本包认识这个意图,但上游没有对位(sdk 型面无具名位,提交体与引擎 spec 也不读)。
- *                          见 {@link UPSTREAM_ABSENT_REQUEST_INTENTS}。恒不发,与车道 / live 无关。
- *   · `other_channel`   —— 是请求体上的真位,但**不归本构造器**盖:归 live 兜底层({@link LIVE_DEFAULT_FIELDS},
- *                          端在构造之后经 {@link applyLiveRequestDefaults} 落位)。塞进本构造器的入参 = 没发出去。
- *   · `off_lane`        —— 在车道表里,但本车道不在那一行的 `lanes` 里(理由读那一行的 `why`)。
- *   · `not_live`        —— 本车道有座,但那一行是 live 门后的位,而这一次 `input.live` 为假(mock / fixture 车道)。
- *
- * 🔴 本词表只答「**本构造器**这一次带没带」。带了 ≠ 引擎兑现了:老版本上游静默忽略新键、部署策略拒、
- *    能力位没开,那些只有引擎知道 —— 端不许拿「回执里没有这一键」去渲一句「已生效」。
- * ⚠️ **值级等价缺席不入回执**:空数组 / `council:false` / `oneShot` 非 `true` 这类值在 wire 上与缺席同义
- *    (构造器发小的那个),没有意图被丢,报它们只是噪音。
- */
 export const TASK_REQUEST_OMISSION_CAUSES = Object.freeze([
     'upstream_absent',
     'other_channel',
@@ -142,10 +59,6 @@ export const TASK_REQUEST_OMISSION_CAUSES = Object.freeze([
     'not_live',
 ]);
 const row = (field) => ({ via: 'matrix', field });
-/**
- * 🔴 键型 = `keyof Required<TaskRequestInput>`:入参型加一个键而这里不登记 ⇒ 编译红;这里多一个入参型没有的
- *    键 ⇒ 同样编译红。「入参型上声明了、构造器却从不读」的键因此不可能再安静存在(修前 `agents` 正是这一形)。
- */
 const INPUT_KEY_ROUTES = {
     objective: { via: 'always' },
     sessionId: { via: 'always' },
@@ -169,6 +82,7 @@ const INPUT_KEY_ROUTES = {
     attachments: row('attachments'),
     attachmentIds: row('attachmentIds'),
     excludeTools: row('excludeTools'),
+    excludeAllTools: row('excludeAllTools'),
     finalVerification: row('finalVerification'),
     limits: row('limits'),
     interactiveTools: row('interactiveTools'),
@@ -205,18 +119,11 @@ const SETTINGS_KEY_ROUTES = {
     webSearch: row('settings.webSearch'),
     ultracode: row('settings.ultracode'),
     hooks: row('settings.hooks'),
-    // 没有车道行:它是 live 兜底层登记的位(`appendSystemPrompt|settings.outputStyle`),构造器无条件原样带。
     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 })] : []));
 const hasOwn = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
-/** live 兜底层的裸键名(表项写法含 `|` 备选位与括号说明)。判据面与装配面同读这一只,不各抄一份解析。 */
 const liveDefaultKeyNames = () => new Set(LIVE_DEFAULT_FIELDS.flatMap(item => item.split('|')).map(name => name.replace(/\(.*\)$/, '').trim()));
-/**
- * **顶层**入参键 → 路由:入参型上的键 / 入参型之外的 live 兜底**裸**键(按 `other_channel` 认)/ 其余 = 不认识。
- * 🔴 点分名在这里**一律不认**:一个字面叫 `settings.ultracode` 的顶层键不是 `settings` 的子键 —— 构造器不读它,
- *    认它 = 判官说「带」而请求体上没有。
- */
 const routeOfTopLevelKey = (key) => {
     if (hasOwn(INPUT_KEY_ROUTES, key))
         return INPUT_KEY_ROUTES[key];
@@ -224,7 +131,6 @@ const routeOfTopLevelKey = (key) => {
         return { via: 'fixed', cause: 'other_channel' };
     return undefined;
 };
-/** 座位读数用的键名 → 路由:`settings.<sub>` 走点分名,其余同顶层。 */
 const routeOfInputKey = (key) => {
     if (key.startsWith('settings.')) {
         const sub = key.slice('settings.'.length);
@@ -232,10 +138,6 @@ const routeOfInputKey = (key) => {
     }
     return routeOfTopLevelKey(key);
 };
-/**
- * 车道表的一行。🔴 查不到 = **本包自己的表漂了**(装配代码点名了一行、表里却没有),不是调用方的错:
- * 修前这里是 `return false` —— 改名一行而漏改装配代码,那个键就此安静地永不上请求体,没有一道门会响。
- */
 const matrixRow = (field) => {
     const spec = REQUEST_FIELD_MATRIX.find(f => f.field === field);
     if (spec === undefined) {
@@ -244,21 +146,14 @@ const matrixRow = (field) => {
     return spec;
 };
 const standingOf = (route) => route.via === 'matrix' ? { via: 'matrix', spec: matrixRow(route.field) } : { via: 'fixed', cause: route.cause };
-/** 逐词判官 —— 键型就是词表的成员型(与词表的双向耦合在编译期咬死,见词表头注)。 */
 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),
     not_live: (s, _lane, live) => s.via === 'matrix' && s.spec.live && !live,
 };
-/** 唯一的「带不带」判官:`undefined` = 带。stamp 门与回执同读这一只 ⇒ 「回执说带了而请求体上没有」不可能成立。 */
 const omissionCauseOf = (s, lane, live) => TASK_REQUEST_OMISSION_CAUSES.find(cause => OMISSION_JUDGES[cause](s, lane, live));
-/** 车道闭集(`Record<RequestLane, true>`:型上加一条车道而这里不加 ⇒ 编译红)。 */
 const REQUEST_LANE_SET = { interactive: true, print: true };
-/**
- * 车道实参的运行期形核。🔴 修前一个表外的车道词(JS 调用方 / 拼写错)让**每一行**的 `lanes.includes` 都答假 ⇒
- * 产出只剩 `{objective, sessionId}`,而调用方拿不到任何信号 —— 与表外键同一个病,只是错在控制位上。
- */
 const refuseBadLane = (lane) => {
     if (typeof lane === 'string' && hasOwn(REQUEST_LANE_SET, lane))
         return;
@@ -266,17 +161,10 @@ const refuseBadLane = (lane) => {
         '表外的车道词会让车道表里每一行都判「不属于本车道」,请求体只剩 objective 与 sessionId 而没有任何信号,所以在装配前拒。错误文本只报形状,不回显值。');
 };
 const present = (v) => v !== undefined && v !== null;
-/** `rewind` 合写项的四个子键(从车道表派生,不手抄;表漂 ⇒ 空集 ⇒ 值级恒缺席,门 A 段当场红)。 */
 const rewindSubKeys = () => {
     const r = INPUT_KEY_ROUTES.rewind;
     return r.via === 'matrix' ? r.field.split('/') : [];
 };
-/**
- * 值级等价缺席(**唯一**判据表;stamp 与回执两口共用,不许各写一份):这些键的某些值在 wire 上与「没带」同义
- * (上游按 `=== true` / `=== false` / `=== 'off'` / 非空读;空数组 = 「带了 0 个」= 没带),本包发小的那个。
- * 🔴 回执口也按它判:一个值级缺席的键既不 stamp、也**不进回执** —— 否则 `oneShot:false` 在无座车道上会生一行
- *    「这一次没发出去」,而它本来就没有东西可发。表外的键值级恒在场(`present` 即在场)。
- */
 const VALUE_LEVEL_IN_PLAY = Object.freeze({
     council: (v) => v === true,
     debate: (v) => v === true,
@@ -285,30 +173,21 @@ const VALUE_LEVEL_IN_PLAY = Object.freeze({
     images: (v) => Array.isArray(v) && v.length > 0,
     attachmentIds: (v) => Array.isArray(v) && v.length > 0,
     excludeTools: (v) => Array.isArray(v) && v.length > 0,
+    excludeAllTools: (v) => v === true,
     memoryCapture: (v) => v === 'off',
     memory: (v) => v === 'off',
     rewind: (v) => typeof v === 'object' && v !== null && rewindSubKeys().some((k) => hasOwn(v, k) && present(v[k])),
 });
-/** 在场 ∧ 值级在场。 */
 const inPlay = (key, v) => present(v) && (VALUE_LEVEL_IN_PLAY[key]?.(v) ?? true);
-/**
- * 按名各读一次成一份无原型快照(读法 = 属性读,继承位 / 访问器与修前同一种读法;每键恰一次)。
- * `seed` = 调用方**已经读过**的位:照抄进快照,不读第二次(权限面那三位要先于一切别的读取,见装配口读序注)。
- */
 const snapshotByName = (source, keys, seed = {}) => {
     const out = Object.create(null);
     for (const k of keys)
         out[k] = hasOwn(seed, String(k)) ? seed[k] : source[k];
     return out;
 };
-/** 拒绝文本里单个键名的显示上限与清单上限(键名可能来自不可信入参 ⇒ 转义 + 封长;只进文案,不进判据)。 */
 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);
-/**
- * 座位读数(静态口:不装配请求就能问「这一键在这条车道上有没有座」)。`key` 是**入参键名**
- * (`settings` 的子键写点分名 `settings.ultracode`);与装配口同读一张路由表、同一只判官。
- */
 export function taskRequestSeatOf(key, lane) {
     refuseBadLane(lane);
     const route = typeof key === 'string' ? routeOfInputKey(key) : undefined;
@@ -317,7 +196,6 @@ export function taskRequestSeatOf(key, lane) {
     if (route.via === 'always' || route.via === 'control' || route.via === 'settings')
         return SEATED_UNGATED;
     const standing = standingOf(route);
-    // live 取真 = 问的是「车道上有没有座」;`not_live` 的判官要 live 为假才中,故此处永不返回它(型上同样排除)。
     const cause = omissionCauseOf(standing, lane, true);
     if (cause !== undefined && cause !== 'not_live')
         return Object.freeze({ seat: 'none', cause });
@@ -326,44 +204,9 @@ export function taskRequestSeatOf(key, lane) {
 const SEAT_UNKNOWN = Object.freeze({ seat: 'unknown' });
 const SEATED_UNGATED = Object.freeze({ seat: 'seated', liveGated: false });
 const SEATED_LIVE_GATED = Object.freeze({ seat: 'seated', liveGated: true });
-/**
- * 本车道**不拥有**的具名 settings 子键(= 表里有 `settings.<sub>` 行、而该行的 lanes 不含本车道)。
- *
- * 用处只有一个:{@link unregisteredRequestKeys} 的判据面。`settings.<resolved>` 是**开放集 spread**
- * —— 快照里的子键原样就是 wire 键,所以那条车道的 `settings` 走开放集口径(表外子键放行)。但
- * 开放集**不是**整只 `settings` 免检:一个「表里点名了、却不属于本车道」的子键(今天 = print 的
- * `settings.ultracode`)是**可枚举的已知量**,放过它等于让那条登记在真 wire 面失效。反过来,本车道
- * **自己**那些具名子键合法出现在 wire 上(它们从具名通道来),所以本集合按车道排除,不含它们。
- *
- * 🔴 构造器侧用的是另一个集合({@link namedSettingsSubKeys},全集)—— 两个集合不是同一件事,别合并:
- * 判据问的是「这个键该不该出现在 wire 上」,构造器问的是「这个键该由哪条通道决定」。
- */
 const foreignSettingsSubKeys = (lane) => REQUEST_FIELD_MATRIX.filter(f => f.field.startsWith('settings.') && f.field !== 'settings.<resolved>' && !f.lanes.includes(lane)).map(f => f.field.slice('settings.'.length));
-/**
- * **具名通道管着的**全部 settings 子键 —— 表里凡有 `settings.<sub>` 行的都算,**不分车道**。
- *
- * 与 {@link foreignSettingsSubKeys} 的分工(两个集合,两件事):
- *   · foreign(**异车道**子集)= 判据面用 —— 真 wire 上出现一个「表里点名了、却不属于本车道」的
- *     子键要被点名;本车道自己那些具名子键**合法**出现在 wire 上(它们从具名通道来)。
- *   · named(**全集**)= 构造器面用 —— 快照通道对具名通道管着的键**一律让位**,理由见下。
- */
 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';
-/**
- * 形状描述(错误文本用):只报**形**,一个字节的内容都不带(快照里有 env / 权限面)。
- *
- * 载体名(prototype 的 constructor 名)是代码标识符不是用户数据,可以报 —— 它是「你传进来的是个
- * 什么东西」这个问题唯一有用的线索。取值整段包在 catch 里:proxy / 带副作用 getter 的载体能让
- * `toString` 与 `constructor` 都抛错,而**构造错误文本时抛错**会把「拒」这个判决换成一个面目全非的
- * 异常。判决是拒,描述只是线索,取不到就报 unreadable。
- */
-/**
- * 拒绝文本用的**粗分类**(0.72.8 异源复审第二轮 [medium] 真修):只用 `typeof` / null / array 三个固定词,**不**读
- * `Symbol.toStringTag`、也不读 prototype 的 constructor 名 —— 那两样都是**调用方可控**的串,对象可以借它们把敏感内容
- * 带进错误展示 / 日志。memory 一族(隐私 / 记忆面声明)的拒绝路径一律走它;`shapeTag` 留给 settings.resolved 那类
- * 载体形诊断(那里报的是构造器名这一线索,与本族的「只报形状不回显值」纪律不同)。
- */
 const coarseShape = (v) => v === null ? 'typeof=object / null' : Array.isArray(v) ? 'typeof=object / array' : `typeof=${typeof v}`;
 const shapeTag = (v) => {
     try {
@@ -374,41 +217,15 @@ const shapeTag = (v) => {
         return `typeof=${typeof v} / ${Object.prototype.toString.call(v)} / prototype=${carrier}`;
     }
     catch {
-        // 形状取不到 ⇒ 只报 typeof(拒本身已经成立,描述缺一半不影响判决)。
         return `typeof=${typeof v} / shape=unreadable`;
     }
 };
-/**
- * plain object 判别 —— 按 **prototype** 判,不按 `Object.prototype.toString` 的标签判。
- *
- * 🔴 标签判法是**假的**(0.35.0 对抗复审 [high] 采纳):`[object Object]` 对**普通类实例**同样
- * 成立,而 `Symbol.toStringTag` 还能让任意载体自报这个标签。放它过去之后,下面的摊开用的是
- * `Object.entries`(**只取自有可枚举键**)—— 于是一个把 `permissions.deny/ask` 挂在**原型 getter**
- * 上的载体会摊出一个**空快照**,请求照发 = 权限静默变宽,正是本节要堵的那个 fail-open 形。
- *
- * 所以合法载体只有两种:**对象字面量**(原型链只有一层)与 `null` 原型(`Object.create(null)`,常见于
- * 「无污染字典」写法)。两者的自有可枚举键集**就是**全部内容,`Object.entries` 不会漏。类实例 /
- * `Map` / `Date` / boxed 包装对象 / 数组一律拒 —— 它们要么内容不在自有键上,要么摊开就是垃圾键;
- * 「上游产出坏了」比「悄悄发一个更宽的权限面」更该被人看见。
- *
- * 🔴 判据 **realm 无关**(0.35.0 对抗复审第八轮 [medium] 采纳):不拿「**本** realm 的
- * `Object.prototype`」做身份比较 —— iframe / `node:vm` / 另一个渲染进程里的对象字面量各有**自己的**
- * `Object.prototype`,身份比较会把这些**完全合法、JSON 忠实**的载体误判成异形,在 web / desktop 宿主
- * 上变成提交前的硬失败。
- *
- * 🔴 但「realm 无关」不等于「按原型链**层数**判」(第九轮 [medium] 采纳):`Object.create(X)`(X 是个
- * 自造的**无原型**对象)与 `class … extends null` 的实例都只有一层,却能把 `deny` 挂在那层**继承**位上
- * —— 而摊开只看自有键(`JSON.stringify` 也只看自有键),于是规则整条不见。所以判的是「直接原型是不是
- * **某个 realm 的**内建 `Object.prototype`」:取那层原型的**自有** `constructor`,要求它是个函数且
- * 源码文本与本 realm 的 `Object` 逐字相同(内建函数的源码是 `function Object() { [native code] }`,
- * 跨 realm 一致、而 `Map`/自定义类各不相同)。自造原型没有自有 `constructor` ⇒ 拒。
- */
 const isPlainRecord = (v) => {
     if (typeof v !== 'object' || v === null)
         return false;
     const proto = Object.getPrototypeOf(v);
     if (proto === null)
-        return true; // Object.create(null) 无污染字典:自有键就是全部内容
+        return true;
     if (typeof proto !== 'object')
         return false;
     if (!Object.prototype.hasOwnProperty.call(proto, 'constructor'))
@@ -418,9 +235,6 @@ const isPlainRecord = (v) => {
         return false;
     if (Function.prototype.toString.call(ctor) !== Function.prototype.toString.call(Object))
         return false;
-    // 🔴 还要求「这个原型**就是**那个构造器的 prototype」(第十轮 [high] 采纳):只比源码文本可以被
-    //    **冒充** —— 自造一个无原型对象、给它塞 `constructor: Object`,源码文本自然对得上,规则却挂在
-    //    它的继承位上。真 `Object.prototype`(任何 realm)恒满足 `Object.prototype === proto`,冒充者不满足。
     return ctor.prototype === proto;
 };
 const materializeJsonFaithful = (v, path, seen = new Set()) => {
@@ -432,56 +246,31 @@ const materializeJsonFaithful = (v, path, seen = new Set()) => {
     if (t === 'number') {
         return Number.isFinite(v) ? { value: v } : { bad: `${path}(非有限数 ⇒ 序列化成 null)` };
     }
-    // function / symbol / bigint / undefined(数组元素形)都不是 JSON 值
     if (t !== 'object')
         return { bad: `${path}(typeof=${t} 不是 JSON 值)` };
     const o = v;
     if (seen.has(o))
         return { bad: `${path}(循环引用)` };
-    // 🔴 读的**次序**要跟原生 `JSON.stringify` 一致,而它只在两件事上有定义(第十三轮 [high] 采纳):
-    //    ① 它**先查一次 `toJSON`**、再枚举内容 —— 所以这一查必须排在捕获**之前**,而且只查一次
-    //      (`toJSON` 可以是个带副作用的**访问器**:实测一个「push 一条规则再返回 undefined」的 getter
-    //      能让原生序列化出 `{"deny":["Write"]}`,我们若晚查一步就会发 `{"deny":[]}` = 比原生更宽);
-    //    ② 它**从不读原型** —— 所以 `isPlainRecord` 那一读只能排在捕获**之后**(见下:那一读可被陷阱化
-    //      并带副作用,排在前面就是本层自己引入的丢失面)。
-    //    一句话:**原生会做的读,按它的次序做;原生不做的读,一律推到捕获之后。**
     const toJSONProp = o.toJSON;
     if (typeof toJSONProp === 'function')
         return { bad: `${path}(自报 toJSON ⇒ 字节被改写)` };
     seen.add(o);
     try {
         if (Array.isArray(o)) {
-            // 🔴 **不调载体自己的实例方法**(第五轮 [high]):`o.entries()` 是可覆盖的 —— 一个 `['Write']`
-            //    自带一个什么都不产的 `entries` 就能让本函数重建出 `[]`,而原生 `JSON.stringify` 照发
-            //    `["Write"]`:那样**重建自己**成了丢规则的那一环。改按捕获长度 + 数字下标走
-            //    (`Array.isArray` 与 `length` 不经用户方法),与 stringify 读数组的方式一致。
-            // 🔴 长度**只强制转换一次**,且按真正的 `ToLength` 边界(第十五轮 [high] + 第十六轮 [high]):
-            //    ① 存下来的可能是个**对象**(Proxy 的 get 陷阱能让 `length` 返回带 `valueOf` 的对象),
-            //      于是 `i < len` 每轮都重新求值 —— 一个「第一次给 3、以后给 1」的 length 能让原生发三条规则、
-            //      我们只发一条 = 掉规则。原生走 `ToLength(Get(O,'length'))` **一次**,这里也只转一次。
-            //    ② `!isFinite ⇒ 0` 是**错的**:实测原生对 `length: Infinity` 抛 `RangeError`、对 BigInt 抛
-            //      `TypeError`(ToNumber 不接 BigInt),而归 0 会让我们**静默发一个空 deny** = 权限变宽。
-            //      两形按契约① 响亮拒。`NaN` / 负数 / `-Infinity` 归 0 才是与原生一致的(原生也发 `[]`)。
             const rawLen = o.length;
             if (typeof rawLen === 'bigint' || typeof rawLen === 'symbol') {
                 return { bad: `${path}(length 是 ${typeof rawLen} ⇒ 原生序列化直接抛,归 0 会静默发空表)` };
             }
-            // 🔴 转换要用**抽象 ToNumber**,而 `Number(x)` 不是它(第十七轮 [high],实测):`Number()` 接受
-            //    **对象强制出来的 BigInt**(`{valueOf(){return 0n}}` / `Object(0n)` / `Symbol.toPrimitive→0n`
-            //    都得 0),而原生 `JSON.stringify` 在同样输入上抛 `TypeError` ⇒ 归 0 就成了「静默发空 deny」。
-            //    一元 `+` **就是** ToNumber:BigInt / symbol 一律抛,接住它翻成本层的「拒」。只转一次不变。
             let lenNum;
             try {
                 lenNum = +rawLen;
             }
             catch {
-                // ToNumber 抛(BigInt / symbol,含对象强制形)⇒ 原生也抛,拒。
                 return { bad: `${path}(length 按 ToNumber 转换即抛(BigInt/symbol 形)⇒ 原生序列化也抛,归 0 会静默发空表)` };
             }
             if (lenNum === Number.POSITIVE_INFINITY) {
                 return { bad: `${path}(length 是 +Infinity ⇒ 原生序列化抛 RangeError,归 0 会静默发空表)` };
             }
-            // ToLength 的其余分支:NaN / 负数 / -Infinity ⇒ 0;有限数截断后封顶 2^53-1。
             const len = Number.isNaN(lenNum)
                 ? 0
                 : Math.min(Math.max(0, Math.trunc(lenNum)), Number.MAX_SAFE_INTEGER);
@@ -492,118 +281,44 @@ const materializeJsonFaithful = (v, path, seen = new Set()) => {
                     return r;
                 items.push(r.value);
             }
-            return { value: items }; // 重建:原数组(可能是子类/带访问器/带覆盖方法)不出门
+            return { value: items };
         }
-        // 🔴 重建成**无原型**记录(0.35.0 对抗复审第七轮 [high] 的可采半场):
-        //   ① 忠实 —— 源本来就允许 `Object.create(null)` 字典,重建成 `{}` 等于把载体形换掉了;
-        //   ② 少一条改写面 —— 无原型记录不会继承任何**事后**装到 `Object.prototype` 上的 `toJSON`。
-        //   ⚠️ 但这只关掉了 record 那一半:重建出来的**数组**必须是真数组(`Array.isArray` / 序列化成
-        //      `[...]` 都依赖 `Array.prototype`),所以「构造之后有人污染内建原型」这条**在数组上无解** ——
-        //      那种进程里每个对象、每个库都已经不可信了,不是本层能兜的射程。少声称,别装。
         const rec = Object.create(null);
-        // 🔴 键先捕获、值**逐个即读即建**(第五轮 [high]):`Object.entries` 会把所有值先读齐再递归拷贝,
-        //    于是后一个属性的 getter 能在前一个值被拷走**之前**把它清空(拿到的是同一个引用)。
-        //    stringify 也是「先取键、再逐键读值」,按它的次序走才叫忠实。
         for (const k of Object.keys(o)) {
             const val = o[k];
             if (val === undefined)
-                continue; // record 值缺席 = 该键不存在,序列化丢它是对的
+                continue;
             const r = materializeJsonFaithful(val, `${path}.${k}`, seen);
             if ('bad' in r)
                 return r;
-            // 🔴 `defineProperty` 而不是 `rec[k] = …`(第五轮 [high]):`k` 可以是 `__proto__` —— 那是
-            //    `JSON.parse` 出来的**普通数据键**(stringify 照发),而 `rec['__proto__'] = v` 会打到
-            //    `Object.prototype` 的 setter 上:键整个丢掉、还顺手换了目标对象的原型。
             Object.defineProperty(rec, k, { value: r.value, enumerable: true, writable: true, configurable: true });
         }
-        // 🔴 判据的读法**一律排在捕获之后**(0.35.0 对抗复审第十二轮 [high] 采纳):`toJSON` 走属性
-        //    查找、`isPlainRecord` 走 `getPrototypeOf`/`constructor` —— 这三种读法**都可以带副作用**
-        //    (`getPrototypeOf` 陷阱在被问的那一刻把 `deny` 清空),而**原生 `JSON.stringify` 从不问原型**。
-        //    校在捕获之前 = 本层自己的读法成了丢内容的那一环(比被动撒谎更糟:那是我们引入的丢失面)。
-        //    次序改成「先按 stringify 的口径捕获,再校原件,校不过就丢掉捕获物」⇒ 校本身再有副作用也
-        //    影响不到已经捕获的那份,而拒绝面一字未变。
         if (!isPlainRecord(o))
             return { bad: `${path}(${shapeTag(o)})` };
-        return { value: rec }; // 重建:出门的是无原型纯记录,访问器/原型/隐藏位都留在原对象上
+        return { value: rec };
     }
     finally {
         seen.delete(o);
     }
 };
-/**
- * 快照 → 摊开成 `settings` 子键前的两道处理:**具名通道让位** + **畸形响亮拒**。
- *
- * ## ① 具名通道管着的键一律让位(0.35.0)
- *
- * 快照是**开放集 spread**(子键原样就是 wire 键),所以它天生是一条**第二通道**。0.34.0 只剥了
- * 「车道异名」键(表里那行的 lanes 不含本车道),于是**两条车道都登记**的具名键剥不到 ——
- * 而那些键各有自己的治理门:`settings.hooks` 的具名通道在「工作区未受信 / 管理侧明令关停全部
- * hooks / 检查本身抛错」时判**不投**(端给的 `settings.hooks` 就是 `undefined`),可快照里那份
- * **没过那道门**的 hooks 照样被摊上 wire ⇒ 关停令等于没下。
- *
- * 所以让位不能靠**合并序**(具名键排在快照之后覆盖它)—— 那只在具名通道**有值**时有效,而
- * 治理门否决时的表现恰恰是**没值**。修形 = 结构剥离:凡具名通道管着的子键,快照一概不产。
- * 「谁该决定这个键上不上 wire」只有一个答案:那条具名通道(和它的门)。
- *
- * 🔴 剥得**窄**:只剥表里点名的具名子键。快照**表外**的子键(permissions / env / model / …)
- * 原样摊开 —— 那是开放集的全部意义;`outputStyle` 没有车道行(它是 live 兜底层的位)故不受影响。
- *
- * ## ② 畸形快照响亮拒(0.35.0,fail-closed)
- *
- * `undefined` / `null` = **合法缺席**(端没解析出快照;老写法拿 null 当空快照传),照旧降空对象。
- * 其余非 plain-object 形(数组 / 原始值 / boxed 包装对象 / Map / **类实例**…)= **上游产出坏了**:
- * 0.34.0 把它们一律降空,可这一位摊开的正是**已解析权限面** —— 降空 = 请求带着「被剥掉的
- * deny/ask」照发出去,引擎侧看到的是一个权限更宽的会话,而且没有任何人会知道。宁可停在提交前:
- * `TypeError` 带形状描述(合法载体的判据见 {@link isPlainRecord} —— 「摊得全」是它的全部理由)。
- * (本包是发出去的 npm 公开面:JS 调用方与版本偏斜的宿主都到得了这里,型面拦不住。)
- *
- * ## ③ 权限面**子树**同样要摊得全(0.35.0 对抗复审第二轮 [high] 采纳)
- *
- * 只校最外层是不够的:`{ permissions: new Map([['deny',['Write']]]) }` 的外层是合法字面量,可
- * `JSON.stringify` 把那只 Map 序列化成 `"permissions":{}` —— deny 规则**静默消失**,与 ② 要堵的
- * 是同一个权限变宽形,只是深了一层。所以 `permissions` 子树递归过 {@link materializeJsonFaithful}:
- * plain record / 数组 / JSON 原始值才算摊得全,`Map`/`Set`/类实例/boxed/环一律拒。
- *
- * 🔴 **射程刻意只到 `permissions`**,不做整份请求体的深净化:那是「包级 wire 载荷 JSON-safe
- * 规范化」独立工单(同一条论证对 `agents`/`hooks`/`attachments` 一样成立),不在本批。这条边界
- * 不是随手划的 —— `permissions` 是**权限方向**的那一位:它的内容丢一条 = 会话权限变宽;而
- * `env`/`model` 之类配置位的同款畸形是功能缺失,会被人当场看见,不是安全面静默偏移。
- * 判据形状**不猜 schema**(不要求「deny 必须是字符串数组」——那会在 server 契约扩形那天误红),
- * 只问「序列化后还是不是同一份内容」。
- */
 const resolvedSnapshotForWire = (resolved) => {
     if (resolved === undefined || resolved === null)
         return {};
-    // 原始值 / 函数 / symbol:没有任何可捕获的内容,立刻拒(不必先捕获 —— 拒得早不会丢东西)。
     if (typeof resolved !== 'object') {
         throw new TypeError(`buildTaskRequest: settings.resolved 只接受 plain object 或缺席(undefined/null)—— 收到 ${shapeTag(resolved)}。` +
             '这一位摊开的是已解析权限面(permissions.deny/ask 等子键即 wire 键):把畸形值降成空对象' +
             '等于让请求带着被剥掉的权限面发出去(deny 静默失效),所以在提交前拒。' +
             '错误文本只报形状,不回显快照内容。');
     }
-    // 🔴 **外层的载体判据也排在捕获之后**(第十二轮 [high],与内层同一条):`isPlainRecord` 要读
-    //    `getPrototypeOf` —— 那是**原生序列化从不做**的一次读,而它可以被陷阱化并带副作用(被问原型的
-    //    那一刻把 `permissions.deny` 清空)。所以先按 stringify 的口径把内容取走(下面的循环会把权限面
-    //    当场物化成脱钩副本),原件的形状判据留到最后;校不过就整体拒,拒绝面一字未变。
     const named = namedSettingsSubKeys();
     const out = {};
-    // 🔴 **键先捕获、值逐个即读即处理**(0.35.0 对抗复审第六轮 [high]):`Object.entries(resolved)`
-    //    会把**所有兄弟键**的值先读齐 —— 于是一个 `env`/`model` 位上的 getter 能在 `permissions` 被
-    //    重建**之前**把它的 deny 数组清空(拿到的是同一个引用)。这与内层那条(见
-    //    {@link materializeJsonFaithful} 第五条)是同一个病、只是高一层:两层都必须按 stringify 的
-    //    次序走(先取键、再逐键读值),否则「校的就是发的」在外层又漏了一次。
     for (const k of Object.keys(resolved)) {
         if (named.includes(k))
             continue;
         const v = resolved[k];
         if (k === PERMISSION_FACE_KEY) {
-            // 值缺席 = 该键不存在(与内层 record 同一条口径),整键不出现。
             if (v === undefined)
                 continue;
-            // ③ 权限面:**即读即校即建**(射程与理由见头注 ③;报的是**路径**不是值)。
-            // 🔴 函数载体也必须走这条 —— 修前它先被下面那条「函数值一律不进」吃掉,于是
-            //    `permissions: () => …`(哪怕自带 deny)**整键静默消失** = 请求带着更宽的权限面发出去,
-            //    正是本节要堵的形。权限面的畸形只有一个诚实终态:拒。
             const checked = materializeJsonFaithful(v, PERMISSION_FACE_KEY);
             if ('bad' in checked) {
                 throw new TypeError(`buildTaskRequest: settings.resolved 的权限面子树在 ${checked.bad} 处不是 JSON 可摊全的载体 —— ` +
@@ -612,22 +327,13 @@ const resolvedSnapshotForWire = (resolved) => {
                     '而权限面丢一条 = 会话权限静默变宽。合法载体 = 对象字面量 / 数组 / JSON 原始值(有限数)。' +
                     '错误文本只报路径与形,不回显内容。');
             }
-            // 出门的是重建那一份(不是原引用):端此后再动原对象、或原对象上挂着访问器,都影响不到已
-            // 提交的这份请求体。合法输入的字节与修前逐字相同(重建只丢 stringify 本来就会丢的东西)。
             out[k] = checked.value;
             continue;
         }
-        // 🔴 函数值一律不进(#292 P1 对抗复审第三轮 [medium] 采纳):JSON wire 上没有函数,而一个
-        // **自有 `toJSON`** 会在序列化那一刻整只改写 `settings` 的字节 —— 实测
-        // `resolved={permissions:…, toJSON(){return {ultracode:true}}}` 能让 `JSON.stringify(req)` 出
-        // `settings:{ultracode:true}`,把上面那道车道剥离(以及一切按对象查的判据)整体绕过。
-        // 「真上 wire 的那份」= 序列化后的字节,所以过滤必须发生在**值**这一层,而不是只看键名。
-        // (权限面**不**走这条:静默丢弃在那一位上是权限变宽,见上面那臂。)
         if (typeof v === 'function')
             continue;
         out[k] = v;
     }
-    // 内容都取走之后才校外层载体的形(见上面那条红线:这一读可能带副作用,不许排在捕获之前)。
     if (!isPlainRecord(resolved)) {
         throw new TypeError(`buildTaskRequest: settings.resolved 只接受 plain object 或缺席(undefined/null)—— 收到 ${shapeTag(resolved)}。` +
             '这一位摊开的是已解析权限面(permissions.deny/ask 等子键即 wire 键):把畸形值降成空对象' +
@@ -636,86 +342,17 @@ const resolvedSnapshotForWire = (resolved) => {
     }
     return out;
 };
-/**
- * 合一后的请求构造器 —— **按车道出两形**,字段集差异全部由 `REQUEST_FIELD_MATRIX` 决定。
- *
- * 🔴 行为纪律:本函数**不做任何统一**。print 没有 `ultracode` 就是没有(表里 `gap:true` 记着账),
- * 补齐要另立项 —— 在这里顺手加一行,就是把「合一」偷换成「行为改动」。
- */
-/**
- * ⑤ 的**响亮拒**([7226] 包侧缺口 ⑤;异源对抗复审轮五 finding① 采纳)。
- *
- * 🔴 修前这里是「不是 `'off'` 就整键不 stamp」——**静默删键**,而删掉的恰是一条**隐私声明**:
- *    一个把 `/memory-capture off` 打成 `OFF` 的会话,请求照发、引擎照常采集,**没有任何人会知道**。
- * 🔴 上游把这条写死了(装机 core `dist/core/memory.d.ts` 的 `capture?: "off"` 头注**逐字**):
- *    「Any other value — `"on"`, `"OFF"`, booleans, garbage — is REFUSED loudly
- *    (`config.memory_capture_spelling`), never read as either state (**a privacy request must not be
- *    dropped by a typo**, and capture must not be switched off by one either)」;server 契约 §12.4
- *    同样写明坏拼写 400 `request.field_invalid`,并点名「把一条隐私请求按打字错误静默丢掉恰是**禁的方向**」。
- *    ⇒ 提前删键 = 把上游那道响亮门**绕过去**,方向正好反了。
- * 🔴 与本文件 `resolvedSnapshotForWire` 对畸形权限快照的处置**同一条纪律**(那里也是抛,理由逐字
- *    是「降空 = 让请求带着被剥掉的权限面发出去」)——两处都是**声明方向**的位:丢了没人看得见。
- * ⚠️ `undefined` / `null` = **合法缺席**(端没有这个入口 / 没有声明),照旧不 stamp,不拒。
- * ⚠️ **不分车道、不受 live 门**:拒绝不是「stamp 一个键」,不改请求形状;而一条打错字的隐私声明
- *    在哪条车道上都不该被默默放行。
- * (本包是发出去的 npm 公开面:JS 调用方与版本偏斜的宿主都到得了这里,型面拦不住。)
- */
-/**
- * wire 上那个**单成员闭集**的唯一字面(server §12.4)。导出它是为了让端的断言/门有一个机读锚,
- * 🔴 **不是**为了让端拿它去自己拼请求 —— 拼请求走 {@link memoryCaptureDeclarationField}。
- */
 export const MEMORY_CAPTURE_OFF = 'off';
-/**
- * 「本会话声明过 opt-out 没有」这个**意图位** → 提交腿的 spread-ready 片段(L-316,0.68.2)。
- *
- * ── 为什么这一只在包里(归层,不是搬家)────────────────────────────────────────────────────
- * 端手里只有一个**布尔**:「这条会话敲过 `/memory-capture off` 没有」。而 wire 上那个值是
- * **单成员闭集**的一个字面串 —— 谁铸这个串,谁就得同时承担「拼错了会被 400 响亮拒、而且这是
- * 一条**隐私**声明、拼错即静默失效」这件事。cli 1.0.x 起这个串在壳里另有一处铸点
- * (`memoryCaptureOptOut.memoryCaptureRequestField`),web / desktop 接这条腿时会各铸第三、第四处
- * —— 三端各写一个字面量,正是本层存在的理由(与 `taskNotificationToPrintFrame` 同一条先例)。
- * ⇒ 端交**意图位**,值由本层唯一铸出;拼写门与 {@link buildTaskRequest} 的响亮拒共用同一个字面。
- *
- * 🔴 **`false` ⇒ 整键缺席**,不是 `{ memoryCapture: undefined }`、更不是某个「on」值:wire 上
- *    压根没有那个值(单成员闭集),**缺席就是「照常采集」的唯一写法**。所以未启用时本片段对
- *    wire 字节零影响。
- * 🔴 **本层只答「下一条提交带不带这一键」,不答「采集关没关」**:后者只有引擎知道(老 worker
- *    静默忽略本键 / 部署策略 403 / 控制面写失败),任何端都不许拿这一位去渲一句「已经关了」。
- *
- * 用法(端逐字照抄,别在外面再包一层字面量):
- * ```ts
- * buildTaskRequest({ …, ...memoryCaptureDeclarationField(declaredForThisSession) }, 'interactive')
- * ```
- */
 export function memoryCaptureDeclarationField(declared) {
     return declared ? { memoryCapture: MEMORY_CAPTURE_OFF } : {};
 }
-/** `memory: "off"` 的唯一字面(server §12.7;core #863 W3)。 */
 export const MEMORY_OFF = 'off';
-/**
- * 「这一次别给我记忆」的**意图位** → 提交腿的 spread-ready 片段(CC-39③,0.72.8;与 {@link memoryCaptureDeclarationField} 同律)。
- * 🔴 `false` ⇒ 整键缺席(= 记忆照常挂的唯一写法),不是 `{ memory: undefined }`、更不是某个「on」值。
- * 🔴 本层只答「下一条提交带不带这一键」,不答「这次真的没挂记忆面」:后者只有引擎知道(老 server 400 / 更老 worker 静默忽略);
- *    终局 memory 状态词 `disabled`(不是 `no-spec`)才是引擎的答案,端别拿这一位去渲「已关」。
- * 🔴 两键同发(`memoryCapture:"off"` + `memory:"off"`)时 capture 的单向记录**不落**(core 只在挂引擎时记)—— 契约 §12.7 写真话,
- *    不许拿 `memory:"off"` 当隐私声明;要「别记住我」用 memoryCapture 那一键。
- */
 export function memoryOffDeclarationField(declared) {
     return declared ? { memory: MEMORY_OFF } : {};
 }
-/**
- * 端的两个入口 → 「这一次别给我记忆」的**意图位**(cli [7510]:发口投影归包,三端同判、壳零自判)。
- *   · `flag`:CLI 旗 `--memory <word>` 的原词 —— **只认恰 `'off'`**(单成员闭集;`'on'` / 大小写 / 带空格一律不认,
- *     那些拼法上 wire 会被 server 400,而本层不替它买路也不替它编);
- *   · `settingsMemory`:settings 的 CC 形 `memory` 段 —— **只认严格 `{ enabled: false }`**(`"false"` / `0` / 缺席 = 沉默不是关,
- *     与 core `ParentSpecSeat.memoryOff` 只从显式 `enabled: false` 铸同律)。
- * 任一成立 ⇒ `true`;其余 / 坏形 / 非对象入参 ⇒ `false`(= 键缺席,记忆照常挂)。喂给 {@link memoryOffDeclarationField}。
- */
 export function memoryOffDeclared(input) {
     if (typeof input !== 'object' || input === null)
         return false;
-    // 🔴 异源对抗复审 [medium] 真修:入口投影**不许**把打错字的收紧声明降级成「缺席」—— 那样片段函数删键、`refuseBadMemoryOff`
-    //    无从校验,用户以为关了、这次运行照常挂上记忆面。旗在场但不是 'off' ⇒ 响亮拒(与 buildTaskRequest 同律,不回显值)。
     const flag = input.flag;
     if (flag !== undefined && flag !== null && flag !== MEMORY_OFF) {
         throw new TypeError(`memoryOffDeclared: --memory 旗只接受字面量 \'off\' 或缺席 —— 收到 ${coarseShape(flag)}。上游是单成员闭集(没有 "on"),` +
@@ -728,7 +365,6 @@ export function memoryOffDeclared(input) {
             throw new TypeError(`memoryOffDeclared: settings 的 memory 段必须是对象 —— 收到 ${coarseShape(sm)}。`);
         }
         const enabled = sm.enabled;
-        // CC 形 `memory: { enabled }`:缺席 = 沉默(不是关);在场必须是布尔 —— "false" / 0 是打错字的收紧声明,同样响亮拒。
         if (enabled !== undefined && typeof enabled !== 'boolean') {
             throw new TypeError(`memoryOffDeclared: settings memory.enabled 在场时必须是布尔 —— 收到 ${coarseShape(enabled)}。`);
         }
@@ -746,6 +382,13 @@ const refuseBadMemoryOff = (v) => {
         '`"on"`,`{ enabled: false }` 对象形也不是 wire 拼法)且对坏拼写**响亮拒**(server 400 `request.field_invalid`)。' +
         '本层若静默删键,这一次运行会照常挂上记忆面而声明人不会知道 —— 与 memoryCapture 同一条纪律。错误文本只报形状,不回显值。');
 };
+const refuseBadExcludeAllTools = (v) => {
+    if (v === undefined || v === null || v === true || v === false)
+        return;
+    throw new TypeError('buildTaskRequest: excludeAllTools 只接受字面量 `true`(`false` / 缺席 = 不卸载)—— ' +
+        `收到 ${coarseShape(v)}。这一位是**整只工具面卸载**的收紧声明:本层若把坏值静默删键,这一次运行会挂上声明人以为已经卸掉的全部工具。` +
+        '错误文本只报形状,不回显值。');
+};
 const refuseBadMemoryCapture = (v) => {
     if (v === undefined || v === null)
         return;
@@ -758,17 +401,6 @@ const refuseBadMemoryCapture = (v) => {
         '而声明人不会知道自己的 opt-out 丢了 —— 把一条隐私请求按打字错误静默丢掉是**禁的方向**。' +
         '错误文本只报形状,不回显值。');
 };
-/**
- * `maxCostUsd` 的**响亮拒**(0.77.0)。
- *
- * 🔴 这一位是**收紧方向**的声明(「这一次最多花这么多」),而上游对它的坏值**不是** 4xx:非数 / 非正一律按
- *    「调用方没给」处理、回落到部署上限 —— 部署没设上限时 = 这一次运行**没有花费闸**。一个把 `--max-budget-usd 5`
- *    原样当字符串 `"5"` 递进来的端,请求照发、运行照跑、上限无声消失,没有任何人会知道。
- *    ⇒ 本层是这条声明最后一处能响的地方(与 `memoryCapture` 坏拼写同一条纪律:收紧声明不许被打字错误安静丢掉)。
- * ⚠️ 判据只有「**有限正数**」这一条,是上游自己的接受域(`typeof === 'number' && > 0`)再去掉序列化不了的
- *    `Infinity`(JSON 里是 `null`,到上游同样被当成没给)—— 不猜上限、不预夹:向下夹到部署上限是上游的事。
- * ⚠️ `undefined` / `null` = 合法缺席。与 `memoryCapture` 同律**不分车道、不受 live 门**:拒绝不是「盖一个键」。
- */
 const refuseBadMaxCostUsd = (v) => {
     if (v === undefined || v === null)
         return;
@@ -778,34 +410,8 @@ const refuseBadMaxCostUsd = (v) => {
         '这一位是花费上限声明(收紧方向),而上游对坏值(非数 / 非正)不是 4xx,是按「没给」处理并回落部署上限:' +
         '部署没设上限时这一次运行就没有花费闸,而声明人不会知道。数字串请先在端侧解析成数。错误文本只报形状,不回显值。');
 };
-/**
- * **装配口**(0.77.0):请求体 + 逐键回执,同一次装配、同一只判官。
- *
- * 与 {@link buildTaskRequest} 的关系:后者**就是**本函数的 `.request`(一行转调)—— 两个口不可能装出两份
- * 不同的请求体。要知道「我给的键这一次到底发没发」的端用本口;只要请求体的端两个口随意。
- *
- * 🔴 两个口的**拒绝面完全相同**(拒绝发生在装配里,不在回执里):
- *   · 表外的车道词 ⇒ `TypeError`;
- *   · 入参(或 `settings`)上**在场**的、本包不认识的键 ⇒ `TypeError`,点名键名(值为 `undefined` / `null` 的键
- *     = 缺席,不算);
- *   · `settings` 在场却不是对象 ⇒ `TypeError`;
- *   · `memoryCapture` / `memory` 坏拼写、`maxCostUsd` 坏值、畸形权限快照 ⇒ `TypeError`(各见其注)。
- * 🔴 入参的每个已知键**恰读一次**,装配与回执共用那一份快照:带 getter / proxy 的入参在两次读取之间可以变值,
- *    那样回执说的与请求体带的就可以不是同一件事(`memoryCapture` 那条「校验与 stamp 共用同一次读取」的推广)。
- */
 export function assembleTaskRequest(input, lane) {
     refuseBadLane(lane);
-    // ── 读序纪律:声明位先读、权限面先物化,然后才碰入参上任何别的键 ────────────────────────────────────
-    // 🔴 调用方可执行属性(getter / Proxy)之间可以互相改写,而快照存的是**引用**不是内容:
-    //    · 两个记忆声明是**原始值**,读走就改不了 —— 所以它们排在一切之前(修前 0.76.x 就是这个次序);
-    //    · `resolved` 是对象,物化之前跑过的任何一个 getter(`settings.webSearch` / 顶层任意键 / 不在场的 stray 键)都能把
-    //      `resolved.permissions.deny` 就地清空,请求体照发 `deny: []`、回执 `[]` —— 所以它紧随其后物化;
-    //    · `maxCostUsd`(本版新键)排在物化之后、其余键之前:它与权限面不能同时排第一,权限变宽比花费闸丢失更坏,
-    //      于是只有 settings 容器 / resolved 上的 getter 还能在读到它之前动它 —— 这是**明写的取舍**,不是遗漏;
-    //    · 其余已知键一次性快照(每键恰一次),unknown 键检测与三条值拒绝都在这些读取之后。
-    //    修前的相对次序(live → 两记忆键 → settings → 物化 → 其余)一条不变,权限面只比修前更早。
-    //    (异源复审 R1 [high] / R2 [high] 各实撞一条:把「其余键」的读取排到物化 / 记忆声明之前,就是本包自己引入的
-    //    权限放宽 / 隐私声明丢失路径 —— 两条门 F12 / F17 钉着。)
     const live = input.live;
     const memoryCaptureIn = input.memoryCapture;
     const memoryIn = input.memory;
@@ -816,31 +422,26 @@ export function assembleTaskRequest(input, lane) {
     }
     const settingsObj = present(settingsIn) ? settingsIn : {};
     const resolvedIn = settingsObj.resolved;
-    // resolved 两车道都进表(#292 P1)——它是**开放集 spread**(子键即 wire 键):值缺席时照旧过一遍
-    // `resolvedSnapshotForWire`(它对 undefined/null 返回空对象),所以这里问的是「车道 + live」而不是「值在场」。
     const resolvedRoute = SETTINGS_KEY_ROUTES.resolved;
     const resolvedOpen = resolvedRoute.via === 'matrix' && omissionCauseOf(standingOf(resolvedRoute), lane, live) === undefined;
     const resolvedWire = resolvedOpen ? resolvedSnapshotForWire(resolvedIn) : {};
     const maxCostUsdIn = input.maxCostUsd;
-    // ── 其余已知键一次性快照(已读过的位用种子,不读第二次;按名读 = 与修前同一种读法)────────────────
+    const excludeAllToolsIn = input.excludeAllTools;
     const INPUT_KEYS = Object.keys(INPUT_KEY_ROUTES);
     const i = snapshotByName(input, INPUT_KEYS, {
         live,
         memoryCapture: memoryCaptureIn,
         memory: memoryIn,
         maxCostUsd: maxCostUsdIn,
+        excludeAllTools: excludeAllToolsIn,
         settings: settingsIn,
     });
     const SETTINGS_KEYS = Object.keys(SETTINGS_KEY_ROUTES);
     const s = snapshotByName(settingsObj, SETTINGS_KEYS, { resolved: resolvedIn });
-    // ⑤ 响亮拒:一条打错字的隐私声明绝不许被后面任何一条「不 stamp」路径吞掉。校验与 stamp 用的是上面同一次读取。
     refuseBadMemoryCapture(memoryCaptureIn);
     refuseBadMemoryOff(memoryIn);
     refuseBadMaxCostUsd(maxCostUsdIn);
-    // ── rewind 合写项:四个具名键按名投影,不整只展开 ──────────────────────────────────────────────────
-    // 🔴 修前 `...input.rewind` 整只展开:一个 `rewind: { maxCostUsd: 2 }` 能把回执说「没带」的键塞上请求体、
-    //    还覆盖同名顶层键、绕过该键的坏值门;`rewind: 'abc'` 会把下标键摊上 wire。四个键名取自车道表那一行的
-    //    合写字段名(`resumeAt/resumeAtMode/rewindFiles/rewindFilesTo`),不另抄一份。
+    refuseBadExcludeAllTools(excludeAllToolsIn);
     const rewindRoute = INPUT_KEY_ROUTES.rewind;
     const REWIND_KEYS = rewindRoute.via === 'matrix' ? rewindRoute.field.split('/') : [];
     const rewindIn = i.rewind;
@@ -849,8 +450,6 @@ export function assembleTaskRequest(input, lane) {
             '它是四个具名请求键(resumeAt / resumeAtMode / rewindFiles / rewindFilesTo)的合写位,不是任意展开口。错误文本只报形状,不回显值。');
     }
     const rewindObj = present(rewindIn) ? rewindIn : {};
-    // 🔴 四子键**在这里恰读一次**(0.77.1 CC-108,外部验收 [7810]):快照之后,值级谓词与 stamp 都只看 `rewindWire`
-    //    这份普通数据 —— 此前谓词的 `.some` 与投影循环各读一次,非幂等子键访问器两向静默丢且回执不报。
     const rewindWire = {};
     for (const k of REWIND_KEYS) {
         if (!hasOwn(rewindObj, k))
@@ -859,9 +458,7 @@ export function assembleTaskRequest(input, lane) {
         if (present(v))
             rewindWire[k] = v;
     }
-    /** 喂给 stamp 门的 `rewind` 值:缺席原样(undefined / null),在场则是已快照的四子键副本(不再碰入参访问器)。 */
     const rewindForGate = present(rewindIn) ? rewindWire : rewindIn;
-    // ── (乙) 不认识的键:响亮拒(理由见本节头注;只看**在场**的自有可枚举键)──────────────────────────
     const omitted = [];
     const omit = (key, cause) => {
         omitted.push(Object.freeze({ key, cause }));
@@ -879,7 +476,6 @@ export function assembleTaskRequest(input, lane) {
             unknownKeys.push(key);
             continue;
         }
-        // 入参型之外、但本包认识的键今天只有一类:live 兜底层的位(`cwd` / `appendSystemPrompt` / …)。成因照样问判官,不在这里另写一个词。
         if (route.via !== 'matrix' && route.via !== 'fixed')
             continue;
         const cause = omissionCauseOf(standingOf(route), lane, live);
@@ -912,7 +508,6 @@ export function assembleTaskRequest(input, lane) {
             '想问某个键有没有座 ⇒ taskRequestSeatOf(key, lane)。`settings` 快照里的开放集子键放进 settings.resolved。' +
             '错误文本只报键名,不回显值。');
     }
-    /** stamp 门:本键在场 ∧ 判官说带。🔴 先问判官再看值 —— 表漂(`matrixRow` 抛)因此每次装配都响,不挑输入。 */
     const carries = (route, value, key) => {
         if (route.via === 'always')
             return present(value);
@@ -926,7 +521,6 @@ export function assembleTaskRequest(input, lane) {
         omit(key, cause);
         return false;
     };
-    // 每个键的门**只问一次**(问一次记一次回执),装配处只读结果 —— 回执行数 = 被拒的在场键数,不多不少。
     const gate = Object.create(null);
     for (const key of INPUT_KEYS) {
         const route = INPUT_KEY_ROUTES[key];
@@ -939,12 +533,6 @@ export function assembleTaskRequest(input, lane) {
     }
     const on = (key) => gate[key] === true;
     const onSetting = (sub) => gate[`settings.${sub}`] === true;
-    // settings 四源合并(cli 原式:任一存在则 stamp,全缺则整个 `settings` 键都不出现)。
-    // ultracode 只在交互车道进表 ⇒ print 传了也不 stamp(表说了算,不是调用方说了算)。
-    // 🔴 具名通道**赢过快照**这件事不靠下面的合并序(0.35.0):合并序只在具名通道**有值**时管用,
-    //    而具名门否决时的表现恰恰是**没值**(端不给这个键)。让位改由 `resolvedSnapshotForWire`
-    //    做**结构剥离** —— 具名通道管着的子键快照一概不产,顺序此后只是可读性,不再是安全依据。
-    //    (那一份快照在本函数开头就物化好了 —— `resolvedWire`,读序理由见那里。)
     const settingsOut = {
         ...resolvedWire,
         ...(onSetting('webSearch') ? { webSearch: s.webSearch } : {}),
@@ -971,49 +559,31 @@ export function assembleTaskRequest(input, lane) {
         ...(on('promptProfile') ? { promptProfile: i.promptProfile } : {}),
         ...(on('enableFork') ? { enableFork: i.enableFork } : {}),
         ...(on('attachments') ? { attachments: i.attachments } : {}),
-        // repo 场景五键([C135]):值级判据(council/debate 非 true 不 stamp,与 server `=== true` 读法合拍——
-        // false 与缺席在 wire 上同义,发小的那个)已折进 `VALUE_LEVEL_IN_PLAY`,门 `on()` 一并判过。
         ...(on('repo') ? { repo: i.repo } : {}),
         ...(on('council') ? { council: true } : {}),
         ...(on('debate') ? { debate: true } : {}),
         ...(on('rounds') ? { rounds: i.rounds } : {}),
         ...(on('lenses') ? { lenses: i.lenses } : {}),
-        // 空数组语义(没带附件与「带了 0 个附件」同义,发小的那个)在 `VALUE_LEVEL_IN_PLAY` 里,门一并判过。
         ...(on('attachmentIds') ? { attachmentIds: [...(i.attachmentIds ?? [])] } : {}),
-        // 「不排除任何工具」同款空数组语义,同上。
         ...(on('excludeTools') ? { excludeTools: [...(i.excludeTools ?? [])] } : {}),
+        ...(on('excludeAllTools') ? { excludeAllTools: true } : {}),
         ...(on('clientContext') ? { clientContext: i.clientContext } : {}),
         ...(on('scratchpadDir') ? { scratchpadDir: i.scratchpadDir } : {}),
         ...(on('finalVerification') ? { finalVerification: i.finalVerification } : {}),
         ...(on('limits') ? { limits: i.limits } : {}),
         ...(on('interactiveTools') ? { interactiveTools: false } : {}),
         ...(on('oneShot') ? { oneShot: true } : {}),
-        // 0.77.0 print 补座两件(原样透传;`maxCostUsd` 的坏值已在上面响亮拒)。
         ...(on('outputSchema') ? { outputSchema: i.outputSchema } : {}),
         ...(on('maxCostUsd') ? { maxCostUsd: maxCostUsdIn } : {}),
-        // ⑤ 单成员闭集:值**恰是** `'off'` 才 stamp。表外拼写在上面已经**响亮拒**(见 `refuseBadMemoryCapture`)。
         ...(on('memoryCapture') ? { memoryCapture: 'off' } : {}),
-        // CC-39③:姊妹键同律(值恰是 'off' 才 stamp;坏拼写已在上面响亮拒)。
         ...(on('memory') ? { memory: 'off' } : {}),
         ...(Object.keys(settingsOut).length > 0 ? { settings: settingsOut } : {}),
     };
     return Object.freeze({ request: out, omitted: Object.freeze([...omitted, ...lateOmitted]) });
 }
-/**
- * 只要请求体的口 —— **就是** {@link assembleTaskRequest} 的 `.request`(拒绝面完全相同,见那里的头注)。
- * ⚠️ 本口没有回执通道:认识而没带的键(车道不符 / live 门没开 / 上游无对位)在这里照旧没有信号。要逐键答案
- *    用装配口;要在不装配的情况下问一个键有没有座用 {@link taskRequestSeatOf}。
- */
 export function buildTaskRequest(input, lane) {
     return assembleTaskRequest(input, lane).request;
 }
-/**
- * live 兜底层(cli `liveClient.toLiveRequest` 的**包内半场**)—— 两条车道共用。
- *
- * 🔴 与 cli 的差分记账:cli 版在函数体里直接读 `process.cwd()` / `getAppStateStoreRef()` /
- * `getLiveModelCatalog()` / `engineCapTrue()`。这些是**取值方式**,全部上移到 `LiveDefaultsInput`。
- * 「调用方已带值就不覆盖」的语义(cli 每条都是 `if (out.X === undefined)`)在这里逐条保留。
- */
 export function applyLiveRequestDefaults(req, host) {
     const out = { ...req };
     if (out.cwd == null && host.cwd !== undefined)
@@ -1021,14 +591,9 @@ export function applyLiveRequestDefaults(req, host) {
     if (out.additionalDirectories === undefined && (host.additionalDirectories?.length ?? 0) > 0) {
         out.additionalDirectories = [...(host.additionalDirectories ?? [])];
     }
-    // A-028.9:只读面宽根(壳 cli 逐字:`if (roots.length > 0) out.additionalReadDirectories = roots`,
-    // 「已带值不覆盖」的守卫同其余各条)。
     if (out.additionalReadDirectories === undefined && (host.additionalReadDirectories?.length ?? 0) > 0) {
         out.additionalReadDirectories = [...(host.additionalReadDirectories ?? [])];
     }
-    // C1 / design/144:交互与 headless 都常开 —— 不开则引擎不建 SubagentRetainLedger,
-    // 后台子代 SendMessage 唤醒直接 "session was not retained" 拒绝。老引擎按 body→spec 白名单
-    // 忽略未知字段,version-safe。
     if (out.forwardSubagentEvents === undefined)
         out.forwardSubagentEvents = true;
     if (out.retainSubagentSessions === undefined)
@@ -1038,8 +603,6 @@ export function applyLiveRequestDefaults(req, host) {
     if (typeof out.scenario === 'string' && host.mockScenarioKeys?.has(out.scenario)) {
         delete out.scenario;
     }
-    // 自我认知块双臂([1487]/[1478] R1 终形):caps 判真走一等位,否则借道 outputStyle。
-    // 两臂同一合并序(知识块恒前、调用方块恒后)——序由端在 selfKnowledge 里拼好,包只选位。
     if (host.selfKnowledge !== undefined) {
         if (host.appendSystemPromptCapable) {
             out.appendSystemPrompt = host.selfKnowledge.forAppend;
@@ -1049,7 +612,6 @@ export function applyLiveRequestDefaults(req, host) {
             out.settings = { ...settings, outputStyle: host.selfKnowledge.forOutputStyle };
         }
     }
-    // E12:与 verify/cascade 互斥(那两个返 result 非 streamed run ⇒ 400)。
     if (out.suggestNextPrompts === undefined &&
         out.verify === undefined &&
         out.cascade === undefined &&
@@ -1059,8 +621,6 @@ export function applyLiveRequestDefaults(req, host) {
     if (out.compactionModel === undefined && host.compactionModel !== undefined) {
         out.compactionModel = host.compactionModel;
     }
-    // 单命名空间三态(cli 逐字):① 已捕获的引擎 session 赢(连续性 —— 引擎 session 绝不在
-    // 会话中途被换掉);③ 还带着 mock 常量 ⇒ 删掉让引擎新铸;② 其余保留(首 turn 壳 id 直传)。
     if (host.capturedSessionId) {
         out.sessionId = host.capturedSessionId;
     }
@@ -1070,35 +630,9 @@ export function applyLiveRequestDefaults(req, host) {
     }
     return out;
 }
-/**
- * ⇄ B8(§8-5 请求拼装合一的**可执行判据**)—— 一份请求体里出现了**没进车道表**的键就点名它。
- *
- * 为什么要有:B4 把字段集做成了 `REQUEST_FIELD_MATRIX` 这张表,但表当时只管住了
- * `buildTaskRequest` 自己;端上真正上 wire 的那份请求仍可以在构造器之外多塞一个键(print lane
- * 修前正是「自己另拼一份」),于是「表说了算」就退化成一句注释。本函数让**真上 wire 的那份**
- * 也过一遍表:print lane 收编之后,`-p` 的请求体逐键都能报出登记出处,再漏就当场红。
- *
- * 判据口径(三类不点名):
- *   ① 车道表里的字段(`lanes` 含本车道);② `LIVE_DEFAULT_FIELDS` —— live 兜底层追加、两条车道
- *   都经过,故本就不进车道表;③ `settings` 的子键按表认(`settings.<sub>`)—— 登记了
- *   `settings.<resolved>` 的车道(#292 P1 起 = **两条**)那份 resolver effective 快照是**开放集**,
- *   所以**表外**子键(permissions/env/model/… 不可枚举)放行。
- *
- * 🔴 开放集**不是**整只 `settings` 免检(#292 P1 对抗复审第二轮 [medium] 采纳):表里点名了、
- * 而 lanes 不含本车道的子键(如 print 车道的 `settings.ultracode`)照旧**点名** —— 那些键是
- * **可枚举的已知量**,放过它们等于让「ultracode 仅 interactive」这条登记在真 wire 面失效。
- * `buildTaskRequest` 内的 `resolvedSnapshotForWire` 只管住构造器自己那一份;端在构造之后仍能往请求体上
- * 塞键(print lane 修前正是「自己另拼一份」),而本函数的整个存在理由就是替**真上 wire 的那份**
- * 过表。两道门缺一不可。
- *
- * 🔴 它**不判**「该不该有」——只判「有没有登记」。补齐一条真实差异要改表(带理由),
- * 而不是绕过本函数:改表这个动作本身就会在 diff 里显形,这正是本判据存在的意义。
- */
 export function unregisteredRequestKeys(req, lane) {
-    /** live 兜底层的键名(表项写法含 `|` 备选位与括号说明,取裸键名;与装配口同读一只解析)。 */
     const liveDefaults = liveDefaultKeyNames();
     const laneRows = REQUEST_FIELD_MATRIX.filter(f => f.lanes.includes(lane));
-    /** 顶层键 → 表项(`resumeAt/resumeAtMode/rewindFiles/rewindFilesTo` 这类斜杠合写项逐键展开)。 */
     const laneTopKeys = new Set();
     for (const row of laneRows) {
         if (row.field.startsWith('settings.'))
@@ -1110,7 +644,6 @@ export function unregisteredRequestKeys(req, lane) {
         .filter(f => f.field.startsWith('settings.') && f.field !== 'settings.<resolved>')
         .map(f => f.field.slice('settings.'.length)));
     const settingsIsOpenSet = laneRows.some(f => f.field === 'settings.<resolved>');
-    /** 表里点名了、但 lanes 不含本车道的具名子键 —— 开放集车道也照旧点名(见头注第二条红线)。 */
     const foreignSettingsKeys = new Set(foreignSettingsSubKeys(lane));
     const out = [];
     for (const key of Object.keys(req)) {
@@ -1118,28 +651,17 @@ export function unregisteredRequestKeys(req, lane) {
             const settings = req.settings;
             if (settings === null || typeof settings !== 'object')
                 continue;
-            // 🔴 自报会改写自己字节的 `settings` 一律点名(#292 P1 复审第四轮的可采部分):`JSON.stringify`
-            // 找 `toJSON` 走的是**属性查找**(原型链上的、非枚举的都算),而下面的逐键遍历只看**可枚举自有**
-            // 键 ⇒ 一个挂在原型上的 `toJSON` 能让本函数看到一份对象、wire 上却是另一份字节。本函数的承诺
-            // 是「替真上 wire 的那份过表」,所以这种「对象与字节不一致」的形必须先被点名,而不是默默通过。
-            // (⚠️ 递归深净化整份请求体不在本层的职责里 —— 那是包级 wire 载荷 JSON-safe 规范化的设计题,
-            //  今天对 agents/hooks/attachments 等一切对象位一样成立,已登记为独立工单;端是同进程受信调用方,
-            //  这里做的是「判据不许被骗」,不是「防御受信宿主」。)
             if (typeof settings.toJSON === 'function')
                 out.push('settings.toJSON');
             for (const [sub, value] of Object.entries(settings)) {
                 if (sub === 'toJSON')
-                    continue; // 上面那条属性查找已点过名(可枚举自有形不重复报)
-                // 🔴 函数值恒点名(复审第三轮 [medium]):wire 上没有函数,而自有 `toJSON` 会在序列化时
-                // 整只改写 `settings` 的字节 ⇒ 一切「按对象查键」的判据(含本函数)都会被它骗过。所以它
-                // 先于任何登记判断被点名 —— 包括登记在册的子键名上挂了函数值的形。
+                    continue;
                 if (typeof value === 'function') {
                     out.push(`settings.${sub}`);
                     continue;
                 }
                 if (laneSettingsKeys.has(sub) || liveDefaults.has(`settings.${sub}`))
                     continue;
-                // 开放集车道:表外子键放行(快照的键不可枚举),表内异车道子键仍点名。
                 if (settingsIsOpenSet && !foreignSettingsKeys.has(sub))
                     continue;
                 out.push(`settings.${sub}`);