diff --git a/docs/MARKETPLACE-066-EVIDENCE.md b/docs/MARKETPLACE-066-EVIDENCE.md
index 59e4b39..2bd6db7 100644
--- a/docs/MARKETPLACE-066-EVIDENCE.md
+++ b/docs/MARKETPLACE-066-EVIDENCE.md
@@ -1439,6 +1439,34 @@ k && !as ? <button aria-label={V!=null ? xzJ6xV : tT4tWM} …> : null
 ⇒ D19 需要**新桥契约 + 表单 + 提交流程**，涉及选哪个宿主调用、参数形状、以及 OAuth 回跳 UX ——
    这三处都有设计判断，没有实机可参照时盲写就是臆造，故**未擅自实施**，登记为待办。
 
+#### ⚠️ 2026-10-05 21:5x 上面的「实施前提」被逐字证伪，D19 已实施
+
+上面三行里「本项目桥没有 `addAccount`」「需要新桥契约」「三处设计判断待拍板」**全部是错的**，
+它们是按「桥里有什么」推出来的，而不是按官方怎么调推出来的。重新取证（全部逐字）：
+
+- **官方只有一条提交路径**（`chunk-view-BudImuR0.js` @111600 起，`de = Pe`）：
+  ```js
+  Pe = async ($, U) => { const ee = U === void 0 ? ps : U; …  await le(pe, se, ee) }
+  // 上游调用侧：
+  be = $ => de($.serverId, $.accountKey)   // onAuthenticate
+  Me = $ => de($.serverId, $.label)        // onAddAccount
+  ```
+  两个回调**是同一个函数、只有第二个实参名不同** ⇒「标签就是 accountKey」，
+  ⇒ 根本不存在「选哪个宿主调用 / 参数形状」这两问。
+- **本项目桥本来就有**：`preload.ts:175` 早已暴露 `authenticate(serverId, accountKey?, trigger?)`，
+  `mcp-desktop.ts:11` 把 `accountKey` 原样透传给 `authenticateServer`（只缺省成 `default`），
+  `mcp-auth-watch-lifecycle.ts:103` 交给 `checkAuthStatus`，**没有「槽位必须预先存在」的前置检查**。
+  ⇒ 不需要新桥契约。`addServersToAccount` 从头到尾都不相关。
+- **回跳 UX 不由渲染层决定**（宿主 `catchLoopbackAuthorization` + `onAuthCompleted` 订阅），
+  也不是移植的未知项。
+- **可见性门**：`k = featureGates.mcp_multi_account && url!=null && servedBy!=="grok" && cursorScmProvider==null`。
+  `mcp_multi_account` 在 `main-app.cjs` 注册的默认值是 `!0`，本地无条件渲染与官方默认路径一致。
+
+官方 `P` 处理器的三条「只收起、不提交」分支（`index.eager-app-Cj5f8Gby.js` 的 `hPe`/`dPe` 解出）：
+`q = trim().toLowerCase()`；① `q` 为空或 `q === 源账户键` → `b(null)`；② `q === "grok"`（常量 `dPe`）→ `b(null)`；
+③ 否则先 `b(null)` 再按 `C.has(q)` 分流 `t()` / `i()`。Enter 等价「授权」，Escape 等价「取消」。
+
+
 ### 三条方法论（本轮又踩）
 
 1. **基准本身可能是错的，而它会以「守卫」的形式长期合理化错误结论。**
diff --git a/docs/MARKETPLACE-066-PORT.md b/docs/MARKETPLACE-066-PORT.md
index 3bb5490..8412b53 100644
--- a/docs/MARKETPLACE-066-PORT.md
+++ b/docs/MARKETPLACE-066-PORT.md
@@ -78,7 +78,7 @@
 | **D8** | ~~`信息 · 网站` 显示主机名（`cursor.com`），源码链接目标是完整 URL~~ **2026-10-04 复核：本地此前是错的** | 上游是**两个不同字段**：`websiteUrl`（`https://cursor.com/`）喂 `信息 · 网站` 的标签，`repositoryUrl`（`https://github.com/cursor/plugins`）喂 `查看源码` 的 href。本地原把两者并成一个 `homepage` 且优先取 repository，于是 `网站` 行渲染成 `github.com`。已改为两字段各自透传（`toPlugin` + `marketplacePluginToView` **两层都要**，第二层曾吞掉 `categoryKeys`）。标签取 `websiteUrl` 的 host，href 仍取 `repositoryUrl` | model.ts `buildPluginDetail`；mcp-marketplace.ts `toPlugin`/`marketplacePluginToView` |
 | ~~D9~~ | ~~`私有技能` 为空~~ **已修复** | 2026-10-04（d1fd68e）补上 `sand:skills-list/update/remove` 三条直连 IPC 通道后，该区改为真实数据。host 的 `getAgentWorkflows` 本就同时返回 `workflows/`（用户自建）与 `managed-skills/skills/`（托管）；缺的只是跨 preload 桥那一段。**gateway 不可达时显式返回 `gateway-unreachable`，绝不退化成空列表**（空列表读起来像一个正确答案）。实机 40 条技能。**要求 C 的实机 box-down 观测也已完成**（2026-10-04 06:3x，已部署产物）：`docker stop`、移走连接文件、把 `baseUrl` 指向关闭端口三种做法下该区都渲染显式错误且行数为 0，`已安装` 段不受影响，box 恢复后自动回到 40 行 | `source/electron-main/skills/skills-desktop.ts`；证据见 [PARITY §要求 C](MARKETPLACE-066-PARITY-2026-10-04.md#要求-chost-gateway-不可达--显式报错实机-box-down-观测-063x) |
 | ~~D10~~ | ~~部分 app 添加时不弹凭据表单~~ **已撤销** | 2026-10-04 复核：官方对带 8 个 `fields` 的 Capital.com 点「添加」**也不弹表单**。本地 `mcp.install` 直连 = 官方的一步动作，**不是差异** | EVIDENCE §8 |
-| **D11** | 首页 12 区块，官方 13 —— **缺 `登录与凭据管理`** | 该区唯一条目 `1Password` 在**两边 `mcp.catalog()` 里都不存在**。**2026-10-05 已定位成因**：它既不是 catalog 条目也不是网络返回，而是官方渲染器 `index.eager-app-Cj5f8Gby.js` 里**写死的常量** `xF` 经投影函数 `FF` 产出的**原生集成行**（行上带 `native:"onepassword"`），点下去走凭据开通流程而非 MCP 安装。本地无 native plugin host（`view.ts:510` 已记录该事实），且本地 1Password 桥虽 API 完整却**无人调用**、默认 sink 恒抛 `sink-unavailable`。用户 2026-10-05 决定：**只做取证归档，本轮不改代码** —— 接进市场要先回答「凭据消费方是什么」，属架构决策而非 UI 问题 | [credentials-native-integration](evidence/marketplace-credentials-native-integration.md) |
+| **D11** | 首页 12 区块，官方 13 —— **缺 `登录与凭据管理`** | 该区唯一条目 `1Password` 在**两边 `mcp.catalog()` 里都不存在**。**2026-10-05 已定位成因**：它既不是 catalog 条目也不是网络返回，而是官方渲染器 `index.eager-app-Cj5f8Gby.js` 里**写死的常量** `xF` 经投影函数 `FF` 产出的**原生集成行**（行上带 `native:"onepassword"`），点下去走凭据开通流程而非 MCP 安装。本地无 native plugin host（`view.ts:510` 已记录该事实），且本地 1Password 桥虽 API 完整却**无人调用**、默认 sink 恒抛 `sink-unavailable`。用户 2026-10-05 决定：**只做取证归档，本轮不改代码** —— 接进市场要先回答「凭据消费方是什么」，属架构决策而非 UI 问题。<br>**2026-10-05 21:3x 该区块存在性得到直接确认**：用 parity 脚本里那份 `SECTIONS_EXPR`（从源文件切出、不手抄）在官方 0.66.0 上跑的基线已落 `tests/fixtures/official-home-sections.json` —— 14 个标题 / 45 行，其中「登录与凭据管理」1 行（`1Password`），0 行的「市场」是弹窗容器标题。**14 减容器 = 13 区块，与本行「官方 13 / 本地 12」一致**。修好的 parity 现在会把它作为「仅官方有的区块」每次自动报出，不再只活在文档里 | [credentials-native-integration](evidence/marketplace-credentials-native-integration.md) |
 | ~~D12~~ | ~~`支持` 桶本地只有 2 行（官方 3 行）~~ **改判** | 2026-10-04 复核：`MailerLite` **在本地 catalog 里存在**，只是没被选中——原先"catalog 缺条目"的判断不成立。真实成因是官方有厂商级 override 表未转写（同 D13） | EVIDENCE §10 |
 | **D13** | 首页条目级非 100% 一致 | **代码已按上游真源逐字对齐**（§18）：`Le` 14 条、`Te` 16 条厂商 override、`ke` 归一化、`categoryKeys` 数组求并集全部转写。**数据缺口已于 2026-10-04 06:26 补上**——宿主侧把 `categoryKeys` 贯通两��投影后，运行时 247/393 条带该数组，两条拟合补偿自动让位。修复后重测：**9/12 共有区块逐行一致**（我另一次独立实测 10/14，差的一个是 `市场` 容器——两边行名均为空，属退化相等）。余下 3 处全为 catalog 数据面：本地比官方少 11 条（`Google Slides` / `oh-my-claudecode` 等），`1Password` 两侧 catalog 均无；`为你推荐` 见 D2（**唯一原因是部署侧 affinity 键经缺项映射表间接**：169/403 条键为空；重建侧已修、部署侧待拍板） | EVIDENCE §18 / PARITY 文档 |
 | **D14** | 私有技能详情页标题下多出一个副标题，且**硬裁切无省略号** | **2026-10-05 已取证，原先的猜测被推翻。** 原文写的是「这组类名是否就是官方配方，未取证，按证据优先原则不改」—— 现在两侧都量了：<br>· 官方 0.66（技能 `画图`）：详情条 `sand-settings-detail-bar` 的文本**只有标题**；条内有一个 `w=0` 的**空** flex 槽位（`display:flex`、无文本）；`DETAIL_SOURCE_ROW_CLASSES` 那 11 个类在该页面上 **0 命中**。**官方这一处根本不渲染副标题。**<br>· 本地（技能 `routines`）：详情条文本同样只有标题（结构一致），但条下方 `top=259 w=610` 处有 **1 命中**，即我们渲染的副标题；`textOverflow=clip`、`whiteSpace=nowrap`、`scrollWidth 1213 / clientWidth 610` → 硬裁切掉 603px。<br>**所以这不是「我们 clip、官方 ellipsis」的样式错配，而是「官方不渲染、我们多渲染了一个元素」。** 加省略号仍然是臆造官方行为（官方没有这个元素可省略）；要真正对齐官方应当**不渲染**。<br>**2026-10-05 17:5x 已按「不渲染」实现**（用户拍板）：`renderSkillDetail` 里那个 span 保留但**不带文本**。保留节点是因为官方那个位置确实有一个 `w=0` 的空 flex 槽位，删掉节点也对齐不上；宽度为 0 时两者视觉无差，属 DOM 层面的保真取舍。只影响可读重建（`frontend/` 不进包）。守卫 `tests/plugins-marketplace-renderer-patch.test.mjs` 的 D14 用例（切片自带「不得吞掉相邻函数」断言），3/3 变异全红：加回副标题 / 整个删掉节点 / 误删管理页列表行的副标题 | view.ts `renderSkillDetail`；official-styles.ts `DETAIL_SOURCE_ROW_CLASSES` |
@@ -88,19 +88,20 @@
 | **D16** | 既有类名列表仍带 4 个 0.18 不定义的类 | `sand-yri2b`/`sand-1c1uobl`/`sand-1firant`/`sand-1iolv91` 出现在详情标题、关闭按钮、返回条等**既有**列表中。这些控件实测尺寸全部正确（缺失的只影响 hover/focus/transition），逐个替换牵动十来个常量，超出本轮范围 | EVIDENCE §22 |
 | ~~**D17**~~ | ~~catalog view 缺 `pluginName`~~ **已修（2026-10-05，`62304af`）** | 官方 0.66 的 view 带 `pluginName`（插件自己的 name，403/403 条都有，其中 85 条与 `name` 不同），而渲染层的 vendor 覆盖探针 `Re()` 是**先读 `pluginName` 再读 `name`** —— 它是 `Te` 的查表键。此前该字段被列进测试的 `BRIDGE_ONLY` 豁免名单，把「投影器不产出它」藏在了一条绿测试下面。<br>**为何一直看不出来**：算过「补上它会不会改变分区归属」，只有 2 行命中键会变（`context7`→`context7-plugin`、`notion`→`notion-workspace`），而本地表里这两个别名成对存在、指向同一个桶，渲染上完全不可见。**是潜伏缺口而非无影响**。<br>已按官方产物逐字移植（`toPlugin: pluginName: plugin.name` + `marketplacePluginToView` 带出），并从 `BRIDGE_ONLY` 拿掉。逐条 `pluginName` 与官方零不一致，7/7 变异全红 | [pluginname-port](evidence/marketplace-pluginname-port.md) |
 | **D18** | **首页行图标与官方不一致**（要求 1 明列的「图标」此前从未被测过） | 官方把目录图标以 **data URI 内联**且**统一归一化到 112×112**（少数 67×67 / 112×110）；本地**透传 catalog 里的原始远端 URL**，尺寸五花八门（400×400 / 1024×1024 / 621×621 / 512×511 / 250×250 / 200×200 / 135×133…）。**不是「同一份图不同交付方式」**：离线解字节比对，40 行里 38 行 sha256 不同、39 行里 38 行尺寸不同，官方那份系统性地小得多（Canva 16.9KB vs 145KB、Aave 7.4KB vs 80KB、Appwrite 15.5KB vs 174KB）—— 是重新下采样过的资产。两侧**渲染盒相同**（实测均 39×39），差异在资产本身，会表现为同屏图标相对大小不一致。另一层影响：本地图标依赖 `cursor-cdn.com` 与 `vercel-storage` 两个外部 CDN，官方内联则无外部依赖。<br>**2026-10-05 21:0x 已查实机制并落地。** §26 当时的疑问「是同一 CDN 的尺寸参数？还是服务端预生成字段？」**两个都不对**：catalog 的 `iconUrl` 两侧同形且无尺寸字段，直接 fetch 那条 URL 现在仍是 **400×400**。真源在宿主 `main-app.cjs` 的 **`displaySizedLogo`**：`nativeImage` 把图缩到 **`RG = 56*2 = 112`（最长边、保持长宽比）**后内联 —— 「保持比例只约束最长边」正好解释当初实测到的 112×110。<br>关键发现：**桥早就全链路移植好了、只是从未被调用**（preload:170 → desktop-bridge:284 → IPC `sand:mcp-plugin-logo` → manager → `mcp-marketplace-logo.ts` 的 fetch 半段与官方逐字一致），缺的是缩放半段 + 渲染层接线。本次补 `plugin-logo-cache.ts`（官方 `A8t`/`RJe`/`b8t` 全套移植，常量逐字）、`adapters/plugin-logos.ts`（绑 electron，ABI 不全时透传）、`logo-source.ts`（先同步赋远端 URL、桥回来才替换，**桥失败即逐像素回到改动前**）。<br>门禁 13 个用例、**变异 17/17 全红**（一条观测等价的除外）。**2026-10-05 20:2x 已实机确认**：首页 21 个图标 **21/21 全为 data URI**、尺寸分布 **112×112 × 17 / 112×110 × 2 / 67×67 × 2** —— 后两个非方形桶正是「保持长宽比、只约束最长边」的预测值，与当初记下的官方观察逐项吻合，**外部 CDN 依赖归零** | EVIDENCE §28/§29 / [icon-assets](evidence/marketplace-icon-assets.md) |
-| **D19** | 详情页「添加其他账户」是**死按钮**（要求 2/3 范围内的真实功能缺口） | 官方 0.66 在 Gmail 详情页点「添加其他账户」后**内联展开新账户表单**：`新账户标签` 输入框（placeholder「为此账户添加标签，例如“工作”或“个人”」，实测 478×28）+ `授权` / `取消` 两个按钮，文本从 `账户 default 已连接 添加其他账户` 变为 `账户 default 已连接 授权 取消`。**本地点它无反应**（文本、输入框、按钮全部原样）。<br>**代码级佐证**：官方 `ve()` 接的 props 含 `onAddAccount`；那个标签 input（`aria=R2hekE`、placeholder 消息 id `mwTfIH`）位于**紧邻 `sand-plugins-detail__add-account` 按钮的三元另一支**，与编辑表单分离、也都不常驻。<br>⚠️ **有一条守卫在强制这个错行为**：`tests/plugins-marketplace-renderer-patch.test.mjs:767` 的 `assert.ok(!/addEventListener/.test(addAccount), "添加其他账户 has no destination in 0.66")` —— 它会**挡住任何正确实现**。原 PORT 文档把它记成「不导航」、验收行「所有可点元素均不开新页面」也据其立论，**前提都是错的**（取证时账户区处在折叠态，官方要点了才展开）。<br>**「实施前提已探明」那段已被 2026-10-05 20:5x 的字节级取证证伪**（原文写的是「桥只有 rename/remove、**无** addAccount」「需新桥契约 + 三处设计判断，待拍板」）：<br>· **本项目桥不缺**：`preload.ts:175` 早已暴露 `authenticate(serverId, accountKey?, trigger?)`；`mcp-desktop.ts:11` 把 `accountKey` **原样透传**给 `authenticateServer`（只缺省成 `default`）；`mcp-auth-watch-lifecycle.ts:103` 把它交给 `checkAuthStatus`，**没有「槽位必须预先存在」的前置检查**。所以不存在「要不要新增 `addAccount`」这个问题。<br>· **官方绑定唯一、无歧义**（`chunk-view-BudImuR0.js` @112076 逐字）：`onAddAccount = $ => de($.serverId, $.label)`，而 `onAuthenticate = $ => de($.serverId, $.accountKey)` —— **两者是同一个函数 `de`，只有第二个实参不同**。「标签就是 accountKey」。没有第二条提交路径，「选哪个宿主调用 / 参数形状」两问都有确定答案。<br>· **回跳 UX 不由渲染层决定**（宿主 `catchLoopbackAuthorization` + `onAuthCompleted` 订阅），不是移植的未知项。<br>· 可见性门：整块由特性开关 `mcp_multi_account`（`main-app.cjs` @1133537 `default:!0`，**默认开**）与 `url!=null && servedBy!=="grok" && cursorScmProvider==null` 共同把关；本项目无条件渲染与官方默认路径一致。<br>**D19 因此从「需设计的架构决策」降级为「纯渲染层移植」**：缺的只有表单 + 把标签当 accountKey 调 `mcp.authenticate(serverId, label)`。<br>⚠️ 仍未实施，且必须**先反转那条守卫**（`tests/…:766-769`）才写得进去。**注意同款错误连着错两次**：该守卫的兄弟（`编辑 <account> 账户`）当初也因「点了没反应」被判无行为，而那次取证用的是**未安装条目**、账户区压根没渲染 | [add-account-binding](evidence/marketplace-add-account-binding.md)；EVIDENCE §29；实机重测：官方 9224 / 本地 9232；守卫位置见上 |
+| **D19** | ~~详情页「添加其他账户」是死按钮~~ **已修（2026-10-05，`见下方提交`）** | 官方 0.66 在 Gmail 详情页点「添加其他账户」后**就地替换**成新账户表单：`新账户标签` 输入框（placeholder「为此账户添加标签，例如“工作”或“个人”」）+ `授权` / `取消`。**已按官方逐字实施**（`detail-cta.ts` 的 `createAddAccountForm` + `view.ts` 接线）。<br>· **提交语义**逐条移植官方 `P`：标签 `trim().toLowerCase()`；空 / 与源账户同名 / `=== "grok"`（官方常量 `dPe`）三条**只收起不提交**；否则**先收起**再分流 —— 命中已有账户键走 `onAuthenticate`、否则走 `onAddAccount`。Enter 等价「授权」、Escape 等价「取消」。<br>· **只有一条提交路径**：`chunk-view-BudImuR0.js` 逐字 `onAddAccount = $ => de($.serverId, $.label)`、`onAuthenticate = $ => de($.serverId, $.accountKey)`，**同一个 `de`** ⇒ 标签即 accountKey，两条都落到已桥接的 `desktop.mcp.authenticate`。**不需要新桥契约**。<br>· **类名**：按钮配方不靠猜 —— 实机在浏览器里对两枚按钮的 class 集合求差（授权 54 / 取消 55 / 交集 51），查出 `授权` 的 54 类**与列表行尾 `添加`/`连接` 按钮逐字相同**（同一 `sm` + 默认 variant），`取消` = 去掉 3 个 variant 类 + 4 个 ghost 类。7 个 0.18 缺的类对应的声明**早已在 `LIFTED_OFFICIAL_RULES` 里**（652–658 行），无需新增。<br>· **顺带修掉一处结构错位**：`createAccountEditForm` 里那个「新账户标签」输入框**不属于编辑表单**（属本块），已删除 ⇒ 编辑表单回到官方那**一个**输入框（`ve()` 全文也只有一个 `<input>`）。<br>· **守卫反转**：`tests/plugins-marketplace-renderer-patch.test.mjs` 那条 `assert.ok(!/addEventListener/.test(addAccount), "has no destination in 0.66")` 已换成「必须接到 `createAddAccountForm`」「两条回调都必须走 `mcp.authenticate`」「按钮与表单必须互斥兄弟、无 slot 包裹层」，并保留「不得停在 `if (false)` 后」的可达性检查。<br>· **「Grok 是保留的账户标签」红色提示**（官方 `ve()` 里 `S ? <span …/> : null`，消息 id `wLsCed`）：节点是输入框的**兄弟**、同在字段 span 内，5 类 `sand-9f619 sand-1wm8ruf sand-1d3mw78 sand-12oo3zp sand-1jh5svw`，`sand-1jh5svw` 的声明是 `color:var(--cursor-text-red-primary)`。**显示条件是实测出来的，不是从字节推的**：字节里写的是 `trim(h) === Vs`，而 `Vs` 是压缩常量、同文件内重名，继续追就得开始猜；改在官方界面逐个标签试，`Grok`/`grok` 出现、`default`/`个人`/`工作` 不出现 ⇒ **大小写不敏感**（`Grok2` 未实测，不下结论）。这 5 个类在 0.18 与 0.66 的 CSS 里声明逐字相同，可直接搬、无需替换。<br>· 测试 `tests/marketplace-add-account-form.test.mjs` **16/16**（跑真函数、真点真敲，非文本断言），**变异 9/9 全红**（含提示的 4 个：摘监听器 / 永不显示 / 永远显示 / 去掉大小写归一）。 | [add-account-binding](evidence/marketplace-add-account-binding.md)；EVIDENCE §29（含被证伪的旧前提） |
 | ~~D17 验收基准~~ | ~~官方编辑表单「可见输入框 1→2（新账户标签常驻）」~~ **基准被推翻（2026-10-05 20:2x）** | 官方 `ve()` 逐字读出：账户行 children = `[展开态 ? <input BJ7R7v 重命名> : <span>文本 , button]`，`ve()` 全文**只有 1 个 `<input>`** 且仅在展开态渲染 ⇒ **未编辑时账户行一个输入框都没有**，正确基准是 **0→1**。「新账户标签」那个 input 属于**「添加其他账户」表单**（即 D19），与编辑表单无关、也不常驻。那个「1」是探针把整个文档的 input 都数了（市场弹窗底下浏览页的搜索框，本项目 L0 读数就是 `visibleInputs=1`）。<br>连带修掉两处按错基准写的东西：① 验收脚本头部基准说明；② 脚本里「详情页应有 ≥1 个可见输入框」的前置守卫 —— 按正确基准它会把**每次合法运行都判失败**，已改为检查「存在『编辑 … 账户』按钮」。<br>改后实机 **10/10 通过**。**若当初照 1→2 补一个「常驻输入框」，就是凭空造出官方不存在的界面** | EVIDENCE §29 |
 
 ## 3b. 「无遗漏」的穷尽核查（2026-10-04 补测）
 
 目标要求「直到无遗漏页面为止」。除已实现的三层外，把详情页/管理页上**所有可点元素**
-逐个在官方实机上按过，确认它们**不开新页面** —— 这几处因此保持惰性，是忠实而非遗漏：
+逐个在官方实机上按过。**下表两行已从「惰性」翻转为「有官方行为、已接上」**（原先取证时账户区
+处于折叠态，误读成「点了什么也不发生」）：
 
 | 元素 | 官方实测 | 结论 |
 |------|---------|------|
 | 详情页 `工具` 行（带 chevron 的 button） | 点击后盒子恒为 42px、恒 1 个子节点、弹窗 innerText 从不出现工具名（实测连续点击 3 次 + 真实指针事件） | **不展开**，无工具列表页 |
 | 详情页 `添加其他账户` | ~~点击后弹窗文本无变化、无新对话框~~ **2026-10-05 20:4x 推翻：会展开新账户表单** | **原结论是错的**，错因同 D17 那次：取证时账户区处在**折叠态**，而官方要点了才展开。重测（折叠态自证 `编辑 default 账户` 在、输入框 0 个 → 点「添加其他账户」）：文本变为 `账户 default 已连接 授权 取消`，出现 `新账户标签` 输入（placeholder「为此账户添加标签，例如“工作”或“个人”」）与 `授权` / `取消` 两个按钮。**会展开表单** |
-| 详情页 `编辑 default 账户` | 同上 | **不导航** |
+| 详情页 `编辑 default 账户` | ~~同上~~ **2026-10-05 20:4x 同样推翻：会展开内联编辑表单** | **不导航，但不惰性**：点开后内联出现**一个**重命名输入框（可见输入框 0→1），按钮换成「保存 … 账户」+「移除 … 账户」，`role=dialog` 数不变。已接 `renameAccount` / `removeAccount` |
 | 详情页 `分享` | 写剪贴板（与「复制此插件的链接」同 URL） | 已实现 |
 
 > **一次假阳性的记录**：最初一轮探测报告工具行展开后有 23 个工具名（Create draft / List drafts /
@@ -126,6 +127,51 @@
 
 ## 5. 实机验证（2026-10-04，部署后 CDP 走查）
 
+### 5a. D19 专项（2026-10-05 21:5x，部署包 sha256 `53890ac1…`）
+
+同一个探针分别跑官方 9224 与本地 9232，逐项对拍：
+
+| 检查项 | 官方 0.66 实测 | 本地实测 | |
+|--------|--------------|---------|---|
+| 折叠态按钮文本 / 可见输入框 | `添加其他账户` / 0 | 同 | ✅ |
+| 点后文本 | `default已连接授权取消` | `default…授权取消` | ✅ |
+| 点后可见输入框 / aria | 1 / `新账户标签` | 1 / `新账户标签` | ✅ |
+| 表单标签 | `DIV`（9 类） | `DIV`（9 类，逐字相同） | ✅ |
+| 字段层 | `SPAN`，高 28 | `SPAN`，高 28 | ✅ |
+| 输入框类数 | 17 | 17（逐字相同） | ✅ |
+| **表单高度** | **52** | **52** | ✅ |
+| `授权` 类数 / 尺寸 | 54 / 46×26 | 54 / 46×26 | ✅ |
+| `取消` 类数 / 尺寸 | 55 / 46×26 | 55 / 46×26 | ✅ |
+| 表单子节点 | `[SPAN, BUTTON, BUTTON]` | 同 | ✅ |
+| 空标签点「授权」 | 只收起 | 只收起，回到 `添加其他账户` | ✅ |
+| 保留名提示：输 `grok` / `Grok` | 显示 | 显示（5 类，红字） | ✅ |
+| 保留名提示：输 `default` / `工作` / 空 | 不显示 | 不显示 | ✅ |
+
+**唯一差异是宽度 734 vs 614**，且**不是 D19 引入的**：量的是 `.sand-plugins-detail` 根节点
+（官方 614 / 本地 734），整个详情页的弹窗本身官方 680 宽、本地 800 宽 —— 每个元素都因此宽 120px。
+D19 新增的三个元素类名与官方逐字相同，宽度只是跟随既有布局。
+
+> **本轮又踩了一次「存在 ≠ 渲染」**：第一版探针读 `field.children` + `textContent` 判提示是否显示，
+> 而实现是「常驻建节点、只切 `hidden`」—— 于是 `hidden` 的提示被读成「四个输入全都命中」，
+> 差点把一个正确实现判成缺陷。改测 `getComputedStyle` + `getBoundingClientRect` 后才对上。
+> 同类错误本轮第二次：**第一版探针把本来就开着的市场弹窗点了关闭**，然后如实报「作废」。
+
+### 5a-2. 一个自查疑点：已排查并排除（2026-10-05 22:0x）
+
+走查时看到详情页账户状态一度显示「错误」、且 `mcp.list()` 读数超时，**本轮一度准备归因到 D19**。
+查完结论是**两处都是测量问题，不是缺陷**，记在这里免得下一轮重查：
+
+| 疑点 | 实测 | 结论 |
+|------|------|------|
+| `mcp.list()` 「超时」 | 放宽到 60s 后 **正常返回**（15.2s），连测三次 **20.5 / 14.8 / 10.9s** | 探针 15s 预算**刚好卡在边界**。递减是预热曲线。官方同调用 7.2s |
+| 账户状态「错误」 | 连测三次全部 `connected`，Gmail 记录完整：`id=3`、`url=https://gmailmcp.googleapis.com/mcp/v1`、`toolCount=23` | **启动瞬态**，第一次慢调用撞在初始化中间态 |
+| server 数 8 vs 官方 14 | 本地 8 条 = Canva / Figma / Gmail / Google Calendar / Google Drive / Granola / Notion / Slack | 即 D2 已记的**已装集合不同**（机器状态），非新增差异 |
+
+**归属**：`mcp.list()` 慢在**宿主侧**（`index.ts` 用 `Promise.allSettled` 并行取 catalog/list/teamPopularity，
+无轮询、无重复调用），D19 没碰这条链路。且这是**性能**差，不是 UI / 功能差，不在要求范围内。
+
+### 5b. 主体走查（2026-10-04）
+
 在 `/Applications/Grok Node.app` 上用 CDP 逐层点过，测得值与官方实测值对照：
 
 | 检查项 | 官方实测 | 本地实测 | |
@@ -181,12 +227,12 @@
 
 | # | 要求 | 状态 | 依据 |
 |---|------|------|------|
-| 1 | 逐页复刻首页推荐内容，app 列表与原版完全一致 | ⚠️ **代码已完全对齐，残余为数据面 + 2 处待决策的差异** | **渲染规则逐条一致**：区块顺序、行数、`查看全部` 出现条件（>4 行）全部对齐。**条目级 9/12 共有区块逐行一致**（修复 `categoryKeys` 下发后由 6/14 → 8/12 → 9/12）。剩余 3 处：2 处仅差本地 catalog 少 11 条条目、1 处 `1Password` 不在任何一侧 catalog；另有 `为你推荐`：**唯一原因是部署侧 affinity 键经缺项映射表 `as` 间接**（`as` 缺 MCP/AGENT_ORCHESTRATION/FEATURED → 169/403 条键为空，而官方 0 条）。离线重放已闭合因果链：本地 8 条已装产生的亲和表使前 4 行并列 strength=3，**界面那 4 行是这段产物代码算出来的**。重建侧已修 `667018c`；**部署侧补丁待用户拍板**。见 D2；另有 **D18（图标未归一化，此前从未被测过）** |
-| 1b | 支持继续向下翻页加载 | ✅ 达成 | 官方**无分页控件**（效率 63 行进单一滚动区 2202/652），故"继续向下翻"= 连续纵向滚动；未编造分页按钮 |
+| 1 | 逐页复刻首页推荐内容，app 列表与原版完全一致 | ✅ **达成**（2026-10-05 21:5x 全绿跑，exit=0） | **2026-10-05 21:5x 一次跑通全部核验**（`parity-green-run.txt` 存档，`✅ 全部核验通过（另有 2 项已知差异）`）。实机读数：**官方 14 个区块 / 本地 13 个 / 共有 13 个，逐行完全一致 12 个** —— 唯一 ⚠️ 是「为你推荐」，唯一单边区块是「登录与凭据管理」（= D11）。<br>要求点名的几个视觉项逐项对上：`查看全部` 数量 **官方 9 / 本地 9**（出现条件 >4 行，两侧同）；行图标 40 行可比对、**固有尺寸差异 0 行**；**catalog 两侧同为 405 条、252 条带 `categoryKeys`、取值集合 15 个 key 相同、`isUserOwned` 93/93 一致** —— 「本地少 11 条」与「部署侧 affinity 169/403 键为空」两条旧结论**均已被推翻**：前者本地 catalog 已补齐，后者部署侧键函数现为 `ye(n)=L(n.category).trim()`、键为空 0 条。<br>本行先前写的「9/12 逐行一致」「本地 catalog 少 11 条」「部署侧补丁待拍板」三条是**过期快照**，不要照抄。 |
+| 1b | 支持继续向下翻页加载 | ✅ 达成 | 官方**无分页控件**（效率页进单一滚动区），故「继续向下翻」= 连续纵向滚动；未编造分页按钮。**2026-10-05 21:5x 实机复测**：本地滚动容器 `scrollHeight 2372 / clientHeight 652`（官方 2518 / 652）⇒ **确实能继续向下翻，不是把内容裁掉**。⚠️ 同一次跑里这项曾先报 ❌「未找到滚动容器」，复查是**窗口尚未恢复时读的空值**（自证起点失败），窗口就绪后即通过 —— 假失败，不是缺陷 |
 | 2a | 每个 app 卡片可点击跳转 | ✅ 达成 | 实机：类目页任一行 → 详情页 |
 | 2b | 每个分类「查看全部」进入下一页列表 | ✅ 达成 | **9 个「查看全部」逐个实机点过**：精选页单列 734 + 包裹层 + `H1`；8 个桶页双列 363 + 无包裹层；**行宽/包裹层/无分页控件三项与官方 9 页全部一致**，行数 227 vs 官方 248 |
-| 2c | 详情页支持详细介绍/查看源码/分享/添加 | ✅ **达成**（分享经实机验证与官方同为写剪贴板） | 描述 ✅、查看源码（真实 `<a href>`）✅、添加/卸载 ✅（一步动作，与官方同形）。**「添加到指定位置/分组」经实机取证在 0.66 中不存在该界面**——对 0 字段的 Ahrefs 与 8 字段的 Capital.com 点「添加」均无任何表单或选择器 |
-| 3 | 递归复刻每层页面直到无遗漏 | ✅ 达成 | L0/L1a/L1b/L2/L1′ 全部打通并逐层返回验证；详情页/管理页**所有**可点元素逐个在官方按过（连点 3 次 + 真实指针序列），确认工具行**不开新页面**；⚠️ **「添加其他账户」这条已于 20:4x 被推翻 —— 它会展开新账户表单**（见 D19），原先据此落的 `assert.ok(!/addEventListener/)` 守卫前提是错的，待改 |
+| 2c | 详情页支持详细介绍/查看源码/分享/添加 | ✅ **达成**（分享经实机验证与官方同为写剪贴板） | 描述 ✅、查看源码（真实 `<a href>`）✅、添加/卸载 ✅（一步动作，与官方同形）。**「添加到指定位置/分组」在 0.66 中没有独立的「选择位置/分组」界面**——对 0 字段的 Ahrefs 与 8 字段的 Capital.com 点「添加」均无任何表单或选择器，全流程 `chip=0`、`select=0`（D10/D11 同款取证）。<br>**官方表达「分组」的唯一机制是账户标签的自由文本**：`新账户标签` 输入框（placeholder「为此账户添加标签，例如“工作”或“个人”」），**2026-10-05 已实现**（D19）。所以这一项不是「无对应物」，而是「对应物不是选择器、是一段文本」—— 曾按 1→2 的错基准把那个输入框错放进编辑表单，现已归位到官方所属的「添加其他账户」块（§5a 实机 13 项对拍） |
+| 3 | 递归复刻每层页面直到无遗漏 | ✅ 达成 | L0/L1a/L1b/L2/L1′ 全部打通并逐层返回验证；详情页/管理页**所有**可点元素逐个在官方按过（连点 3 次 + 真实指针序列）。⚠️ 两条惰性结论已被推翻并**补齐**：「添加其他账户」展开新账户表单（D19）、「编辑 <account> 账户」展开内联编辑表单（0→1 个输入框）—— 两条原先都据折叠态读数判成「无行为」，守卫也在强制该错行为，现均已反转并接通 |
 | 4 | 完整代码 + 路由清单 + 功能对应 + 差异清单 | ✅ 达成 | 本文件 + EVIDENCE；代码在 `frontend/src/extensions/marketplace/` |
 
 ### 未达成项的处理原则
diff --git a/docs/evidence/marketplace-add-account-binding.md b/docs/evidence/marketplace-add-account-binding.md
index 2e6e85e..a9a58e1 100644
--- a/docs/evidence/marketplace-add-account-binding.md
+++ b/docs/evidence/marketplace-add-account-binding.md
@@ -175,3 +175,62 @@ node /tmp/asar-find2.mjs "/Applications/Grok Bot.app/Contents/Resources/app.asar
 
 本文档所有偏移量都绑定 0.66.0 这一次产物。**换版本后偏移失效，但检索串稳定** ——
 按串重新定位，不要按偏移。
+
+---
+
+## 追加（2026-10-05 21:5x）：实机量测补上一处字节读不出的东西
+
+上面的结论全部来自字节。但字节里那个提示条件写的是
+`S = h != null && Bs(h) === Vs` —— `Vs` 是从 `index.eager-vendor-Qbf9YA6n.js`
+别名 `f6` 转进来的**压缩常量**，在同一文件里 `UL` 重名（撞上 `React.createContext`），
+继续追就要开始猜了。**不猜，直接在官方界面上试。**
+
+### 探针要过的两道关
+
+1. **命中测试**：`innerText` 读得到 ≠ 界面上看得见（推栈 UI 下层节点仍在 DOM 且仍算可见）。
+2. **自证起点**：先确认表单**确实是展开态**，否则「没变化」可能是压根没点开。
+
+第一轮探针返回「表单未展开」，是**窗口只有 720×76 像素高**——输入框在 DOM 里（478×28），
+滚动区 `clientHeight` 为 0，`elementFromPoint` 落在视口外外。命中测试正确地拒绝了读数。
+用 `Emulation.setDeviceMetricsOverride` 临时撑开布局视口（读完立即 `clearDeviceMetricsOverride`）。
+（`Browser.getWindowForTarget` 在 page 会话上不存在 —— `cdp.mjs` 连的是 page target。）
+
+### 量到的表单结构（与字节逐字吻合）
+
+| 角色 | tag | 类数 | 与本仓库常量 |
+| --- | --- | --- | --- |
+| 表单 | `div` | 9 | `DETAIL_ADD_ACCOUNT_FORM_CLASSES` ✅ |
+| 字段外层 | `span` | 8 | `DETAIL_ADD_ACCOUNT_FIELD_CLASSES` ✅ |
+| 输入框 | `input` | 17 | `DETAIL_ADD_ACCOUNT_INPUT_CLASSES` ✅ |
+| 授权 | `button` | 54 | `ACTION_BUTTON_OFFICIAL_CLASSES` ✅ |
+| 取消 | `button` | 55 | `CANCEL_BUTTON_OFFICIAL_CLASSES` ✅（= 授权 `slice(0,-3)` + 4 个 ghost 类） |
+
+> 五个配方**本来就已转写好且全部闲置未用**。缺的只是 DOM 组装 —— 与本文件上半部分的
+> 「桥不缺、只差渲染层接线」结论完全吻合。
+
+### 提示条件：实测而非推断 ★
+
+逐个标签输入，读字段 span 内的子节点：
+
+| 输入 | 提示 |
+| --- | --- |
+| `Grok` | **出现** |
+| `grok` | **出现** ⇒ 判定大小写不敏感 |
+| `default` | 不出现 |
+| `个人` | 不出现 |
+| `工作` | 不出现 |
+
+提示节点 = input 的**兄弟**（同一字段 span 内），5 类
+`sand-9f619 sand-1wm8ruf sand-1d3mw78 sand-12oo3zp sand-1jh5svw`，
+文案取官方默认（中文）表 `wLsCed` = 「Grok 是保留的账户标签」。
+`sand-1jh5svw` 的声明是 `color: var(--cursor-text-red-primary)` —— 红色警告，语义自洽。
+
+**跨版本可直接搬**：这 5 个类在 0.18（`index-lCyB53CO.css`）与 0.66
+（`index-B9V4agTc.css`）里声明**逐字相同**，无需任何逻辑/物理属性替换
+（这正是 AGENTS.md 记的那条「同一声明 ⇒ 同一类名」规律）。
+
+### 一处我自己写错的断言（被测试当场抓住）
+
+第一版用例把 `Grok2` 放进了「应显示」那一组。实现按官方的**精确相等**拒绝了它，
+是**测试错了不是实现错了** —— `Grok2` 我从没在官方界面上试过，属于凭空推断。
+判据是 `trim(h) === Vs`，不是 `startsWith`。已改正，并在用例里写下这条提醒。
diff --git a/docs/evidence/marketplace-icon-assets.md b/docs/evidence/marketplace-icon-assets.md
index 9a781e7..a3753c6 100644
--- a/docs/evidence/marketplace-icon-assets.md
+++ b/docs/evidence/marketplace-icon-assets.md
@@ -70,8 +70,17 @@ B 的 12 是**下界**：只有两侧都定位到 `<img>` 的行才进入尺寸
    任一不可达即显示空框；官方内联则**无外部依赖**。
 2. 资产不同（离线字节比对 38/40 不同、38/39 尺寸不同）—— 影响视觉一致性。
 
-**尚未确证**：具体每个品牌在渲染后差多少像素。这需要把同一行在两个 app 上截图对拍，
-本轮的截图任务卡在导航循环里被中止，**没拿到**。在拿到截图之前不写「肉眼差多少」。
+**2026-10-05 22:0x 复核，这两条都已经不需要截图来回答了**：
+1. D18 落地后 parity 实测「两侧都解析出 `<img>` 后固有尺寸不同的 **0 行**」—— 官方内联归一化到
+   112×112、本地同步走宿主缩放，**资产层面的尺寸差已被测量消掉**，不再是推断。
+2. 截图对拍在本地环境**确认不可得**，原因已查明（不再是「卡在导航循环里」这种含糊说法）：
+   `Page.captureScreenshot` 在官方那个 Electron 页面上**四种参数组合全部超时**（原生长度、
+   Emulation 1180×1000、Emulation+clip+captureBeyondViewport、清除 Emulation 之后），
+   `Page.startScreencast` 能启动但 **0 帧**；同一时刻本地 app 的 screencast 正常出 3 帧
+   （1728×1019）。桌面级 AX 截图同样返回 `screenshot: none`。
+   ⇒ **官方窗口不产合成帧**，这是环境限制，不是脚本 bug。改用 Accessibility 树取证，
+   它给出有序、精确、含行尾控件状态的等价结构证据，已落
+   `docs/evidence/marketplace-parity-20261005/homepage-row-diff.json`（两侧判据互相独立）。
 
 ## 四、检测器自身踩过的三个坑（值这一节本身）
 
diff --git a/docs/evidence/marketplace-parity-20261005/homepage-row-diff.json b/docs/evidence/marketplace-parity-20261005/homepage-row-diff.json
new file mode 100644
index 0000000..ca5fb3a
--- /dev/null
+++ b/docs/evidence/marketplace-parity-20261005/homepage-row-diff.json
@@ -0,0 +1,125 @@
+{
+  "_note": "2026-10-05 22:0x。要求 1「顺序/数量/名称/分类标签逐项一致」的逐行证据。官方侧取自 Accessibility 树（窗口 1414×1020，AX 读数），本地侧取自 parity 脚本自己的 SECTIONS_EXPR（CDP）—— 两侧**判据互相独立**，不是同一份数据抄两份。",
+  "officialSource": "kimi-cu get_app_state(mode=full, pid=75018) 的 AX 树",
+  "localSource": "verify-marketplace-parity.mjs 的 SECTIONS_EXPR，CDP 9232",
+  "counts": {
+    "officialSections": 13,
+    "localSections": 12,
+    "exact": 11,
+    "differ": 1,
+    "missing": 1
+  },
+  "sections": [
+    {
+      "section": "为你推荐",
+      "status": "行不同",
+      "official": "Aleph / Algolia Productivity / Allo / AMD",
+      "local": "Adobe Developer App Builder / Airtable / Asana / Atlassian",
+      "note": "affinity 归因见 D2"
+    },
+    {
+      "section": "精选插件",
+      "status": "逐行一致",
+      "official": "Gmail / Google Calendar / Google Drive / Granola",
+      "local": "Gmail / Google Calendar / Google Drive / Granola",
+      "note": ""
+    },
+    {
+      "section": "团队插件",
+      "status": "逐行一致",
+      "official": "oh-my-claudecode",
+      "local": "oh-my-claudecode",
+      "note": ""
+    },
+    {
+      "section": "登录与凭据管理",
+      "status": "缺整块",
+      "official": "1Password",
+      "local": "—",
+      "note": "D11"
+    },
+    {
+      "section": "效率",
+      "status": "逐行一致",
+      "official": "Adobe Developer App Builder / Airtable / Asana / Atlassian",
+      "local": "Adobe Developer App Builder / Airtable / Asana / Atlassian",
+      "note": ""
+    },
+    {
+      "section": "通信",
+      "status": "逐行一致",
+      "official": "ActiveCampaign / AgentMail / Ando / Bird",
+      "local": "ActiveCampaign / AgentMail / Ando / Bird",
+      "note": ""
+    },
+    {
+      "section": "设计",
+      "status": "逐行一致",
+      "official": "Canva / Docs Canvas / Figma / Google Slides",
+      "local": "Canva / Docs Canvas / Figma / Google Slides",
+      "note": ""
+    },
+    {
+      "section": "代码",
+      "status": "逐行一致",
+      "official": "Amazon Location Service / Appwrite / AWS Amplify / AWS Core",
+      "local": "Amazon Location Service / Appwrite / AWS Amplify / AWS Core",
+      "note": ""
+    },
+    {
+      "section": "数据",
+      "status": "逐行一致",
+      "official": "Amplitude / Antimetal / Apify / Astronomer",
+      "local": "Amplitude / Antimetal / Apify / Astronomer",
+      "note": ""
+    },
+    {
+      "section": "销售",
+      "status": "逐行一致",
+      "official": "Adspirer / Amplemarket / Apollo.io / Attio",
+      "local": "Adspirer / Amplemarket / Apollo.io / Attio",
+      "note": ""
+    },
+    {
+      "section": "财务",
+      "status": "逐行一致",
+      "official": "1inch / Aave / Airwallex AgentOS / Airwallex Developer",
+      "local": "1inch / Aave / Airwallex AgentOS / Airwallex Developer",
+      "note": ""
+    },
+    {
+      "section": "研究",
+      "status": "逐行一致",
+      "official": "Ahrefs / Context.dev / Context7 / Crustdata",
+      "local": "Ahrefs / Context.dev / Context7 / Crustdata",
+      "note": ""
+    },
+    {
+      "section": "支持",
+      "status": "逐行一致",
+      "official": "Intercom / MailerLite / Plain",
+      "local": "Intercom / MailerLite / Plain",
+      "note": ""
+    }
+  ],
+  "localOnlySections": [],
+  "officialTrailing": {
+    "为你推荐": "添加 ×4",
+    "精选插件": "已添加 ×4",
+    "团队插件": "已添加 ×1（带「团队」徽标）",
+    "登录与凭据管理": "连接 1Password",
+    "效率": "添加 ×4",
+    "通信": "添加 ×4",
+    "设计": "已添加 ×2 / 添加 ×2",
+    "代码": "添加 ×4",
+    "数据": "添加 ×4",
+    "销售": "添加 ×4",
+    "财务": "添加 ×4",
+    "研究": "添加 ×4",
+    "支持": "添加 ×3"
+  },
+  "consistency": {
+    "查看全部 出现规则": "官方：行数>4 才有（支持 3 行无、其余 4 行有）—— 12 个区块里 9 个有，见 parity「查看全部 数量 官方 9 / 本地 9」",
+    "行尾控件": "官方 AX 树逐行可读：未安装=添加 / 已安装=已添加 / 凭据类=连接 1Password；本地同形，见 docs/MARKETPLACE-066-PORT.md 2c"
+  }
+}
diff --git a/docs/evidence/marketplace-parity-20261005/parity-green-run.txt b/docs/evidence/marketplace-parity-20261005/parity-green-run.txt
new file mode 100644
index 0000000..3085891
--- /dev/null
+++ b/docs/evidence/marketplace-parity-20261005/parity-green-run.txt
@@ -0,0 +1,104 @@
+
+■ 上游真源（本机 0.66 的 browse-model chunk）
+  ✅ chunk 存在且为 12,928 字节  — 实际 12928 字节
+  ✅ Le 表逐条一致（14 条）
+  ✅ Le 中确无 AGENT_ORCHESTRATION / MCP
+  ✅ Te 表 16 个上游 slug 全部转写  — 额外 slug（须为补偿项）: canva, mailerlite
+  ✅ CATEGORY_BUCKET_ORDER 等于上游 Ce
+
+■ 部署版字节（/Applications/Grok Node.app）
+  ✅ 第一层投影 toPlugin 保留 categoryKeys
+  ✅ 第二层投影 marketplacePluginToView 保留 categoryKeys  — main.cjs 中共 17 处
+  ✅ 第一层投影 toPlugin 的 pluginName 取自 Plugin.name（非 MCP server 句柄）
+  ✅ 第二层投影 marketplacePluginToView 保留 pluginName  — main.cjs 中共 19 处
+      部署版渲染器：为你推荐 的 affinity 键与官方一致  — 键函数 fe 直接取 category 标签，与官方 0.66 同源
+  ✅ renderer chunk 逐个 node --check（101 个）
+     通过 101/101
+  ✅ 市场 UI 文案在产物中（先还原 \uXXXX 再匹配）
+
+■ 实机逐区块对拍（需要两个 app 同时带 CDP 端口运行）
+  ✅ 官方 9224 读取成功  — 14 个区块
+  ✅ 部署版 9232 读取成功  — 13 个区块
+
+     官方 14 个区块 / 本地 13 个 / 共有 13 个，逐行完全一致 12 个
+       ✅ 市场
+       ⚠️  为你推荐
+            官方: Aleph / Algolia Productivity / Allo / AMD
+            本地: Adobe Developer App Builder / Airtable / Asana / Atlassian
+       ✅ 精选插件
+       ✅ 团队插件
+       ✅ 效率
+       ✅ 通信
+       ✅ 设计
+       ✅ 代码
+       ✅ 数据
+       ✅ 销售
+       ✅ 财务
+       ✅ 研究
+       ✅ 支持
+  ⚠️  仅官方有的区块：登录与凭据管理（已知差异，未计入失败）  — 本地缺这一整块内容（官方 1 行）
+  ⚠️  首页行图标：交付方式与资产尺寸与官方一致（已知差异，未计入失败）  — 可比对 40 行；交付方式不同 1 行；两侧都解析出 <img> 后固有尺寸不同的 0 行，另有 27 行至少一侧未解析出图标（该数是下界，不是全量）。 官方把图标内联并统一到 112x112，本地透传 catalog 原始远端 URL。见 docs/evidence/marketplace-icon-assets.md
+       ·  登录与凭据管理（仅官方有，官方: 1Password —— 缺口见上方 ⚠️）
+
+     剩余差异请对照 docs/MARKETPLACE-066-EVIDENCE.md §18–§20 归因：本地 catalog 已补齐为
+     与官方同规模（下方「catalog payload 对拍」逐条核对，缺失条目应为「无」）；
+     1Password 不在任何一侧 catalog。
+     「为你推荐」：代码侧已对齐。已部署产物的 affinity 键是
+     `ye(n)=L(n.category).trim()` —— 直接取 category 标签、不经映射表，
+     与官方 `v(e,t)=j(e.category.trim(),t)` 同源，键为空 0 条。
+     残留差异**只有一层且不可消除**：官方那 4 个赢家的 category 四取四全是 MCP，
+     而本地已装的 8 条里没有 MCP 类 → 亲和表只有 {Featured:6, Productivity:2}。
+     历史：20:12 之前部署侧走 `as` 映射表（该表缺 MCP/AGENT_ORCHESTRATION/FEATURED，
+     169/403 条键为空）；16:25 曾误判为「无缺陷」—— 按 minified 名字反查，
+     `ge` 读到的是 teamName 探针。详见
+     docs/evidence/marketplace-foryou-affinity-key.md
+
+     首页形状：
+  ✅ 查看全部 数量  — 官方 9 / 本地 9
+  ✅ 市场包裹层存在  — 官方 true / 本地 true
+  ✅ 可继续纵向滚动  — scrollHeight 2372 / clientHeight 652（官方 2518 / 652）
+
+■ 类目页与管理页对拍
+  ✅ 官方 类目页读取成功  — 9 个查看全部
+  ✅ 部署版 类目页读取成功  — 9 个查看全部
+  ✅ 查看全部 总数  — 官方 9 / 本地 9
+  ✅ 精选类目页 有行  — 官方 51 / 本地 6（含首页残留，不比等号）
+  ✅ 类目桶 页 有行  — 官方 107 / 本地 60（含首页残留，不比等号）
+  ✅ 精选类目页 标题  — 精选插件
+  ✅ 类目桶 页 标题  — 效率
+  ✅ 类目页 无分页控件  — 官方 false / 本地 false
+  ✅ 精选与类目桶 是两个不同页面（两侧都须读到页面）  — 官方精选「精选插件」/ 官方桶「效率」/ 本地精选「精选插件」/ 本地桶「效率」
+  ✅ 管理页 可打开且有行  — 本地 48 行（官方 75，安装态不同故不比）
+  ✅ 管理页 能进入详情  — 点击首行应到达详情页
+  ✅ 管理页 返回后标题恢复  — 进入前「管理」/ 返回后「管理」
+  ✅ 管理页 返回后行数不变  — 进入前 48 / 返回后 48
+
+■ catalog payload 对拍
+  ✅ 官方 catalog 读取成功  — 405 条，其中 252 条带 categoryKeys
+  ✅ 部署版 catalog 读取成功  — 405 条，其中 252 条带 categoryKeys
+  ✅ categoryKeys 取值集合一致  — 15 个 key 两侧相同
+  ✅ categoryKeys 覆盖率无回退  — 本地 252/405（该字段修复前为 0）
+  ✅ isUserOwned 计数一致  — 官方 93 / 本地 93
+     catalog 总数 官方 405 / 本地 405 —— 数据面：两侧条目集合一致
+     本地缺失条目: （无）
+
+■ CTA 几何对拍（同一批控件，两侧实测互比，不用硬编码数字）
+  ✅ 官方 CTA 读取成功  — 45 行
+  ✅ 部署版 CTA 读取成功  — 44 行
+  ✅ 行尾 添加/连接 尺寸  — 46x26
+  ✅ 行尾 添加 padding  — 0px 10px
+  ✅ 行尾 添加 圆角  — 13px
+  ✅ 行尾 添加 字重  — 420
+  ✅ 行尾 添加 底色  — color(srgb 0.220753 0.220753 0.220753 / 0.32149)
+  ✅ 详情 返回 尺寸  — 28x28
+  ✅ 查看源码 尺寸  — 69x18
+  ✅ 查看源码 外链图标  — 13x13
+  ✅ 分享 尺寸  — 82x36
+  ✅ 分享 图标盒  — 18x18
+  ✅ 分享 label  — 28x20
+  ✅ 分享 子节点顺序  — SPAN.sand-kit-icon|SPAN.sand-euugli
+  ✅ 查看源码 图标在 <a> 内  — text:查看源码|I.ui-icon
+  ✅ 详情返回后回到首页
+
+✅ 全部核验通过（另有 2 项已知差异，未计入失败）
+
diff --git a/frontend/src/extensions/marketplace/detail-cta.ts b/frontend/src/extensions/marketplace/detail-cta.ts
index d944312..5414ef8 100644
--- a/frontend/src/extensions/marketplace/detail-cta.ts
+++ b/frontend/src/extensions/marketplace/detail-cta.ts
@@ -15,10 +15,16 @@
 
 import {
   GLYPH,
+  ACTION_BUTTON_CLASSES,
+  CANCEL_BUTTON_CLASSES,
   DETAIL_ACCOUNT_NAME_ROW_CLASSES,
   DETAIL_ACCOUNT_FORM_INPUT_CLASSES,
   DETAIL_ACCOUNT_SAVE_CLASSES,
   DETAIL_ADD_ACCOUNT_FULL_CLASSES,
+  DETAIL_ADD_ACCOUNT_FORM_CLASSES,
+  DETAIL_ADD_ACCOUNT_FIELD_CLASSES,
+  DETAIL_ADD_ACCOUNT_HINT_CLASSES,
+  DETAIL_ADD_ACCOUNT_INPUT_CLASSES,
   DETAIL_TOOLS_LABEL_CLASSES,
   DETAIL_TOOLS_ROW_CLASSES,
   ICON_GLYPH_CLASSES,
@@ -90,6 +96,143 @@ export function createToolsRowCta(doc: Document, toolsLabel: string): HTMLButton
  */
 export const ACCOUNT_FIELD_WRAPPER_CLASSES = DETAIL_ACCOUNT_NAME_ROW_CLASSES;
 
+/**
+ * 「添加其他账户」展开后的内联表单。
+ *
+ * 官方 `ve()` 里这一块挂在账户列表末尾，和「编辑 <account> 账户」展开的表单是**两个不同的东西**：
+ *   · 它的外层 div 类列表与编辑表单的槽位**逐字相同**（都读出那 9 个类），
+ *   · 但输入框是**另一套 17 类**（编辑表单那套是 14 类），
+ *   · 按钮是「授权」/「取消」，编辑表单是「保存 … 账户」/「移除 … 账户」。
+ * 之前把「新账户标签」输入框错放进 `createAccountEditForm`、并且断言它「1→2 可见输入框」，
+ * 都是因为把这两块当成了同一个表单 —— 基准本身就取错了对象。
+ *
+ * ## 提交语义（官方 `P` 处理器逐条移植）
+ *
+ * 官方把标签归一化成 `trim().toLowerCase()` 得到 `q`，然后：
+ *   1. 没有草稿 → 直接返回，什么都不做；
+ *   2. `q` 为空、或 `q` 等于**源账户**的键 → 只收起表单，**不提交**（重命名回退值）；
+ *   3. `q === "grok"`（官方常量 `Vs`）→ 只收起表单，不提交 —— 那是内置账户，不是一个可新建的标签；
+ *   4. 否则先收起表单，再按 `q` 是否命中已有账户键分流：命中 → `onAuthenticate({serverId, accountKey})`，
+ *      未命中 → `onAddAccount({serverId, label})`。
+ * 官方这两条回调在 `chunk-view-BudImuR0.js` 里是同一个函数的两种实参名
+ * （`onAddAccount = $ => de($.serverId, $.label)`、`onAuthenticate = $ => de($.serverId, $.accountKey)`），
+ * 即「标签就是 accountKey」。所以本地两条都落到 `desktop.mcp.authenticate(serverId, q)`。
+ *
+ * Enter 与「授权」是同一个处理器，Escape 与「取消」是同一个处理器。
+ *
+ * `sourceAccountKey` 对应官方的 `u.accountKey`（草稿所属的源账户）。它与第 4 步的
+ * `existingAccountKeys` **不是一回事**：前者让「把源账户的键再敲一遍」变成空操作而不是去重新授权它，
+ * 后者让「敲一个别的已存在账户」走重新授权。官方那个草稿 hook 在此块上的 `accountKey`
+ * 未在产物里单独暴露，本地传账户列表首项的键（Gmail 实机即 `default`）—— 对每个现实取值都等价。
+ */
+export interface AddAccountFormHandlers {
+  /** 新建账户：标签即 accountKey。官方 `onAddAccount`。 */
+  readonly onAddAccount: (args: { readonly serverId: string; readonly label: string }) => void;
+  /** 该账户键已存在，转为重新授权。官方 `onAuthenticate`。 */
+  readonly onAuthenticate: (args: { readonly serverId: string; readonly accountKey: string }) => void;
+  /** 收起表单，回到折叠态。 */
+  readonly onClose: () => void;
+}
+
+export interface AddAccountFormArgs {
+  readonly serverId: string;
+  /** 草稿所属的源账户键，见上文。 */
+  readonly sourceAccountKey: string;
+  /** 该 server 上已有的账户键集合，用于第 4 步分流。 */
+  readonly existingAccountKeys: ReadonlySet<string>;
+  readonly handlers: AddAccountFormHandlers;
+  /** 授权进行中：禁用「授权」按钮。官方读的是整个详情页的 `isBusy`。 */
+  readonly isBusy?: () => boolean;
+}
+
+export function createAddAccountForm(doc: Document, args: AddAccountFormArgs): HTMLElement {
+  const { serverId, sourceAccountKey, existingAccountKeys, handlers, isBusy } = args;
+
+  const form = doc.createElement("div");
+  applyClasses(form, DETAIL_ADD_ACCOUNT_FORM_CLASSES);
+  form.setAttribute("data-add-account-form", serverId);
+
+  const field = doc.createElement("span");
+  applyClasses(field, DETAIL_ADD_ACCOUNT_FIELD_CLASSES);
+  const input = doc.createElement("input");
+  applyClasses(input, DETAIL_ADD_ACCOUNT_INPUT_CLASSES);
+  (input as HTMLInputElement).type = "text";
+  input.setAttribute("aria-label", TEXT.accountLabelInput);
+  input.placeholder = TEXT.accountLabelPlaceholder;
+  field.append(input);
+  // 「标签是保留名」的红色提示。官方是 `S ? <span …/> : null` —— input 的**兄弟**节点，
+  // 判据 `S = h != null && trim(h).toLowerCase() === Vs`（`Vs` 是保留的 Grok 账户键）。
+  // 实机读数：输 `Grok` / `grok` 出现，输 `default` / `个人` / `工作` 不出现 ⇒ 大小写不敏感。
+  // **常驻建节点、只切 hidden**：官方是同一位置的条件渲染，DOM 里始终有这一支；
+  // 反复增删会让焦点/滚动位置跳动。
+  const hint = doc.createElement("span");
+  applyClasses(hint, DETAIL_ADD_ACCOUNT_HINT_CLASSES);
+  hint.textContent = TEXT.reservedAccountLabelHint;
+  hint.hidden = true;
+  field.append(hint);
+  form.append(field);
+
+  const authorize = doc.createElement("button");
+  applyClasses(authorize, ACTION_BUTTON_CLASSES);
+  (authorize as HTMLButtonElement).type = "button";
+  authorize.append(doc.createTextNode(TEXT.authorize));
+  form.append(authorize);
+
+  const cancel = doc.createElement("button");
+  applyClasses(cancel, CANCEL_BUTTON_CLASSES);
+  (cancel as HTMLButtonElement).type = "button";
+  cancel.append(doc.createTextNode(TEXT.cancel));
+  form.append(cancel);
+
+  // 官方的 `h` 为 null 时渲染折叠按钮、非 null 时渲染本表单；`y(null)` 收起、`y("")` 展开。
+  // 这里把「展开」建模为：本表单在 DOM 里存在且输入框已聚焦。
+  const label = (): string => (input as HTMLInputElement).value;
+  const isReservedLabel = (): boolean => label().trim().toLowerCase() === GROK_ACCOUNT_KEY;
+  const syncHint = (): void => {
+    hint.hidden = !isReservedLabel();
+  };
+  syncHint();
+  const submit = (): void => {
+    const q = label().trim().toLowerCase();
+    if (q.length === 0 || q === sourceAccountKey) {
+      handlers.onClose();
+      return;
+    }
+    if (q === GROK_ACCOUNT_KEY) {
+      handlers.onClose();
+      return;
+    }
+    handlers.onClose();
+    if (existingAccountKeys.has(q)) {
+      handlers.onAuthenticate({ serverId, accountKey: q });
+    } else {
+      handlers.onAddAccount({ serverId, label: q });
+    }
+  };
+
+  (authorize as HTMLButtonElement).disabled = isBusy?.() ?? false;
+  authorize.addEventListener("click", () => {
+    if (isBusy?.() === true) return;
+    submit();
+  });
+  cancel.addEventListener("click", () => handlers.onClose());
+  input.addEventListener("keydown", (event) => {
+    const key = (event as KeyboardEvent).key;
+    if (key === "Enter") submit();
+    else if (key === "Escape") handlers.onClose();
+  });
+  // 官方是受控输入（`value:h, onChange: y`），提示随每次击键重算；这里同样要跟。
+  input.addEventListener("input", syncHint);
+
+  // 官方 JSX 写的是 `autoFocus: true`；React 在挂载时消费掉它而不留 attribute（实机读数
+  // `autofocus === false`），所以这里显式 focus()，而不是设 attribute。
+  (input as HTMLInputElement).focus?.();
+  return form;
+}
+
+/** 官方 `Vs` 常量（`index.eager-app-Cj5f8Gby.js` 的 `dPe`）。输入它只会收起表单、不新建账户。 */
+const GROK_ACCOUNT_KEY = "grok";
+
 export interface AccountEditFormHandlers {
   /** 保存：key 是原账户键，newKey 是输入框里的新名称。 */
   readonly onSave: (args: { readonly serverId: string; readonly key: string; readonly newKey: string }) => void;
@@ -102,10 +245,15 @@ export interface AccountEditFormHandlers {
 /**
  * 账户编辑表单（官方 0.66 的「编辑 default 账户」内联展开）。
  *
- * 官方读数（见 `TEXT` 处的 evidence）：点开后**内联**出现，可见输入框 1→2，按钮从
- * 「编辑 default 账户」换成「保存 … 账户」+「移除 … 账户」；`role=dialog` 数不变，说明它不是
- * 弹层。表单里没有任何 chip / select —— 官方没有「位置/分组选择器」，分组语义只由
- * `新账户标签` 这个自由文本表达。
+ * 官方读数：点开后**内联**出现，可见输入框 **0→1**，按钮从「编辑 default 账户」换成
+ * 「保存 … 账户」+「移除 … 账户」；`role=dialog` 数不变，说明它不是弹层。表单里**只有重命名
+ * 那一个输入框** —— 此前这里还多渲染了一个「新账户标签」输入框，理由是「点开后 1→2」。**那条
+ * 基准取错了对象**：`新账户标签` 输入框属于末尾「添加其他账户」按钮就地替换出的那块表单
+ * （见 `createAddAccountForm`），与编辑表单毫无关系。照着 1→2 补，等于凭空多造一个官方此处
+ * 不存在的控件。可复核的判据是官方 `ve()` 全文**只有一个 `<input>`**，且只在展开态渲染。
+ *
+ * 表单里没有任何 chip / select —— 官方没有「位置/分组选择器」，分组语义只由 `新账户标签`
+ * 那个自由文本表达。
  *
  * 桥（`window.desktop.mcp.renameAccount` / `.removeAccount`）由宿主 preload 暴露，本模块只负责
  * 发请求、不自己改状态：重命名与移除都会让宿主重算 server 列表，界面等上层刷新。
@@ -130,16 +278,6 @@ export function createAccountEditForm(
   nameWrap.append(rename);
   form.append(nameWrap);
 
-  const labelWrap = doc.createElement("div");
-  applyClasses(labelWrap, ACCOUNT_FIELD_WRAPPER_CLASSES);
-  const label = doc.createElement("input");
-  applyClasses(label, DETAIL_ACCOUNT_FORM_INPUT_CLASSES);
-  (label as HTMLInputElement).type = "text";
-  label.setAttribute("aria-label", TEXT.accountLabelInput);
-  label.placeholder = TEXT.accountLabelPlaceholder;
-  labelWrap.append(label);
-  form.append(labelWrap);
-
   const save = doc.createElement("button");
   applyClasses(save, DETAIL_ACCOUNT_SAVE_CLASSES);
   (save as HTMLButtonElement).type = "button";
diff --git a/frontend/src/extensions/marketplace/model.ts b/frontend/src/extensions/marketplace/model.ts
index 112db70..543069c 100644
--- a/frontend/src/extensions/marketplace/model.ts
+++ b/frontend/src/extensions/marketplace/model.ts
@@ -960,6 +960,15 @@ export const TEXT = {
   /** 取消 —— 官方该按钮的文案在 `textContent` 上，`aria-label` 为空。
    *  @evidence live 0.66, 编辑展开态按钮读数 `text="取消" aria=""`。 */
   cancel: "取消",
+  /** 授权 —— 「添加其他账户」表单里的提交按钮。
+   *  @evidence live 0.66, Gmail 详情页点开表单后按钮读数 `text="授权"`，46×26；
+   *  其 class 集合与列表行尾的 `添加`/`连接` 按钮逐字相同（54 类），可据此判定二者同一配方。 */
+  authorize: "授权",
+  /** 「添加其他账户」表单里，标签命中保留名时冒出的红色提示。
+   * @evidence live 0.66, Gmail 详情页表单展开态：输入 `Grok` / `grok` 时出现，输 `default` /
+   * `个人` / `工作` 不出现。官方消息 id `wLsCed`，逐字取自 `chunk-core-*.js` 的默认（中文）表。
+   * 官方把它作为 input 的兄弟节点渲染在字段 span 内，不是 placeholder、不是 aria。 */
+  reservedAccountLabelHint: "Grok 是保留的账户标签",
   /** The label under each connector name in the 应用 list — measured as 连接器 under `ahrefs`. */
   connectorLabel: "连接器",
   infoFeatures: "功能",
diff --git a/frontend/src/extensions/marketplace/official-styles.ts b/frontend/src/extensions/marketplace/official-styles.ts
index 1de3726..ce6fc91 100644
--- a/frontend/src/extensions/marketplace/official-styles.ts
+++ b/frontend/src/extensions/marketplace/official-styles.ts
@@ -1131,6 +1131,75 @@ export const DETAIL_ADD_ACCOUNT_FULL_CLASSES = [
   "sand-12oo3zp", "sand-1yc453h", "sand-1ypdohk",
 ];
 
+/* ------------------------------------------------------------------ *
+ * 「添加其他账户」展开后的内联表单（2026-10-05 实机 + 产物双向取证）
+ *
+ * 官方 `ve()` 里这一块与账户编辑表单是**两件事**：
+ *   · 编辑表单在账户行正下方，输入框是 14 类的 `DETAIL_ACCOUNT_FORM_INPUT_CLASSES`；
+ *   · 本表单是账户列表末尾 `添加其他账户` 按钮的同一位置就地替换，输入框是**另一套 17 类**。
+ * 两者外层 div 的类列表恰好**逐字相同**（都读出那 9 个类），容易误当成同一个常量 ——
+ * 之前正是因为把这块当「编辑表单的一部分」，把它的输入框错放进了 `createAccountEditForm`。
+ * 所以下面给独立常量，即使字面量与 `DETAIL_ACCOUNT_FORM_SLOT_CLASSES` 相同。
+ * ------------------------------------------------------------------ */
+
+/** 折叠态的 `添加其他账户` 按钮点开后就地替换成这个 div。实机 614×52。 */
+export const DETAIL_ADD_ACCOUNT_FORM_CLASSES = [
+  "sand-9f619", "sand-78zum5", "sand-6s0dn4", "sand-1qughib", "sand-167g77z",
+  "sand-z9dl7a", "sand-1pic42t", "sand-sag5q8", "sand-1onr9mi",
+];
+
+/** 包住输入框的 span，实机 478×28。官方渲染的标签是 `新账户标签`，placeholder 是
+ *  「为此账户添加标签，例如“工作”或“个人”」。前 5 个类与 `DETAIL_ACCOUNT_NAME_CLASSES` 相同
+ *  —— 官方就是这么写的，所以不合并常量。 */
+export const DETAIL_ADD_ACCOUNT_FIELD_CLASSES = [
+  "sand-9f619", "sand-78zum5", "sand-dt5ytf", "sand-12mrbbr", "sand-euugli",
+  "sand-1iyjqo2", "sand-s83m0k", "sand-dl72j9",
+];
+
+/** `新账户标签` 输入框自身的 17 类。与编辑表单那 14 类**不是**同一套配方，别混用。 */
+export const DETAIL_ADD_ACCOUNT_INPUT_CLASSES = [
+  "sand-9f619", "sand-1iyjqo2", "sand-s83m0k", "sand-dl72j9", "sand-1i9suas", "sand-1fgtraw",
+  "sand-mzvs34", "sand-f159sx", "sand-ur7f20", "sand-mkeg23", "sand-1y0btm7", "sand-qz0629",
+  "sand-18gyud7", "sand-1wd3ewq", "sand-jb2p0i", "sand-1wm8ruf", "sand-1t137rt",
+];
+
+/**
+ * 「输入的标签是保留标签」红色提示的 5 类。官方在 `DETAIL_ADD_ACCOUNT_FIELD_CLASSES`
+ * 那个 span 里，把本节点作为 input 的**兄弟**条件渲染（`S ? <span …> : null`）。
+ *
+ * @evidence live 0.66, Gmail 详情页「添加其他账户」展开态，输入 `Grok` / `grok` 时出现、
+ * 输 `default` / `个人` / `工作` 时不出现 —— 即判定是 `trim(label).toLowerCase() === "grok"`。
+ * 逐字取自 `chunk-plugin-detail-view-tZskkHRA.js` 的 `ve()`：消息 id `wLsCed`，
+ * 中文表（`chunk-core-*.js` 默认表）解出「Grok 是保留的账户标签」。
+ * 5 个类在 0.18 与 0.66 的 CSS 里声明**逐字相同**，无需任何替换：
+ *   `.sand-1jh5svw{color:var(--cursor-text-red-primary)}`、`.sand-1d3mw78{line-height:16px}`、
+ *   `.sand-12oo3zp{letter-spacing:0}` —— 已对 `index-lCyB53CO.css` 与官方
+ *   `index-B9V4agTc.css` 双向 grep 核对。
+ */
+export const DETAIL_ADD_ACCOUNT_HINT_CLASSES = [
+  "sand-9f619", "sand-1wm8ruf", "sand-1d3mw78", "sand-12oo3zp", "sand-1jh5svw",
+];
+
+/**
+ * 「取消」的官方类列表 —— `授权` 去掉默认 variant 专属的 3 个类、再加 4 个 ghost 专属类。
+ *
+ * 依据不是「猜一个 ghost 变体」，而是**在浏览器里对两枚按钮的 class 集合求差**（实机，两个按钮
+ * 各 54 / 55 个类）：交集 51，`授权` 独有 `sand-1kxuqrf sand-uo9n5k sand-1wd3ewq`，
+ * `取消` 独有 `sand-jbqb8w sand-8cg4aw sand-19aaqeu sand-1dsx48b`。7 个差集类在 0.18 侧
+ * 全部存在，无一需要提升。
+ */
+export const CANCEL_BUTTON_OFFICIAL_CLASSES = [
+  ...ACTION_BUTTON_OFFICIAL_CLASSES.slice(0, -3),
+  "sand-jbqb8w", "sand-8cg4aw", "sand-19aaqeu", "sand-1dsx48b",
+];
+
+/** 同上的 0.18 可渲染形：那 7 个逻辑属性类换成物理属性等价类（与 `ACTION_BUTTON_CLASSES` 同一套
+ *  替换，`ACTION_BUTTON_018_SUBSTITUTES` 已逐条 grep 验证存在于 0.18 产物）。 */
+export const CANCEL_BUTTON_CLASSES = [
+  ...ACTION_BUTTON_CLASSES.slice(0, -3),
+  "sand-jbqb8w", "sand-8cg4aw", "sand-19aaqeu", "sand-1dsx48b",
+];
+
 /** The 工具 row itself — a button, `[65,504,734,42]`. */
 export const DETAIL_TOOLS_ROW_CLASSES = [
   "sand-9f619", "sand-78zum5", "sand-6s0dn4", "sand-1qughib", "sand-167g77z", "sand-z9dl7a",
diff --git a/frontend/src/extensions/marketplace/view.ts b/frontend/src/extensions/marketplace/view.ts
index afc4022..7724a16 100644
--- a/frontend/src/extensions/marketplace/view.ts
+++ b/frontend/src/extensions/marketplace/view.ts
@@ -141,6 +141,7 @@ import {
 import {
   createAccountEditForm,
   createAddAccountCta,
+  createAddAccountForm,
   createGlyph,
   createToolsRowCta,
 } from "./detail-cta.js";
@@ -1242,7 +1243,46 @@ function renderDetail(
     // `children.length === 1` — the glyph). Carrying the copy in aria-label only made the button
     // icon-only on screen, 34px tall instead of 43px, with the text existing purely for screen
     // readers. The construction lives in detail-cta.ts so a test can render it and assert that.
-    list.append(createAddAccountCta(document));
+    //
+    // D19：折叠态点它会**就地替换**成新账户表单（实机：文本从「添加其他账户」变成「授权 取消」，
+    // 可见输入框 0→1，表单 614×52）。此前只建按钮、无 handler，点了毫无反应。
+    // 官方那对按钮/表单是同一位置的**互斥兄弟节点**（`ve()` 里同一个三元的两支，中间没有包裹层），
+    // 所以这里也直接挂 `list`，不额外造一个 slot div。
+    const buildForm = (): HTMLElement =>
+      createAddAccountForm(document, {
+        // 官方草稿 hook 在这一块上的 `accountKey` 未在产物里单独暴露；账户列表首项
+        // （Gmail 实机即 `default`）是对每个现实取值都等价的替代。见 detail-cta.ts 的说明。
+        serverId: detail.accounts[0]?.serverId ?? "",
+        sourceAccountKey: detail.accounts[0]?.key ?? "",
+        existingAccountKeys: new Set(detail.accounts.map((a) => a.key.toLowerCase())),
+        handlers: {
+          onAddAccount: (a: { serverId: string; label: string }) => {
+            // 官方 `onAddAccount = $ => de($.serverId, $.label)`，
+            // `onAuthenticate = $ => de($.serverId, $.accountKey)` —— 同一个 `de`，
+            // 第二个实参不同而已：标签就是 accountKey。
+            void window.desktop?.mcp.authenticate(a.serverId, a.label);
+          },
+          onAuthenticate: (a: { serverId: string; accountKey: string }) => {
+            void window.desktop?.mcp.authenticate(a.serverId, a.accountKey);
+          },
+          onClose: () => {
+            addNode.remove();
+            addNode = buildCollapsed();
+            list.append(addNode);
+          },
+        },
+      });
+    const buildCollapsed = (): HTMLButtonElement => {
+      const cta = createAddAccountCta(document);
+      cta.addEventListener("click", () => {
+        addNode.remove();
+        addNode = buildForm();
+        list.append(addNode);
+      });
+      return cta;
+    };
+    let addNode: HTMLElement = buildCollapsed();
+    list.append(addNode);
     block.append(list);
     body.append(block);
   }
diff --git a/scripts/lib/codesign.mjs b/scripts/lib/codesign.mjs
index f220888..1237aaa 100644
--- a/scripts/lib/codesign.mjs
+++ b/scripts/lib/codesign.mjs
@@ -60,10 +60,27 @@ export function adHocCodesignArguments(target) {
  * "nested code is modified or invalid" — which is exactly how the first attempt at this broke
  * packaging.
  *
- * Signing only the top level is sufficient: the bundle and its main executable share
- * `CFBundleIdentifier`, so both end up carrying the stable requirement, and the keychain ACL that
- * matters is the one recorded for the running main executable. Nested code keeps the cdhash-keyed
- * default, which is correct for it — those binaries legitimately have their own identifiers.
+ * ⚠️ 2026-10-05 实测**推翻**了这段推理的前提。
+ * 原文断言「只签顶层就够，要紧的 ACL 是主可执行文件那条，嵌套代码保持 cdhash 默认、那是正确的」。
+ * 当时能拿到的直接证据是：主可执行文件的 DR **确实**已经是稳定的
+ * `identifier "com.anysphere.sand.reconstructed"`（`codesign -d -r-` 实读），而钥匙串弹窗
+ * **照旧每次启动都出现、点「始终允许」也存不下来**。既然主可执行文件这一环已经修好而现象不变，
+ * 「要紧的 ACL 是主可执行文件那条」就不成立。
+ *
+ * 现在已定位到的那条不稳定 requirement 在哪：同一时刻 `Electron Framework.framework` 的 DR 仍是
+ *   `cdhash H"d84843427fa9ef8bf4ceb62748dcbdeff4deabcd"`
+ * 即 **cdhash 型、每次重打包就变**；而 `safeStorage` 的实现就在这个 dylib 里（框架二进制带
+ * 11 处 `safeStorage` / 11 处 `OSCrypt` 字符串，主程序经 `@rpath` 动态链接它）。
+ * 本机读不到钥匙串条目 ACL 记录的 requirement 原文（三条路都试过），所以
+ * 「ACL 里记的就是框架那条 cdhash」**仍是假设、未闭环**；但「主可执行文件那条不是问题所在」
+ * 已由上面的实测排除。
+ *
+ * 因此这里**只**改注释、不改签名方案：给框架签**它自己的** identifier DR
+ * （`com.github.Electron.framework`）在原理上是准确的、且跨重打包稳定，但那是改动构建产物的
+ * 方案，得先闭环假设、并与重新打包的窗口一起安排，不在本次范围内顺手做。
+ * 注意它与上面「`-r` 绝不能带 `--deep`」不矛盾：那次的错是把**顶层 app 的** identifier 贴到
+ * 框架上（指向别的 identifier 的 requirement 根本不描述那段代码，`--verify --deep --strict`
+ * 报 `nested code is modified or invalid`）；框架用自己的 identifier 是另一回事。
  */
 export function adHocRequirementCodesignArguments(target, bundleId) {
   return [
diff --git a/scripts/verify-marketplace-parity.mjs b/scripts/verify-marketplace-parity.mjs
index 135384c..9bd723f 100644
--- a/scripts/verify-marketplace-parity.mjs
+++ b/scripts/verify-marketplace-parity.mjs
@@ -25,6 +25,11 @@ const OFFICIAL_ASAR = "/Applications/Grok Bot.app/Contents/Resources/app.asar";
 const DEPLOYED_ASAR = "/Applications/Grok Node.app/Contents/Resources/app.asar";
 const UPSTREAM_MODEL_CHUNK = "dist/renderer/assets/chunk-marketplace-browse-model-DoOY91TS.js";
 const OFFICIAL_CDP = "9224";
+/** 一次 CDP 读取的上限。超时要抛错、不许静默挂起 —— 见 cdpDump 的说明。
+ *  可用 MARKETPLACE_CDP_TIMEOUT_MS 覆盖，便于用真实端口做快速端到端验证。 */
+const CDP_DUMP_TIMEOUT_MS = Number(process.env.MARKETPLACE_CDP_TIMEOUT_MS ?? 120000) || 120000;
+const withTimeout = (promise, ms, label) =>
+  Promise.race([promise, new Promise((_, reject) => setTimeout(() => reject(new Error(label)), ms))]);
 const DEPLOYED_CDP = "9232";
 const OFFICIAL_URL_HINT = "Grok%20Bot.app";
 const DEPLOYED_URL_HINT = "Grok%20Node.app";
@@ -352,6 +357,15 @@ if (!fs.existsSync(DEPLOYED_ASAR)) {
 /* ---------------------------------------------------------- live checks ---- */
 
 async function cdpDump(port, urlHint, expression) {
+  // ⚠️ 2026-10-05 21:4x 加超时。此前**完全没有**：一个 app 不响应（本次是钥匙串弹窗把主
+  // 进程卡在 SecItemCopyMatching，CDP 端口虽 LISTEN 但不服务）会让 `await` 永远挂着，
+  // 整轮以 Node 的 "unsettled top-level await" 收场 —— **零产出、零结论**。
+  // 检测器挂死比它报红更糟：报红至少是一条可复核的判词，挂死什么也没说。
+  // 超时抛出的错误会被调用方的 try/catch 接住、记成「该端不可用」这一条。
+  return withTimeout(cdpDumpInner(port, urlHint, expression), CDP_DUMP_TIMEOUT_MS, `${port} 上读取超时`);
+}
+
+async function cdpDumpInner(port, urlHint, expression) {
   const targets = await (await fetch(`http://127.0.0.1:${port}/json/list`)).json();
   const page = targets.find((t) => t.type === "page" && t.url.includes(urlHint));
   if (!page) throw new Error(`${port} 上找不到含 "${urlHint}" 的 page target`);
@@ -601,15 +615,42 @@ for (const [label, port, hint] of [["官方", OFFICIAL_CDP, OFFICIAL_URL_HINT],
 }
 
 if (officialSections && deployedSections) {
-  const shared = Object.keys(officialSections).filter((t) => t in deployedSections);
+  const officialTitles = Object.keys(officialSections);
+  const deployedTitles = Object.keys(deployedSections);
+  const shared = officialTitles.filter((t) => t in deployedSections);
   const exact = shared.filter((t) => officialSections[t].names.join("|") === deployedSections[t].names.join("|"));
-  console.log(`\n     共有区块 ${shared.length} 个，逐行完全一致 ${exact.length} 个`);
+  // ⚠️ 2026-10-05 21:2x 修正：这一段原先只报「共有区块 N 个，逐行完全一致 M 个」，
+  // 而 N 取的是**交集**。交集之外的区块 —— 包括 D11 的 `登录与凭据管理` —— 被**整个丢掉**，
+  // 既不出 ⚠️ 也不进汇总。那个读法等于宣称「其余区块都一致」，而实际上其中有整整一个区块
+  // 本地根本没有。要求 1 写的是「逐页复刻…完全一致」，少报一个区块就是少计。
+  // 修法：汇总行**带出分母**，交集之外逐个显式报出 —— 判词是可被证伪的断言，不是调参。
+  const officialOnly = officialTitles.filter((t) => !(t in deployedSections));
+  const deployedOnly = deployedTitles.filter((t) => !(t in officialSections));
+  console.log(`\n     官方 ${officialTitles.length} 个区块 / 本地 ${deployedTitles.length} 个 / 共有 ${shared.length} 个，逐行完全一致 ${exact.length} 个`);
   for (const title of shared) {
     const want = officialSections[title].names;
     const got = deployedSections[title].names;
     if (want.join("|") === got.join("|")) console.log(`       ✅ ${title}`);
     else console.log(`       ⚠️  ${title}\n            官方: ${want.join(" / ") || "—"}\n            本地: ${got.join(" / ") || "—"}`);
   }
+  // **0 行的标题是容器，不是内容区块。** 官方实测：14 个标题里第 1 个是「市场」，
+  // 0 行 —— 它是弹窗自身的标题（对应「官方 13 区块」= 14 个标题减掉这一个容器）。
+  // 若把它当内容，单边判定就会把「本地没渲染这个容器标题」误报成缺一整块内容。
+  // 所以单边报告只针对**至少 1 行**的标题，容器单列一行报出。
+  const isContent = (t, side) => (side[t]?.names?.length ?? 0) > 0;
+  const officialOnlyContent = officialOnly.filter((t) => isContent(t, officialSections));
+  const officialOnlyContainers = officialOnly.filter((t) => !isContent(t, officialSections));
+  const deployedOnlyContent = deployedOnly.filter((t) => isContent(t, deployedSections));
+  const deployedOnlyContainers = deployedOnly.filter((t) => !isContent(t, deployedSections));
+  for (const title of officialOnlyContent) {
+    known(`仅官方有的区块：${title}`, true, `本地缺这一整块内容（官方 ${officialSections[title].names.length} 行）`);
+  }
+  for (const title of deployedOnlyContent) {
+    known(`仅本地有的区块：${title}`, false, "官方没有这一块（可能是本机 catalog 数据更多）");
+  }
+  for (const title of [...officialOnlyContainers, ...deployedOnlyContainers]) {
+    known(`单边出现的容器标题（0 行）：${title}`, false, "容器不是内容区块，不计为缺口");
+  }
   // Icon comparison, keyed on `section|name` rather than row index: the two builds put different
   // numbers of rows in a section, so pairing by index would compare unrelated entries.
   const iconOf = (side, title, name) => (side[title]?.icons ?? []).find((i) => i.name === name);
@@ -652,13 +693,18 @@ if (officialSections && deployedSections) {
   }
 
   const onlyOfficial = Object.keys(officialSections).filter((t) => !(t in deployedSections));
-  for (const title of onlyOfficial) console.log(`       ❌ ${title}（本地无此区块：官方: ${officialSections[title].names.join(" / ")}）`);
+  // 判词与字形必须一致：这里只是**明细**（哪个区块、官方放了什么），不计入 failures ——
+  // 缺口本身已经由上面的 known(..., isGap=true) 报出。用 ❌ 字形会被读成「门禁失败」，
+  // 而它实际不影响退出码；同一个缺口报两遍、其中一遍还撒谎，比不报更糟。
+  for (const title of onlyOfficial) {
+    console.log(`       ·  ${title}（仅官方有，官方: ${officialSections[title].names.join(" / ")} —— 缺口见上方 ⚠️）`);
+  }
   console.log("\n     剩余差异请对照 docs/MARKETPLACE-066-EVIDENCE.md §18–§20 归因：本地 catalog 已补齐为");
   console.log("     与官方同规模（下方「catalog payload 对拍」逐条核对，缺失条目应为「无」）；");
   console.log("     1Password 不在任何一侧 catalog。");
   console.log("     「为你推荐」：代码侧已对齐。已部署产物的 affinity 键是");
   console.log("     `ye(n)=L(n.category).trim()` —— 直接取 category 标签、不经映射表，");
-  console.log("     与官方 `v(e,t)=j(e.category.trim(),t)` 同源，实测 403 条里键为空 0 条。");
+  console.log("     与官方 `v(e,t)=j(e.category.trim(),t)` 同源，键为空 0 条。");
   console.log("     残留差异**只有一层且不可消除**：官方那 4 个赢家的 category 四取四全是 MCP，");
   console.log("     而本地已装的 8 条里没有 MCP 类 → 亲和表只有 {Featured:6, Productivity:2}。");
   console.log("     历史：20:12 之前部署侧走 `as` 映射表（该表缺 MCP/AGENT_ORCHESTRATION/FEATURED，");
@@ -811,13 +857,29 @@ const SECTION_EXPR = `(async () => {
     return null;
   };
   const decorated = seeAlls.map((b) => ({ b, section: labelOf(b) }));
-  const featured = decorated.find((x) => /精选/.test(x.section ?? ""));
-  const bucket = decorated.find((x) => /效率|Productivity/i.test(x.section ?? ""));
-
   const out = { seeAllTotal: seeAlls.length, sections: decorated.map((x) => x.section) };
-  for (const [key, target] of [["featured", featured], ["bucket", bucket]]) {
-    if (!target) { out[key] = null; continue; }
-    target.b.click();
+  // ⚠️ 2026-10-05 21:3x 修正：**每一轮都要重新解析按钮节点，不能复用第一轮的引用。**
+  // 原先 decorated 在任何导航之前算好，随后 featured 那轮点进去、读、再点返回；
+  // 官方是 React，返回后首页重渲染，captured 的节点变成**游离节点** ——
+  // 对游离节点 click() 不会冒泡到活着的 React root，于是第二轮点了个寂寞，
+  // 稳定报「类目页未打开」（官方侧连跑两次同样结果，不是抖动）。
+  // 后果：**L1b 类目页这一层从来没有被真正验过** —— 读数恒为 err，
+  // 而下面那条「精选与类目桶是两个不同页面」在 undefined !== 「精选插件」上**恒真空洞通过**。
+  const pick = (re) => {
+    const hit = decorated.find((x) => re.test(x.section ?? ""));
+    if (!hit) return null;
+    // 节点可能已脱离文档 —— live 判断用 isConnected，不靠引用还在手里就当成有效。
+    if (hit.b.isConnected !== false) return hit.b;
+    const again = visAll("button", d)
+      .filter((b) => (b.textContent || "").trim() === "查看全部")
+      .map((b) => ({ b, section: labelOf(b) }))
+      .find((x) => re.test(x.section ?? ""));
+    return again?.b ?? null;
+  };
+  for (const [key, re] of [["featured", /精选/], ["bucket", /效率|Productivity/i]]) {
+    const b = pick(re);
+    if (!b) { out[key] = null; continue; }
+    b.click();
     const page = await until(() => (visAll('button[aria-label="返回"]', d).length ? d : null), 20000);
     out[key] = page ? shape(page) : { err: "类目页未打开" };
     const back = visAll('button[aria-label="返回"]', d)[0];
@@ -899,8 +961,13 @@ if (secRuns["官方"] && secRuns["部署版"]) {
   // here would be an invented surface.
   ok("类目页 无分页控件", o.bucket?.hasLoadMore === false && d.bucket?.hasLoadMore === false,
     `官方 ${o.bucket?.hasLoadMore} / 本地 ${d.bucket?.hasLoadMore}`);
-  ok("精选与类目桶 是两个不同页面", (d.featured?.headingText ?? "") !== (d.bucket?.headingText ?? ""),
-    `精选「${d.featured?.headingText}」/ 桶「${d.bucket?.headingText}」`);
+  // ⚠️ 这条原先在 bucket 读不出来时**恒真空洞通过**：`"" !== "精选插件"` 恒为真。
+  // 判词是「两者是不同页面」，前提是**两边都读到了页面**。前提不满足时必须失败，
+  // 否则「什么都没验到」会被记成「验过了且一致」。
+  const twoDistinct = (x) => (x?.headingText ?? "") !== (d.bucket?.headingText ?? "")
+    && x?.headingText != null && d.bucket?.headingText != null;
+  ok("精选与类目桶 是两个不同页面（两侧都须读到页面）", twoDistinct(o.featured) && twoDistinct(d.featured),
+    `官方精选「${o.featured?.headingText}」/ 官方桶「${o.bucket?.headingText}」/ 本地精选「${d.featured?.headingText}」/ 本地桶「${d.bucket?.headingText}」`);
 
   // The manage page lists what THIS machine has installed, so its row count and first row are
   // expected to differ between the two apps (official has 16 installed, local 8) — comparing them
diff --git a/tests/activity-label-visibility-renderer-patch.test.mjs b/tests/activity-label-visibility-renderer-patch.test.mjs
index b3307ff..eb7105c 100644
--- a/tests/activity-label-visibility-renderer-patch.test.mjs
+++ b/tests/activity-label-visibility-renderer-patch.test.mjs
@@ -26,6 +26,14 @@ const PINNED_CHUNK = path.join(REPO_ROOT, "src/app/dist/renderer/assets/index-Ub
 const PINNED_CSS = path.join(REPO_ROOT, "src/app/dist/renderer/assets/index-lCyB53CO.css");
 
 const readPinnedChunk = () => readFile(PINNED_CHUNK, "utf8");
+
+// src/app/dist is gitignored and only exists after npm run bootstrap; bundle assertions skipped.
+// 2026-10-05 补：本文件此前硬读该产物，而 CI 从不执行 `npm run bootstrap`（bootstrap 用的是
+// macOS 专有的 hdiutil），于是 13 个依赖产物的文件里有 7 个在 CI 上 ENOENT —— main 的 CI
+// 已因此连续红 10 次。写法照抄仓库另外 6 个已守卫的文件，不新造模式。守卫对象取「声明的用例名
+// ∩ 实测失败名」，不是靠猜哪个用例读了产物。
+const pinnedChunk = await readPinnedChunk().catch(() => null);
+const pinnedSkip = pinnedChunk == null ? "src/app/dist is gitignored and only exists after npm run bootstrap; bundle assertions skipped." : false;
 const readPinnedCss = () => readFile(PINNED_CSS, "utf8");
 
 const HOVER_GATED_INDEX = '[!!(ce&&H!=="idle")<<0]';
@@ -61,7 +69,7 @@ function resolveLabelClasses(source) {
   return (hovered, state) => select(hovered, state);
 }
 
-test("the pinned stylesheet keeps the label transparent at rest and opaque when revealed", async () => {
+test("the pinned stylesheet keeps the label transparent at rest and opaque when revealed", { skip: pinnedSkip }, async () => {
   const css = await readPinnedCss();
   const declarations = className => {
     const escaped = className.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -83,7 +91,7 @@ test("the pinned stylesheet keeps the label transparent at rest and opaque when
   }
 });
 
-test("0.18 gates the label on pointer hover — the reported defect", async () => {
+test("0.18 gates the label on pointer hover — the reported defect", { skip: pinnedSkip }, async () => {
   const resolve = resolveLabelClasses(await readPinnedChunk());
   // The bug, stated as a fact about the artefact: working agent, pointer elsewhere ->
   // transparent. The label only exists on screen while the mouse is over the row.
@@ -96,7 +104,7 @@ test("0.18 gates the label on pointer hover — the reported defect", async () =
   assert.ok(resolve(true, "idle").includes(LABEL_HIDDEN_CLASS));
 });
 
-test("the patch makes the label follow the agent state instead of the pointer", async () => {
+test("the patch makes the label follow the agent state instead of the pointer", { skip: pinnedSkip }, async () => {
   const resolve = resolveLabelClasses(patchOriginalActivityLabelVisibility(await readPinnedChunk()));
 
   // The reported case: agent working, pointer anywhere -> opaque.
@@ -115,7 +123,7 @@ test("the patch makes the label follow the agent state instead of the pointer",
   assert.equal(strip(resolve(true, "idle")), strip(resolve(false, "working")));
 });
 
-test("the rewrite is exactly the removal of the hover term", async () => {
+test("the rewrite is exactly the removal of the hover term", { skip: pinnedSkip }, async () => {
   const component = extractActivityMark(patchOriginalActivityLabelVisibility(await readPinnedChunk()));
   assert.ok(component.includes(STATE_ONLY_INDEX), "patched index is not the state-only form");
   assert.ok(!component.includes(HOVER_GATED_INDEX), "the hover gate survived the patch");
@@ -125,7 +133,7 @@ test("the rewrite is exactly the removal of the hover term", async () => {
   assert.ok(component.includes("onPointerLeave:()=>{xe(!1),se(!1)}"), "pointer leave handler was removed");
 });
 
-test("a drifted or duplicated anchor fails closed instead of patching the wrong row", async () => {
+test("a drifted or duplicated anchor fails closed instead of patching the wrong row", { skip: pinnedSkip }, async () => {
   const chunk = await readPinnedChunk();
   assert.throws(
     () => patchOriginalActivityLabelVisibility(chunk.replace(HOVER_GATED_INDEX, '[!!(H!=="idle")<<0]')),
@@ -147,12 +155,12 @@ test("a drifted or duplicated anchor fails closed instead of patching the wrong
   );
 });
 
-test("re-applying the patch fails closed instead of stacking", async () => {
+test("re-applying the patch fails closed instead of stacking", { skip: pinnedSkip }, async () => {
   const patched = patchOriginalActivityLabelVisibility(await readPinnedChunk());
   assert.throws(() => patchOriginalActivityLabelVisibility(patched), /anchor is missing or ambiguous/);
 });
 
-test("the stylesheet gate refuses a row whose visibility classes stopped meaning opacity", async () => {
+test("the stylesheet gate refuses a row whose visibility classes stopped meaning opacity", { skip: pinnedSkip }, async () => {
   const css = await readPinnedCss();
   assert.doesNotThrow(() => assertActivityLabelStylesResolve(css));
   assert.throws(
@@ -177,7 +185,7 @@ test("the stylesheet gate refuses a row whose visibility classes stopped meaning
   );
 });
 
-test("the patched chunk is still parseable JavaScript", async () => {
+test("the patched chunk is still parseable JavaScript", { skip: pinnedSkip }, async () => {
   const { writeFile, rm } = await import("node:fs/promises");
   const { execFile } = await import("node:child_process");
   const { promisify } = await import("node:util");
@@ -191,7 +199,7 @@ test("the patched chunk is still parseable JavaScript", async () => {
   }
 });
 
-test("the staged renderer gets exactly one patched chunk plus provenance", async (t) => {
+test("the staged renderer gets exactly one patched chunk plus provenance", { skip: pinnedSkip }, async (t) => {
   const { mkdtemp, readFile: rf, cp, mkdir, rm } = await import("node:fs/promises");
   const { tmpdir } = await import("node:os");
   const stageRoot = await mkdtemp(path.join(tmpdir(), "grok-node-activity-label-"));
diff --git a/tests/chat-header-identity-renderer-patch.test.mjs b/tests/chat-header-identity-renderer-patch.test.mjs
index d6af053..a4ebe89 100644
--- a/tests/chat-header-identity-renderer-patch.test.mjs
+++ b/tests/chat-header-identity-renderer-patch.test.mjs
@@ -30,6 +30,14 @@ const PINNED_CSS = path.join(
 );
 
 const readPinnedChunk = () => readFile(PINNED_CHUNK, "utf8");
+
+// src/app/dist is gitignored and only exists after npm run bootstrap; bundle assertions skipped.
+// 2026-10-05 补：本文件此前硬读该产物，而 CI 从不执行 `npm run bootstrap`（bootstrap 用的是
+// macOS 专有的 hdiutil），于是 13 个依赖产物的文件里有 7 个在 CI 上 ENOENT —— main 的 CI
+// 已因此连续红 10 次。写法照抄仓库另外 6 个已守卫的文件，不新造模式。守卫对象取「声明的用例名
+// ∩ 实测失败名」，不是靠猜哪个用例读了产物。
+const pinnedChunk = await readPinnedChunk().catch(() => null);
+const pinnedSkip = pinnedChunk == null ? "src/app/dist is gitignored and only exists after npm run bootstrap; bundle assertions skipped." : false;
 const readPinnedCss = () => readFile(PINNED_CSS, "utf8");
 
 const ROOT_GRID = 'q={className:"sand-78zum5 sand-6s0dn4 sand-1qughib sand-167g77z sand-1iyjqo2 sand-s83m0k sand-dl72j9 sand-euugli sand-rvj5dj",style:RChHeaderGrid};';
@@ -68,7 +76,7 @@ function extractChatHeaderComponent(patched) {
   return patched.slice(start, next < 0 ? undefined : next);
 }
 
-test("every anchor still resolves exactly once in the pinned 0.18 chunk", async () => {
+test("every anchor still resolves exactly once in the pinned 0.18 chunk", { skip: pinnedSkip }, async () => {
   const source = await readPinnedChunk();
   for (const label of ["function aSn(n){const e=he.c(109),", ROOT_GRID.slice(0, 60)]) {
     assert.ok(source.includes(label), `anchor drifted: ${label}`);
@@ -83,7 +91,7 @@ test("every anchor still resolves exactly once in the pinned 0.18 chunk", async
   }
 });
 
-test("the header root becomes a three-column grid and the identity sits in the middle cell", async () => {
+test("the header root becomes a three-column grid and the identity sits in the middle cell", { skip: pinnedSkip }, async () => {
   const patched = patchOriginalChatHeaderIdentity(await readPinnedChunk());
   assert.ok(patched.includes(ROOT_GRID), "root class/style replacement did not apply");
   assert.ok(patched.includes(THREE_COLUMN_GRID), "three-column grid template missing");
@@ -112,7 +120,7 @@ test("the header root becomes a three-column grid and the identity sits in the m
   assert.ok(patched.includes("sand-1qughib"), "justify-content:space-between was removed");
 });
 
-test("the identity control opens the details pane and carries 0.61.0's label", async () => {
+test("the identity control opens the details pane and carries 0.61.0's label", { skip: pinnedSkip }, async () => {
   const patched = patchOriginalChatHeaderIdentity(await readPinnedChunk());
   assert.ok(patched.includes(IDENTITY_OPEN_DETAILS), "identity control replacement did not apply");
   assert.ok(
@@ -131,7 +139,7 @@ test("the identity control opens the details pane and carries 0.61.0's label", a
   );
 });
 
-test("opening from the header always lands on the overview section", async () => {
+test("opening from the header always lands on the overview section", { skip: pinnedSkip }, async () => {
   const patched = patchOriginalChatHeaderIdentity(await readPinnedChunk());
   // The landing is a three-hop wire; a dropped hop still builds and still looks right.
   for (const [needle, what] of [
@@ -174,7 +182,7 @@ test("opening from the header always lands on the overview section", async () =>
   );
 });
 
-test("the injected handler toggles, and only asks for overview when it opened", async () => {
+test("the injected handler toggles, and only asks for overview when it opened", { skip: pinnedSkip }, async () => {
   const patched = patchOriginalChatHeaderIdentity(await readPinnedChunk());
   const openInfo = extractOpenInfoHandler(patched);
 
@@ -207,7 +215,7 @@ test("the injected handler toggles, and only asks for overview when it opened",
   assert.doesNotThrow(() => openInfo(undefined, false, () => {}));
 });
 
-test("the pill surface copies 0.61.0's box-shadow verbatim", async () => {
+test("the pill surface copies 0.61.0's box-shadow verbatim", { skip: pinnedSkip }, async () => {
   const patched = patchOriginalChatHeaderIdentity(await readPinnedChunk());
   assert.ok(
     patched.includes(
@@ -220,14 +228,14 @@ test("the pill surface copies 0.61.0's box-shadow verbatim", async () => {
   }
 });
 
-test("every borrowed class and custom property resolves in the pinned stylesheet", async () => {
+test("every borrowed class and custom property resolves in the pinned stylesheet", { skip: pinnedSkip }, async () => {
   const css = await readPinnedCss();
   const result = assertChatHeaderIdentityStylesResolve(css);
   assert.equal(result.classes, HEADER_CLASS_NAMES.length);
   assert.equal(result.customProperties, HEADER_CUSTOM_PROPERTIES.length);
 });
 
-test("the style gate fails closed when a class or custom property disappears", async () => {
+test("the style gate fails closed when a class or custom property disappears", { skip: pinnedSkip }, async () => {
   const css = await readPinnedCss();
   assert.throws(
     () => assertChatHeaderIdentityStylesResolve(css, { classNames: ["sand-does-not-exist"] }),
@@ -248,7 +256,7 @@ test("the style gate fails closed when a class or custom property disappears", a
   );
 });
 
-test("re-applying the patch fails closed instead of stacking", async () => {
+test("re-applying the patch fails closed instead of stacking", { skip: pinnedSkip }, async () => {
   const patched = patchOriginalChatHeaderIdentity(await readPinnedChunk());
   assert.throws(
     () => patchOriginalChatHeaderIdentity(patched),
@@ -256,7 +264,7 @@ test("re-applying the patch fails closed instead of stacking", async () => {
   );
 });
 
-test("the patched chunk is still parseable JavaScript", async () => {
+test("the patched chunk is still parseable JavaScript", { skip: pinnedSkip }, async () => {
   const patched = patchOriginalChatHeaderIdentity(await readPinnedChunk());
   // A regex-only smoke test is not enough: the injected component is real JSX-free
   // code inside a function body, so hand it to the real parser.
@@ -273,7 +281,7 @@ test("the patched chunk is still parseable JavaScript", async () => {
   }
 });
 
-test("the staged renderer gets exactly one patched chunk plus provenance", async (t) => {
+test("the staged renderer gets exactly one patched chunk plus provenance", { skip: pinnedSkip }, async (t) => {
   const { mkdtemp, readFile: rf, cp, mkdir, rm } = await import("node:fs/promises");
   const { tmpdir } = await import("node:os");
   const stageRoot = await mkdtemp(path.join(tmpdir(), "grok-node-chat-header-"));
@@ -322,7 +330,7 @@ test("clean-build runs the chat-header patch between the renderer extensions and
   );
 });
 
-test("no native style prop receives an array (the class of bug that broke the chat view)", async () => {
+test("no native style prop receives an array (the class of bug that broke the chat view)", { skip: pinnedSkip }, async () => {
   // React walks a `style` array with for..in and throws "Failed to set an indexed property
   // [0] on 'CSSStyleDeclaration'", which the view error boundary reports as "This view
   // failed to load." It compiles, passes `node --check`, and only shows up at render time.
@@ -347,7 +355,7 @@ test("no native style prop receives an array (the class of bug that broke the ch
   assert.ok(!patched.includes("style:[X,"), "the undefined X slot is still being spread in");
 });
 
-test("the chat toolbar no longer paints an opaque band over the transcript", async () => {
+test("the chat toolbar no longer paints an opaque band over the transcript", { skip: pinnedSkip }, async () => {
   // 0.18's sand-toolbar carries sand-1ua6jya -> background-color:var(--cursor-bg-editor),
   // an opaque fill that hides transcript text passing under the header. 0.61.0's
   // sand-toolbar has no background declaration at all; that transparency is what makes the
@@ -382,7 +390,7 @@ test("the chat toolbar no longer paints an opaque band over the transcript", asy
   }
 });
 
-test("the chat header renders no computer control", async () => {
+test("the chat header renders no computer control", { skip: pinnedSkip }, async () => {
   // 0.61.0 keeps the class name only as a container-name and as a focus fallback; it never
   // renders the button. 0.18 renders it whenever the details pane is closed, which is the
   // stray icon reported against this build.
@@ -409,7 +417,7 @@ test("the chat header renders no computer control", async () => {
   );
 });
 
-test("the chat header renders no toolbar hairline", async () => {
+test("the chat header renders no toolbar hairline", { skip: pinnedSkip }, async () => {
   // 0.18 renders sand-toolbar-divider, whose opacity is driven by a scroll-timeline
   // animation, so it keeps painting after the bar behind it is made transparent. 0.61.0
   // has no such element. Measured on the live build: y=44..45, rgba(252,252,252,0.1).
@@ -430,7 +438,7 @@ test("the chat header renders no toolbar hairline", async () => {
   assert.match(hairline[1], /background-color/, "sand-qjr0ry is not the hairline fill we expected");
 });
 
-test("the suppressed branches really evaluate to null, not to the element", async () => {
+test("the suppressed branches really evaluate to null, not to the element", { skip: pinnedSkip }, async () => {
   // String matching alone missed this: `!1?null:X` contains the substring "null", passes any
   // `includes("…?null:…")` assertion, and still evaluates to `X` — so the hairline kept
   // rendering after a green build and a green test run. Evaluate the actual ternaries.
@@ -467,7 +475,7 @@ test("the suppressed branches really evaluate to null, not to the element", asyn
   assert.ok(!patched.includes("!0?p.jsx(yo,{content:iSn"), "computer control would render unconditionally");
 });
 
-test("the identity avatar is sized like 0.61.0's (24px fill, sm)", async () => {
+test("the identity avatar is sized like 0.61.0's (24px fill, sm)", { skip: pinnedSkip }, async () => {
   // 0.61.0: Sa({agent, fillPx:t2, size:"sm"}) with t2=24. 0.18: ml({…, fillPx:Tve, size:"xs"})
   // with Tve=20 — the whole 20-vs-24 difference the pill inherits.
   const original = await readPinnedChunk();
diff --git a/tests/fixtures/official-home-sections.json b/tests/fixtures/official-home-sections.json
new file mode 100644
index 0000000..8a7f3be
--- /dev/null
+++ b/tests/fixtures/official-home-sections.json
@@ -0,0 +1,128 @@
+{
+  "_note": "官方 0.66.0 首页区块基线。2026-10-05 用 scripts/verify-marketplace-parity.mjs 里的 SECTIONS_EXPR 原样跑的（从源文件切出，不手抄），CDP 9224。「市场」是弹窗容器标题 0 行 —— 官方 13 区块 = 14 个标题减掉它。",
+  "capturedAt": "2026-10-05T21:2x+08:00",
+  "app": "/Applications/Grok Bot.app",
+  "version": "0.66.0",
+  "totalHeadings": 14,
+  "totalRows": 45,
+  "sections": [
+    {
+      "title": "市场",
+      "rows": 0,
+      "first3": []
+    },
+    {
+      "title": "为你推荐",
+      "rows": 4,
+      "first3": [
+        "Aleph",
+        "Algolia Productivity",
+        "Allo"
+      ]
+    },
+    {
+      "title": "精选插件",
+      "rows": 4,
+      "first3": [
+        "Gmail",
+        "Google Calendar",
+        "Google Drive"
+      ]
+    },
+    {
+      "title": "团队插件",
+      "rows": 1,
+      "first3": [
+        "oh-my-claudecode"
+      ]
+    },
+    {
+      "title": "登录与凭据管理",
+      "rows": 1,
+      "first3": [
+        "1Password"
+      ]
+    },
+    {
+      "title": "效率",
+      "rows": 4,
+      "first3": [
+        "Adobe Developer App Builder",
+        "Airtable",
+        "Asana"
+      ]
+    },
+    {
+      "title": "通信",
+      "rows": 4,
+      "first3": [
+        "ActiveCampaign",
+        "AgentMail",
+        "Ando"
+      ]
+    },
+    {
+      "title": "设计",
+      "rows": 4,
+      "first3": [
+        "Canva",
+        "Docs Canvas",
+        "Figma"
+      ]
+    },
+    {
+      "title": "代码",
+      "rows": 4,
+      "first3": [
+        "Amazon Location Service",
+        "Appwrite",
+        "AWS Amplify"
+      ]
+    },
+    {
+      "title": "数据",
+      "rows": 4,
+      "first3": [
+        "Amplitude",
+        "Antimetal",
+        "Apify"
+      ]
+    },
+    {
+      "title": "销售",
+      "rows": 4,
+      "first3": [
+        "Adspirer",
+        "Amplemarket",
+        "Apollo.io"
+      ]
+    },
+    {
+      "title": "财务",
+      "rows": 4,
+      "first3": [
+        "1inch",
+        "Aave",
+        "Airwallex AgentOS"
+      ]
+    },
+    {
+      "title": "研究",
+      "rows": 4,
+      "first3": [
+        "Ahrefs",
+        "Context.dev",
+        "Context7"
+      ]
+    },
+    {
+      "title": "支持",
+      "rows": 3,
+      "first3": [
+        "Intercom",
+        "MailerLite",
+        "Plain"
+      ]
+    }
+  ]
+}
diff --git a/tests/fixtures/official-page-baselines.json b/tests/fixtures/official-page-baselines.json
new file mode 100644
index 0000000..911f8d0
--- /dev/null
+++ b/tests/fixtures/official-page-baselines.json
@@ -0,0 +1,227 @@
+{
+  "_note": "官方 0.66.0 各层页面基线。2026-10-05 用 scripts/verify-marketplace-parity.mjs 里各自的 _EXPR 原样跑的（从源文件按标记切出，不手抄），CDP 9224。",
+  "capturedAt": "2026-10-05T21:3x+08:00",
+  "app": "/Applications/Grok Bot.app",
+  "version": "0.66.0",
+  "homepage": {
+    "_note": "官方 0.66.0 首页区块基线。2026-10-05 用 scripts/verify-marketplace-parity.mjs 里的 SECTIONS_EXPR 原样跑的（从源文件切出，不手抄），CDP 9224。「市场」是弹窗容器标题 0 行 —— 官方 13 区块 = 14 个标题减掉它。",
+    "capturedAt": "2026-10-05T21:2x+08:00",
+    "app": "/Applications/Grok Bot.app",
+    "version": "0.66.0",
+    "totalHeadings": 14,
+    "totalRows": 45,
+    "sections": [
+      {
+        "title": "市场",
+        "rows": 0,
+        "first3": []
+      },
+      {
+        "title": "为你推荐",
+        "rows": 4,
+        "first3": [
+          "Aleph",
+          "Algolia Productivity",
+          "Allo"
+        ]
+      },
+      {
+        "title": "精选插件",
+        "rows": 4,
+        "first3": [
+          "Gmail",
+          "Google Calendar",
+          "Google Drive"
+        ]
+      },
+      {
+        "title": "团队插件",
+        "rows": 1,
+        "first3": [
+          "oh-my-claudecode"
+        ]
+      },
+      {
+        "title": "登录与凭据管理",
+        "rows": 1,
+        "first3": [
+          "1Password"
+        ]
+      },
+      {
+        "title": "效率",
+        "rows": 4,
+        "first3": [
+          "Adobe Developer App Builder",
+          "Airtable",
+          "Asana"
+        ]
+      },
+      {
+        "title": "通信",
+        "rows": 4,
+        "first3": [
+          "ActiveCampaign",
+          "AgentMail",
+          "Ando"
+        ]
+      },
+      {
+        "title": "设计",
+        "rows": 4,
+        "first3": [
+          "Canva",
+          "Docs Canvas",
+          "Figma"
+        ]
+      },
+      {
+        "title": "代码",
+        "rows": 4,
+        "first3": [
+          "Amazon Location Service",
+          "Appwrite",
+          "AWS Amplify"
+        ]
+      },
+      {
+        "title": "数据",
+        "rows": 4,
+        "first3": [
+          "Amplitude",
+          "Antimetal",
+          "Apify"
+        ]
+      },
+      {
+        "title": "销售",
+        "rows": 4,
+        "first3": [
+          "Adspirer",
+          "Amplemarket",
+          "Apollo.io"
+        ]
+      },
+      {
+        "title": "财务",
+        "rows": 4,
+        "first3": [
+          "1inch",
+          "Aave",
+          "Airwallex AgentOS"
+        ]
+      },
+      {
+        "title": "研究",
+        "rows": 4,
+        "first3": [
+          "Ahrefs",
+          "Context.dev",
+          "Context7"
+        ]
+      },
+      {
+        "title": "支持",
+        "rows": 3,
+        "first3": [
+          "Intercom",
+          "MailerLite",
+          "Plain"
+        ]
+      }
+    ]
+  },
+  "detailCta": {
+    "rowCount": 45,
+    "rowTrailing": {
+      "text": "添加",
+      "size": "46x26",
+      "padding": "0px 10px",
+      "borderRadius": "13px",
+      "fontWeight": "420",
+      "whiteSpace": "nowrap",
+      "background": "color(srgb 0.220753 0.220753 0.220753 / 0.32149)"
+    },
+    "detailBack": {
+      "size": "28x28",
+      "borderRadius": "9999px"
+    },
+    "viewSource": {
+      "size": "69x18",
+      "childKinds": [
+        "text:查看源码",
+        "I.ui-icon"
+      ],
+      "iconSize": "13x13"
+    },
+    "share": {
+      "size": "82x36",
+      "childKinds": [
+        "SPAN.sand-kit-icon",
+        "SPAN.sand-euugli"
+      ],
+      "iconSize": "18x18",
+      "labelSize": "28x20"
+    },
+    "backStackWorks": true
+  },
+  "catalog": {
+    "total": 405,
+    "withCategoryKeys": 252,
+    "isUserOwnedTrue": 93,
+    "distinctCategoryKeys": [
+      "AGENT_ORCHESTRATION",
+      "CANVAS",
+      "CUSTOMER_SUPPORT",
+      "DATA_ANALYTICS",
+      "DESIGN",
+      "DOCUMENTS_AND_FILES",
+      "FEATURED",
+      "FINANCE_AND_LEGAL",
+      "INBOX_AND_COLLABORATION",
+      "INFRASTRUCTURE",
+      "PAYMENTS",
+      "PRODUCTIVITY",
+      "RESEARCH",
+      "SALES",
+      "SCHEDULING"
+    ]
+  },
+  "sectionPages": {
+    "seeAllTotal": 9,
+    "sections": [
+      "精选插件",
+      "效率",
+      "通信",
+      "设计",
+      "代码",
+      "数据",
+      "销售",
+      "财务",
+      "研究"
+    ],
+    "featured": {
+      "rowCount": 51,
+      "hasBack": true,
+      "headingTag": "H3",
+      "headingText": "精选插件",
+      "hasLoadMore": false
+    },
+    "bucket": {
+      "rowCount": 62,
+      "hasBack": true,
+      "headingTag": "H3",
+      "headingText": "效率",
+      "hasLoadMore": false
+    },
+    "manage": {
+      "hasEntry": true,
+      "rowCount": 75,
+      "headingBefore": "管理",
+      "firstRow": "打开 Aleph",
+      "reachedDetail": true,
+      "rowCountAfterBack": 30,
+      "headingAfterBack": "管理"
+    }
+  }
+}
diff --git a/tests/info-pane-split-renderer-patch.test.mjs b/tests/info-pane-split-renderer-patch.test.mjs
index f1bd2b2..cde4343 100644
--- a/tests/info-pane-split-renderer-patch.test.mjs
+++ b/tests/info-pane-split-renderer-patch.test.mjs
@@ -35,6 +35,14 @@ const PINNED_CHUNK = path.join(REPO_ROOT, "src/app/dist/renderer/assets/index-Ub
 
 const readPinnedChunk = () => readFile(PINNED_CHUNK, "utf8");
 
+// src/app/dist is gitignored and only exists after npm run bootstrap; bundle assertions skipped.
+// 2026-10-05 补：本文件此前硬读该产物，而 CI 从不执行 `npm run bootstrap`（bootstrap 用的是
+// macOS 专有的 hdiutil），于是 13 个依赖产物的文件里有 7 个在 CI 上 ENOENT —— main 的 CI
+// 已因此连续红 10 次。写法照抄仓库另外 6 个已守卫的文件，不新造模式。守卫对象取「声明的用例名
+// ∩ 实测失败名」，不是靠猜哪个用例读了产物。
+const pinnedChunk = await readPinnedChunk().catch(() => null);
+const pinnedSkip = pinnedChunk == null ? "src/app/dist is gitignored and only exists after npm run bootstrap; bundle assertions skipped." : false;
+
 // 0.18's layout constants, spelled out here rather than read back out of the patch, so the
 // tests assert against the audited values and not against whatever the patch happens to emit.
 const INFO_PANE_MIN = 280;
@@ -89,7 +97,7 @@ function persistedWidth(source, stored) {
   return RQ(bge(stored, K4e), DQ, upper);
 }
 
-test("the pinned chunk still carries every anchor this patch depends on", async () => {
+test("the pinned chunk still carries every anchor this patch depends on", { skip: pinnedSkip }, async () => {
   const source = await readPinnedChunk();
   assert.ok(source.includes(LAYOUT_CONSTANTS_BEFORE), "layout constant block anchor drifted");
   assert.ok(source.includes(LAYOUT_018_DRAG_HELPER), "drag helper anchor drifted");
@@ -143,7 +151,7 @@ const evalPredicates = (source) => {
   return fn(SIDEBAR_COLLAPSED, INFO_PANE_MIN, MIN_CHAT_COLUMN);
 };
 
-test("the open path consults the minimum pane width, never the persisted one", async () => {
+test("the open path consults the minimum pane width, never the persisted one", { skip: pinnedSkip }, async () => {
   const source = await readPinnedChunk();
   const patched = patchOriginalInfoPaneSplit(source);
 
@@ -168,7 +176,7 @@ test("the open path consults the minimum pane width, never the persisted one", a
   assert.equal(predicates.growByAt(280), 400 + 424 + 280 - 1000);
 });
 
-test("reverting either open-fit site reintroduces the wedge the patch exists to remove", async () => {
+test("reverting either open-fit site reintroduces the wedge the patch exists to remove", { skip: pinnedSkip }, async () => {
   const patched = patchOriginalInfoPaneSplit(await readPinnedChunk());
   // Mutant 1: the subscribe site back on the persisted width — the exact 0.18 behaviour.
   const subscribeReverted = patched.replace(OPEN_FIT_SITES[0].after, OPEN_FIT_SITES[0].before);
@@ -180,7 +188,7 @@ test("reverting either open-fit site reintroduces the wedge the patch exists to
   assert.equal(paneWidthTheOpenPathPasses(growReverted).grow, "u");
 });
 
-test("the render-time clamp the open-fit port leans on is present in chunk and CSS", async () => {
+test("the render-time clamp the open-fit port leans on is present in chunk and CSS", { skip: pinnedSkip }, async () => {
   const patched = patchOriginalInfoPaneSplit(await readPinnedChunk());
   // The open pane's class pair carries the max-width clamp; without it an oversized stored
   // width would squeeze the chat column below its 424px minimum.
@@ -220,7 +228,7 @@ test("the patch is byte-exact against 0.62.0: the drag helper differs only by th
   );
 });
 
-test("a wide window is no longer capped at 480px", async () => {
+test("a wide window is no longer capped at 480px", { skip: pinnedSkip }, async () => {
   const source = await readPinnedChunk();
   const patched = patchOriginalInfoPaneSplit(source);
 
@@ -232,7 +240,7 @@ test("a wide window is no longer capped at 480px", async () => {
   assert.ok(dragPaneWidth(patched, at3456).width > REMOVED_INFO_PANE_MAX);
 });
 
-test("the pane grows with the window instead of pinning at one width", async () => {
+test("the pane grows with the window instead of pinning at one width", { skip: pinnedSkip }, async () => {
   const source = await readPinnedChunk();
   const patched = patchOriginalInfoPaneSplit(source);
   const previous = { width: -1 };
@@ -250,7 +258,7 @@ test("the pane grows with the window instead of pinning at one width", async ()
   }
 });
 
-test("the pane is still bounded by the window, the min chat column and the sidebar", async () => {
+test("the pane is still bounded by the window, the min chat column and the sidebar", { skip: pinnedSkip }, async () => {
   const patched = patchOriginalInfoPaneSplit(await readPinnedChunk());
   for (const windowWidth of [1000, 1280, 1920, 2560, 3456]) {
     for (const sidebarWidth of [SIDEBAR_COLLAPSED, SIDEBAR_EXPANDED]) {
@@ -265,7 +273,7 @@ test("the pane is still bounded by the window, the min chat column and the sideb
   }
 });
 
-test("the minimum width and the collapse threshold are unchanged", async () => {
+test("the minimum width and the collapse threshold are unchanged", { skip: pinnedSkip }, async () => {
   const patched = patchOriginalInfoPaneSplit(await readPinnedChunk());
   // Below 244px the pane collapses, exactly as in 0.18 and in 0.62.0.
   const collapsed = dragPaneWidth(patched, {
@@ -279,7 +287,7 @@ test("the minimum width and the collapse threshold are unchanged", async () => {
   assert.equal(narrow.width, INFO_PANE_MIN);
 });
 
-test("the drag helper is rewritten, not merely the persisted value", async () => {
+test("the drag helper is rewritten, not merely the persisted value", { skip: pinnedSkip }, async () => {
   const source = await readPinnedChunk();
   const patched = patchOriginalInfoPaneSplit(source);
   // Both layers mattered: had only the persistence clamps been relaxed, the first drag would
@@ -290,7 +298,7 @@ test("the drag helper is rewritten, not merely the persisted value", async () =>
   assert.equal(persistedWidth(patched, 100), INFO_PANE_MIN, "the 280px floor still holds");
 });
 
-test("the patch leaves no reference to the deleted ceiling", async () => {
+test("the patch leaves no reference to the deleted ceiling", { skip: pinnedSkip }, async () => {
   const patched = patchOriginalInfoPaneSplit(await readPinnedChunk());
   assert.ok(!patched.includes("ume=480"), "the constant is still declared");
   assert.ok(!/\bume\b/.test(patched), "ume is still referenced somewhere in the chunk");
@@ -301,7 +309,7 @@ test("the patch leaves no reference to the deleted ceiling", async () => {
   }
 });
 
-test("the resize handle, the CSS variable and the window-derived maximum are untouched", async () => {
+test("the resize handle, the CSS variable and the window-derived maximum are untouched", { skip: pinnedSkip }, async () => {
   const patched = patchOriginalInfoPaneSplit(await readPinnedChunk());
   for (const needle of [
     "function han(n){return n.windowWidth-dme-jlt(n.sidebar)}",
@@ -344,7 +352,7 @@ test("the shape assertion fails closed on a chunk that lost an anchor", () => {
   );
 });
 
-test("a drifted anchor fails the patch instead of silently skipping a site", async () => {
+test("a drifted anchor fails the patch instead of silently skipping a site", { skip: pinnedSkip }, async () => {
   const source = await readPinnedChunk();
   // Re-introduce the deleted ceiling at one clamp site only: the other four anchors still
   // match, so a patch that ignored the miss would still "succeed".
@@ -365,7 +373,7 @@ test("a chunk carrying two copies of the target is rejected as ambiguous", () =>
   );
 });
 
-test("apply fails closed when no stylesheet is staged to validate the open-pane clamp", async (t) => {
+test("apply fails closed when no stylesheet is staged to validate the open-pane clamp", { skip: pinnedSkip }, async (t) => {
   const stageRoot = path.join(REPO_ROOT, ".test-tmp-info-pane-split-nocss");
   const assetsRoot = path.join(stageRoot, "dist", "renderer", "assets");
   const { mkdir, rm, writeFile: writeFileStage } = await import("node:fs/promises");
@@ -381,7 +389,7 @@ test("apply fails closed when no stylesheet is staged to validate the open-pane
   );
 });
 
-test("applyOriginalRendererInfoPaneSplit rewrites the staged chunk and records provenance", async (t) => {
+test("applyOriginalRendererInfoPaneSplit rewrites the staged chunk and records provenance", { skip: pinnedSkip }, async (t) => {
   const stageRoot = path.join(REPO_ROOT, ".test-tmp-info-pane-split");
   const assetsRoot = path.join(stageRoot, "dist", "renderer", "assets");
   const { mkdir, rm, writeFile: writeFileStage } = await import("node:fs/promises");
diff --git a/tests/main-agent-renderer-patch.test.mjs b/tests/main-agent-renderer-patch.test.mjs
index b6339a6..91c9850 100644
--- a/tests/main-agent-renderer-patch.test.mjs
+++ b/tests/main-agent-renderer-patch.test.mjs
@@ -51,6 +51,14 @@ const PINNED_CSS = path.join(REPO_ROOT, "src/app/dist/renderer/assets/index-lCyB
 const run = promisify(execFile);
 
 const readPinnedChunk = () => readFile(PINNED_CHUNK, "utf8");
+
+// src/app/dist is gitignored and only exists after npm run bootstrap; bundle assertions skipped.
+// 2026-10-05 补：本文件此前硬读该产物，而 CI 从不执行 `npm run bootstrap`（bootstrap 用的是
+// macOS 专有的 hdiutil），于是 13 个依赖产物的文件里有 7 个在 CI 上 ENOENT —— main 的 CI
+// 已因此连续红 10 次。写法照抄仓库另外 6 个已守卫的文件，不新造模式。守卫对象取「声明的用例名
+// ∩ 实测失败名」，不是靠猜哪个用例读了产物。
+const pinnedChunk = await readPinnedChunk().catch(() => null);
+const pinnedSkip = pinnedChunk == null ? "src/app/dist is gitignored and only exists after npm run bootstrap; bundle assertions skipped." : false;
 const readPinnedCss = () => readFile(PINNED_CSS, "utf8");
 const patchedChunk = async () => patchMainAgentRenderer(await readPinnedChunk());
 
@@ -268,7 +276,7 @@ test("the injected literals contain no backtick and no interpolation", () => {
   }
 });
 
-test("every anchor resolves exactly once in the pristine bundle", async () => {
+test("every anchor resolves exactly once in the pristine bundle", { skip: pinnedSkip }, async () => {
   const chunk = await readPinnedChunk();
   for (const anchor of [
     "function u0n(n){",
@@ -284,7 +292,7 @@ test("every anchor resolves exactly once in the pristine bundle", async () => {
     "0.18 must already ship the arrow-swap icon the replacement row uses");
 });
 
-test("the injection names only bindings the bundle actually has", async () => {
+test("the injection names only bindings the bundle actually has", { skip: pinnedSkip }, async () => {
   // Checked against the PATCHED bundle, not the pristine one: that is the artifact that
   // ships, and it is also where the patch introduces its own names (the original sidebar
   // is renamed to RMainOriginalSidebar at the first anchor).
@@ -322,7 +330,7 @@ test("MUTATION: a fabricated binding is reported instead of shipping", () => {
   assert.ok(bindings.has("hnt"), "while the real resolver still resolves");
 });
 
-test("RLocT is absent from the bundle and the injection guards it", async () => {
+test("RLocT is absent from the bundle and the injection guards it", { skip: pinnedSkip }, async () => {
   const chunk = await readPinnedChunk();
   assert.equal(chunk.split("RLocT").length - 1, 0,
     "0.18 must not already provide the i18n runtime, or the fallback is untested");
@@ -330,7 +338,7 @@ test("RLocT is absent from the bundle and the injection guards it", async () =>
     "an unguarded RLocT reference would throw in the 0.18 bundle");
 });
 
-test("the agent-item splice keeps the caller's memoization coherent", async () => {
+test("the agent-item splice keeps the caller's memoization coherent", { skip: pinnedSkip }, async () => {
   const patched = await patchedChunk();
   assert.ok(patched.includes("function RMainOriginalSidebar(n){"), "the original sidebar must be renamed, not replaced");
   assert.ok(patched.includes('Hs=p.jsx(RMainAgentItem,{base:lt,"aria-current":pt,'),
@@ -344,7 +352,7 @@ test("the agent-item splice keeps the caller's memoization coherent", async () =
   assert.ok(/function d4e\(n\)\{/.test(chunk), "d4e must be the agent item component");
 });
 
-test("the agent item really is called with the props the wrapper reads", async () => {
+test("the agent item really is called with the props the wrapper reads", { skip: pinnedSkip }, async () => {
   const chunk = await readPinnedChunk();
   const call = /Hs=p\.jsx\(lt,\{([^}]*)\}/.exec(chunk);
   assert.ok(call, "could not lift the agent-item call site");
@@ -353,7 +361,7 @@ test("the agent item really is called with the props the wrapper reads", async (
   }
 });
 
-test("the main marker yields to the corner resolver, as 0.66's s1e does", async () => {
+test("the main marker yields to the corner resolver, as 0.66's s1e does", { skip: pinnedSkip }, async () => {
   const patched = await patchedChunk();
   assert.ok(patched.includes("const corner=hnt({layout:props.layout,marker:props.marker,isWorking:props.isWorking,isActivityNamed:props.isPreviewActivity});"),
     "the wrapper must reuse the bundle's own corner resolver");
@@ -367,7 +375,7 @@ test("the main marker yields to the corner resolver, as 0.66's s1e does", async
     "the corner resolver's signature changed — the wrapper's call would be wrong");
 });
 
-test("the dialog is driven by the prop the 0.18 kit actually reads", async () => {
+test("the dialog is driven by the prop the 0.18 kit actually reads", { skip: pinnedSkip }, async () => {
   const patched = await patchedChunk();
   assert.ok(patched.includes("onOpenChange:next=>{if(!next)close()}"),
     "Gt.Root is a passthrough that only 0.18's onOpenChange can close");
@@ -384,7 +392,7 @@ test("the dialog is driven by the prop the 0.18 kit actually reads", async () =>
     "the dismissible shipped dialogs drive visibility through onOpenChange");
 });
 
-test("the dialog width is a key of the kit's own width table", async () => {
+test("the dialog width is a key of the kit's own width table", { skip: pinnedSkip }, async () => {
   const chunk = await readPinnedChunk();
   const table = /_in=\{([^}]*)\}/.exec(chunk);
   assert.ok(table, "could not lift the dialog width table");
@@ -402,7 +410,7 @@ test("the dialog width is a key of the kit's own width table", async () => {
   assert.ok(!widths.has("400"), "if 400 ever ships, the dialog can go back to 0.66's width");
 });
 
-test("the dialog primitives and button variants the block uses are real", async () => {
+test("the dialog primitives and button variants the block uses are real", { skip: pinnedSkip }, async () => {
   const chunk = await readPinnedChunk();
   const namespace = /const Gt=\{([^}]*)\}/.exec(chunk);
   assert.ok(namespace, "could not lift the dialog namespace");
@@ -421,7 +429,7 @@ test("the dialog primitives and button variants the block uses are real", async
     "0.18's Gt.Action does not take a secondary variant; the block must not pass one");
 });
 
-test("the replacement row uses the real menu and icon primitives", async () => {
+test("the replacement row uses the real menu and icon primitives", { skip: pinnedSkip }, async () => {
   const patched = await patchedChunk();
   assert.ok(patched.includes("ee=p.jsx(RMainDeleteOrReplace,{batchCount:r,id:t.id,onRequestDelete:A})"),
     "the delete slot must be taken over, not duplicated");
@@ -433,7 +441,7 @@ test("the replacement row uses the real menu and icon primitives", async () => {
     "the replacement row must be replaced by delete in a multi-select, as in 0.66");
 });
 
-test("the sidebar wrapper keeps the original sidebar mounted", async () => {
+test("the sidebar wrapper keeps the original sidebar mounted", { skip: pinnedSkip }, async () => {
   const patched = await patchedChunk();
   assert.ok(patched.includes("function u0n(props){return p.jsxs(p.Fragment,{children:[p.jsx(RMainOriginalSidebar,props),p.jsx(RMainRoot,{sidebar:props})]})}"),
     "the wrapper must render the original sidebar AND the chooser, never replace it");
@@ -538,7 +546,7 @@ test("the dialog copy is quoted from 0.66's message tables", () => {
     "the dialog title must keep 0.66's 'primary Bot' wording, not a tidied-up variant");
 });
 
-test("the picker binds only module-scope names from the bundle", async () => {
+test("the picker binds only module-scope names from the bundle", { skip: pinnedSkip }, async () => {
   // The injection is appended at module scope, so a name that merely exists somewhere inside
   // a function body is a ReferenceError at render time. `Ar` is the concrete case that a
   // regex misses: it is declared as `const pTt=1e4,fie=5,Ar=S.forwardRef(…)`.
@@ -551,7 +559,7 @@ test("the picker binds only module-scope names from the bundle", async () => {
     "the original sidebar is renamed by the first anchor, not a pre-existing binding");
 });
 
-test("the search row carries an inline icon, as 0.66's does", async () => {
+test("the search row carries an inline icon, as 0.66's does", { skip: pinnedSkip }, async () => {
   assert.ok(denseComponents().includes(
     "p.jsx(bt,{name:'search',size:'md',className:RMAIN_CLASSES.searchIcon+'r-main-searchicon','aria-hidden':true})"),
     "the search icon belongs inside the input row, not beside it");
@@ -583,7 +591,7 @@ test("Confirm stays disabled until a visible row is picked", () => {
     "0.66's picker has Cancel, not Back — the intro is a separate flow");
 });
 
-test("0.66's picker class list is reused verbatim where 0.18 has the same declarations", async () => {
+test("0.66's picker class list is reused verbatim where 0.18 has the same declarations", { skip: pinnedSkip }, async () => {
   // A stylix hash is a hash of the declarations, so a class keeps its name across versions.
   // 45 of the 47 survive; the two that do not ship without a rule in 0.66 either, so the port
   // drops them rather than inventing replacements.
@@ -600,7 +608,7 @@ test("0.66's picker class list is reused verbatim where 0.18 has the same declar
   assert.ok(unique.length >= 40, `expected the bulk of 0.66's picker classes to be reused, found ${unique.length}`);
 });
 
-test("the ported stylesheet tokens all resolve in the pinned sheet", async () => {
+test("the ported stylesheet tokens all resolve in the pinned sheet", { skip: pinnedSkip }, async () => {
   const css = await readPinnedCss();
   const used = [...new Set([...MAIN_AGENT_STYLE.matchAll(/var\((--sand-[a-z-]+)\)/g)].map(m => m[1]))];
   assert.ok(used.length >= 7, `the stylesheet should consume the design tokens it needs, found ${used.length}`);
@@ -611,12 +619,12 @@ test("the ported stylesheet tokens all resolve in the pinned sheet", async () =>
   }
 });
 
-test("the patched chunk parses as real JavaScript", async () => {
+test("the patched chunk parses as real JavaScript", { skip: pinnedSkip }, async () => {
   const patched = await patchedChunk();
   await assertParses(patched);
 });
 
-test("applying the patch writes a provenance record and a patched chunk", async () => {
+test("applying the patch writes a provenance record and a patched chunk", { skip: pinnedSkip }, async () => {
   const stageRoot = await mkdtemp(path.join(tmpdir(), "main-agent-stage-"));
   const assets = path.join(stageRoot, "dist/renderer/assets");
   await mkdir(assets, { recursive: true });
@@ -640,12 +648,12 @@ test("applying the patch writes a provenance record and a patched chunk", async
   assert.equal(provenance.files[1].file, "index-lCyB53CO.css");
 });
 
-test("re-applying onto patched sources fails closed", async () => {
+test("re-applying onto patched sources fails closed", { skip: pinnedSkip }, async () => {
   const patched = await patchedChunk();
   assert.throws(() => patchMainAgentRenderer(patched), /already applied/);
 });
 
-test("a drifted anchor fails closed instead of silently no-oping", async () => {
+test("a drifted anchor fails closed instead of silently no-oping", { skip: pinnedSkip }, async () => {
   for (const [anchor, replacement] of [
     ["function u0n(n){", "function u0nRenamed(n){"],
     ['Hs=p.jsx(lt,{"aria-current":pt,', "Hs=p.jsx(d4e,{***"],
@@ -656,7 +664,7 @@ test("a drifted anchor fails closed instead of silently no-oping", async () => {
   }
 });
 
-test("an ambiguous anchor fails closed too", async () => {
+test("an ambiguous anchor fails closed too", { skip: pinnedSkip }, async () => {
   const chunk = await readPinnedChunk();
   const duplicated = chunk.replace("ee=p.jsx(mcn,{batchCount:r,id:t.id,onRequestDelete:A})",
     "ee=p.jsx(mcn,{batchCount:r,id:t.id,onRequestDelete:A});ee=p.jsx(mcn,{batchCount:r,id:t.id,onRequestDelete:A})");
diff --git a/tests/marketplace-add-account-form.test.mjs b/tests/marketplace-add-account-form.test.mjs
new file mode 100644
index 0000000..cbbe8d8
--- /dev/null
+++ b/tests/marketplace-add-account-form.test.mjs
@@ -0,0 +1,336 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+import { build } from "esbuild";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+async function load(entry) {
+  const outfile = path.join(repoRoot, "node_modules", ".cache", `tests-addacct-${path.basename(entry, ".ts")}.mjs`);
+  mkdirSync(path.dirname(outfile), { recursive: true });
+  await build({
+    entryPoints: [path.join(repoRoot, entry)],
+    bundle: true,
+    platform: "node",
+    format: "esm",
+    outfile,
+    logLevel: "error",
+    plugins: [{
+      name: "js-to-ts",
+      setup(builder) {
+        builder.onResolve({ filter: /^\.\.?\/.*\.js$/ }, (args) => {
+          const candidate = path.resolve(path.dirname(args.importer), args.path.replace(/\.js$/, ".ts"));
+          return existsSync(candidate) ? { path: candidate } : null;
+        });
+      },
+    }],
+  });
+  return import(pathToFileURL(outfile).href);
+}
+
+const { createAddAccountForm, createAccountEditForm, createAddAccountCta } = await load(
+  "frontend/src/extensions/marketplace/detail-cta.ts",
+);
+const styles = await load("frontend/src/extensions/marketplace/official-styles.ts");
+const { TEXT } = await load("frontend/src/extensions/marketplace/model.ts");
+
+/**
+ * A DOM shim with the event plumbing the add-account form needs.
+ *
+ * The point of this file is that every assertion below drives the **real** `createAddAccountForm`
+ * through real listeners. A text assertion on the source cannot tell a live handler from one parked
+ * behind a dead branch — that exact failure mode is what a previous guard in this repo fell into
+ * twice, so the shim carries `addEventListener`/`dispatch` and the tests click and type for real.
+ */
+function makeDocument() {
+  const makeStyle = () => {
+    const props = new Map();
+    return { setProperty: (name, value) => void props.set(name, value), props };
+  };
+  const makeNode = (tagName) => {
+    const classes = [];
+    const attributes = new Map();
+    const children = [];
+    const listeners = new Map();
+    const node = {
+      nodeType: 1,
+      tagName: tagName.toUpperCase(),
+      type: "",
+      value: "",
+      disabled: false,
+      placeholder: "",
+      focused: false,
+      className: "",
+      classList: { add: (name) => { if (!classes.includes(name)) classes.push(name); } },
+      style: makeStyle(),
+      setAttribute: (name, value) => void attributes.set(name, String(value)),
+      getAttribute: (name) => (attributes.has(name) ? attributes.get(name) : null),
+      hasAttribute: (name) => attributes.has(name),
+      append: (...nodes) => void children.push(...nodes),
+      remove: () => {},
+      focus: () => { node.focused = true; },
+      addEventListener: (type, fn) => {
+        if (!listeners.has(type)) listeners.set(type, []);
+        listeners.get(type).push(fn);
+      },
+      dispatch: (type, event = {}) => {
+        for (const fn of listeners.get(type) ?? []) fn(event);
+      },
+      hasListener: (type) => (listeners.get(type) ?? []).length > 0,
+      get textContent() {
+        return children.map((c) => (typeof c === "string" ? c : c.textContent)).join("");
+      },
+      set textContent(value) {
+        children.length = 0;
+        if (value !== "") children.push(String(value));
+      },
+      get children() { return children; },
+      get classListValues() { return classes; },
+    };
+    return node;
+  };
+  return { createElement: (tagName) => makeNode(tagName), createTextNode: (text) => ({ nodeType: 3, textContent: String(text), tagName: null }) };
+}
+
+/** Build the form with recording handlers, plus a way to type into its input and click its buttons. */
+function harness(overrides = {}) {
+  const doc = makeDocument();
+  const calls = [];
+  const form = createAddAccountForm(doc, {
+    serverId: "srv-1",
+    sourceAccountKey: "default",
+    existingAccountKeys: new Set(["default", "work"]),
+    handlers: {
+      onAddAccount: (a) => calls.push(["add", a]),
+      onAuthenticate: (a) => calls.push(["auth", a]),
+      onClose: () => calls.push(["close"]),
+    },
+    ...overrides,
+  });
+  const [field, authorize, cancel] = form.children;
+  const input = field.children[0];
+  const hint = field.children[1];
+  return {
+    form, field, input, hint, authorize, cancel, calls,
+    // 真实击键会同时改 value 并派发 input —— 只赋值不派发会让「随输入实时重算」的那部分
+    // 永远测不到，于是把「建了节点但从不更新」当成通过。
+    type(v) { input.value = v; input.dispatch("input"); },
+    clickAuthorize() { authorize.dispatch("click"); },
+    clickCancel() { cancel.dispatch("click"); },
+    pressEnter() { input.dispatch("keydown", { key: "Enter" }); },
+    pressEscape() { input.dispatch("keydown", { key: "Escape" }); },
+  };
+}
+
+test("结构：表单三层 + 授权/取消，类名逐字对齐官方", () => {
+  const h = harness();
+  assert.equal(h.form.tagName, "DIV");
+  assert.deepEqual(h.form.classListValues, styles.DETAIL_ADD_ACCOUNT_FORM_CLASSES);
+  assert.equal(h.field.tagName, "SPAN");
+  assert.deepEqual(h.field.classListValues, styles.DETAIL_ADD_ACCOUNT_FIELD_CLASSES);
+  assert.equal(h.input.tagName, "INPUT");
+  assert.deepEqual(h.input.classListValues, styles.DETAIL_ADD_ACCOUNT_INPUT_CLASSES);
+
+  // 表单只有三个子节点：field + 授权 + 取消。官方 `ve()` 的那个 div 也正是这三支。
+  assert.equal(h.form.children.length, 3);
+
+  // 输入框是官方那套 17 类，与编辑表单的 14 类**不是**同一套 —— 混用是最早那次错位的根。
+  assert.equal(styles.DETAIL_ADD_ACCOUNT_INPUT_CLASSES.length, 17);
+  assert.equal(styles.DETAIL_ACCOUNT_FORM_INPUT_CLASSES.length, 14);
+  assert.notDeepEqual(styles.DETAIL_ADD_ACCOUNT_INPUT_CLASSES, styles.DETAIL_ACCOUNT_FORM_INPUT_CLASSES);
+});
+
+test("输入框的 aria-label / placeholder 是官方文案，不是自拟", () => {
+  const h = harness();
+  assert.equal(h.input.getAttribute("aria-label"), "新账户标签");
+  assert.equal(h.input.placeholder, "为此账户添加标签，例如“工作”或“个人”");
+  assert.equal(TEXT.accountLabelInput, "新账户标签");
+  // 官方 JSX 写 autoFocus，实机 `autofocus` 属性读数为 false（React 挂载时消费掉），
+  // 所以实现是显式 focus()，不是设 attribute。
+  assert.equal(h.input.focused, true);
+  assert.equal(h.input.hasAttribute("autofocus"), false);
+});
+
+test("新标签走 onAddAccount，且标签即 accountKey（官方同一函数两种实参名）", () => {
+  const h = harness();
+  h.type("工作");
+  h.clickAuthorize();
+  assert.deepEqual(h.calls, [["close"], ["add", { serverId: "srv-1", label: "工作" }]]);
+});
+
+test("标签先归一化成 trim().toLowerCase() 再提交", () => {
+  const h = harness();
+  h.type("  Personal  ");
+  h.clickAuthorize();
+  assert.deepEqual(h.calls, [["close"], ["add", { serverId: "srv-1", label: "personal" }]]);
+});
+
+test("已存在的账户键走 onAuthenticate，不是 onAddAccount", () => {
+  const h = harness();
+  h.type("work");
+  h.clickAuthorize();
+  assert.deepEqual(h.calls, [["close"], ["auth", { serverId: "srv-1", accountKey: "work" }]]);
+  // 大小写不同也必须命中同一账户：existingAccountKeys 是小写化的，官方 `C` 也是拿归一化后的 q 去比。
+  const h2 = harness();
+  h2.type("WORK");
+  h2.clickAuthorize();
+  assert.deepEqual(h2.calls, [["close"], ["auth", { serverId: "srv-1", accountKey: "work" }]]);
+});
+
+test("先收起表单、再回调 —— 官方两条提交路径都是这个顺序", () => {
+  const h = harness();
+  h.type("新账户");
+  h.clickAuthorize();
+  assert.equal(h.calls[0][0], "close", "官方先 b(null) 收起，再调 i()/t()");
+  const h2 = harness();
+  h2.type("work");
+  h2.clickAuthorize();
+  assert.equal(h2.calls[0][0], "close");
+});
+
+test("三条不提交的分支：空 / 与源账户同名 / grok", () => {
+  for (const [label, typed] of [["空串", ""], ["纯空白", "   "], ["与源账户同名", "default"], ["grok 哨兵", "grok"], ["grok 带空白与大小写", "  GROK "]]) {
+    const h = harness();
+    h.type(typed);
+    h.clickAuthorize();
+    assert.deepEqual(h.calls, [["close"]], `${label}：只应收起表单，不得提交`);
+  }
+});
+
+test("Enter 等价于「授权」，Escape 等价于「取消」", () => {
+  const a = harness();
+  a.type("工作");
+  a.pressEnter();
+  assert.deepEqual(a.calls, [["close"], ["add", { serverId: "srv-1", label: "工作" }]]);
+
+  const b = harness();
+  b.pressEscape();
+  assert.deepEqual(b.calls, [["close"]]);
+
+  // 归一化也要一致：Enter 不能绕过 trim/lower。
+  const c = harness();
+  c.type("  Work  ");
+  c.pressEnter();
+  assert.deepEqual(c.calls, [["close"], ["auth", { serverId: "srv-1", accountKey: "work" }]]);
+});
+
+test("「取消」只收起，不提交", () => {
+  const h = harness();
+  h.type("工作");
+  h.clickCancel();
+  assert.deepEqual(h.calls, [["close"]]);
+});
+
+test("两个按钮都真的挂了监听器（不是文本里看着像）", () => {
+  const h = harness();
+  assert.equal(h.authorize.hasListener("click"), true);
+  assert.equal(h.cancel.hasListener("click"), true);
+  assert.equal(h.input.hasListener("keydown"), true);
+  // 折叠态的 CTA 自己**没有**监听器 —— 它的 handler 装在 view.ts 装上的那一层。
+  assert.equal(createAddAccountCta(makeDocument()).hasListener("click"), false);
+});
+
+test("按钮类名：授权 = 列表行尾那颗按钮的同一配方，取消 = 它加 4 个 ghost 类", () => {
+  // 官方实机：授权 54 类、取消 55 类、交集 51。差集是在浏览器里对 class 集合求差算出来的，
+  // 不是肉眼比的。这三个数任一漂移都说明配方被改过。
+  assert.equal(styles.ACTION_BUTTON_OFFICIAL_CLASSES.length, 54);
+  assert.equal(styles.CANCEL_BUTTON_OFFICIAL_CLASSES.length, 55);
+  assert.deepEqual(
+    styles.CANCEL_BUTTON_OFFICIAL_CLASSES.filter((c) => !styles.ACTION_BUTTON_OFFICIAL_CLASSES.includes(c)),
+    ["sand-jbqb8w", "sand-8cg4aw", "sand-19aaqeu", "sand-1dsx48b"],
+  );
+  assert.deepEqual(
+    styles.ACTION_BUTTON_OFFICIAL_CLASSES.filter((c) => !styles.CANCEL_BUTTON_OFFICIAL_CLASSES.includes(c)),
+    ["sand-1kxuqrf", "sand-uo9n5k", "sand-1wd3ewq"],
+  );
+  // 渲染用的是 0.18 可渲染形（7 个逻辑属性类换成物理属性等价类），长度不变。
+  assert.equal(styles.ACTION_BUTTON_CLASSES.length, 54);
+  assert.equal(styles.CANCEL_BUTTON_CLASSES.length, 55);
+
+  const h = harness();
+  assert.deepEqual(h.authorize.classListValues, styles.ACTION_BUTTON_CLASSES);
+  assert.deepEqual(h.cancel.classListValues, styles.CANCEL_BUTTON_CLASSES);
+  assert.equal(h.authorize.textContent, "授权");
+  assert.equal(h.cancel.textContent, "取消");
+  assert.equal(h.authorize.type, "button");
+  assert.equal(h.cancel.type, "button");
+});
+
+test("编辑表单只有**一个**输入框 —— 错位回归守卫", () => {
+  // 这条挡的是最早那个错：`新账户标签` 被当成了编辑表单的一部分，于是基准写成「1→2」，
+  // 而官方的编辑表单只有重命名那一个。`ve()` 全文也只有一个 `<input>`。
+  const doc = makeDocument();
+  const form = createAccountEditForm(doc, {
+    serverId: "srv-1",
+    accountKey: "default",
+    handlers: { onSave: () => {}, onRemove: () => {}, onCancel: () => {} },
+  });
+  const inputs = form.children
+    .filter((c) => c.nodeType === 1)
+    .flatMap((wrap) => wrap.children.filter((c) => c.nodeType === 1 && c.tagName === "INPUT"));
+  assert.equal(inputs.length, 1, "编辑表单必须只有一个输入框");
+  assert.equal(inputs[0].value, "default");
+  assert.equal(inputs[0].getAttribute("aria-label"), TEXT.accountRenameInput("default"));
+  for (const c of form.children.flatMap((w) => w.children ?? [])) {
+    assert.notEqual(c.placeholder, TEXT.accountLabelPlaceholder, "新账户标签输入框不属于编辑表单");
+  }
+});
+
+// ── 「Grok 是保留的账户标签」提示 ────────────────────────────────────────────
+// 官方 `ve()`：`S ? <span …>{I({id:"wLsCed"})}</span> : null`，`S = h != null &&
+// trim(h) === Vs`（`Vs` = 保留的 Grok 账户键）。它是**字段 span 里的兄弟节点**，
+// 不是 placeholder、不是 aria、也不是 tooltip。
+// 实机判据（官方 0.66, Gmail 详情页表单展开态，逐个标签试出来）：
+//   `Grok` 出现 / `grok` 出现 / `default` 不出现 / `个人` 不出现 / `工作` 不出现
+//   ⇒ 判定是 trim + **大小写不敏感**。
+
+test("提示节点：字段 span 内、input 的兄弟、5 类配方逐字对齐、初始隐藏", () => {
+  const h = harness();
+  assert.ok(h.hint, "提示节点必须存在");
+  assert.equal(h.hint.tagName, "SPAN");
+  // 它是 input 的**兄弟**（同一父节点），不是 input 的子节点 —— 官方 JSX 就是这么嵌的。
+  assert.equal(h.field.children[0], h.input);
+  assert.equal(h.field.children[1], h.hint);
+  assert.deepEqual(h.hint.classListValues, styles.DETAIL_ADD_ACCOUNT_HINT_CLASSES);
+  assert.equal(styles.DETAIL_ADD_ACCOUNT_HINT_CLASSES.length, 5);
+  assert.equal(h.hint.textContent, "Grok 是保留的账户标签");
+  assert.equal(TEXT.reservedAccountLabelHint, "Grok 是保留的账户标签");
+  // 官方 `S` 还要 `h != null`；初值是空串 ⇒ 提示必须收着。
+  assert.equal(h.hint.hidden, true);
+});
+
+test("提示随输入实时切换，且大小写不敏感（实机逐个标签试出来的判据）", () => {
+  // ⚠️ 只把**实测过**的那些标签列进「应显示」。判据是精确相等而非前缀匹配 ——
+  // `Grok2` 曾被我写进这一组，实现按官方的精确相等拒绝了它，是**测试**错了不是实现错了。
+  // 写这类用例前先问：这一条我真在官方界面上看到过吗？
+  for (const typed of ["Grok", "grok", "  GROK  "]) {
+    const h = harness();
+    h.type(typed);
+    assert.equal(h.hint.hidden, false, `输入 ${JSON.stringify(typed)} 应显示提示`);
+  }
+  // 「grokish」「Grok2」等**不得**命中：官方是 `trim(h) === Vs`，不是 startsWith。
+  for (const typed of ["", "   ", "工作", "个人", "default", "Default", "grokish", "Grok2"]) {
+    const h = harness();
+    h.type(typed);
+    assert.equal(h.hint.hidden, true, `输入 ${JSON.stringify(typed)} 不应显示提示`);
+  }
+});
+
+test("提示是**实时**的：先命中再改回，必须跟着翻回去", () => {
+  // 只测「建了节点」会漏掉「从不更新」。这里同一实例连续改两次，两个方向都要变。
+  const h = harness();
+  h.type("Grok");
+  assert.equal(h.hint.hidden, false);
+  h.type("工作");
+  assert.equal(h.hint.hidden, true, "提示必须随输入收起，不能只会在出现方向上工作");
+  h.type("grok");
+  assert.equal(h.hint.hidden, false);
+});
+
+test("提示的 input 监听器真的挂着（不是靠建节点蒙混过关）", () => {
+  const h = harness();
+  assert.equal(h.input.hasListener("input"), true, "删掉这个监听器，上面两条实时用例就会变红");
+});
diff --git a/tests/marketplace-detail-cta-render.test.mjs b/tests/marketplace-detail-cta-render.test.mjs
index 8955cf9..59bae35 100644
--- a/tests/marketplace-detail-cta-render.test.mjs
+++ b/tests/marketplace-detail-cta-render.test.mjs
@@ -172,8 +172,12 @@ test("the 工具 row renders its label and chevron, and keeps the 14px inset cla
 test("view.ts actually calls these builders, rather than re-inlining them", () => {
   // Without this the two tests above could keep passing while the render path drifted back to
   // building the button inline — the classic way a guard protects dead code.
+  // 2026-10-05: the add-account CTA is no longer appended directly. It became a collapsible
+  // sibling (collapsed button ⇄ expanded form) so the node reference has to be mutable; the
+  // builder call is what this test pins, not the literal `list.append(...)` form.
   const view = readFileSync(path.join(repoRoot, "frontend", "src", "extensions", "marketplace", "view.ts"), "utf8");
-  assert.match(view, /list\.append\(createAddAccountCta\(document\)\);/);
+  assert.match(view, /const buildCollapsed = \(\): HTMLButtonElement => \{\s*\n\s*const cta = createAddAccountCta\(document\);/);
+  assert.match(view, /const buildForm = \(\): HTMLElement =>\s*\n\s*createAddAccountForm\(document,/);
   assert.match(view, /list\.append\(createToolsRowCta\(document, detail\.toolsLabel\)\);/);
   assert.doesNotMatch(view, /setAttribute\("aria-label", TEXT\.addAccount\)/);
   assert.doesNotMatch(view, /createTextNode\(TEXT\.addAccount\)/, "the text node now belongs to detail-cta.ts");
diff --git a/tests/marketplace-parity-expr-literals.test.mjs b/tests/marketplace-parity-expr-literals.test.mjs
new file mode 100644
index 0000000..f7fa672
--- /dev/null
+++ b/tests/marketplace-parity-expr-literals.test.mjs
@@ -0,0 +1,74 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+/**
+ * 守卫 `scripts/verify-marketplace-parity.mjs` 里那几个 CDP 表达式常量。
+ *
+ * 它们是以**模板字面量**存的页面上下文 JS。这个脚本没被任何测试 import，所以测试套件
+ * 对它内部的破坏是全绿的 —— 只有 `node --check` 抓得到。而 `node --check` 不在 `npm test` 里。
+ *
+ * 2026-10-05 本人就栽了一次：在 `SECTION_EXPR` **内部**写注释时给 `decorated` 加了反引号，
+ * 反引号把模板字面量截断，文件直接语法错误。探针当时还能跑（提取器按原文切片，注释在页面
+ * 上下文里只是注释），**只有 `node --check` 报了错** —— 两边表现不一致，正是最容易被忽略的形态。
+ *
+ * 所以这里断言的不是「脚本能跑」，而是「四个字面量都完整、没被反引号截断」。
+ */
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const SCRIPT = path.join(repoRoot, "scripts", "verify-marketplace-parity.mjs");
+const SOURCE = readFileSync(SCRIPT, "utf8");
+
+/** 按 `const NAME = \`` … `` `; `` 切出字面量原文。切法必须与探针实际用的完全一致。 */
+function extractExpr(name) {
+  const marker = `const ${name} = \``;
+  const at = SOURCE.indexOf(marker);
+  assert.notEqual(at, -1, `${name} 不在 ${SCRIPT} 里；改名了就同步这条守卫`);
+  const body = at + marker.length;
+  const end = SOURCE.indexOf("`;", body);
+  assert.notEqual(end, -1, `${name} 的模板字面量没有闭合`);
+  return SOURCE.slice(body, end);
+}
+
+const NAMES = ["SECTIONS_EXPR", "CTA_EXPR", "CATALOG_EXPR", "SECTION_EXPR"];
+
+test("四个 CDP 表达式字面量都完整，未被反引号截断", () => {
+  for (const name of NAMES) {
+    const expr = extractExpr(name);
+    // 每个都是 `(async () => { … })()`，尾部必须完整。
+    assert.match(expr, /\}\)\(\)\s*$/, `${name} 的结尾被截断了（多半是注释里混进了反引号）`);
+    assert.ok(expr.length > 2000, `${name} 只有 ${expr.length} 字符，异常短，疑似被提前截断`);
+  }
+});
+
+test("字面量内部的反引号全部是转义的（裸反引号会截断模板串）", () => {
+  for (const name of NAMES) {
+    const expr = extractExpr(name);
+    // `CATALOG_EXPR` 的注释里**合法地**有 6 处转义反引号（页面注释里给 `id` 加引号）。
+    // 所以判据不是「一个反引号都不许有」，而是「每个反引号都得被反斜杠转义」——
+    // 裸的那个才会把外层模板字面量截断、让整个文件语法报错。
+    // 先去掉合法转义，剩下任何反引号都是截断源。
+    const afterStrippingEscapes = expr.replace(/\\`/g, "");
+    assert.equal(
+      afterStrippingEscapes.includes("`"),
+      false,
+      `${name} 里有**未转义**的反引号，它会截断模板字面量（多半是某条注释里忘了转义）`,
+    );
+  }
+});
+
+test("字面量内部不含会在页面上下文里报错的 Node 专有写法", () => {
+  // 这些表达式是被原样发到 `Runtime.evaluate` 里跑的页面 JS，出现 Node 专有标识符
+  // 说明有人把宿主侧代码误写进了字面量。
+  for (const name of NAMES) {
+    const expr = extractExpr(name);
+    for (const forbidden of ["process.env", "require(", "__dirname", "await import("]) {
+      assert.equal(
+        expr.includes(forbidden),
+        false,
+        `${name} 里出现 ${forbidden} —— 它跑在浏览器上下文，不是 Node`,
+      );
+    }
+  }
+});
diff --git a/tests/plugins-dock-connect-apps-pill.test.mjs b/tests/plugins-dock-connect-apps-pill.test.mjs
index 5d9cbcc..9dc612f 100644
--- a/tests/plugins-dock-connect-apps-pill.test.mjs
+++ b/tests/plugins-dock-connect-apps-pill.test.mjs
@@ -611,7 +611,11 @@ test("every rail class resolves in 0.18 or is lifted", () => {
     "RAIL_ICON_GLYPH_CLASSES",
   ];
   let css = null;
-  const staged = readdirSync(STAGED_ASSETS).filter((f) => f.endsWith(".css"));
+  // The same `existsSync` guard this file already uses at :214. `.build` is the packaging staging
+  // dir and only exists after `npm run package`, which CI never runs — so the directory itself can
+  // be absent, not merely empty. The line below already tolerated "no staged CSS"; it did not
+  // tolerate "no staged directory", which is the state CI is actually in.
+  const staged = existsSync(STAGED_ASSETS) ? readdirSync(STAGED_ASSETS).filter((f) => f.endsWith(".css")) : [];
   if (staged.length > 0) css = readFileSync(path.join(STAGED_ASSETS, staged[0]), "utf8");
   for (const name of arrays) {
     for (const className of readStringArray(name)) {
diff --git a/tests/plugins-marketplace-renderer-patch.test.mjs b/tests/plugins-marketplace-renderer-patch.test.mjs
index bf9ec95..1501a0d 100644
--- a/tests/plugins-marketplace-renderer-patch.test.mjs
+++ b/tests/plugins-marketplace-renderer-patch.test.mjs
@@ -201,7 +201,14 @@ test("each lifted rule is emitted as a selector that can actually match", () =>
   assert.match(STYLES, /grid-template-columns:repeat\(2/, "the two-column template must be a lifted/styled class, not ad-hoc CSS");
 });
 
-test("the two-column grid class is present, since the row grid is not one column", () => {
+// `.build/fidelity/app/dist/renderer/assets` is the packaging staging dir: it only exists after
+// `npm run package`, which CI never runs. `cssName()` already returns "" for that case (and
+// `CSS_TEXT()` below already handles it) — the one caller that forgot to check took the whole
+// file down with a readFileSync on the directory itself. Same half-done-guard shape as the
+// src/app/dist guards.
+const stagedCssSkip = () => (cssName() === "" ? ".build is the packaging staging dir and only exists after npm run package; staged-CSS assertions skipped." : false);
+
+test("the two-column grid class is present, since the row grid is not one column", { skip: stagedCssSkip() }, () => {
   // The official marketplace lays each section out in two columns. That comes from
   // `.sand-nby9oq { grid-template-columns:repeat(2,minmax(0,1fr)) }`, which the upstream style-object
   // extraction missed. 0.18 carries the identical declaration under the identical hash.
@@ -758,14 +765,60 @@ test("detail-page affordances that open nothing in 0.66 stay inert", () => {
     "the 工具 row must not grow a handler: 0.66 does not expand it",
   );
 
-  const addAccount = DETAIL_CTA.slice(
-    DETAIL_CTA.indexOf("export function createAddAccountCta"),
-    DETAIL_CTA.indexOf("export function createToolsRowCta"),
+  // ⚠️ 2026-10-05 21:3x 更正：原先这里断言「添加其他账户 **不得**有 handler」，
+  // 判词是「has no destination in 0.66」。**前提是错的** —— 当次取证账户区处于折叠态，
+  // 官方要点一下才展开，于是被读成「点了什么也不发生」。
+  // 重新取证（产物 + 实机双向）：
+  //   · `chunk-plugin-detail-view-tZskkHRA.js` 的 `ve()` 里，`.sand-plugins-detail__add-account`
+  //     按钮与一个 `div` 处在**同一个三元的两支**，两支互斥、无包裹层；按钮 `onClick:()=>y("")`
+  //     把它换成非 null，`y(null)` 换回来 ⇒ 官方确实就地展开表单。
+  //   · 实机 Gmail 详情页点它：文本「添加其他账户」→「授权 取消」，可见输入框 0→1，表单 614×52。
+  // 守卫方向随之反转：不是「不得有 handler」，而是「必须接到 createAddAccountForm」。
+  // 同款错误已连着错两次（本条 + 上方「编辑 <account> 账户」那条），两次都是**用折叠态的
+  // 读数去否定展开态的行为**。
+  //
+  // 判词写成可被证伪的断言（「必须展开」由 ⚠️/断言表示它成立），而不是把布尔取反了事 ——
+  // 取反只是让检查方向一致，不会让判词本身变成对的。
+  assert.doesNotMatch(
+    VIEW,
+    /if \(false\)[\s\S]{0,300}?createAddAccountCta\(document\)/,
+    "the add-account CTA's handler must stay reachable, not parked behind a dead branch",
   );
-  assert.ok(addAccount.length > 0, "createAddAccountCta is gone; this guard would silently pass");
-  assert.ok(
-    !/addEventListener/.test(addAccount),
-    "添加其他账户 has no destination in 0.66",
+  assert.match(
+    VIEW,
+    /const buildForm = \(\): HTMLElement =>\s*\n\s*createAddAccountForm\(document,/,
+    "添加其他账户 must expand the inline add-account form — 0.66 replaces the button in place",
+  );
+  assert.match(
+    VIEW,
+    /createAddAccountCta\(document\);\s*\n\s*cta\.addEventListener\("click",[\s\S]{0,300}?addNode = buildForm\(\);/,
+    "the collapsed CTA's click must swap the node for the form, not merely call something",
+  );
+  // 按钮与表单必须是**互斥兄弟**、直接挂在 list 上：官方 `ve()` 里它们是同一个三元的两支，
+  // 中间没有包裹层。多造一个 slot div 会凭空加一个官方不存在的节点。
+  assert.match(
+    VIEW,
+    /let addNode: HTMLElement = buildCollapsed\(\);\s*\n\s*list\.append\(addNode\);/,
+    "the add-account CTA goes straight onto the account list, with no wrapper node",
+  );
+  assert.doesNotMatch(
+    VIEW,
+    /createAddAccountForm\(document,[\s\S]{0,1200}?addSlot|addSlot[\s\S]{0,200}?createAddAccountForm\(/,
+    "no extra slot wrapper: official's button and form are two arms of one ternary",
+  );
+  // 官方只有一条提交路径：`onAddAccount` 与 `onAuthenticate` 是同一个函数的两种实参名
+  // （`chunk-view-BudImuR0.js`：`onAddAccount = $ => de($.serverId, $.label)`、
+  //  `onAuthenticate = $ => de($.serverId, $.accountKey)`）⇒ 两条都必须落到
+  // `mcp.authenticate`，不得自己造一个新增账户的桥契约。
+  assert.match(
+    VIEW,
+    /onAddAccount:[\s\S]{0,300}?mcp\.authenticate\(a\.serverId, a\.label\)/,
+    "onAddAccount must go through the host bridge's authenticate — the label IS the accountKey",
+  );
+  assert.match(
+    VIEW,
+    /onAuthenticate:[\s\S]{0,200}?mcp\.authenticate\(a\.serverId, a\.accountKey\)/,
+    "onAuthenticate must go through the same bridge call",
   );
 
   // ⚠️ 2026-10-05 19:4x 更正：原先这里断言「编辑 <account> 账户 不得有 handler」，
@@ -835,7 +888,11 @@ test("添加 is a one-shot install: no credential form, no destination picker",
   //
   // What 0.66 DOES have for the grouping half of the brief is the account-label free-text field
   // (`新账户标签`, placeholder 为此账户添加标签，例如"工作"或"个人") — a text input, not a picker.
-  // That lives on the account edit form, not on the install path; guarded further down.
+  //
+  // 2026-10-05 更正：原文写「它在账户**编辑**表单上」。**归属搞错了**。该 input 属于账户列表末尾
+  // 「添加其他账户」按钮就地替换出的那块表单（`ve()` 里紧邻该按钮的同一个三元的另一支），与编辑
+  // 表单是两件事 —— 编辑表单只有重命名那一个输入框，官方 `ve()` 全文也只有 1 个 `<input>`。
+  // 归属错了会连带把验收基准写错（曾据此断言「点开后可见输入框 1→2」），故在此显式钉住。
   //
   // 26 catalog entries carry `fields[]`; none of them is a surface this page renders. The primary
   // button is therefore a one-shot install, which is exactly what `mcp.install` does here.
diff --git a/tests/selection-add-to-prompt-renderer-patch.test.mjs b/tests/selection-add-to-prompt-renderer-patch.test.mjs
index 55b6184..7c4d3eb 100644
--- a/tests/selection-add-to-prompt-renderer-patch.test.mjs
+++ b/tests/selection-add-to-prompt-renderer-patch.test.mjs
@@ -66,17 +66,17 @@ function moduleLevelBindings(source) {
 let topLevel = null;
 
 const patched = bundle == null ? null : patchOriginalSelectionAddToPrompt(bundle);
+// The two slices below are derived from `patched`, which is null whenever the pinned bundle is
+// absent (CI never runs `npm run bootstrap`). Slicing null throws at module load and takes the
+// whole file down — which is how this guard read as "done": `bundleSkip` was in place, but the
+// derivation below it was not. Every test that consumes these is already skipped by `bundleSkip`,
+// so an empty string is the correct derived value when there is no bundle to slice.
+const sliceBetween = (from, to) => (patched == null ? "" : patched.slice(patched.indexOf(from), patched.indexOf(to)));
 // Everything the patch injects as components: the toolbar and the button it renders.
-const toolbar = patched.slice(
-  patched.indexOf("function RSelToolbar("),
-  patched.indexOf("function e9n({fieldClassName:n,"),
-);
+const toolbar = sliceBetween("function RSelToolbar(", "function e9n({fieldClassName:n,");
 // The chip view on its own. 0.18's own code renders `chat-bubbles` elsewhere, so icon
 // assertions must be scoped to what this patch injects rather than the whole chunk.
-const chipView = patched.slice(
-  patched.indexOf("function RSelChip("),
-  patched.indexOf("const RSelQuoteNode="),
-);
+const chipView = sliceBetween("function RSelChip(", "const RSelQuoteNode=");
 
 test("selection patch applies once to the pinned 0.18 chunk and stays parseable", { skip: bundleSkip }, () => {
   assert.doesNotThrow(() => parse(patched, { ecmaVersion: "latest", sourceType: "module" }));
diff --git a/tests/teach-gate-restore-patch.test.mjs b/tests/teach-gate-restore-patch.test.mjs
index 43bcc15..c301f01 100644
--- a/tests/teach-gate-restore-patch.test.mjs
+++ b/tests/teach-gate-restore-patch.test.mjs
@@ -25,6 +25,14 @@ const PINNED_CHUNK = path.join(REPO_ROOT, "src/app/dist/renderer/assets/index-Ub
 const PINNED_HOST = path.join(REPO_ROOT, "src/app/dist/host/host-main.cjs");
 
 const readPinnedChunk = () => readFile(PINNED_CHUNK, "utf8");
+
+// src/app/dist is gitignored and only exists after npm run bootstrap; bundle assertions skipped.
+// 2026-10-05 补：本文件此前硬读该产物，而 CI 从不执行 `npm run bootstrap`（bootstrap 用的是
+// macOS 专有的 hdiutil），于是 13 个依赖产物的文件里有 7 个在 CI 上 ENOENT —— main 的 CI
+// 已因此连续红 10 次。写法照抄仓库另外 6 个已守卫的文件，不新造模式。守卫对象取「声明的用例名
+// ∩ 实测失败名」，不是靠猜哪个用例读了产物。
+const pinnedChunk = await readPinnedChunk().catch(() => null);
+const pinnedSkip = pinnedChunk == null ? "src/app/dist is gitignored and only exists after npm run bootstrap; bundle assertions skipped." : false;
 const readPinnedHost = () => readFile(PINNED_HOST, "utf8");
 const run = promisify(execFile);
 
@@ -52,7 +60,7 @@ function extractBracedObject(source, start) {
   return source.slice(bodyStart, end);
 }
 
-test("anchors resolve exactly once in the pristine bundles", async () => {
+test("anchors resolve exactly once in the pristine bundles", { skip: pinnedSkip }, async () => {
   const chunk = await readPinnedChunk();
   assert.equal(chunk.split("sand_teach_by_demonstration").length - 1, 1,
     "the gate name should occur exactly once in the renderer chunk");
@@ -62,7 +70,7 @@ test("anchors resolve exactly once in the pristine bundles", async () => {
     "host extension read is not unique");
 });
 
-test("the flip changes the renderer fallback and nothing else in the chunk", async () => {
+test("the flip changes the renderer fallback and nothing else in the chunk", { skip: pinnedSkip }, async () => {
   const { patchedRenderer } = patchTeachGateRestore({
     rendererSource: await readPinnedChunk(),
     hostSource: await readPinnedHost(),
@@ -85,7 +93,7 @@ test("the flip changes the renderer fallback and nothing else in the chunk", asy
     "the teach label literal count changed");
 });
 
-test("the patched gate reader really evaluates true when no snapshot carries the gate", async () => {
+test("the patched gate reader really evaluates true when no snapshot carries the gate", { skip: pinnedSkip }, async () => {
   const { patchedRenderer } = patchTeachGateRestore({
     rendererSource: await readPinnedChunk(),
     hostSource: await readPinnedHost(),
@@ -118,7 +126,7 @@ test("the patched gate reader really evaluates true when no snapshot carries the
     "polarity guard: original must be false");
 });
 
-test("the host FLAGS default flips and the extension read survives untouched", async () => {
+test("the host FLAGS default flips and the extension read survives untouched", { skip: pinnedSkip }, async () => {
   const { patchedHost } = patchTeachGateRestore({
     rendererSource: await readPinnedChunk(),
     hostSource: await readPinnedHost(),
@@ -148,7 +156,7 @@ test("the host FLAGS default flips and the extension read survives untouched", a
     "sand_client_pause default must stay false");
 });
 
-test("re-applying onto patched sources fails closed", async () => {
+test("re-applying onto patched sources fails closed", { skip: pinnedSkip }, async () => {
   const { patchedRenderer, patchedHost } = patchTeachGateRestore({
     rendererSource: await readPinnedChunk(),
     hostSource: await readPinnedHost(),
@@ -159,7 +167,7 @@ test("re-applying onto patched sources fails closed", async () => {
   );
 });
 
-test("both patched outputs are still parseable JavaScript", async (t) => {
+test("both patched outputs are still parseable JavaScript", { skip: pinnedSkip }, async (t) => {
   const { patchedRenderer, patchedHost } = patchTeachGateRestore({
     rendererSource: await readPinnedChunk(),
     hostSource: await readPinnedHost(),
@@ -174,7 +182,7 @@ test("both patched outputs are still parseable JavaScript", async (t) => {
   await run(process.execPath, ["--check", hostTmp]);
 });
 
-test("the staged renderer and host both get patched with provenance", async (t) => {
+test("the staged renderer and host both get patched with provenance", { skip: pinnedSkip }, async (t) => {
   const stageRoot = await mkdtemp(path.join(tmpdir(), "grok-node-teach-gate-"));
   t.after(() => rm(stageRoot, { recursive: true, force: true }));
   const assets = path.join(stageRoot, "dist", "renderer", "assets");
diff --git a/tests/teach-success-path-renderer-patch.test.mjs b/tests/teach-success-path-renderer-patch.test.mjs
index 8da7bf8..2280155 100644
--- a/tests/teach-success-path-renderer-patch.test.mjs
+++ b/tests/teach-success-path-renderer-patch.test.mjs
@@ -41,6 +41,14 @@ const PINNED_CSS = path.join(REPO_ROOT, "src/app/dist/renderer/assets/index-lCyB
 const run = promisify(execFile);
 
 const readPinnedChunk = () => readFile(PINNED_CHUNK, "utf8");
+
+// src/app/dist is gitignored and only exists after npm run bootstrap; bundle assertions skipped.
+// 2026-10-05 补：本文件此前硬读该产物，而 CI 从不执行 `npm run bootstrap`（bootstrap 用的是
+// macOS 专有的 hdiutil），于是 13 个依赖产物的文件里有 7 个在 CI 上 ENOENT —— main 的 CI
+// 已因此连续红 10 次。写法照抄仓库另外 6 个已守卫的文件，不新造模式。守卫对象取「声明的用例名
+// ∩ 实测失败名」，不是靠猜哪个用例读了产物。
+const pinnedChunk = await readPinnedChunk().catch(() => null);
+const pinnedSkip = pinnedChunk == null ? "src/app/dist is gitignored and only exists after npm run bootstrap; bundle assertions skipped." : false;
 const readPinnedCss = () => readFile(PINNED_CSS, "utf8");
 
 const GATE_BEFORE = "function pWn(){return es(Qe().experiments.snapshots)?.featureGates?.publish_user_skills??!1}";
@@ -95,7 +103,7 @@ function gateReader(source) {
   return snapshot => fn(x => x, () => ({ experiments: { snapshots: snapshot } }));
 }
 
-test("every anchor resolves exactly once in the pristine bundle", async () => {
+test("every anchor resolves exactly once in the pristine bundle", { skip: pinnedSkip }, async () => {
   const chunk = await readPinnedChunk();
   assert.equal(chunk.split("publish_user_skills").length - 1, 1,
     "publish_user_skills should occur exactly once in the renderer chunk");
@@ -110,7 +118,7 @@ test("every anchor resolves exactly once in the pristine bundle", async () => {
     "the skill chip destructure is not unique");
 });
 
-test("the patch flips only the publish gate and leaves every other gate alone", async () => {
+test("the patch flips only the publish gate and leaves every other gate alone", { skip: pinnedSkip }, async () => {
   const pristine = await readPinnedChunk();
   const patched = await patchedChunk();
   assert.ok(!patched.includes(GATE_BEFORE), "the publish gate fallback was left unflipped");
@@ -123,7 +131,7 @@ test("the patch flips only the publish gate and leaves every other gate alone",
   void pristine;
 });
 
-test("the flipped gate reader really returns true — polarity is evaluated, not compared", async () => {
+test("the flipped gate reader really returns true — polarity is evaluated, not compared", { skip: pinnedSkip }, async () => {
   const evaluate = gateReader(await patchedChunk());
   assert.equal(evaluate({ featureGates: { publish_user_skills: true } }), true, "a served true must stay true");
   assert.equal(evaluate({ featureGates: {} }), true, "an absent gate must fall back to the flipped default");
@@ -132,7 +140,7 @@ test("the flipped gate reader really returns true — polarity is evaluated, not
   assert.equal(evaluate(undefined), true, "an absent snapshot must fall back to the flipped default");
 });
 
-test("the transcript line renders the 0.62.0 zh-Hans string and only for teach-recording entries", async () => {
+test("the transcript line renders the 0.62.0 zh-Hans string and only for teach-recording entries", { skip: pinnedSkip }, async () => {
   const helpers = await evaluateHelpers(await patchedChunk(), "zh-CN");
   const teachEntry = { clientNonce: "teach-recording:abc123:teach-2026-09-30-010101.json", content: "The recording is finished. Learn the task from it." };
   assert.equal(helpers.RTeachIsRecording(teachEntry), true, "the real host payload must classify as teach-recording");
@@ -151,14 +159,14 @@ test("the transcript line renders the 0.62.0 zh-Hans string and only for teach-r
   assert.equal(helpers.RTeachIsRecording({ content: undefined }), false, "a contentless entry must not classify");
 });
 
-test("the classifier falls back to the English string in an English UI", async () => {
+test("the classifier falls back to the English string in an English UI", { skip: pinnedSkip }, async () => {
   const helpers = await evaluateHelpers(await patchedChunk(), "en-US");
   assert.equal(helpers.RTeachRecordingText(), "The recording is finished. Learn the task from it.",
     "the English value must be 0.62.0's /WKm9a source string");
   assert.equal(helpers.RTeachSkillLabel("learn-from-demonstration", "Learn from demonstration"), "Learn from demonstration");
 });
 
-test("the managed-skill chip label localizes only the learn-from-demonstration skill", async () => {
+test("the managed-skill chip label localizes only the learn-from-demonstration skill", { skip: pinnedSkip }, async () => {
   const helpers = await evaluateHelpers(await patchedChunk(), "zh-CN");
   assert.equal(helpers.RTeachSkillLabel("learn-from-demonstration", "Learn from demonstration"), "从演示中学习",
     "the managed teach skill must read as 0.62.0's zh-Hans 3Fgqpv value");
@@ -173,7 +181,7 @@ test("the managed-skill chip label localizes only the learn-from-demonstration s
   assert.equal(helpers.RTeachSkillLabel("", ""), "", "an empty chip must stay empty");
 });
 
-test("the message renderer takes contentBeforeRichText and puts it BEFORE the rich text", async () => {
+test("the message renderer takes contentBeforeRichText and puts it BEFORE the rich text", { skip: pinnedSkip }, async () => {
   const patched = await patchedChunk();
   assert.ok(patched.includes("contentBeforeRichText:RTeachBefore"), "BPn must destructure the new prop");
   assert.ok(patched.includes('children:[RTeachNode,l]'), "the prose container must render the line before the rich text");
@@ -186,7 +194,7 @@ test("the message renderer takes contentBeforeRichText and puts it BEFORE the ri
   assert.ok(patched.includes('gpt(x,r,"c")'), "the no-rich-text path must keep its 0.18 key prefix");
 });
 
-test("the call site classifies the entry and forwards both strings", async () => {
+test("the call site classifies the entry and forwards both strings", { skip: pinnedSkip }, async () => {
   const patched = await patchedChunk();
   assert.ok(patched.includes("content:RTeachIsRecording(r)?RTeachRecordingText():r.content"),
     "the call site must localize the content for teach-recording entries and pass the rest through");
@@ -196,7 +204,7 @@ test("the call site classifies the entry and forwards both strings", async () =>
     "the caller's memo must depend on clientNonce or a relabelled entry would reuse the stale node");
 });
 
-test("the skill chip localizes its label at the single point 0.62.0 uses", async () => {
+test("the skill chip localizes its label at the single point 0.62.0 uses", { skip: pinnedSkip }, async () => {
   const patched = await patchedChunk();
   assert.ok(patched.includes("label:RTeachRawLabel,iconId:r,iconUrl:i}=n,o=ict(),s=RTeachSkillLabel(t,RTeachRawLabel);"),
     "the chip must re-bind its label to the localized value");
@@ -229,7 +237,7 @@ function sliceFunction(source, signature) {
   throw new Error(`${signature} did not brace-balance`);
 }
 
-test("memo-cache sizes are grown to cover every slot the patch adds", async () => {
+test("memo-cache sizes are grown to cover every slot the patch adds", { skip: pinnedSkip }, async () => {
   const patched = await patchedChunk();
   for (const [signature, size] of [["function BPn(n){const e=he.c(26),", 26], ["function KWn(n){const e=he.c(45);", 45]]) {
     const body = sliceFunction(patched, signature);
@@ -246,19 +254,19 @@ test("memo-cache sizes are grown to cover every slot the patch adds", async () =
   }
 });
 
-test("the ported classes all exist in the pinned stylesheet", async () => {
+test("the ported classes all exist in the pinned stylesheet", { skip: pinnedSkip }, async () => {
   const css = await readPinnedCss();
   assert.equal(assertTeachSuccessPathClassesResolve(css), TEACH_SUCCESS_PATH_CLASS_NAMES.length);
   assert.throws(() => assertTeachSuccessPathClassesResolve(".sand-10im51j{color:red}"), /missing from the pinned/,
     "a stylesheet missing a class must fail the build, not ship an unstyled line");
 });
 
-test("the patched chunk parses as real JavaScript", async () => {
+test("the patched chunk parses as real JavaScript", { skip: pinnedSkip }, async () => {
   const patched = await patchedChunk();
   await assertParses(patched, "patched chunk");
 });
 
-test("applying the patch writes a provenance record and a patched chunk", async () => {
+test("applying the patch writes a provenance record and a patched chunk", { skip: pinnedSkip }, async () => {
   const stageRoot = await mkdtemp(path.join(tmpdir(), "teach-success-stage-"));
   const assets = path.join(stageRoot, "dist/renderer/assets");
   await mkdir(assets, { recursive: true });
@@ -280,12 +288,12 @@ test("applying the patch writes a provenance record and a patched chunk", async
   assert.equal(provenance.upstream.version, "0.62.0");
 });
 
-test("a drifted anchor fails closed instead of silently no-oping", async () => {
+test("a drifted anchor fails closed instead of silently no-oping", { skip: pinnedSkip }, async () => {
   const chunk = (await readPinnedChunk()).replace(GATE_BEFORE, "function pWn(){return false}");
   assert.throws(() => patchOriginalTeachSuccessPath(chunk), /publish gate fallback anchor is missing or ambiguous/);
 });
 
-test("MUTATION: an unfipped gate keeps the publish button hidden", async () => {
+test("MUTATION: an unfipped gate keeps the publish button hidden", { skip: pinnedSkip }, async () => {
   const chunk = await readPinnedChunk();
   const mutated = patchOriginalTeachSuccessPath(chunk).replace(
     "featureGates?.publish_user_skills??!0",
@@ -300,7 +308,7 @@ test("MUTATION: an unfipped gate keeps the publish button hidden", async () => {
     "with the fallback back at ??!1 an empty snapshot reads the gate as off");
 });
 
-test("MUTATION: dropping the classifier makes the transcript line unreachable", async () => {
+test("MUTATION: dropping the classifier makes the transcript line unreachable", { skip: pinnedSkip }, async () => {
   const patched = await patchedChunk();
   const mutated = patched.replace(
     "function RTeachIsRecording(e){return e.clientNonce?.startsWith(RTeachRecordingNoncePrefix)===!0&&e.content===RTeachRecordingContent}",
@@ -312,7 +320,7 @@ test("MUTATION: dropping the classifier makes the transcript line unreachable",
     "with the classifier neutered the line can never render");
 });
 
-test("MUTATION: a widened classifier relabels ordinary user messages", async () => {
+test("MUTATION: a widened classifier relabels ordinary user messages", { skip: pinnedSkip }, async () => {
   const patched = await patchedChunk();
   // Drop the content half of 0.62.0's conjunction and keep only the nonce prefix.
   const widened = patched.replace("&&e.content===RTeachRecordingContent", "");
@@ -330,12 +338,12 @@ test("MUTATION: a widened classifier relabels ordinary user messages", async ()
   );
 });
 
-test("MUTATION: rendering the line after the rich text reverses 0.62.0's order", async () => {
+test("MUTATION: rendering the line after the rich text reverses 0.62.0's order", { skip: pinnedSkip }, async () => {
   const mutated = (await patchedChunk()).replace("children:[RTeachNode,l]", "children:[l,RTeachNode]");
   assert.ok(!mutated.includes("children:[RTeachNode,l]"), "the mutation must actually reverse the order");
 });
 
-test("MUTATION: an un-grown memo cache makes the new slots read out of bounds", async () => {
+test("MUTATION: an un-grown memo cache makes the new slots read out of bounds", { skip: pinnedSkip }, async () => {
   const mutated = (await patchedChunk()).replace("function BPn(n){const e=he.c(26),", "function BPn(n){const e=he.c(22),");
   const body = mutated.slice(mutated.indexOf("function BPn(n){const e=he.c(22),"));
   const used = [...new Set([...body.slice(0, 12000).matchAll(/\be\[(\d+)\]/g)].map(m => Number(m[1])))];